@prefecthq/prefab-ui-docs 0.17.0 → 0.18.1

package/dist/_renderer/carousel-DtQ-l7Gc.mjs

@@ -0,0 +1,2021 @@
+import { j as W, c as Xt } from "./embed-DguKmtmL.mjs";
+import { r as _, R as It, C as fn, a as dn, b as pn, c as gn } from "./icons-z7UO1VFZ.mjs";
+function mn(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function _t(t) {
+  return mn(t) || Array.isArray(t);
+}
+function hn() {
+  return !!(typeof window < "u" && window.document && window.document.createElement);
+}
+function Tt(t, n) {
+  const e = Object.keys(t), i = Object.keys(n);
+  if (e.length !== i.length) return !1;
+  const s = JSON.stringify(Object.keys(t.breakpoints || {})), r = JSON.stringify(Object.keys(n.breakpoints || {}));
+  return s !== r ? !1 : e.every((o) => {
+    const l = t[o], c = n[o];
+    return typeof l == "function" ? `${l}` == `${c}` : !_t(l) || !_t(c) ? l === c : Tt(l, c);
+  });
+}
+function qt(t) {
+  return t.concat().sort((n, e) => n.name > e.name ? 1 : -1).map((n) => n.options);
+}
+function yn(t, n) {
+  if (t.length !== n.length) return !1;
+  const e = qt(t), i = qt(n);
+  return e.every((s, r) => {
+    const o = i[r];
+    return Tt(s, o);
+  });
+}
+function Pt(t) {
+  return typeof t == "number";
+}
+function Dt(t) {
+  return typeof t == "string";
+}
+function xt(t) {
+  return typeof t == "boolean";
+}
+function Gt(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function q(t) {
+  return Math.abs(t);
+}
+function Mt(t) {
+  return Math.sign(t);
+}
+function pt(t, n) {
+  return q(t - n);
+}
+function Sn(t, n) {
+  if (t === 0 || n === 0 || q(t) <= q(n)) return 0;
+  const e = pt(q(t), q(n));
+  return q(e / t);
+}
+function bn(t) {
+  return Math.round(t * 100) / 100;
+}
+function gt(t) {
+  return mt(t).map(Number);
+}
+function st(t) {
+  return t[yt(t)];
+}
+function yt(t) {
+  return Math.max(0, t.length - 1);
+}
+function At(t, n) {
+  return n === yt(t);
+}
+function Yt(t, n = 0) {
+  return Array.from(Array(t), (e, i) => n + i);
+}
+function mt(t) {
+  return Object.keys(t);
+}
+function Qt(t, n) {
+  return [t, n].reduce((e, i) => (mt(i).forEach((s) => {
+    const r = e[s], o = i[s], l = Gt(r) && Gt(o);
+    e[s] = l ? Qt(r, o) : o;
+  }), e), {});
+}
+function Lt(t, n) {
+  return typeof n.MouseEvent < "u" && t instanceof n.MouseEvent;
+}
+function xn(t, n) {
+  const e = {
+    start: i,
+    center: s,
+    end: r
+  };
+  function i() {
+    return 0;
+  }
+  function s(c) {
+    return r(c) / 2;
+  }
+  function r(c) {
+    return n - c;
+  }
+  function o(c, a) {
+    return Dt(t) ? e[t](c) : t(n, c, a);
+  }
+  return {
+    measure: o
+  };
+}
+function ht() {
+  let t = [];
+  function n(s, r, o, l = {
+    passive: !0
+  }) {
+    let c;
+    if ("addEventListener" in s)
+      s.addEventListener(r, o, l), c = () => s.removeEventListener(r, o, l);
+    else {
+      const a = s;
+      a.addListener(o), c = () => a.removeListener(o);
+    }
+    return t.push(c), i;
+  }
+  function e() {
+    t = t.filter((s) => s());
+  }
+  const i = {
+    add: n,
+    clear: e
+  };
+  return i;
+}
+function vn(t, n, e, i) {
+  const s = ht(), r = 1e3 / 60;
+  let o = null, l = 0, c = 0;
+  function a() {
+    s.add(t, "visibilitychange", () => {
+      t.hidden && d();
+    });
+  }
+  function y() {
+    v(), s.clear();
+  }
+  function f(h) {
+    if (!c) return;
+    o || (o = h, e(), e());
+    const u = h - o;
+    for (o = h, l += u; l >= r; )
+      e(), l -= r;
+    const S = l / r;
+    i(S), c && (c = n.requestAnimationFrame(f));
+  }
+  function p() {
+    c || (c = n.requestAnimationFrame(f));
+  }
+  function v() {
+    n.cancelAnimationFrame(c), o = null, l = 0, c = 0;
+  }
+  function d() {
+    o = null, l = 0;
+  }
+  return {
+    init: a,
+    destroy: y,
+    start: p,
+    stop: v,
+    update: e,
+    render: i
+  };
+}
+function En(t, n) {
+  const e = n === "rtl", i = t === "y", s = i ? "y" : "x", r = i ? "x" : "y", o = !i && e ? -1 : 1, l = y(), c = f();
+  function a(d) {
+    const {
+      height: g,
+      width: h
+    } = d;
+    return i ? g : h;
+  }
+  function y() {
+    return i ? "top" : e ? "right" : "left";
+  }
+  function f() {
+    return i ? "bottom" : e ? "left" : "right";
+  }
+  function p(d) {
+    return d * o;
+  }
+  return {
+    scroll: s,
+    cross: r,
+    startEdge: l,
+    endEdge: c,
+    measureSize: a,
+    direction: p
+  };
+}
+function lt(t = 0, n = 0) {
+  const e = q(t - n);
+  function i(a) {
+    return a < t;
+  }
+  function s(a) {
+    return a > n;
+  }
+  function r(a) {
+    return i(a) || s(a);
+  }
+  function o(a) {
+    return r(a) ? i(a) ? t : n : a;
+  }
+  function l(a) {
+    return e ? a - e * Math.ceil((a - n) / e) : a;
+  }
+  return {
+    length: e,
+    max: n,
+    min: t,
+    constrain: o,
+    reachedAny: r,
+    reachedMax: s,
+    reachedMin: i,
+    removeOffset: l
+  };
+}
+function Jt(t, n, e) {
+  const {
+    constrain: i
+  } = lt(0, t), s = t + 1;
+  let r = o(n);
+  function o(p) {
+    return e ? q((s + p) % s) : i(p);
+  }
+  function l() {
+    return r;
+  }
+  function c(p) {
+    return r = o(p), f;
+  }
+  function a(p) {
+    return y().set(l() + p);
+  }
+  function y() {
+    return Jt(t, l(), e);
+  }
+  const f = {
+    get: l,
+    set: c,
+    add: a,
+    clone: y
+  };
+  return f;
+}
+function On(t, n, e, i, s, r, o, l, c, a, y, f, p, v, d, g, h, u, S) {
+  const {
+    cross: E,
+    direction: P
+  } = t, F = ["INPUT", "SELECT", "TEXTAREA"], L = {
+    passive: !1
+  }, w = ht(), T = ht(), m = lt(50, 225).constrain(v.measure(20)), D = {
+    mouse: 300,
+    touch: 400
+  }, C = {
+    mouse: 500,
+    touch: 600
+  }, U = d ? 43 : 25;
+  let Y = !1, b = 0, I = 0, O = !1, M = !1, A = !1, k = !1;
+  function N(x) {
+    if (!S) return;
+    function B(Z) {
+      (xt(S) || S(x, Z)) && rt(Z);
+    }
+    const X = n;
+    w.add(X, "dragstart", (Z) => Z.preventDefault(), L).add(X, "touchmove", () => {
+    }, L).add(X, "touchend", () => {
+    }).add(X, "touchstart", B).add(X, "mousedown", B).add(X, "touchcancel", K).add(X, "contextmenu", K).add(X, "click", tt, !0);
+  }
+  function j() {
+    w.clear(), T.clear();
+  }
+  function R() {
+    const x = k ? e : n;
+    T.add(x, "touchmove", Q, L).add(x, "touchend", K).add(x, "mousemove", Q, L).add(x, "mouseup", K);
+  }
+  function z(x) {
+    const B = x.nodeName || "";
+    return F.includes(B);
+  }
+  function H() {
+    return (d ? C : D)[k ? "mouse" : "touch"];
+  }
+  function nt(x, B) {
+    const X = f.add(Mt(x) * -1), Z = y.byDistance(x, !d).distance;
+    return d || q(x) < m ? Z : h && B ? Z * 0.5 : y.byIndex(X.get(), 0).distance;
+  }
+  function rt(x) {
+    const B = Lt(x, i);
+    k = B, A = d && B && !x.buttons && Y, Y = pt(s.get(), o.get()) >= 2, !(B && x.button !== 0) && (z(x.target) || (O = !0, r.pointerDown(x), a.useFriction(0).useDuration(0), s.set(o), R(), b = r.readPoint(x), I = r.readPoint(x, E), p.emit("pointerDown")));
+  }
+  function Q(x) {
+    if (!Lt(x, i) && x.touches.length >= 2) return K(x);
+    const X = r.readPoint(x), Z = r.readPoint(x, E), et = pt(X, b), ot = pt(Z, I);
+    if (!M && !k && (!x.cancelable || (M = et > ot, !M)))
+      return K(x);
+    const V = r.pointerMove(x);
+    et > g && (A = !0), a.useFriction(0.3).useDuration(0.75), l.start(), s.add(P(V)), x.preventDefault();
+  }
+  function K(x) {
+    const X = y.byDistance(0, !1).index !== f.get(), Z = r.pointerUp(x) * H(), et = nt(P(Z), X), ot = Sn(Z, et), V = U - 10 * ot, G = u + ot / 50;
+    M = !1, O = !1, T.clear(), a.useDuration(V).useFriction(G), c.distance(et, !d), k = !1, p.emit("pointerUp");
+  }
+  function tt(x) {
+    A && (x.stopPropagation(), x.preventDefault(), A = !1);
+  }
+  function J() {
+    return O;
+  }
+  return {
+    init: N,
+    destroy: j,
+    pointerDown: J
+  };
+}
+function In(t, n) {
+  let i, s;
+  function r(f) {
+    return f.timeStamp;
+  }
+  function o(f, p) {
+    const d = `client${(p || t.scroll) === "x" ? "X" : "Y"}`;
+    return (Lt(f, n) ? f : f.touches[0])[d];
+  }
+  function l(f) {
+    return i = f, s = f, o(f);
+  }
+  function c(f) {
+    const p = o(f) - o(s), v = r(f) - r(i) > 170;
+    return s = f, v && (i = f), p;
+  }
+  function a(f) {
+    if (!i || !s) return 0;
+    const p = o(s) - o(i), v = r(f) - r(i), d = r(f) - r(s) > 170, g = p / v;
+    return v && !d && q(g) > 0.1 ? g : 0;
+  }
+  return {
+    pointerDown: l,
+    pointerMove: c,
+    pointerUp: a,
+    readPoint: o
+  };
+}
+function wn() {
+  function t(e) {
+    const {
+      offsetTop: i,
+      offsetLeft: s,
+      offsetWidth: r,
+      offsetHeight: o
+    } = e;
+    return {
+      top: i,
+      right: s + r,
+      bottom: i + o,
+      left: s,
+      width: r,
+      height: o
+    };
+  }
+  return {
+    measure: t
+  };
+}
+function Dn(t) {
+  function n(i) {
+    return t * (i / 100);
+  }
+  return {
+    measure: n
+  };
+}
+function Ln(t, n, e, i, s, r, o) {
+  const l = [t].concat(i);
+  let c, a, y = [], f = !1;
+  function p(h) {
+    return s.measureSize(o.measure(h));
+  }
+  function v(h) {
+    if (!r) return;
+    a = p(t), y = i.map(p);
+    function u(S) {
+      for (const E of S) {
+        if (f) return;
+        const P = E.target === t, F = i.indexOf(E.target), L = P ? a : y[F], w = p(P ? t : i[F]);
+        if (q(w - L) >= 0.5) {
+          h.reInit(), n.emit("resize");
+          break;
+        }
+      }
+    }
+    c = new ResizeObserver((S) => {
+      (xt(r) || r(h, S)) && u(S);
+    }), e.requestAnimationFrame(() => {
+      l.forEach((S) => c.observe(S));
+    });
+  }
+  function d() {
+    f = !0, c && c.disconnect();
+  }
+  return {
+    init: v,
+    destroy: d
+  };
+}
+function Tn(t, n, e, i, s, r) {
+  let o = 0, l = 0, c = s, a = r, y = t.get(), f = 0;
+  function p() {
+    const L = i.get() - t.get(), w = !c;
+    let T = 0;
+    return w ? (o = 0, e.set(i), t.set(i), T = L) : (e.set(t), o += L / c, o *= a, y += o, t.add(o), T = y - f), l = Mt(T), f = y, F;
+  }
+  function v() {
+    const L = i.get() - n.get();
+    return q(L) < 1e-3;
+  }
+  function d() {
+    return c;
+  }
+  function g() {
+    return l;
+  }
+  function h() {
+    return o;
+  }
+  function u() {
+    return E(s);
+  }
+  function S() {
+    return P(r);
+  }
+  function E(L) {
+    return c = L, F;
+  }
+  function P(L) {
+    return a = L, F;
+  }
+  const F = {
+    direction: g,
+    duration: d,
+    velocity: h,
+    seek: p,
+    settled: v,
+    useBaseFriction: S,
+    useBaseDuration: u,
+    useFriction: P,
+    useDuration: E
+  };
+  return F;
+}
+function Pn(t, n, e, i, s) {
+  const r = s.measure(10), o = s.measure(50), l = lt(0.1, 0.99);
+  let c = !1;
+  function a() {
+    return !(c || !t.reachedAny(e.get()) || !t.reachedAny(n.get()));
+  }
+  function y(v) {
+    if (!a()) return;
+    const d = t.reachedMin(n.get()) ? "min" : "max", g = q(t[d] - n.get()), h = e.get() - n.get(), u = l.constrain(g / o);
+    e.subtract(h * u), !v && q(h) < r && (e.set(t.constrain(e.get())), i.useDuration(25).useBaseFriction());
+  }
+  function f(v) {
+    c = !v;
+  }
+  return {
+    shouldConstrain: a,
+    constrain: y,
+    toggleActive: f
+  };
+}
+function Mn(t, n, e, i, s) {
+  const r = lt(-n + t, 0), o = f(), l = y(), c = p();
+  function a(d, g) {
+    return pt(d, g) <= 1;
+  }
+  function y() {
+    const d = o[0], g = st(o), h = o.lastIndexOf(d), u = o.indexOf(g) + 1;
+    return lt(h, u);
+  }
+  function f() {
+    return e.map((d, g) => {
+      const {
+        min: h,
+        max: u
+      } = r, S = r.constrain(d), E = !g, P = At(e, g);
+      return E ? u : P || a(h, S) ? h : a(u, S) ? u : S;
+    }).map((d) => parseFloat(d.toFixed(3)));
+  }
+  function p() {
+    if (n <= t + s) return [r.max];
+    if (i === "keepSnaps") return o;
+    const {
+      min: d,
+      max: g
+    } = l;
+    return o.slice(d, g);
+  }
+  return {
+    snapsContained: c,
+    scrollContainLimit: l
+  };
+}
+function An(t, n, e) {
+  const i = n[0], s = e ? i - t : st(n);
+  return {
+    limit: lt(s, i)
+  };
+}
+function Cn(t, n, e, i) {
+  const r = n.min + 0.1, o = n.max + 0.1, {
+    reachedMin: l,
+    reachedMax: c
+  } = lt(r, o);
+  function a(p) {
+    return p === 1 ? c(e.get()) : p === -1 ? l(e.get()) : !1;
+  }
+  function y(p) {
+    if (!a(p)) return;
+    const v = t * (p * -1);
+    i.forEach((d) => d.add(v));
+  }
+  return {
+    loop: y
+  };
+}
+function Fn(t) {
+  const {
+    max: n,
+    length: e
+  } = t;
+  function i(r) {
+    const o = r - n;
+    return e ? o / -e : 0;
+  }
+  return {
+    get: i
+  };
+}
+function kn(t, n, e, i, s) {
+  const {
+    startEdge: r,
+    endEdge: o
+  } = t, {
+    groupSlides: l
+  } = s, c = f().map(n.measure), a = p(), y = v();
+  function f() {
+    return l(i).map((g) => st(g)[o] - g[0][r]).map(q);
+  }
+  function p() {
+    return i.map((g) => e[r] - g[r]).map((g) => -q(g));
+  }
+  function v() {
+    return l(a).map((g) => g[0]).map((g, h) => g + c[h]);
+  }
+  return {
+    snaps: a,
+    snapsAligned: y
+  };
+}
+function Nn(t, n, e, i, s, r) {
+  const {
+    groupSlides: o
+  } = s, {
+    min: l,
+    max: c
+  } = i, a = y();
+  function y() {
+    const p = o(r), v = !t || n === "keepSnaps";
+    return e.length === 1 ? [r] : v ? p : p.slice(l, c).map((d, g, h) => {
+      const u = !g, S = At(h, g);
+      if (u) {
+        const E = st(h[0]) + 1;
+        return Yt(E);
+      }
+      if (S) {
+        const E = yt(r) - st(h)[0] + 1;
+        return Yt(E, st(h)[0]);
+      }
+      return d;
+    });
+  }
+  return {
+    slideRegistry: a
+  };
+}
+function Bn(t, n, e, i, s) {
+  const {
+    reachedAny: r,
+    removeOffset: o,
+    constrain: l
+  } = i;
+  function c(d) {
+    return d.concat().sort((g, h) => q(g) - q(h))[0];
+  }
+  function a(d) {
+    const g = t ? o(d) : l(d), h = n.map((S, E) => ({
+      diff: y(S - g, 0),
+      index: E
+    })).sort((S, E) => q(S.diff) - q(E.diff)), {
+      index: u
+    } = h[0];
+    return {
+      index: u,
+      distance: g
+    };
+  }
+  function y(d, g) {
+    const h = [d, d + e, d - e];
+    if (!t) return d;
+    if (!g) return c(h);
+    const u = h.filter((S) => Mt(S) === g);
+    return u.length ? c(u) : st(h) - e;
+  }
+  function f(d, g) {
+    const h = n[d] - s.get(), u = y(h, g);
+    return {
+      index: d,
+      distance: u
+    };
+  }
+  function p(d, g) {
+    const h = s.get() + d, {
+      index: u,
+      distance: S
+    } = a(h), E = !t && r(h);
+    if (!g || E) return {
+      index: u,
+      distance: d
+    };
+    const P = n[u] - S, F = d + y(P, 0);
+    return {
+      index: u,
+      distance: F
+    };
+  }
+  return {
+    byDistance: p,
+    byIndex: f,
+    shortcut: y
+  };
+}
+function jn(t, n, e, i, s, r, o) {
+  function l(f) {
+    const p = f.distance, v = f.index !== n.get();
+    r.add(p), p && (i.duration() ? t.start() : (t.update(), t.render(1), t.update())), v && (e.set(n.get()), n.set(f.index), o.emit("select"));
+  }
+  function c(f, p) {
+    const v = s.byDistance(f, p);
+    l(v);
+  }
+  function a(f, p) {
+    const v = n.clone().set(f), d = s.byIndex(v.get(), p);
+    l(d);
+  }
+  return {
+    distance: c,
+    index: a
+  };
+}
+function Rn(t, n, e, i, s, r, o, l) {
+  const c = {
+    passive: !0,
+    capture: !0
+  };
+  let a = 0;
+  function y(v) {
+    if (!l) return;
+    function d(g) {
+      if ((/* @__PURE__ */ new Date()).getTime() - a > 10) return;
+      o.emit("slideFocusStart"), t.scrollLeft = 0;
+      const S = e.findIndex((E) => E.includes(g));
+      Pt(S) && (s.useDuration(0), i.index(S, 0), o.emit("slideFocus"));
+    }
+    r.add(document, "keydown", f, !1), n.forEach((g, h) => {
+      r.add(g, "focus", (u) => {
+        (xt(l) || l(v, u)) && d(h);
+      }, c);
+    });
+  }
+  function f(v) {
+    v.code === "Tab" && (a = (/* @__PURE__ */ new Date()).getTime());
+  }
+  return {
+    init: y
+  };
+}
+function dt(t) {
+  let n = t;
+  function e() {
+    return n;
+  }
+  function i(c) {
+    n = o(c);
+  }
+  function s(c) {
+    n += o(c);
+  }
+  function r(c) {
+    n -= o(c);
+  }
+  function o(c) {
+    return Pt(c) ? c : c.get();
+  }
+  return {
+    get: e,
+    set: i,
+    add: s,
+    subtract: r
+  };
+}
+function Zt(t, n) {
+  const e = t.scroll === "x" ? o : l, i = n.style;
+  let s = null, r = !1;
+  function o(p) {
+    return `translate3d(${p}px,0px,0px)`;
+  }
+  function l(p) {
+    return `translate3d(0px,${p}px,0px)`;
+  }
+  function c(p) {
+    if (r) return;
+    const v = bn(t.direction(p));
+    v !== s && (i.transform = e(v), s = v);
+  }
+  function a(p) {
+    r = !p;
+  }
+  function y() {
+    r || (i.transform = "", n.getAttribute("style") || n.removeAttribute("style"));
+  }
+  return {
+    clear: y,
+    to: c,
+    toggleActive: a
+  };
+}
+function zn(t, n, e, i, s, r, o, l, c) {
+  const y = gt(s), f = gt(s).reverse(), p = u().concat(S());
+  function v(w, T) {
+    return w.reduce((m, D) => m - s[D], T);
+  }
+  function d(w, T) {
+    return w.reduce((m, D) => v(m, T) > 0 ? m.concat([D]) : m, []);
+  }
+  function g(w) {
+    return r.map((T, m) => ({
+      start: T - i[m] + 0.5 + w,
+      end: T + n - 0.5 + w
+    }));
+  }
+  function h(w, T, m) {
+    const D = g(T);
+    return w.map((C) => {
+      const U = m ? 0 : -e, Y = m ? e : 0, b = m ? "end" : "start", I = D[C][b];
+      return {
+        index: C,
+        loopPoint: I,
+        slideLocation: dt(-1),
+        translate: Zt(t, c[C]),
+        target: () => l.get() > I ? U : Y
+      };
+    });
+  }
+  function u() {
+    const w = o[0], T = d(f, w);
+    return h(T, e, !1);
+  }
+  function S() {
+    const w = n - o[0] - 1, T = d(y, w);
+    return h(T, -e, !0);
+  }
+  function E() {
+    return p.every(({
+      index: w
+    }) => {
+      const T = y.filter((m) => m !== w);
+      return v(T, n) <= 0.1;
+    });
+  }
+  function P() {
+    p.forEach((w) => {
+      const {
+        target: T,
+        translate: m,
+        slideLocation: D
+      } = w, C = T();
+      C !== D.get() && (m.to(C), D.set(C));
+    });
+  }
+  function F() {
+    p.forEach((w) => w.translate.clear());
+  }
+  return {
+    canLoop: E,
+    clear: F,
+    loop: P,
+    loopPoints: p
+  };
+}
+function Un(t, n, e) {
+  let i, s = !1;
+  function r(c) {
+    if (!e) return;
+    function a(y) {
+      for (const f of y)
+        if (f.type === "childList") {
+          c.reInit(), n.emit("slidesChanged");
+          break;
+        }
+    }
+    i = new MutationObserver((y) => {
+      s || (xt(e) || e(c, y)) && a(y);
+    }), i.observe(t, {
+      childList: !0
+    });
+  }
+  function o() {
+    i && i.disconnect(), s = !0;
+  }
+  return {
+    init: r,
+    destroy: o
+  };
+}
+function $n(t, n, e, i) {
+  const s = {};
+  let r = null, o = null, l, c = !1;
+  function a() {
+    l = new IntersectionObserver((d) => {
+      c || (d.forEach((g) => {
+        const h = n.indexOf(g.target);
+        s[h] = g;
+      }), r = null, o = null, e.emit("slidesInView"));
+    }, {
+      root: t.parentElement,
+      threshold: i
+    }), n.forEach((d) => l.observe(d));
+  }
+  function y() {
+    l && l.disconnect(), c = !0;
+  }
+  function f(d) {
+    return mt(s).reduce((g, h) => {
+      const u = parseInt(h), {
+        isIntersecting: S
+      } = s[u];
+      return (d && S || !d && !S) && g.push(u), g;
+    }, []);
+  }
+  function p(d = !0) {
+    if (d && r) return r;
+    if (!d && o) return o;
+    const g = f(d);
+    return d && (r = g), d || (o = g), g;
+  }
+  return {
+    init: a,
+    destroy: y,
+    get: p
+  };
+}
+function Hn(t, n, e, i, s, r) {
+  const {
+    measureSize: o,
+    startEdge: l,
+    endEdge: c
+  } = t, a = e[0] && s, y = d(), f = g(), p = e.map(o), v = h();
+  function d() {
+    if (!a) return 0;
+    const S = e[0];
+    return q(n[l] - S[l]);
+  }
+  function g() {
+    if (!a) return 0;
+    const S = r.getComputedStyle(st(i));
+    return parseFloat(S.getPropertyValue(`margin-${c}`));
+  }
+  function h() {
+    return e.map((S, E, P) => {
+      const F = !E, L = At(P, E);
+      return F ? p[E] + y : L ? p[E] + f : P[E + 1][l] - S[l];
+    }).map(q);
+  }
+  return {
+    slideSizes: p,
+    slideSizesWithGaps: v,
+    startGap: y,
+    endGap: f
+  };
+}
+function Vn(t, n, e, i, s, r, o, l, c) {
+  const {
+    startEdge: a,
+    endEdge: y,
+    direction: f
+  } = t, p = Pt(e);
+  function v(u, S) {
+    return gt(u).filter((E) => E % S === 0).map((E) => u.slice(E, E + S));
+  }
+  function d(u) {
+    return u.length ? gt(u).reduce((S, E, P) => {
+      const F = st(S) || 0, L = F === 0, w = E === yt(u), T = s[a] - r[F][a], m = s[a] - r[E][y], D = !i && L ? f(o) : 0, C = !i && w ? f(l) : 0, U = q(m - C - (T + D));
+      return P && U > n + c && S.push(E), w && S.push(u.length), S;
+    }, []).map((S, E, P) => {
+      const F = Math.max(P[E - 1] || 0);
+      return u.slice(F, S);
+    }) : [];
+  }
+  function g(u) {
+    return p ? v(u, e) : d(u);
+  }
+  return {
+    groupSlides: g
+  };
+}
+function _n(t, n, e, i, s, r, o) {
+  const {
+    align: l,
+    axis: c,
+    direction: a,
+    startIndex: y,
+    loop: f,
+    duration: p,
+    dragFree: v,
+    dragThreshold: d,
+    inViewThreshold: g,
+    slidesToScroll: h,
+    skipSnaps: u,
+    containScroll: S,
+    watchResize: E,
+    watchSlides: P,
+    watchDrag: F,
+    watchFocus: L
+  } = r, w = 2, T = wn(), m = T.measure(n), D = e.map(T.measure), C = En(c, a), U = C.measureSize(m), Y = Dn(U), b = xn(l, U), I = !f && !!S, O = f || !!S, {
+    slideSizes: M,
+    slideSizesWithGaps: A,
+    startGap: k,
+    endGap: N
+  } = Hn(C, m, D, e, O, s), j = Vn(C, U, h, f, m, D, k, N, w), {
+    snaps: R,
+    snapsAligned: z
+  } = kn(C, b, m, D, j), H = -st(R) + st(A), {
+    snapsContained: nt,
+    scrollContainLimit: rt
+  } = Mn(U, H, z, S, w), Q = I ? nt : z, {
+    limit: K
+  } = An(H, Q, f), tt = Jt(yt(Q), y, f), J = tt.clone(), $ = gt(e), x = ({
+    dragHandler: at,
+    scrollBody: Et,
+    scrollBounds: Ot,
+    options: {
+      loop: St
+    }
+  }) => {
+    St || Ot.constrain(at.pointerDown()), Et.seek();
+  }, B = ({
+    scrollBody: at,
+    translate: Et,
+    location: Ot,
+    offsetLocation: St,
+    previousLocation: en,
+    scrollLooper: on,
+    slideLooper: sn,
+    dragHandler: rn,
+    animation: cn,
+    eventHandler: Rt,
+    scrollBounds: ln,
+    options: {
+      loop: zt
+    }
+  }, Ut) => {
+    const $t = at.settled(), an = !ln.shouldConstrain(), Ht = zt ? $t : $t && an, Vt = Ht && !rn.pointerDown();
+    Vt && cn.stop();
+    const un = Ot.get() * Ut + en.get() * (1 - Ut);
+    St.set(un), zt && (on.loop(at.direction()), sn.loop()), Et.to(St.get()), Vt && Rt.emit("settle"), Ht || Rt.emit("scroll");
+  }, X = vn(i, s, () => x(vt), (at) => B(vt, at)), Z = 0.68, et = Q[tt.get()], ot = dt(et), V = dt(et), G = dt(et), it = dt(et), ct = Tn(ot, G, V, it, p, Z), ut = Bn(f, Q, H, K, it), ft = jn(X, tt, J, ct, ut, it, o), Nt = Fn(K), Bt = ht(), tn = $n(n, e, o, g), {
+    slideRegistry: jt
+  } = Nn(I, S, Q, rt, j, $), nn = Rn(t, e, jt, ft, ct, Bt, o, L), vt = {
+    ownerDocument: i,
+    ownerWindow: s,
+    eventHandler: o,
+    containerRect: m,
+    slideRects: D,
+    animation: X,
+    axis: C,
+    dragHandler: On(C, t, i, s, it, In(C, s), ot, X, ft, ct, ut, tt, o, Y, v, d, u, Z, F),
+    eventStore: Bt,
+    percentOfView: Y,
+    index: tt,
+    indexPrevious: J,
+    limit: K,
+    location: ot,
+    offsetLocation: G,
+    previousLocation: V,
+    options: r,
+    resizeHandler: Ln(n, o, s, e, C, E, T),
+    scrollBody: ct,
+    scrollBounds: Pn(K, G, it, ct, Y),
+    scrollLooper: Cn(H, K, G, [ot, G, V, it]),
+    scrollProgress: Nt,
+    scrollSnapList: Q.map(Nt.get),
+    scrollSnaps: Q,
+    scrollTarget: ut,
+    scrollTo: ft,
+    slideLooper: zn(C, U, H, M, A, R, Q, G, e),
+    slideFocus: nn,
+    slidesHandler: Un(n, o, P),
+    slidesInView: tn,
+    slideIndexes: $,
+    slideRegistry: jt,
+    slidesToScroll: j,
+    target: it,
+    translate: Zt(C, n)
+  };
+  return vt;
+}
+function qn() {
+  let t = {}, n;
+  function e(a) {
+    n = a;
+  }
+  function i(a) {
+    return t[a] || [];
+  }
+  function s(a) {
+    return i(a).forEach((y) => y(n, a)), c;
+  }
+  function r(a, y) {
+    return t[a] = i(a).concat([y]), c;
+  }
+  function o(a, y) {
+    return t[a] = i(a).filter((f) => f !== y), c;
+  }
+  function l() {
+    t = {};
+  }
+  const c = {
+    init: e,
+    emit: s,
+    off: o,
+    on: r,
+    clear: l
+  };
+  return c;
+}
+const Gn = {
+  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 Yn(t) {
+  function n(r, o) {
+    return Qt(r, o || {});
+  }
+  function e(r) {
+    const o = r.breakpoints || {}, l = mt(o).filter((c) => t.matchMedia(c).matches).map((c) => o[c]).reduce((c, a) => n(c, a), {});
+    return n(r, l);
+  }
+  function i(r) {
+    return r.map((o) => mt(o.breakpoints || {})).reduce((o, l) => o.concat(l), []).map(t.matchMedia);
+  }
+  return {
+    mergeOptions: n,
+    optionsAtMedia: e,
+    optionsMediaQueries: i
+  };
+}
+function Kn(t) {
+  let n = [];
+  function e(r, o) {
+    return n = o.filter(({
+      options: l
+    }) => t.optionsAtMedia(l).active !== !1), n.forEach((l) => l.init(r, t)), o.reduce((l, c) => Object.assign(l, {
+      [c.name]: c
+    }), {});
+  }
+  function i() {
+    n = n.filter((r) => r.destroy());
+  }
+  return {
+    init: e,
+    destroy: i
+  };
+}
+function bt(t, n, e) {
+  const i = t.ownerDocument, s = i.defaultView, r = Yn(s), o = Kn(r), l = ht(), c = qn(), {
+    mergeOptions: a,
+    optionsAtMedia: y,
+    optionsMediaQueries: f
+  } = r, {
+    on: p,
+    off: v,
+    emit: d
+  } = c, g = C;
+  let h = !1, u, S = a(Gn, bt.globalOptions), E = a(S), P = [], F, L, w;
+  function T() {
+    const {
+      container: $,
+      slides: x
+    } = E;
+    L = (Dt($) ? t.querySelector($) : $) || t.children[0];
+    const X = Dt(x) ? L.querySelectorAll(x) : x;
+    w = [].slice.call(X || L.children);
+  }
+  function m($) {
+    const x = _n(t, L, w, i, s, $, c);
+    if ($.loop && !x.slideLooper.canLoop()) {
+      const B = Object.assign({}, $, {
+        loop: !1
+      });
+      return m(B);
+    }
+    return x;
+  }
+  function D($, x) {
+    h || (S = a(S, $), E = y(S), P = x || P, T(), u = m(E), f([S, ...P.map(({
+      options: B
+    }) => B)]).forEach((B) => l.add(B, "change", C)), E.active && (u.translate.to(u.location.get()), u.animation.init(), u.slidesInView.init(), u.slideFocus.init(J), u.eventHandler.init(J), u.resizeHandler.init(J), u.slidesHandler.init(J), u.options.loop && u.slideLooper.loop(), L.offsetParent && w.length && u.dragHandler.init(J), F = o.init(J, P)));
+  }
+  function C($, x) {
+    const B = j();
+    U(), D(a({
+      startIndex: B
+    }, $), x), c.emit("reInit");
+  }
+  function U() {
+    u.dragHandler.destroy(), u.eventStore.clear(), u.translate.clear(), u.slideLooper.clear(), u.resizeHandler.destroy(), u.slidesHandler.destroy(), u.slidesInView.destroy(), u.animation.destroy(), o.destroy(), l.clear();
+  }
+  function Y() {
+    h || (h = !0, l.clear(), U(), c.emit("destroy"), c.clear());
+  }
+  function b($, x, B) {
+    !E.active || h || (u.scrollBody.useBaseFriction().useDuration(x === !0 ? 0 : E.duration), u.scrollTo.index($, B || 0));
+  }
+  function I($) {
+    const x = u.index.add(1).get();
+    b(x, $, -1);
+  }
+  function O($) {
+    const x = u.index.add(-1).get();
+    b(x, $, 1);
+  }
+  function M() {
+    return u.index.add(1).get() !== j();
+  }
+  function A() {
+    return u.index.add(-1).get() !== j();
+  }
+  function k() {
+    return u.scrollSnapList;
+  }
+  function N() {
+    return u.scrollProgress.get(u.offsetLocation.get());
+  }
+  function j() {
+    return u.index.get();
+  }
+  function R() {
+    return u.indexPrevious.get();
+  }
+  function z() {
+    return u.slidesInView.get();
+  }
+  function H() {
+    return u.slidesInView.get(!1);
+  }
+  function nt() {
+    return F;
+  }
+  function rt() {
+    return u;
+  }
+  function Q() {
+    return t;
+  }
+  function K() {
+    return L;
+  }
+  function tt() {
+    return w;
+  }
+  const J = {
+    canScrollNext: M,
+    canScrollPrev: A,
+    containerNode: K,
+    internalEngine: rt,
+    destroy: Y,
+    off: v,
+    on: p,
+    emit: d,
+    plugins: nt,
+    previousScrollSnap: R,
+    reInit: g,
+    rootNode: Q,
+    scrollNext: I,
+    scrollPrev: O,
+    scrollProgress: N,
+    scrollSnapList: k,
+    scrollTo: b,
+    selectedScrollSnap: j,
+    slideNodes: tt,
+    slidesInView: z,
+    slidesNotInView: H
+  };
+  return D(n, e), setTimeout(() => c.emit("init"), 0), J;
+}
+bt.globalOptions = void 0;
+function Ct(t = {}, n = []) {
+  const e = _.useRef(t), i = _.useRef(n), [s, r] = _.useState(), [o, l] = _.useState(), c = _.useCallback(() => {
+    s && s.reInit(e.current, i.current);
+  }, [s]);
+  return _.useEffect(() => {
+    Tt(e.current, t) || (e.current = t, c());
+  }, [t, c]), _.useEffect(() => {
+    yn(i.current, n) || (i.current = n, c());
+  }, [n, c]), _.useEffect(() => {
+    if (hn() && o) {
+      bt.globalOptions = Ct.globalOptions;
+      const a = bt(o, e.current, i.current);
+      return r(a), () => a.destroy();
+    } else
+      r(void 0);
+  }, [o, r]), [l, s];
+}
+Ct.globalOptions = void 0;
+const Xn = {
+  active: !0,
+  breakpoints: {},
+  delay: 4e3,
+  jump: !1,
+  playOnInit: !0,
+  stopOnFocusIn: !0,
+  stopOnInteraction: !0,
+  stopOnMouseEnter: !1,
+  stopOnLastSnap: !1,
+  rootNode: null
+};
+function Qn(t, n) {
+  const e = t.scrollSnapList();
+  return typeof n == "number" ? e.map(() => n) : n(e, t);
+}
+function Jn(t, n) {
+  const e = t.rootNode();
+  return n && n(e) || e;
+}
+function Ft(t = {}) {
+  let n, e, i, s, r = null, o = 0, l = !1, c = !1, a = !1, y = !1;
+  function f(b, I) {
+    e = b;
+    const {
+      mergeOptions: O,
+      optionsAtMedia: M
+    } = I, A = O(Xn, Ft.globalOptions), k = O(A, t);
+    if (n = M(k), e.scrollSnapList().length <= 1) return;
+    y = n.jump, i = !1, s = Qn(e, n.delay);
+    const {
+      eventStore: N,
+      ownerDocument: j
+    } = e.internalEngine(), R = !!e.internalEngine().options.watchDrag, z = Jn(e, n.rootNode);
+    N.add(j, "visibilitychange", u), R && e.on("pointerDown", E), R && !n.stopOnInteraction && e.on("pointerUp", P), n.stopOnMouseEnter && N.add(z, "mouseenter", F), n.stopOnMouseEnter && !n.stopOnInteraction && N.add(z, "mouseleave", L), n.stopOnFocusIn && e.on("slideFocusStart", h), n.stopOnFocusIn && !n.stopOnInteraction && N.add(e.containerNode(), "focusout", g), n.playOnInit && g();
+  }
+  function p() {
+    e.off("pointerDown", E).off("pointerUp", P).off("slideFocusStart", h), h(), i = !0, l = !1;
+  }
+  function v() {
+    const {
+      ownerWindow: b
+    } = e.internalEngine();
+    b.clearTimeout(o), o = b.setTimeout(C, s[e.selectedScrollSnap()]), r = (/* @__PURE__ */ new Date()).getTime(), e.emit("autoplay:timerset");
+  }
+  function d() {
+    const {
+      ownerWindow: b
+    } = e.internalEngine();
+    b.clearTimeout(o), o = 0, r = null, e.emit("autoplay:timerstopped");
+  }
+  function g() {
+    if (!i) {
+      if (S()) {
+        a = !0;
+        return;
+      }
+      l || e.emit("autoplay:play"), v(), l = !0;
+    }
+  }
+  function h() {
+    i || (l && e.emit("autoplay:stop"), d(), l = !1);
+  }
+  function u() {
+    if (S())
+      return a = l, h();
+    a && g();
+  }
+  function S() {
+    const {
+      ownerDocument: b
+    } = e.internalEngine();
+    return b.visibilityState === "hidden";
+  }
+  function E() {
+    c || h();
+  }
+  function P() {
+    c || g();
+  }
+  function F() {
+    c = !0, h();
+  }
+  function L() {
+    c = !1, g();
+  }
+  function w(b) {
+    typeof b < "u" && (y = b), g();
+  }
+  function T() {
+    l && h();
+  }
+  function m() {
+    l && g();
+  }
+  function D() {
+    return l;
+  }
+  function C() {
+    const {
+      index: b
+    } = e.internalEngine(), I = b.clone().add(1).get(), O = e.scrollSnapList().length - 1, M = n.stopOnLastSnap && I === O;
+    if (e.canScrollNext() ? e.scrollNext(y) : e.scrollTo(0, y), e.emit("autoplay:select"), M) return h();
+    g();
+  }
+  function U() {
+    if (!r) return null;
+    const b = s[e.selectedScrollSnap()], I = (/* @__PURE__ */ new Date()).getTime() - r;
+    return b - I;
+  }
+  return {
+    name: "autoplay",
+    options: t,
+    init: f,
+    destroy: p,
+    play: w,
+    stop: T,
+    reset: m,
+    isPlaying: D,
+    timeUntilNext: U
+  };
+}
+Ft.globalOptions = void 0;
+const Zn = {
+  direction: "forward",
+  speed: 2,
+  startDelay: 1e3,
+  active: !0,
+  breakpoints: {},
+  playOnInit: !0,
+  stopOnFocusIn: !0,
+  stopOnInteraction: !0,
+  stopOnMouseEnter: !1,
+  rootNode: null
+};
+function Wn(t, n) {
+  const e = t.rootNode();
+  return n && n(e) || e;
+}
+function kt(t = {}) {
+  let n, e, i, s, r = 0, o = !1, l = !1, c;
+  function a(m, D) {
+    e = m;
+    const {
+      mergeOptions: C,
+      optionsAtMedia: U
+    } = D, Y = C(Zn, kt.globalOptions), b = C(Y, t);
+    if (n = U(b), e.scrollSnapList().length <= 1) return;
+    s = n.startDelay, i = !1, c = e.internalEngine().scrollBody;
+    const {
+      eventStore: I
+    } = e.internalEngine(), O = !!e.internalEngine().options.watchDrag, M = Wn(e, n.rootNode);
+    O && e.on("pointerDown", d), O && !n.stopOnInteraction && e.on("pointerUp", g), n.stopOnMouseEnter && I.add(M, "mouseenter", h), n.stopOnMouseEnter && !n.stopOnInteraction && I.add(M, "mouseleave", u), n.stopOnFocusIn && e.on("slideFocusStart", p), n.stopOnFocusIn && !n.stopOnInteraction && I.add(e.containerNode(), "focusout", f), n.playOnInit && f();
+  }
+  function y() {
+    e.off("pointerDown", d).off("pointerUp", g).off("slideFocusStart", p).off("settle", S), p(), i = !0, o = !1;
+  }
+  function f() {
+    if (i || o) return;
+    e.emit("autoScroll:play");
+    const m = e.internalEngine(), {
+      ownerWindow: D
+    } = m;
+    r = D.setTimeout(() => {
+      m.scrollBody = v(m), m.animation.start();
+    }, s), o = !0;
+  }
+  function p() {
+    if (i || !o) return;
+    e.emit("autoScroll:stop");
+    const m = e.internalEngine(), {
+      ownerWindow: D
+    } = m;
+    m.scrollBody = c, D.clearTimeout(r), r = 0, o = !1;
+  }
+  function v(m) {
+    const {
+      location: D,
+      previousLocation: C,
+      offsetLocation: U,
+      target: Y,
+      scrollTarget: b,
+      index: I,
+      indexPrevious: O,
+      limit: {
+        reachedMin: M,
+        reachedMax: A,
+        constrain: k
+      },
+      options: {
+        loop: N
+      }
+    } = m, j = n.direction === "forward" ? -1 : 1, R = () => tt;
+    let z = 0, H = 0, nt = D.get(), rt = 0, Q = !1;
+    function K() {
+      let J = 0;
+      C.set(D), z = j * n.speed, nt += z, D.add(z), Y.set(D), J = nt - rt, H = Math.sign(J), rt = nt;
+      const $ = b.byDistance(0, !1).index;
+      I.get() !== $ && (O.set(I.get()), I.set($), e.emit("select"));
+      const x = n.direction === "forward" ? M(U.get()) : A(U.get());
+      if (!N && x) {
+        Q = !0;
+        const B = k(D.get());
+        D.set(B), Y.set(D), p();
+      }
+      return tt;
+    }
+    const tt = {
+      direction: () => H,
+      duration: () => -1,
+      velocity: () => z,
+      settled: () => Q,
+      seek: K,
+      useBaseFriction: R,
+      useBaseDuration: R,
+      useFriction: R,
+      useDuration: R
+    };
+    return tt;
+  }
+  function d() {
+    l || p();
+  }
+  function g() {
+    l || E();
+  }
+  function h() {
+    l = !0, p();
+  }
+  function u() {
+    l = !1, f();
+  }
+  function S() {
+    e.off("settle", S), f();
+  }
+  function E() {
+    e.on("settle", S);
+  }
+  function P(m) {
+    typeof m < "u" && (s = m), f();
+  }
+  function F() {
+    o && p();
+  }
+  function L() {
+    o && (p(), E());
+  }
+  function w() {
+    return o;
+  }
+  return {
+    name: "autoScroll",
+    options: t,
+    init: a,
+    destroy: y,
+    play: P,
+    stop: F,
+    reset: L,
+    isPlaying: w
+  };
+}
+kt.globalOptions = void 0;
+function Kt(t, n, e) {
+  return Math.min(Math.max(t, n), e);
+}
+function wt(t) {
+  return typeof t == "number" && !isNaN(t);
+}
+function Wt(t = {}) {
+  let s, r = [], o, l = 0, c = 0, a = 0, y = !1, f, p;
+  function v(b) {
+    s = b;
+    const I = s.selectedScrollSnap(), {
+      scrollBody: O,
+      containerRect: M,
+      axis: A
+    } = s.internalEngine(), k = A.measureSize(M);
+    o = Kt(k * 0.75, 200, 500), y = !1, r = s.scrollSnapList().map((N, j) => j === I ? 1 : 0), f = O.settled, p = s.scrollProgress, O.settled = C, s.scrollProgress = U, s.on("select", S).on("slideFocus", g).on("pointerDown", u).on("pointerUp", h), P(), g();
+  }
+  function d() {
+    const {
+      scrollBody: b
+    } = s.internalEngine();
+    b.settled = f, s.scrollProgress = p, s.off("select", S).off("slideFocus", g).off("pointerDown", u).off("pointerUp", h), s.slideNodes().forEach((I) => {
+      const O = I.style;
+      O.opacity = "", O.transform = "", O.pointerEvents = "", I.getAttribute("style") || I.removeAttribute("style");
+    });
+  }
+  function g() {
+    const b = s.selectedScrollSnap();
+    L(b, 1);
+  }
+  function h() {
+    y = !1;
+  }
+  function u() {
+    y = !1, l = 0, c = 0;
+  }
+  function S() {
+    const b = s.internalEngine().scrollBody.duration();
+    c = b ? 0 : 1, y = !0, b || g();
+  }
+  function E(b) {
+    const {
+      axis: I
+    } = s.internalEngine();
+    return `translate${I.scroll.toUpperCase()}(${I.direction(b)}px)`;
+  }
+  function P() {
+    const {
+      translate: b,
+      slideLooper: I
+    } = s.internalEngine();
+    b.clear(), b.toggleActive(!1), I.loopPoints.forEach(({
+      translate: O
+    }) => {
+      O.clear(), O.toggleActive(!1);
+    });
+  }
+  function F(b) {
+    const {
+      scrollSnaps: I,
+      location: O,
+      target: M
+    } = s.internalEngine();
+    !wt(b) || r[b] < 0.5 || (O.set(I[b]), M.set(O));
+  }
+  function L(b, I) {
+    s.scrollSnapList().forEach((M, A) => {
+      const k = Math.abs(I), N = r[A], j = A === b, R = j ? N + k : N - k, z = Kt(R, 0, 1);
+      r[A] = z;
+      const H = j && y, nt = s.previousScrollSnap();
+      H && (r[nt] = 1 - z), j && T(b, z), w(A);
+    });
+  }
+  function w(b) {
+    const I = s.internalEngine().slideRegistry[b], {
+      scrollSnaps: O,
+      containerRect: M
+    } = s.internalEngine(), A = r[b];
+    I.forEach((k) => {
+      const N = s.slideNodes()[k].style, j = parseFloat(A.toFixed(2)), R = j > 0, z = R ? O[b] : M.width + 2, H = E(z);
+      R && (N.transform = H), N.opacity = j.toString(), N.pointerEvents = A > 0.5 ? "auto" : "none", R || (N.transform = H);
+    });
+  }
+  function T(b, I) {
+    const {
+      index: O,
+      dragHandler: M,
+      scrollSnaps: A
+    } = s.internalEngine(), k = M.pointerDown(), N = 1 / (A.length - 1);
+    let j = b, R = k ? s.selectedScrollSnap() : s.previousScrollSnap();
+    if (k && j === R) {
+      const nt = Math.sign(l) * -1;
+      j = R, R = O.clone().set(R).add(nt).get();
+    }
+    const z = R * N, H = (j - R) * N;
+    a = z + H * I;
+  }
+  function m() {
+    const {
+      dragHandler: b,
+      index: I,
+      scrollBody: O
+    } = s.internalEngine(), M = s.selectedScrollSnap();
+    if (!b.pointerDown()) return M;
+    const A = Math.sign(O.velocity()), k = Math.sign(l), N = I.clone().set(M).add(A * -1).get();
+    return !A || !k ? null : k === A ? N : M;
+  }
+  function D(b) {
+    const {
+      dragHandler: I,
+      scrollBody: O
+    } = b.internalEngine(), M = I.pointerDown(), A = O.velocity(), k = O.duration(), N = m(), j = !wt(N);
+    if (M) {
+      if (!A) return;
+      l += A, c = Math.abs(A / o), F(N);
+    }
+    if (!M) {
+      if (!k || j) return;
+      c += (1 - r[N]) / k, c *= 0.68;
+    }
+    j || L(N, c);
+  }
+  function C() {
+    const {
+      target: b,
+      location: I
+    } = s.internalEngine(), O = b.get() - I.get(), M = Math.abs(O) >= 1, A = m(), k = !wt(A);
+    return D(s), k || M ? !1 : r[A] > 0.999;
+  }
+  function U() {
+    return a;
+  }
+  return {
+    name: "fade",
+    options: t,
+    init: v,
+    destroy: d
+  };
+}
+Wt.globalOptions = void 0;
+function te(t, n, e) {
+  return e === "fade" ? 1 : t !== void 0 ? t : n ? null : 1;
+}
+function ne(t, n, e) {
+  return n === "fade" && e === 1 ? 0 : t;
+}
+function ee({
+  loop: t,
+  continuous: n,
+  visibleCount: e,
+  childCount: i
+}) {
+  if (!t || n || e == null || e <= 1 || i <= 0) return 1;
+  const s = Math.ceil(e) + 1;
+  return i >= s ? 1 : Math.ceil(s / i);
+}
+function oe(t, n) {
+  const [e, i] = _.useState(void 0);
+  return [_.useCallback(
+    (r) => {
+      if (!r || !t || n != null) return;
+      const o = r.firstElementChild;
+      o && o.offsetHeight > 0 ? i(o.offsetHeight) : requestAnimationFrame(() => {
+        const l = r.firstElementChild;
+        l && l.offsetHeight > 0 && i(l.offsetHeight);
+      });
+    },
+    [t, n]
+  ), n ?? e];
+}
+function ce({
+  visible: t,
+  gap: n = 0,
+  height: e,
+  direction: i = "left",
+  loop: s = !0,
+  autoAdvance: r = 0,
+  continuous: o = !1,
+  speed: l = 2,
+  effect: c = "slide",
+  dimInactive: a = !1,
+  showControls: y = !0,
+  controlsPosition: f = "outside",
+  showDots: p = !1,
+  pauseOnHover: v = !0,
+  align: d = "start",
+  slidesToScroll: g = 1,
+  drag: h = !0,
+  className: u,
+  cssClass: S,
+  children: E
+}) {
+  const P = i === "up" || i === "down", F = te(t, o, c), L = _.Children.toArray(E).filter(
+    (O) => O != null && O !== ""
+  ), [w, T] = oe(P, e), m = !P || T != null, D = F != null && F > 0 ? F : null, C = ne(n, c, D), U = C > 0 ? C / 2 : 0, Y = D != null ? P && T != null ? `${T / D}px` : `${100 / D}%` : void 0;
+  let b = L;
+  if (s && o)
+    b = [
+      ...L,
+      ...L.map(
+        (O, M) => It.cloneElement(O, { key: `dup1-${M}` })
+      ),
+      ...L.map(
+        (O, M) => It.cloneElement(O, { key: `dup2-${M}` })
+      )
+    ];
+  else if (s && D != null && D > 1 && L.length > 0) {
+    const O = ee({
+      loop: s,
+      continuous: o,
+      visibleCount: D,
+      childCount: L.length
+    });
+    O > 1 && (b = Array.from(
+      { length: O },
+      (M, A) => L.map(
+        (k, N) => It.cloneElement(k, {
+          key: `loopdup-${A}-${N}`
+        })
+      )
+    ).flat());
+  }
+  const I = L.length;
+  return m ? /* @__PURE__ */ W.jsx(
+    se,
+    {
+      isVertical: P,
+      effectiveHeight: T,
+      validChildren: b,
+      realSlideCount: I,
+      slideBasis: Y,
+      halfGap: U,
+      loop: s,
+      align: d,
+      slidesToScroll: g,
+      continuous: o,
+      drag: h,
+      effect: c,
+      autoAdvance: r,
+      speed: l,
+      direction: i,
+      pauseOnHover: v,
+      dimInactive: a,
+      showControls: y,
+      controlsPosition: f,
+      showDots: p,
+      className: u,
+      cssClass: S
+    }
+  ) : /* @__PURE__ */ W.jsx(
+    "div",
+    {
+      ref: w,
+      className: Xt(u, S),
+      style: { overflow: "hidden", height: 0, position: "relative" },
+      children: L[0]
+    }
+  );
+}
+function se({
+  isVertical: t,
+  effectiveHeight: n,
+  validChildren: e,
+  realSlideCount: i,
+  slideBasis: s,
+  halfGap: r,
+  loop: o,
+  align: l,
+  slidesToScroll: c,
+  continuous: a,
+  drag: y,
+  effect: f,
+  autoAdvance: p,
+  speed: v,
+  direction: d,
+  pauseOnHover: g,
+  dimInactive: h,
+  showControls: u,
+  controlsPosition: S,
+  showDots: E,
+  className: P,
+  cssClass: F
+}) {
+  const L = {
+    axis: t ? "y" : "x",
+    loop: o,
+    align: l,
+    slidesToScroll: c,
+    dragFree: a,
+    watchDrag: y
+  }, w = [];
+  f === "fade" && w.push(Wt()), a ? w.push(
+    kt({
+      speed: v,
+      direction: d === "right" || d === "down" ? "backward" : "forward",
+      playOnInit: !0,
+      stopOnMouseEnter: g,
+      stopOnInteraction: !1
+    })
+  ) : p > 0 && w.push(
+    Ft({
+      delay: p,
+      playOnInit: !0,
+      stopOnMouseEnter: g,
+      stopOnInteraction: !1
+    })
+  );
+  const [T, m] = Ct(L, w);
+  _.useEffect(() => {
+    if (!m) return;
+    const V = window;
+    V.__emblaDebug || (V.__emblaDebug = []), V.__emblaDebug.push(m), console.log(
+      "[Carousel] init axis=" + (t ? "y" : "x") + " snaps=" + m.scrollSnapList().length + " canNext=" + m.canScrollNext() + " canPrev=" + m.canScrollPrev() + " slides=" + m.slideNodes().length
+    );
+  }, [m]);
+  const [D, C] = _.useState(!1), [U, Y] = _.useState(!1), [b, I] = _.useState(0), [O, M] = _.useState(0), [A, k] = _.useState([]), N = _.useCallback(() => m == null ? void 0 : m.scrollPrev(), [m]), j = _.useCallback(() => m == null ? void 0 : m.scrollNext(), [m]), R = _.useCallback(
+    (V) => m == null ? void 0 : m.scrollTo(V),
+    [m]
+  ), z = _.useCallback(() => {
+    if (!m) return;
+    C(m.canScrollPrev()), Y(m.canScrollNext());
+    const V = m.selectedScrollSnap();
+    I(i > 0 ? V % i : V);
+  }, [m, i]), H = _.useCallback((V) => {
+    const G = V.scrollProgress(), ct = V.scrollSnapList().map((ut) => {
+      const ft = Math.abs(G - ut);
+      return Math.max(0.3, 1 - ft * 2);
+    });
+    k(ct);
+  }, []);
+  _.useEffect(() => {
+    if (m)
+      return M(i), z(), m.on("select", z), m.on("reInit", z), h && (H(m), m.on("scroll", H), m.on("reInit", H)), () => {
+        m.off("select", z), m.off("reInit", z), h && (m.off("scroll", H), m.off("reInit", H));
+      };
+  }, [m, z, h, H, i]);
+  const nt = t ? fn : dn, rt = t ? pn : gn, Q = u && !a, K = S === "outside", tt = E && O > 1, J = tt && t, $ = tt && !t, x = 32, B = x + 8, Z = {
+    position: "relative",
+    ...Q && K ? t ? { paddingTop: B, paddingBottom: B } : { paddingLeft: B, paddingRight: B } : {},
+    ...J ? { paddingRight: 20 } : {}
+  }, et = K ? t ? { top: 0, left: "50%", transform: "translateX(-50%)" } : { left: 0, top: "50%", transform: "translateY(-50%)" } : t ? { top: 8, right: 8 } : { left: 8, top: "50%", transform: "translateY(-50%)" }, ot = K ? t ? { bottom: 0, left: "50%", transform: "translateX(-50%)" } : { right: 0, top: "50%", transform: "translateY(-50%)" } : t ? { bottom: 8, right: 8 } : { right: 8, top: "50%", transform: "translateY(-50%)" };
+  return /* @__PURE__ */ W.jsxs("div", { className: Xt(P, F), style: { position: "relative" }, children: [
+    /* @__PURE__ */ W.jsxs("div", { style: Z, children: [
+      /* @__PURE__ */ W.jsx(
+        "div",
+        {
+          ref: T,
+          style: {
+            overflow: "hidden",
+            // For vertical: set height on the viewport so Embla knows the
+            // visible area. This was measured before this component mounted.
+            ...t && n != null ? { height: n } : {}
+          },
+          children: /* @__PURE__ */ W.jsx(
+            "div",
+            {
+              style: {
+                display: "flex",
+                flexDirection: t ? "column" : "row",
+                // For vertical carousels, Embla measures the container rect for
+                // view size. Keep container height fixed to the viewport height.
+                ...t && n != null ? { height: n } : {},
+                touchAction: t ? "pan-x pinch-zoom" : "pan-y pinch-zoom",
+                ...r > 0 ? t ? { marginTop: -r, marginBottom: -r } : { marginLeft: -r, marginRight: -r } : {},
+                ...f === "fade" ? { position: "relative" } : {}
+              },
+              children: e.map((V, G) => /* @__PURE__ */ W.jsx(
+                "div",
+                {
+                  role: "group",
+                  "aria-roledescription": "slide",
+                  style: {
+                    flexShrink: 0,
+                    flexGrow: 0,
+                    ...t ? { minHeight: 0 } : { minWidth: 0 },
+                    ...s != null ? { flexBasis: s } : {},
+                    ...r > 0 ? t ? { paddingTop: r, paddingBottom: r } : { paddingLeft: r, paddingRight: r } : {},
+                    ...h && A[G] != null ? {
+                      opacity: A[G],
+                      transition: "opacity 300ms ease"
+                    } : {}
+                  },
+                  children: V
+                },
+                G
+              ))
+            }
+          )
+        }
+      ),
+      Q && /* @__PURE__ */ W.jsxs(W.Fragment, { children: [
+        /* @__PURE__ */ W.jsx(
+          "button",
+          {
+            onClick: N,
+            disabled: !o && !D,
+            style: {
+              position: "absolute",
+              zIndex: 10,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              width: x,
+              height: x,
+              borderRadius: "50%",
+              border: "1px solid var(--border, #e5e7eb)",
+              background: "var(--background, #fff)",
+              boxShadow: "0 1px 3px rgba(0,0,0,.1)",
+              cursor: "pointer",
+              opacity: !o && !D ? 0 : 1,
+              transition: "opacity 150ms",
+              ...et
+            },
+            children: /* @__PURE__ */ W.jsx(nt, { style: { width: 16, height: 16 } })
+          }
+        ),
+        /* @__PURE__ */ W.jsx(
+          "button",
+          {
+            onClick: j,
+            disabled: !o && !U,
+            style: {
+              position: "absolute",
+              zIndex: 10,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              width: x,
+              height: x,
+              borderRadius: "50%",
+              border: "1px solid var(--border, #e5e7eb)",
+              background: "var(--background, #fff)",
+              boxShadow: "0 1px 3px rgba(0,0,0,.1)",
+              cursor: "pointer",
+              opacity: !o && !U ? 0 : 1,
+              transition: "opacity 150ms",
+              ...ot
+            },
+            children: /* @__PURE__ */ W.jsx(rt, { style: { width: 16, height: 16 } })
+          }
+        )
+      ] }),
+      J && /* @__PURE__ */ W.jsx(
+        "div",
+        {
+          style: {
+            position: "absolute",
+            top: "50%",
+            right: 0,
+            transform: "translateY(-50%)",
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            gap: 6
+          },
+          children: Array.from({ length: O }, (V, G) => /* @__PURE__ */ W.jsx(
+            "button",
+            {
+              onClick: () => R(G),
+              style: {
+                width: 8,
+                height: 8,
+                borderRadius: "50%",
+                border: "none",
+                cursor: "pointer",
+                transition: "opacity 150ms",
+                background: "var(--foreground, #000)",
+                opacity: G === b ? 1 : 0.2
+              }
+            },
+            G
+          ))
+        }
+      )
+    ] }),
+    $ && /* @__PURE__ */ W.jsx(
+      "div",
+      {
+        style: {
+          display: "flex",
+          justifyContent: "center",
+          gap: 6,
+          marginTop: 12
+        },
+        children: Array.from({ length: O }, (V, G) => /* @__PURE__ */ W.jsx(
+          "button",
+          {
+            onClick: () => R(G),
+            style: {
+              width: 8,
+              height: 8,
+              borderRadius: "50%",
+              border: "none",
+              cursor: "pointer",
+              transition: "opacity 150ms",
+              background: "var(--foreground, #000)",
+              opacity: G === b ? 1 : 0.2
+            }
+          },
+          G
+        ))
+      }
+    )
+  ] });
+}
+export {
+  ce as PrefabCarousel
+};