@g4rcez/components 3.0.0 → 3.0.2

package/dist/index-BtlhELJ3.js

@@ -0,0 +1,3416 @@
+import { jsx as A, jsxs as Ke, Fragment as an } from "react/jsx-runtime";
+import H, { createElement as je } from "react";
+import cn from "react-dom";
+const Ct = 0, De = 1, Qe = 2, ko = 4;
+function uo(e) {
+  return () => e;
+}
+function dn(e) {
+  e();
+}
+function it(e, t) {
+  return (o) => e(t(o));
+}
+function ao(e, t) {
+  return () => e(t);
+}
+function fn(e, t) {
+  return (o) => e(t, o);
+}
+function Lt(e) {
+  return e !== void 0;
+}
+function hn(...e) {
+  return () => {
+    e.map(dn);
+  };
+}
+function et() {
+}
+function zt(e, t) {
+  return t(e), e;
+}
+function mn(e, t) {
+  return t(e);
+}
+function oe(...e) {
+  return e;
+}
+function q(e, t) {
+  return e(De, t);
+}
+function N(e, t) {
+  e(Ct, t);
+}
+function Dt(e) {
+  e(Qe);
+}
+function ie(e) {
+  return e(ko);
+}
+function k(e, t) {
+  return q(e, fn(t, Ct));
+}
+function He(e, t) {
+  const o = e(De, (n) => {
+    o(), t(n);
+  });
+  return o;
+}
+function co(e) {
+  let t, o;
+  return (n) => (r) => {
+    t = r, o && clearTimeout(o), o = setTimeout(() => {
+      n(t);
+    }, e);
+  };
+}
+function Oo(e, t) {
+  return e === t;
+}
+function ee(e = Oo) {
+  let t;
+  return (o) => (n) => {
+    e(t, n) || (t = n, o(n));
+  };
+}
+function M(e) {
+  return (t) => (o) => {
+    e(o) && t(o);
+  };
+}
+function B(e) {
+  return (t) => it(t, e);
+}
+function Fe(e) {
+  return (t) => () => {
+    t(e);
+  };
+}
+function v(e, ...t) {
+  const o = gn(...t);
+  return ((n, r) => {
+    switch (n) {
+      case Qe:
+        Dt(e);
+        return;
+      case De:
+        return q(e, o(r));
+    }
+  });
+}
+function We(e, t) {
+  return (o) => (n) => {
+    o(t = e(t, n));
+  };
+}
+function $e(e) {
+  return (t) => (o) => {
+    e > 0 ? e-- : t(o);
+  };
+}
+function Ae(e) {
+  let t = null, o;
+  return (n) => (r) => {
+    t = r, !o && (o = setTimeout(() => {
+      o = void 0, n(t);
+    }, e));
+  };
+}
+function _(...e) {
+  const t = new Array(e.length);
+  let o = 0, n = null;
+  const r = Math.pow(2, e.length) - 1;
+  return e.forEach((i, l) => {
+    const s = Math.pow(2, l);
+    q(i, (u) => {
+      const d = o;
+      o = o | s, t[l] = u, d !== r && o === r && n && (n(), n = null);
+    });
+  }), (i) => (l) => {
+    const s = () => {
+      i([l].concat(t));
+    };
+    o === r ? s() : n = s;
+  };
+}
+function gn(...e) {
+  return (t) => e.reduceRight(mn, t);
+}
+function pn(e) {
+  let t, o;
+  const n = () => t?.();
+  return function(r, i) {
+    switch (r) {
+      case De:
+        return i ? o === i ? void 0 : (n(), o = i, t = q(e, i), t) : (n(), et);
+      case Qe:
+        n(), o = null;
+        return;
+    }
+  };
+}
+function S(e) {
+  let t = e;
+  const o = j();
+  return ((n, r) => {
+    switch (n) {
+      case Ct:
+        t = r;
+        break;
+      case De: {
+        r(t);
+        break;
+      }
+      case ko:
+        return t;
+    }
+    return o(n, r);
+  });
+}
+function me(e, t) {
+  return zt(S(t), (o) => k(e, o));
+}
+function j() {
+  const e = [];
+  return ((t, o) => {
+    switch (t) {
+      case Ct:
+        e.slice().forEach((n) => {
+          n(o);
+        });
+        return;
+      case Qe:
+        e.splice(0, e.length);
+        return;
+      case De:
+        return e.push(o), () => {
+          const n = e.indexOf(o);
+          n > -1 && e.splice(n, 1);
+        };
+    }
+  });
+}
+function we(e) {
+  return zt(j(), (t) => k(e, t));
+}
+function K(e, t = [], { singleton: o } = { singleton: !0 }) {
+  return {
+    constructor: e,
+    dependencies: t,
+    id: vn(),
+    singleton: o
+  };
+}
+const vn = () => /* @__PURE__ */ Symbol();
+function In(e) {
+  const t = /* @__PURE__ */ new Map(), o = ({ constructor: n, dependencies: r, id: i, singleton: l }) => {
+    if (l && t.has(i))
+      return t.get(i);
+    const s = n(r.map((u) => o(u)));
+    return l && t.set(i, s), s;
+  };
+  return o(e);
+}
+function ue(...e) {
+  const t = j(), o = new Array(e.length);
+  let n = 0;
+  const r = Math.pow(2, e.length) - 1;
+  return e.forEach((i, l) => {
+    const s = Math.pow(2, l);
+    q(i, (u) => {
+      o[l] = u, n = n | s, n === r && N(t, o);
+    });
+  }), function(i, l) {
+    switch (i) {
+      case Qe: {
+        Dt(t);
+        return;
+      }
+      case De:
+        return n === r && l(o), q(t, l);
+    }
+  };
+}
+function P(e, t = Oo) {
+  return v(e, ee(t));
+}
+function Ft(...e) {
+  return function(t, o) {
+    switch (t) {
+      case Qe:
+        return;
+      case De:
+        return hn(...e.map((n) => q(n, o)));
+    }
+  };
+}
+var pe = /* @__PURE__ */ ((e) => (e[e.DEBUG = 0] = "DEBUG", e[e.INFO = 1] = "INFO", e[e.WARN = 2] = "WARN", e[e.ERROR = 3] = "ERROR", e))(pe || {});
+const xn = {
+  0: "debug",
+  3: "error",
+  1: "log",
+  2: "warn"
+}, Tn = () => typeof globalThis > "u" ? window : globalThis, Ge = K(
+  () => {
+    const e = S(
+      3
+      /* ERROR */
+    );
+    return {
+      log: S((t, o, n = 1) => {
+        var r;
+        const i = (r = Tn().VIRTUOSO_LOG_LEVEL) != null ? r : ie(e);
+        n >= i && console[xn[n]](
+          "%creact-virtuoso: %c%s %o",
+          "color: #0253b3; font-weight: bold",
+          "color: initial",
+          t,
+          o
+        );
+      }),
+      logLevel: e
+    };
+  },
+  [],
+  { singleton: !0 }
+);
+function Pe(e, t, o) {
+  return Gt(e, t, o).callbackRef;
+}
+function Gt(e, t, o) {
+  const n = H.useRef(null);
+  let r = (l) => {
+  };
+  const i = H.useMemo(() => typeof ResizeObserver < "u" ? new ResizeObserver((l) => {
+    const s = () => {
+      const u = l[0].target;
+      u.offsetParent !== null && e(u);
+    };
+    o ? s() : requestAnimationFrame(s);
+  }) : null, [e, o]);
+  return r = (l) => {
+    l && t ? (i?.observe(l), n.current = l) : (n.current && i?.unobserve(n.current), n.current = null);
+  }, { callbackRef: r, ref: n };
+}
+function Fo(e, t, o, n, r, i, l, s, u) {
+  const d = H.useCallback(
+    (h) => {
+      const x = Sn(h.children, t, s ? "offsetWidth" : "offsetHeight", r);
+      let m = h.parentElement;
+      for (; !m.dataset.virtuosoScroller; )
+        m = m.parentElement;
+      const I = m.lastElementChild.dataset.viewportType === "window";
+      let z;
+      I && (z = m.ownerDocument.defaultView);
+      const T = l ? s ? l.scrollLeft : l.scrollTop : I ? s ? z.scrollX || z.document.documentElement.scrollLeft : z.scrollY || z.document.documentElement.scrollTop : s ? m.scrollLeft : m.scrollTop, g = l ? s ? l.scrollWidth : l.scrollHeight : I ? s ? z.document.documentElement.scrollWidth : z.document.documentElement.scrollHeight : s ? m.scrollWidth : m.scrollHeight, c = l ? s ? l.offsetWidth : l.offsetHeight : I ? s ? z.innerWidth : z.innerHeight : s ? m.offsetWidth : m.offsetHeight;
+      n({
+        scrollHeight: g,
+        scrollTop: Math.max(T, 0),
+        viewportHeight: c
+      }), i?.(
+        s ? fo("column-gap", getComputedStyle(h).columnGap, r) : fo("row-gap", getComputedStyle(h).rowGap, r)
+      ), x !== null && e(x);
+    },
+    [e, t, r, i, l, n, s]
+  );
+  return Gt(d, o, u);
+}
+function Sn(e, t, o, n) {
+  const r = e.length;
+  if (r === 0)
+    return null;
+  const i = [];
+  for (let l = 0; l < r; l++) {
+    const s = e.item(l);
+    if (s.dataset.index === void 0)
+      continue;
+    const u = parseInt(s.dataset.index), d = parseFloat(s.dataset.knownSize), h = t(s, o);
+    if (h === 0 && n("Zero-sized element, this should not happen", { child: s }, pe.ERROR), h === d)
+      continue;
+    const x = i[i.length - 1];
+    i.length === 0 || x.size !== h || x.endIndex !== u - 1 ? i.push({ endIndex: u, size: h, startIndex: u }) : i[i.length - 1].endIndex++;
+  }
+  return i;
+}
+function fo(e, t, o) {
+  return t !== "normal" && !(t != null && t.endsWith("px")) && o(`${e} was not resolved to pixel value correctly`, t, pe.WARN), t === "normal" ? 0 : parseInt(t ?? "0", 10);
+}
+function Nt(e, t, o) {
+  const n = H.useRef(null), r = H.useCallback(
+    (u) => {
+      if (!(u != null && u.offsetParent))
+        return;
+      const d = u.getBoundingClientRect(), h = d.width;
+      let x, m;
+      if (t) {
+        const I = t.getBoundingClientRect(), z = d.top - I.top;
+        m = I.height - Math.max(0, z), x = z + t.scrollTop;
+      } else {
+        const I = l.current.ownerDocument.defaultView;
+        m = I.innerHeight - Math.max(0, d.top), x = d.top + I.scrollY;
+      }
+      n.current = {
+        offsetTop: x,
+        visibleHeight: m,
+        visibleWidth: h
+      }, e(n.current);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e, t]
+  ), { callbackRef: i, ref: l } = Gt(r, !0, o), s = H.useCallback(() => {
+    r(l.current);
+  }, [r, l]);
+  return H.useEffect(() => {
+    var u;
+    if (t) {
+      t.addEventListener("scroll", s);
+      const d = new ResizeObserver(() => {
+        requestAnimationFrame(s);
+      });
+      return d.observe(t), () => {
+        t.removeEventListener("scroll", s), d.unobserve(t);
+      };
+    } else {
+      const d = (u = l.current) == null ? void 0 : u.ownerDocument.defaultView;
+      return d?.addEventListener("scroll", s), d?.addEventListener("resize", s), () => {
+        d?.removeEventListener("scroll", s), d?.removeEventListener("resize", s);
+      };
+    }
+  }, [s, t, l]), i;
+}
+const ge = K(
+  () => {
+    const e = j(), t = j(), o = S(0), n = j(), r = S(0), i = j(), l = j(), s = S(0), u = S(0), d = S(0), h = S(0), x = j(), m = j(), I = S(!1), z = S(!1), T = S(!1);
+    return k(
+      v(
+        e,
+        B(({ scrollTop: g }) => g)
+      ),
+      t
+    ), k(
+      v(
+        e,
+        B(({ scrollHeight: g }) => g)
+      ),
+      l
+    ), k(t, r), {
+      deviation: o,
+      fixedFooterHeight: d,
+      fixedHeaderHeight: u,
+      footerHeight: h,
+      headerHeight: s,
+      horizontalDirection: z,
+      scrollBy: m,
+      // input
+      scrollContainerState: e,
+      scrollHeight: l,
+      scrollingInProgress: I,
+      // signals
+      scrollTo: x,
+      scrollTop: t,
+      skipAnimationFrameInResizeObserver: T,
+      smoothScrollTargetReached: n,
+      // state
+      statefulScrollTop: r,
+      viewportHeight: i
+    };
+  },
+  [],
+  { singleton: !0 }
+), lt = { lvl: 0 };
+function Wo(e, t) {
+  const o = e.length;
+  if (o === 0)
+    return [];
+  let { index: n, value: r } = t(e[0]);
+  const i = [];
+  for (let l = 1; l < o; l++) {
+    const { index: s, value: u } = t(e[l]);
+    i.push({ end: s - 1, start: n, value: r }), n = s, r = u;
+  }
+  return i.push({ end: 1 / 0, start: n, value: r }), i;
+}
+function X(e) {
+  return e === lt;
+}
+function st(e, t) {
+  if (!X(e))
+    return t === e.k ? e.v : t < e.k ? st(e.l, t) : st(e.r, t);
+}
+function Ee(e, t, o = "k") {
+  if (X(e))
+    return [-1 / 0, void 0];
+  if (Number(e[o]) === t)
+    return [e.k, e.v];
+  if (Number(e[o]) < t) {
+    const n = Ee(e.r, t, o);
+    return n[0] === -1 / 0 ? [e.k, e.v] : n;
+  }
+  return Ee(e.l, t, o);
+}
+function Se(e, t, o) {
+  return X(e) ? Ao(t, o, 1) : t === e.k ? ce(e, { k: t, v: o }) : t < e.k ? ho(ce(e, { l: Se(e.l, t, o) })) : ho(ce(e, { r: Se(e.r, t, o) }));
+}
+function Xe() {
+  return lt;
+}
+function Je(e, t, o) {
+  if (X(e))
+    return [];
+  const n = Ee(e, t)[0];
+  return wn(Pt(e, n, o));
+}
+function Wt(e, t) {
+  if (X(e)) return lt;
+  const { k: o, l: n, r } = e;
+  if (t === o) {
+    if (X(n))
+      return r;
+    if (X(r))
+      return n;
+    {
+      const [i, l] = Mo(n);
+      return xt(ce(e, { k: i, l: Po(n), v: l }));
+    }
+  } else return t < o ? xt(ce(e, { l: Wt(n, t) })) : xt(ce(e, { r: Wt(r, t) }));
+}
+function Ue(e) {
+  return X(e) ? [] : [...Ue(e.l), { k: e.k, v: e.v }, ...Ue(e.r)];
+}
+function Pt(e, t, o) {
+  if (X(e))
+    return [];
+  const { k: n, l: r, r: i, v: l } = e;
+  let s = [];
+  return n > t && (s = s.concat(Pt(r, t, o))), n >= t && n <= o && s.push({ k: n, v: l }), n <= o && (s = s.concat(Pt(i, t, o))), s;
+}
+function xt(e) {
+  const { l: t, lvl: o, r: n } = e;
+  if (n.lvl >= o - 1 && t.lvl >= o - 1)
+    return e;
+  if (o > n.lvl + 1) {
+    if (Ht(t))
+      return Vo(ce(e, { lvl: o - 1 }));
+    if (!X(t) && !X(t.r))
+      return ce(t.r, {
+        l: ce(t, { r: t.r.l }),
+        lvl: o,
+        r: ce(e, {
+          l: t.r.r,
+          lvl: o - 1
+        })
+      });
+    throw new Error("Unexpected empty nodes");
+  } else {
+    if (Ht(e))
+      return Mt(ce(e, { lvl: o - 1 }));
+    if (!X(n) && !X(n.l)) {
+      const r = n.l, i = Ht(r) ? n.lvl - 1 : n.lvl;
+      return ce(r, {
+        l: ce(e, {
+          lvl: o - 1,
+          r: r.l
+        }),
+        lvl: r.lvl + 1,
+        r: Mt(ce(n, { l: r.r, lvl: i }))
+      });
+    } else
+      throw new Error("Unexpected empty nodes");
+  }
+}
+function ce(e, t) {
+  return Ao(
+    t.k !== void 0 ? t.k : e.k,
+    t.v !== void 0 ? t.v : e.v,
+    t.lvl !== void 0 ? t.lvl : e.lvl,
+    t.l !== void 0 ? t.l : e.l,
+    t.r !== void 0 ? t.r : e.r
+  );
+}
+function Po(e) {
+  return X(e.r) ? e.l : xt(ce(e, { r: Po(e.r) }));
+}
+function Ht(e) {
+  return X(e) || e.lvl > e.r.lvl;
+}
+function Mo(e) {
+  return X(e.r) ? [e.k, e.v] : Mo(e.r);
+}
+function Ao(e, t, o, n = lt, r = lt) {
+  return { k: e, l: n, lvl: o, r, v: t };
+}
+function ho(e) {
+  return Mt(Vo(e));
+}
+function Vo(e) {
+  const { l: t } = e;
+  return !X(t) && t.lvl === e.lvl ? ce(t, { r: ce(e, { l: t.r }) }) : e;
+}
+function Mt(e) {
+  const { lvl: t, r: o } = e;
+  return !X(o) && !X(o.r) && o.lvl === t && o.r.lvl === t ? ce(o, { l: ce(e, { r: o.l }), lvl: t + 1 }) : e;
+}
+function wn(e) {
+  return Wo(e, ({ k: t, v: o }) => ({ index: t, value: o }));
+}
+function Lo(e, t) {
+  return !!(e && e.startIndex === t.startIndex && e.endIndex === t.endIndex);
+}
+function ut(e, t) {
+  return !!(e && e[0] === t[0] && e[1] === t[1]);
+}
+const _t = K(
+  () => ({ recalcInProgress: S(!1) }),
+  [],
+  { singleton: !0 }
+);
+function Do(e, t, o) {
+  return e[St(e, t, o)];
+}
+function St(e, t, o, n = 0) {
+  let r = e.length - 1;
+  for (; n <= r; ) {
+    const i = Math.floor((n + r) / 2), l = e[i], s = o(l, t);
+    if (s === 0)
+      return i;
+    if (s === -1) {
+      if (r - n < 2)
+        return i - 1;
+      r = i - 1;
+    } else {
+      if (r === n)
+        return i;
+      n = i + 1;
+    }
+  }
+  throw new Error(`Failed binary finding record in array - ${e.join(",")}, searched for ${t}`);
+}
+function Cn(e, t, o, n) {
+  const r = St(e, t, n), i = St(e, o, n, r);
+  return e.slice(r, i + 1);
+}
+function ke(e, t) {
+  return Math.round(e.getBoundingClientRect()[t]);
+}
+function Rt(e) {
+  return !X(e.groupOffsetTree);
+}
+function Ut({ index: e }, t) {
+  return t === e ? 0 : t < e ? -1 : 1;
+}
+function zn() {
+  return {
+    groupIndices: [],
+    groupOffsetTree: Xe(),
+    lastIndex: 0,
+    lastOffset: 0,
+    lastSize: 0,
+    offsetTree: [],
+    sizeTree: Xe()
+  };
+}
+function Rn(e, t) {
+  let o = X(e) ? 0 : 1 / 0;
+  for (const n of t) {
+    const { endIndex: r, size: i, startIndex: l } = n;
+    if (o = Math.min(o, l), X(e)) {
+      e = Se(e, 0, i);
+      continue;
+    }
+    const s = Je(e, l - 1, r + 1);
+    if (s.some(On(n)))
+      continue;
+    let u = !1, d = !1;
+    for (const { end: h, start: x, value: m } of s)
+      u ? (r >= x || i === m) && (e = Wt(e, x)) : (d = m !== i, u = !0), h > r && r >= x && m !== i && (e = Se(e, r + 1, m));
+    d && (e = Se(e, l, i));
+  }
+  return [e, o];
+}
+function yn(e) {
+  return typeof e.groupIndex < "u";
+}
+function bn({ offset: e }, t) {
+  return t === e ? 0 : t < e ? -1 : 1;
+}
+function at(e, t, o) {
+  if (t.length === 0)
+    return 0;
+  const { index: n, offset: r, size: i } = Do(t, e, Ut), l = e - n, s = i * l + (l - 1) * o + r;
+  return s > 0 ? s + o : s;
+}
+function Go(e, t) {
+  if (!Rt(t))
+    return e;
+  let o = 0;
+  for (; t.groupIndices[o] <= e + o; )
+    o++;
+  return e + o;
+}
+function No(e, t, o) {
+  if (yn(e))
+    return t.groupIndices[e.groupIndex] + 1;
+  {
+    const n = e.index === "LAST" ? o : e.index;
+    let r = Go(n, t);
+    return r = Math.max(0, r, Math.min(o, r)), r;
+  }
+}
+function Hn(e, t, o, n = 0) {
+  return n > 0 && (t = Math.max(t, Do(e, n, Ut).offset)), Wo(Cn(e, t, o, bn), kn);
+}
+function Bn(e, [t, o, n, r]) {
+  t.length > 0 && n("received item sizes", t, pe.DEBUG);
+  const i = e.sizeTree;
+  let l = i, s = 0;
+  if (o.length > 0 && X(i) && t.length === 2) {
+    const m = t[0].size, I = t[1].size;
+    l = o.reduce((z, T) => Se(Se(z, T, m), T + 1, I), l);
+  } else
+    [l, s] = Rn(l, t);
+  if (l === i)
+    return e;
+  const { lastIndex: u, lastOffset: d, lastSize: h, offsetTree: x } = At(e.offsetTree, s, l, r);
+  return {
+    groupIndices: o,
+    groupOffsetTree: o.reduce((m, I) => Se(m, I, at(I, x, r)), Xe()),
+    lastIndex: u,
+    lastOffset: d,
+    lastSize: h,
+    offsetTree: x,
+    sizeTree: l
+  };
+}
+function En(e) {
+  return Ue(e).map(({ k: t, v: o }, n, r) => {
+    const i = r[n + 1];
+    return { endIndex: i ? i.k - 1 : 1 / 0, size: o, startIndex: t };
+  });
+}
+function mo(e, t) {
+  let o = 0, n = 0;
+  for (; o < e; )
+    o += t[n + 1] - t[n] - 1, n++;
+  return n - (o === e ? 0 : 1);
+}
+function At(e, t, o, n) {
+  let r = e, i = 0, l = 0, s = 0, u = 0;
+  if (t !== 0) {
+    u = St(r, t - 1, Ut), s = r[u].offset;
+    const d = Ee(o, t - 1);
+    i = d[0], l = d[1], r.length && r[u].size === Ee(o, t)[1] && (u -= 1), r = r.slice(0, u + 1);
+  } else
+    r = [];
+  for (const { start: d, value: h } of Je(o, t, 1 / 0)) {
+    const x = d - i, m = x * l + s + x * n;
+    r.push({
+      index: d,
+      offset: m,
+      size: h
+    }), i = d, s = m, l = h;
+  }
+  return {
+    lastIndex: i,
+    lastOffset: s,
+    lastSize: l,
+    offsetTree: r
+  };
+}
+function kn(e) {
+  return { index: e.index, value: e };
+}
+function On(e) {
+  const { endIndex: t, size: o, startIndex: n } = e;
+  return (r) => r.start === n && (r.end === t || r.end === 1 / 0) && r.value === o;
+}
+const Fn = {
+  offsetHeight: "height",
+  offsetWidth: "width"
+}, Me = K(
+  ([{ log: e }, { recalcInProgress: t }]) => {
+    const o = j(), n = j(), r = me(n, 0), i = j(), l = j(), s = S(0), u = S([]), d = S(void 0), h = S(void 0), x = S(void 0), m = S(void 0), I = S((a, p) => ke(a, Fn[p])), z = S(void 0), T = S(0), g = zn(), c = me(
+      v(o, _(u, e, T), We(Bn, g), ee()),
+      g
+    ), f = me(
+      v(
+        u,
+        ee(),
+        We((a, p) => ({ current: p, prev: a.current }), {
+          current: [],
+          prev: []
+        }),
+        B(({ prev: a }) => a)
+      ),
+      []
+    );
+    k(
+      v(
+        u,
+        M((a) => a.length > 0),
+        _(c, T),
+        B(([a, p, C]) => {
+          const R = a.reduce((O, L, D) => Se(O, L, at(L, p.offsetTree, C) || D), Xe());
+          return {
+            ...p,
+            groupIndices: a,
+            groupOffsetTree: R
+          };
+        })
+      ),
+      c
+    ), k(
+      v(
+        n,
+        _(c),
+        M(([a, { lastIndex: p }]) => a < p),
+        B(([a, { lastIndex: p, lastSize: C }]) => [
+          {
+            endIndex: p,
+            size: C,
+            startIndex: a
+          }
+        ])
+      ),
+      o
+    ), k(d, h);
+    const w = me(
+      v(
+        d,
+        B((a) => a === void 0)
+      ),
+      !0
+    );
+    k(
+      v(
+        h,
+        M((a) => a !== void 0 && X(ie(c).sizeTree)),
+        B((a) => {
+          const p = ie(x), C = ie(u).length > 0;
+          return p ? C ? [
+            { endIndex: 0, size: p, startIndex: 0 },
+            { endIndex: 1, size: a, startIndex: 1 }
+          ] : [] : [{ endIndex: 0, size: a, startIndex: 0 }];
+        })
+      ),
+      o
+    ), k(
+      v(
+        m,
+        M((a) => a !== void 0 && a.length > 0 && X(ie(c).sizeTree)),
+        B((a) => {
+          const p = [];
+          let C = a[0], R = 0;
+          for (let O = 1; O < a.length; O++) {
+            const L = a[O];
+            L !== C && (p.push({
+              endIndex: O - 1,
+              size: C,
+              startIndex: R
+            }), C = L, R = O);
+          }
+          return p.push({
+            endIndex: a.length - 1,
+            size: C,
+            startIndex: R
+          }), p;
+        })
+      ),
+      o
+    ), k(
+      v(
+        u,
+        _(x, h),
+        M(([, a, p]) => a !== void 0 && p !== void 0),
+        B(([a, p, C]) => {
+          const R = [];
+          for (let O = 0; O < a.length; O++) {
+            const L = a[O], D = a[O + 1];
+            R.push({
+              startIndex: L,
+              endIndex: L,
+              size: p
+            }), D !== void 0 && R.push({
+              startIndex: L + 1,
+              endIndex: D - 1,
+              size: C
+            });
+          }
+          return R;
+        })
+      ),
+      o
+    );
+    const E = we(
+      v(
+        o,
+        _(c),
+        We(
+          ({ sizes: a }, [p, C]) => ({
+            changed: C !== a,
+            sizes: C
+          }),
+          { changed: !1, sizes: g }
+        ),
+        B((a) => a.changed)
+      )
+    );
+    q(
+      v(
+        s,
+        We(
+          (a, p) => ({ diff: a.prev - p, prev: p }),
+          { diff: 0, prev: 0 }
+        ),
+        B((a) => a.diff)
+      ),
+      (a) => {
+        const { groupIndices: p } = ie(c);
+        if (a > 0)
+          N(t, !0), N(i, a + mo(a, p));
+        else if (a < 0) {
+          const C = ie(f);
+          C.length > 0 && (a -= mo(-a, C)), N(l, a);
+        }
+      }
+    ), q(v(s, _(e)), ([a, p]) => {
+      a < 0 && p(
+        "`firstItemIndex` prop should not be set to less than zero. If you don't know the total count, just use a very high value",
+        { firstItemIndex: s },
+        pe.ERROR
+      );
+    });
+    const b = we(i);
+    k(
+      v(
+        i,
+        _(c),
+        B(([a, p]) => {
+          const C = p.groupIndices.length > 0, R = [], O = p.lastSize;
+          if (C) {
+            const L = st(p.sizeTree, 0);
+            let D = 0, W = 0;
+            for (; D < a; ) {
+              const Y = p.groupIndices[W], J = p.groupIndices.length === W + 1 ? 1 / 0 : p.groupIndices[W + 1] - Y - 1;
+              R.push({
+                endIndex: Y,
+                size: L,
+                startIndex: Y
+              }), R.push({
+                endIndex: Y + 1 + J - 1,
+                size: O,
+                startIndex: Y + 1
+              }), W++, D += J + 1;
+            }
+            const U = Ue(p.sizeTree);
+            return D !== a && U.shift(), U.reduce(
+              (Y, { k: J, v: ve }) => {
+                let Ie = Y.ranges;
+                return Y.prevSize !== 0 && (Ie = [
+                  ...Y.ranges,
+                  {
+                    endIndex: J + a - 1,
+                    size: Y.prevSize,
+                    startIndex: Y.prevIndex
+                  }
+                ]), {
+                  prevIndex: J + a,
+                  prevSize: ve,
+                  ranges: Ie
+                };
+              },
+              {
+                prevIndex: a,
+                prevSize: 0,
+                ranges: R
+              }
+            ).ranges;
+          }
+          return Ue(p.sizeTree).reduce(
+            (L, { k: D, v: W }) => ({
+              prevIndex: D + a,
+              prevSize: W,
+              ranges: [...L.ranges, { endIndex: D + a - 1, size: L.prevSize, startIndex: L.prevIndex }]
+            }),
+            {
+              prevIndex: 0,
+              prevSize: O,
+              ranges: []
+            }
+          ).ranges;
+        })
+      ),
+      o
+    );
+    const F = we(
+      v(
+        l,
+        _(c, T),
+        B(([a, { offsetTree: p }, C]) => {
+          const R = -a;
+          return at(R, p, C);
+        })
+      )
+    );
+    return k(
+      v(
+        l,
+        _(c, T),
+        B(([a, p, C]) => {
+          if (p.groupIndices.length > 0) {
+            if (X(p.sizeTree))
+              return p;
+            let R = Xe();
+            const O = ie(f);
+            let L = 0, D = 0, W = 0;
+            for (; L < -a; ) {
+              W = O[D];
+              const U = O[D + 1] - W - 1;
+              D++, L += U + 1;
+            }
+            if (R = Ue(p.sizeTree).reduce((U, { k: Y, v: J }) => Se(U, Math.max(0, Y + a), J), R), L !== -a) {
+              const U = st(p.sizeTree, W);
+              R = Se(R, 0, U);
+              const Y = Ee(p.sizeTree, -a + 1)[1];
+              R = Se(R, 1, Y);
+            }
+            return {
+              ...p,
+              sizeTree: R,
+              ...At(p.offsetTree, 0, R, C)
+            };
+          } else {
+            const R = Ue(p.sizeTree).reduce((O, { k: L, v: D }) => Se(O, Math.max(0, L + a), D), Xe());
+            return {
+              ...p,
+              sizeTree: R,
+              ...At(p.offsetTree, 0, R, C)
+            };
+          }
+        })
+      ),
+      c
+    ), {
+      beforeUnshiftWith: b,
+      // input
+      data: z,
+      defaultItemSize: h,
+      firstItemIndex: s,
+      fixedItemSize: d,
+      fixedGroupSize: x,
+      gap: T,
+      groupIndices: u,
+      heightEstimates: m,
+      itemSize: I,
+      listRefresh: E,
+      shiftWith: l,
+      shiftWithOffset: F,
+      sizeRanges: o,
+      // output
+      sizes: c,
+      statefulTotalCount: r,
+      totalCount: n,
+      trackItemSizes: w,
+      unshiftWith: i
+    };
+  },
+  oe(Ge, _t),
+  { singleton: !0 }
+);
+function Wn(e) {
+  return e.reduce(
+    (t, o) => (t.groupIndices.push(t.totalCount), t.totalCount += o + 1, t),
+    {
+      groupIndices: [],
+      totalCount: 0
+    }
+  );
+}
+const _o = K(
+  ([{ groupIndices: e, sizes: t, totalCount: o }, { headerHeight: n, scrollTop: r }]) => {
+    const i = j(), l = j(), s = we(v(i, B(Wn)));
+    return k(
+      v(
+        s,
+        B((u) => u.totalCount)
+      ),
+      o
+    ), k(
+      v(
+        s,
+        B((u) => u.groupIndices)
+      ),
+      e
+    ), k(
+      v(
+        ue(r, t, n),
+        M(([u, d]) => Rt(d)),
+        B(([u, d, h]) => Ee(d.groupOffsetTree, Math.max(u - h, 0), "v")[0]),
+        ee(),
+        B((u) => [u])
+      ),
+      l
+    ), { groupCounts: i, topItemsIndexes: l };
+  },
+  oe(Me, ge)
+), Ne = K(
+  ([{ log: e }]) => {
+    const t = S(!1), o = we(
+      v(
+        t,
+        M((n) => n),
+        ee()
+      )
+    );
+    return q(t, (n) => {
+      n && ie(e)("props updated", {}, pe.DEBUG);
+    }), { didMount: o, propsReady: t };
+  },
+  oe(Ge),
+  { singleton: !0 }
+), Pn = typeof document < "u" && "scrollBehavior" in document.documentElement.style;
+function Uo(e) {
+  const t = typeof e == "number" ? { index: e } : e;
+  return t.align || (t.align = "start"), (!t.behavior || !Pn) && (t.behavior = "auto"), t.offset || (t.offset = 0), t;
+}
+const ht = K(
+  ([
+    { gap: e, listRefresh: t, sizes: o, totalCount: n },
+    {
+      fixedFooterHeight: r,
+      fixedHeaderHeight: i,
+      footerHeight: l,
+      headerHeight: s,
+      scrollingInProgress: u,
+      scrollTo: d,
+      smoothScrollTargetReached: h,
+      viewportHeight: x
+    },
+    { log: m }
+  ]) => {
+    const I = j(), z = j(), T = S(0);
+    let g = null, c = null, f = null;
+    function w() {
+      g && (g(), g = null), f && (f(), f = null), c && (clearTimeout(c), c = null), N(u, !1);
+    }
+    return k(
+      v(
+        I,
+        _(o, x, n, T, s, l, m),
+        _(e, i, r),
+        B(
+          ([
+            [E, b, F, a, p, C, R, O],
+            L,
+            D,
+            W
+          ]) => {
+            const U = Uo(E), { align: Y, behavior: J, offset: ve } = U, Ie = a - 1, xe = No(U, b, Ie);
+            let Te = at(xe, b.offsetTree, L) + C;
+            Y === "end" ? (Te += D + Ee(b.sizeTree, xe)[1] - F + W, xe === Ie && (Te += R)) : Y === "center" ? Te += (D + Ee(b.sizeTree, xe)[1] - F + W) / 2 : Te -= p, ve && (Te += ve);
+            const Oe = (be) => {
+              w(), be ? (O("retrying to scroll to", { location: E }, pe.DEBUG), N(I, E)) : (N(z, !0), O("list did not change, scroll successful", {}, pe.DEBUG));
+            };
+            if (w(), J === "smooth") {
+              let be = !1;
+              f = q(t, (Ve) => {
+                be = be || Ve;
+              }), g = He(h, () => {
+                Oe(be);
+              });
+            } else
+              g = He(v(t, Mn(150)), Oe);
+            return c = setTimeout(() => {
+              w();
+            }, 1200), N(u, !0), O("scrolling from index to", { behavior: J, index: xe, top: Te }, pe.DEBUG), { behavior: J, top: Te };
+          }
+        )
+      ),
+      d
+    ), {
+      scrollTargetReached: z,
+      scrollToIndex: I,
+      topListHeight: T
+    };
+  },
+  oe(Me, ge, Ge),
+  { singleton: !0 }
+);
+function Mn(e) {
+  return (t) => {
+    const o = setTimeout(() => {
+      t(!1);
+    }, e);
+    return (n) => {
+      n && (t(!0), clearTimeout(o));
+    };
+  };
+}
+function jt(e, t) {
+  e == 0 ? t() : requestAnimationFrame(() => {
+    jt(e - 1, t);
+  });
+}
+function Kt(e, t) {
+  const o = t - 1;
+  return typeof e == "number" ? e : e.index === "LAST" ? o : e.index;
+}
+const mt = K(
+  ([{ defaultItemSize: e, listRefresh: t, sizes: o }, { scrollTop: n }, { scrollTargetReached: r, scrollToIndex: i }, { didMount: l }]) => {
+    const s = S(!0), u = S(0), d = S(!0);
+    return k(
+      v(
+        l,
+        _(u),
+        M(([h, x]) => !!x),
+        Fe(!1)
+      ),
+      s
+    ), k(
+      v(
+        l,
+        _(u),
+        M(([h, x]) => !!x),
+        Fe(!1)
+      ),
+      d
+    ), q(
+      v(
+        ue(t, l),
+        _(s, o, e, d),
+        M(([[, h], x, { sizeTree: m }, I, z]) => h && (!X(m) || Lt(I)) && !x && !z),
+        _(u)
+      ),
+      ([, h]) => {
+        He(r, () => {
+          N(d, !0);
+        }), jt(4, () => {
+          He(n, () => {
+            N(s, !0);
+          }), N(i, h);
+        });
+      }
+    ), {
+      initialItemFinalLocationReached: d,
+      initialTopMostItemIndex: u,
+      scrolledToInitialItem: s
+    };
+  },
+  oe(Me, ge, ht, Ne),
+  { singleton: !0 }
+);
+function jo(e, t) {
+  return Math.abs(e - t) < 1.01;
+}
+const ct = "up", nt = "down", An = "none", Vn = {
+  atBottom: !1,
+  notAtBottomBecause: "NOT_SHOWING_LAST_ITEM",
+  state: {
+    offsetBottom: 0,
+    scrollHeight: 0,
+    scrollTop: 0,
+    viewportHeight: 0
+  }
+}, Ln = 0, gt = K(([{ footerHeight: e, headerHeight: t, scrollBy: o, scrollContainerState: n, scrollTop: r, viewportHeight: i }]) => {
+  const l = S(!1), s = S(!0), u = j(), d = j(), h = S(4), x = S(Ln), m = me(
+    v(
+      Ft(v(P(r), $e(1), Fe(!0)), v(P(r), $e(1), Fe(!1), co(100))),
+      ee()
+    ),
+    !1
+  ), I = me(
+    v(Ft(v(o, Fe(!0)), v(o, Fe(!1), co(200))), ee()),
+    !1
+  );
+  k(
+    v(
+      ue(P(r), P(x)),
+      B(([f, w]) => f <= w),
+      ee()
+    ),
+    s
+  ), k(v(s, Ae(50)), d);
+  const z = we(
+    v(
+      ue(n, P(i), P(t), P(e), P(h)),
+      We((f, [{ scrollHeight: w, scrollTop: E }, b, F, a, p]) => {
+        const C = E + b - w > -p, R = {
+          scrollHeight: w,
+          scrollTop: E,
+          viewportHeight: b
+        };
+        if (C) {
+          let L, D;
+          return E > f.state.scrollTop ? (L = "SCROLLED_DOWN", D = f.state.scrollTop - E) : (L = "SIZE_DECREASED", D = f.state.scrollTop - E || f.scrollTopDelta), {
+            atBottom: !0,
+            atBottomBecause: L,
+            scrollTopDelta: D,
+            state: R
+          };
+        }
+        let O;
+        return R.scrollHeight > f.state.scrollHeight ? O = "SIZE_INCREASED" : b < f.state.viewportHeight ? O = "VIEWPORT_HEIGHT_DECREASING" : E < f.state.scrollTop ? O = "SCROLLING_UPWARDS" : O = "NOT_FULLY_SCROLLED_TO_LAST_ITEM_BOTTOM", {
+          atBottom: !1,
+          notAtBottomBecause: O,
+          state: R
+        };
+      }, Vn),
+      ee((f, w) => f && f.atBottom === w.atBottom)
+    )
+  ), T = me(
+    v(
+      n,
+      We(
+        (f, { scrollHeight: w, scrollTop: E, viewportHeight: b }) => {
+          if (jo(f.scrollHeight, w))
+            return {
+              changed: !1,
+              jump: 0,
+              scrollHeight: w,
+              scrollTop: E
+            };
+          {
+            const F = w - (E + b) < 1;
+            return f.scrollTop !== E && F ? {
+              changed: !0,
+              jump: f.scrollTop - E,
+              scrollHeight: w,
+              scrollTop: E
+            } : {
+              changed: !0,
+              jump: 0,
+              scrollHeight: w,
+              scrollTop: E
+            };
+          }
+        },
+        { changed: !1, jump: 0, scrollHeight: 0, scrollTop: 0 }
+      ),
+      M((f) => f.changed),
+      B((f) => f.jump)
+    ),
+    0
+  );
+  k(
+    v(
+      z,
+      B((f) => f.atBottom)
+    ),
+    l
+  ), k(v(l, Ae(50)), u);
+  const g = S(nt);
+  k(
+    v(
+      n,
+      B(({ scrollTop: f }) => f),
+      ee(),
+      We(
+        (f, w) => ie(I) ? { direction: f.direction, prevScrollTop: w } : { direction: w < f.prevScrollTop ? ct : nt, prevScrollTop: w },
+        { direction: nt, prevScrollTop: 0 }
+      ),
+      B((f) => f.direction)
+    ),
+    g
+  ), k(v(n, Ae(50), Fe(An)), g);
+  const c = S(0);
+  return k(
+    v(
+      m,
+      M((f) => !f),
+      Fe(0)
+    ),
+    c
+  ), k(
+    v(
+      r,
+      Ae(100),
+      _(m),
+      M(([f, w]) => w),
+      We(([f, w], [E]) => [w, E], [0, 0]),
+      B(([f, w]) => w - f)
+    ),
+    c
+  ), {
+    atBottomState: z,
+    atBottomStateChange: u,
+    atBottomThreshold: h,
+    atTopStateChange: d,
+    atTopThreshold: x,
+    isAtBottom: l,
+    isAtTop: s,
+    isScrolling: m,
+    lastJumpDueToItemResize: T,
+    scrollDirection: g,
+    scrollVelocity: c
+  };
+}, oe(ge)), dt = "top", ft = "bottom", go = "none";
+function po(e, t, o) {
+  return typeof e == "number" ? o === ct && t === dt || o === nt && t === ft ? e : 0 : o === ct ? t === dt ? e.main : e.reverse : t === ft ? e.main : e.reverse;
+}
+function vo(e, t) {
+  var o;
+  return typeof e == "number" ? e : (o = e[t]) != null ? o : 0;
+}
+const $t = K(
+  ([{ deviation: e, fixedHeaderHeight: t, headerHeight: o, scrollTop: n, viewportHeight: r }]) => {
+    const i = j(), l = S(0), s = S(0), u = S(0), d = me(
+      v(
+        ue(
+          P(n),
+          P(r),
+          P(o),
+          P(i, ut),
+          P(u),
+          P(l),
+          P(t),
+          P(e),
+          P(s)
+        ),
+        B(
+          ([
+            h,
+            x,
+            m,
+            [I, z],
+            T,
+            g,
+            c,
+            f,
+            w
+          ]) => {
+            const E = h - f, b = g + c, F = Math.max(m - E, 0);
+            let a = go;
+            const p = vo(w, dt), C = vo(w, ft);
+            return I -= f, I += m + c, z += m + c, z -= f, I > h + b - p && (a = ct), z < h - F + x + C && (a = nt), a !== go ? [
+              Math.max(E - m - po(T, dt, a) - p, 0),
+              E - F - c + x + po(T, ft, a) + C
+            ] : null;
+          }
+        ),
+        M((h) => h != null),
+        ee(ut)
+      ),
+      [0, 0]
+    );
+    return {
+      increaseViewportBy: s,
+      // input
+      listBoundary: i,
+      overscan: u,
+      topListHeight: l,
+      // output
+      visibleRange: d
+    };
+  },
+  oe(ge),
+  { singleton: !0 }
+);
+function Dn(e, t, o) {
+  if (Rt(t)) {
+    const n = Go(e, t);
+    return [
+      { index: Ee(t.groupOffsetTree, n)[0], offset: 0, size: 0 },
+      { data: o?.[0], index: n, offset: 0, size: 0 }
+    ];
+  }
+  return [{ data: o?.[0], index: e, offset: 0, size: 0 }];
+}
+const Bt = {
+  bottom: 0,
+  firstItemIndex: 0,
+  items: [],
+  offsetBottom: 0,
+  offsetTop: 0,
+  top: 0,
+  topItems: [],
+  topListHeight: 0,
+  totalCount: 0
+};
+function Tt(e, t, o, n, r, i) {
+  const { lastIndex: l, lastOffset: s, lastSize: u } = r;
+  let d = 0, h = 0;
+  if (e.length > 0) {
+    d = e[0].offset;
+    const T = e[e.length - 1];
+    h = T.offset + T.size;
+  }
+  const x = o - l, m = s + x * u + (x - 1) * n, I = d, z = m - h;
+  return {
+    bottom: h,
+    firstItemIndex: i,
+    items: Io(e, r, i),
+    offsetBottom: z,
+    offsetTop: d,
+    top: I,
+    topItems: Io(t, r, i),
+    topListHeight: t.reduce((T, g) => g.size + T, 0),
+    totalCount: o
+  };
+}
+function Ko(e, t, o, n, r, i) {
+  let l = 0;
+  if (o.groupIndices.length > 0)
+    for (const h of o.groupIndices) {
+      if (h - l >= e)
+        break;
+      l++;
+    }
+  const s = e + l, u = Kt(t, s), d = Array.from({ length: s }).map((h, x) => ({
+    data: i[x + u],
+    index: x + u,
+    offset: 0,
+    size: 0
+  }));
+  return Tt(d, [], s, r, o, n);
+}
+function Io(e, t, o) {
+  if (e.length === 0)
+    return [];
+  if (!Rt(t))
+    return e.map((d) => ({ ...d, index: d.index + o, originalIndex: d.index }));
+  const n = e[0].index, r = e[e.length - 1].index, i = [], l = Je(t.groupOffsetTree, n, r);
+  let s, u = 0;
+  for (const d of e) {
+    (!s || s.end < d.index) && (s = l.shift(), u = t.groupIndices.indexOf(s.start));
+    let h;
+    d.index === s.start ? h = {
+      index: u,
+      type: "group"
+    } : h = {
+      groupIndex: u,
+      index: d.index - (u + 1) + o
+    }, i.push({
+      ...h,
+      data: d.data,
+      offset: d.offset,
+      originalIndex: d.index,
+      size: d.size
+    });
+  }
+  return i;
+}
+function xo(e, t) {
+  var o;
+  return e === void 0 ? 0 : typeof e == "number" ? e : (o = e[t]) != null ? o : 0;
+}
+const qe = K(
+  ([
+    { data: e, firstItemIndex: t, gap: o, sizes: n, totalCount: r },
+    i,
+    { listBoundary: l, topListHeight: s, visibleRange: u },
+    { initialTopMostItemIndex: d, scrolledToInitialItem: h },
+    { topListHeight: x },
+    m,
+    { didMount: I },
+    { recalcInProgress: z }
+  ]) => {
+    const T = S([]), g = S(0), c = j(), f = S(0);
+    k(i.topItemsIndexes, T);
+    const w = me(
+      v(
+        ue(
+          I,
+          z,
+          P(u, ut),
+          P(r),
+          P(n),
+          P(d),
+          h,
+          P(T),
+          P(t),
+          P(o),
+          P(f),
+          e
+        ),
+        M(([a, p, , C, , , , , , , , R]) => {
+          const O = R && R.length !== C;
+          return a && !p && !O;
+        }),
+        B(
+          ([
+            ,
+            ,
+            [a, p],
+            C,
+            R,
+            O,
+            L,
+            D,
+            W,
+            U,
+            Y,
+            J
+          ]) => {
+            var ve, Ie, xe, Te;
+            const Oe = R, { offsetTree: be, sizeTree: Ve } = Oe, ot = ie(g);
+            if (C === 0)
+              return { ...Bt, totalCount: C };
+            if (a === 0 && p === 0)
+              return ot === 0 ? { ...Bt, totalCount: C } : Ko(ot, O, R, W, U, J || []);
+            if (X(Ve))
+              return ot > 0 ? null : Tt(
+                Dn(Kt(O, C), Oe, J),
+                [],
+                C,
+                U,
+                Oe,
+                W
+              );
+            const Ye = [];
+            if (D.length > 0) {
+              const ae = D[0], le = D[D.length - 1];
+              let de = 0;
+              for (const se of Je(Ve, ae, le)) {
+                const Z = se.value, Q = Math.max(se.start, ae), ze = Math.min(se.end, le);
+                for (let he = Q; he <= ze; he++)
+                  Ye.push({ data: J?.[he], index: he, offset: de, size: Z }), de += Z;
+              }
+            }
+            if (!L)
+              return Tt([], Ye, C, U, Oe, W);
+            const Le = D.length > 0 ? D[D.length - 1] + 1 : 0, y = Hn(be, a, p, Le);
+            if (y.length === 0)
+              return null;
+            const $ = C - 1, ne = zt([], (ae) => {
+              for (const le of y) {
+                const de = le.value;
+                let se = de.offset, Z = le.start;
+                const Q = de.size;
+                if (de.offset < a) {
+                  Z += Math.floor((a - de.offset + U) / (Q + U));
+                  const he = Z - le.start;
+                  se += he * Q + he * U;
+                }
+                Z < Le && (se += (Le - Z) * Q, Z = Le);
+                const ze = Math.min(le.end, $);
+                for (let he = Z; he <= ze && !(se >= p); he++)
+                  ae.push({ data: J?.[he], index: he, offset: se, size: Q }), se += Q + U;
+              }
+            }), fe = xo(Y, dt), Ce = xo(Y, ft);
+            if (ne.length > 0 && (fe > 0 || Ce > 0)) {
+              const ae = ne[0], le = ne[ne.length - 1];
+              if (fe > 0 && ae.index > Le) {
+                const de = Math.min(fe, ae.index - Le), se = [];
+                let Z = ae.offset;
+                for (let Q = ae.index - 1; Q >= ae.index - de; Q--) {
+                  const ze = (Ie = (ve = Je(Ve, Q, Q)[0]) == null ? void 0 : ve.value) != null ? Ie : ae.size;
+                  Z -= ze + U, se.unshift({ data: J?.[Q], index: Q, offset: Z, size: ze });
+                }
+                ne.unshift(...se);
+              }
+              if (Ce > 0 && le.index < $) {
+                const de = Math.min(Ce, $ - le.index);
+                let se = le.offset + le.size + U;
+                for (let Z = le.index + 1; Z <= le.index + de; Z++) {
+                  const Q = (Te = (xe = Je(Ve, Z, Z)[0]) == null ? void 0 : xe.value) != null ? Te : le.size;
+                  ne.push({ data: J?.[Z], index: Z, offset: se, size: Q }), se += Q + U;
+                }
+              }
+            }
+            return Tt(ne, Ye, C, U, Oe, W);
+          }
+        ),
+        //@ts-expect-error filter needs to be fixed
+        M((a) => a !== null),
+        ee()
+      ),
+      Bt
+    );
+    k(
+      v(
+        e,
+        M(Lt),
+        B((a) => a?.length)
+      ),
+      r
+    ), k(
+      v(
+        w,
+        B((a) => a.topListHeight)
+      ),
+      x
+    ), k(x, s), k(
+      v(
+        w,
+        B((a) => [a.top, a.bottom])
+      ),
+      l
+    ), k(
+      v(
+        w,
+        B((a) => a.items)
+      ),
+      c
+    );
+    const E = we(
+      v(
+        w,
+        M(({ items: a }) => a.length > 0),
+        _(r, e),
+        M(([{ items: a }, p]) => a[a.length - 1].originalIndex === p - 1),
+        B(([, a, p]) => [a - 1, p]),
+        ee(ut),
+        B(([a]) => a)
+      )
+    ), b = we(
+      v(
+        w,
+        Ae(200),
+        M(({ items: a, topItems: p }) => a.length > 0 && a[0].originalIndex === p.length),
+        B(({ items: a }) => a[0].index),
+        ee()
+      )
+    ), F = we(
+      v(
+        w,
+        M(({ items: a }) => a.length > 0),
+        B(({ items: a }) => {
+          let p = 0, C = a.length - 1;
+          for (; a[p].type === "group" && p < C; )
+            p++;
+          for (; a[C].type === "group" && C > p; )
+            C--;
+          return {
+            endIndex: a[C].index,
+            startIndex: a[p].index
+          };
+        }),
+        ee(Lo)
+      )
+    );
+    return {
+      endReached: E,
+      initialItemCount: g,
+      itemsRendered: c,
+      listState: w,
+      minOverscanItemCount: f,
+      rangeChanged: F,
+      startReached: b,
+      topItemsIndexes: T,
+      ...m
+    };
+  },
+  oe(
+    Me,
+    _o,
+    $t,
+    mt,
+    ht,
+    gt,
+    Ne,
+    _t
+  ),
+  { singleton: !0 }
+), $o = K(
+  ([{ fixedFooterHeight: e, fixedHeaderHeight: t, footerHeight: o, headerHeight: n }, { listState: r }]) => {
+    const i = j(), l = me(
+      v(
+        ue(o, e, n, t, r),
+        B(([s, u, d, h, x]) => s + u + d + h + x.offsetBottom + x.bottom)
+      ),
+      0
+    );
+    return k(P(l), i), { totalListHeight: l, totalListHeightChanged: i };
+  },
+  oe(ge, qe),
+  { singleton: !0 }
+), Gn = K(
+  ([{ viewportHeight: e }, { totalListHeight: t }]) => {
+    const o = S(!1), n = me(
+      v(
+        ue(o, e, t),
+        M(([r]) => r),
+        B(([, r, i]) => Math.max(0, r - i)),
+        Ae(0),
+        ee()
+      ),
+      0
+    );
+    return { alignToBottom: o, paddingTopAddition: n };
+  },
+  oe(ge, $o),
+  { singleton: !0 }
+), qo = K(() => ({
+  context: S(null)
+})), Nn = ({
+  itemBottom: e,
+  itemTop: t,
+  locationParams: { align: o, behavior: n, ...r },
+  viewportBottom: i,
+  viewportTop: l
+}) => t < l ? { ...r, align: o ?? "start", behavior: n } : e > i ? { ...r, align: o ?? "end", behavior: n } : null, Yo = K(
+  ([
+    { gap: e, sizes: t, totalCount: o },
+    { fixedFooterHeight: n, fixedHeaderHeight: r, headerHeight: i, scrollingInProgress: l, scrollTop: s, viewportHeight: u },
+    { scrollToIndex: d }
+  ]) => {
+    const h = j();
+    return k(
+      v(
+        h,
+        _(t, u, o, i, r, n, s),
+        _(e),
+        B(([[x, m, I, z, T, g, c, f], w]) => {
+          const { align: E, behavior: b, calculateViewLocation: F = Nn, done: a, ...p } = x, C = No(x, m, z - 1), R = at(C, m.offsetTree, w) + T + g, O = R + Ee(m.sizeTree, C)[1], L = f + g, D = f + I - c, W = F({
+            itemBottom: O,
+            itemTop: R,
+            locationParams: { align: E, behavior: b, ...p },
+            viewportBottom: D,
+            viewportTop: L
+          });
+          return W ? a && He(
+            v(
+              l,
+              M((U) => !U),
+              // skips the initial publish of false, and the cleanup call.
+              // but if scrollingInProgress is true, we skip the initial publish.
+              $e(ie(l) ? 1 : 2)
+            ),
+            a
+          ) : a?.(), W;
+        }),
+        M((x) => x !== null)
+      ),
+      d
+    ), {
+      scrollIntoView: h
+    };
+  },
+  oe(Me, ge, ht, qe, Ge),
+  { singleton: !0 }
+);
+function To(e) {
+  return e ? e === "smooth" ? "smooth" : "auto" : !1;
+}
+const _n = (e, t) => typeof e == "function" ? To(e(t)) : t && To(e), Un = K(
+  ([
+    { listRefresh: e, totalCount: t, fixedItemSize: o, data: n },
+    { atBottomState: r, isAtBottom: i },
+    { scrollToIndex: l },
+    { scrolledToInitialItem: s },
+    { didMount: u, propsReady: d },
+    { log: h },
+    { scrollingInProgress: x },
+    { context: m },
+    { scrollIntoView: I }
+  ]) => {
+    const z = S(!1), T = j();
+    let g = null;
+    function c(b) {
+      N(l, {
+        align: "end",
+        behavior: b,
+        index: "LAST"
+      });
+    }
+    q(
+      v(
+        ue(v(P(t), $e(1)), u),
+        _(P(z), i, s, x),
+        B(([[b, F], a, p, C, R]) => {
+          let O = F && C, L = "auto";
+          return O && (L = _n(a, p || R), O = O && !!L), { followOutputBehavior: L, shouldFollow: O, totalCount: b };
+        }),
+        M(({ shouldFollow: b }) => b)
+      ),
+      ({ followOutputBehavior: b, totalCount: F }) => {
+        g && (g(), g = null), ie(o) ? requestAnimationFrame(() => {
+          ie(h)("following output to ", { totalCount: F }, pe.DEBUG), c(b);
+        }) : g = He(e, () => {
+          ie(h)("following output to ", { totalCount: F }, pe.DEBUG), c(b), g = null;
+        });
+      }
+    );
+    function f(b) {
+      const F = He(r, (a) => {
+        b && !a.atBottom && a.notAtBottomBecause === "SIZE_INCREASED" && !g && (ie(h)("scrolling to bottom due to increased size", {}, pe.DEBUG), c("auto"));
+      });
+      setTimeout(F, 100);
+    }
+    q(
+      v(
+        ue(P(z), t, d),
+        M(([b, , F]) => b && F),
+        We(
+          ({ value: b }, [, F]) => ({ refreshed: b === F, value: F }),
+          { refreshed: !1, value: 0 }
+        ),
+        M(({ refreshed: b }) => b),
+        _(z, t)
+      ),
+      ([, b]) => {
+        ie(s) && f(b !== !1);
+      }
+    ), q(T, () => {
+      f(ie(z) !== !1);
+    }), q(ue(P(z), r), ([b, F]) => {
+      b && !F.atBottom && F.notAtBottomBecause === "VIEWPORT_HEIGHT_DECREASING" && c("auto");
+    });
+    const w = S(null), E = j();
+    return k(
+      Ft(
+        v(
+          P(n),
+          B((b) => {
+            var F;
+            return (F = b?.length) != null ? F : 0;
+          })
+        ),
+        v(P(t))
+      ),
+      E
+    ), q(
+      v(
+        ue(v(E, $e(1)), u),
+        _(P(w), s, x, m),
+        B(([[b, F], a, p, C, R]) => F && p && a?.({ context: R, totalCount: b, scrollingInProgress: C })),
+        M((b) => !!b),
+        Ae(0)
+      ),
+      (b) => {
+        g && (g(), g = null), ie(o) ? requestAnimationFrame(() => {
+          ie(h)("scrolling into view", {}), N(I, b);
+        }) : g = He(e, () => {
+          ie(h)("scrolling into view", {}), N(I, b), g = null;
+        });
+      }
+    ), { autoscrollToBottom: T, followOutput: z, scrollIntoViewOnChange: w };
+  },
+  oe(
+    Me,
+    gt,
+    ht,
+    mt,
+    Ne,
+    Ge,
+    ge,
+    qo,
+    Yo
+  )
+), jn = K(
+  ([{ data: e, firstItemIndex: t, gap: o, sizes: n }, { initialTopMostItemIndex: r }, { initialItemCount: i, listState: l }, { didMount: s }]) => (k(
+    v(
+      s,
+      _(i),
+      M(([, u]) => u !== 0),
+      _(r, n, t, o, e),
+      B(([[, u], d, h, x, m, I = []]) => Ko(u, d, h, x, m, I))
+    ),
+    l
+  ), {}),
+  oe(Me, mt, qe, Ne),
+  { singleton: !0 }
+), Kn = K(
+  ([{ didMount: e }, { scrollTo: t }, { listState: o }]) => {
+    const n = S(0);
+    return q(
+      v(
+        e,
+        _(n),
+        M(([, r]) => r !== 0),
+        B(([, r]) => ({ top: r }))
+      ),
+      (r) => {
+        He(
+          v(
+            o,
+            $e(1),
+            M((i) => i.items.length > 1)
+          ),
+          () => {
+            requestAnimationFrame(() => {
+              N(t, r);
+            });
+          }
+        );
+      }
+    ), {
+      initialScrollTop: n
+    };
+  },
+  oe(Ne, ge, qe),
+  { singleton: !0 }
+), Zo = K(
+  ([{ scrollVelocity: e }]) => {
+    const t = S(!1), o = j(), n = S(!1);
+    return k(
+      v(
+        e,
+        _(n, t, o),
+        M(([r, i]) => !!i),
+        B(([r, i, l, s]) => {
+          const { enter: u, exit: d } = i;
+          if (l) {
+            if (d(r, s))
+              return !1;
+          } else if (u(r, s))
+            return !0;
+          return l;
+        }),
+        ee()
+      ),
+      t
+    ), q(
+      v(ue(t, e, o), _(n)),
+      ([[r, i, l], s]) => {
+        r && s && s.change && s.change(i, l);
+      }
+    ), { isSeeking: t, scrollSeekConfiguration: n, scrollSeekRangeChanged: o, scrollVelocity: e };
+  },
+  oe(gt),
+  { singleton: !0 }
+), qt = K(([{ scrollContainerState: e, scrollTo: t }]) => {
+  const o = j(), n = j(), r = j(), i = S(!1), l = S(void 0);
+  return k(
+    v(
+      ue(o, n),
+      B(([{ scrollHeight: s, scrollTop: u, viewportHeight: d }, { offsetTop: h }]) => ({
+        scrollHeight: s,
+        scrollTop: Math.max(0, u - h),
+        viewportHeight: d
+      }))
+    ),
+    e
+  ), k(
+    v(
+      t,
+      _(n),
+      B(([s, { offsetTop: u }]) => ({
+        ...s,
+        top: s.top + u
+      }))
+    ),
+    r
+  ), {
+    customScrollParent: l,
+    // config
+    useWindowScroll: i,
+    // input
+    windowScrollContainerState: o,
+    // signals
+    windowScrollTo: r,
+    windowViewportRect: n
+  };
+}, oe(ge)), $n = K(
+  ([
+    { sizeRanges: e, sizes: t },
+    { headerHeight: o, scrollTop: n },
+    { initialTopMostItemIndex: r },
+    { didMount: i },
+    { useWindowScroll: l, windowScrollContainerState: s, windowViewportRect: u }
+  ]) => {
+    const d = j(), h = S(void 0), x = S(null), m = S(null);
+    return k(s, x), k(u, m), q(
+      v(
+        d,
+        _(t, n, l, x, m, o)
+      ),
+      ([I, z, T, g, c, f, w]) => {
+        const E = En(z.sizeTree);
+        g && c !== null && f !== null && (T = c.scrollTop - f.offsetTop), T -= w, I({ ranges: E, scrollTop: T });
+      }
+    ), k(v(h, M(Lt), B(qn)), r), k(
+      v(
+        i,
+        _(h),
+        M(([, I]) => I !== void 0),
+        ee(),
+        B(([, I]) => I.ranges)
+      ),
+      e
+    ), {
+      getState: d,
+      restoreStateFrom: h
+    };
+  },
+  oe(Me, ge, mt, Ne, qt)
+);
+function qn(e) {
+  return { align: "start", index: 0, offset: e.scrollTop };
+}
+const Yn = K(([{ topItemsIndexes: e }]) => {
+  const t = S(0);
+  return k(
+    v(
+      t,
+      M((o) => o >= 0),
+      B((o) => Array.from({ length: o }).map((n, r) => r))
+    ),
+    e
+  ), { topItemCount: t };
+}, oe(qe));
+function Xo(e) {
+  let t = !1, o;
+  return (() => (t || (t = !0, o = e()), o));
+}
+const Zn = Xo(() => /iP(ad|od|hone)/i.test(navigator.userAgent) && /WebKit/i.test(navigator.userAgent)), Xn = K(
+  ([
+    { deviation: e, scrollBy: t, scrollingInProgress: o, scrollTop: n },
+    { isAtBottom: r, isScrolling: i, lastJumpDueToItemResize: l, scrollDirection: s },
+    { listState: u },
+    { beforeUnshiftWith: d, gap: h, shiftWithOffset: x, sizes: m },
+    { log: I },
+    { recalcInProgress: z }
+  ]) => {
+    const T = we(
+      v(
+        u,
+        _(l),
+        We(
+          ([, c, f, w], [{ bottom: E, items: b, offsetBottom: F, totalCount: a }, p]) => {
+            const C = E + F;
+            let R = 0;
+            return f === a && c.length > 0 && b.length > 0 && (b[0].originalIndex === 0 && c[0].originalIndex === 0 || (R = C - w, R !== 0 && (R += p))), [R, b, a, C];
+          },
+          [0, [], 0, 0]
+        ),
+        M(([c]) => c !== 0),
+        _(n, s, o, r, I, z),
+        M(([, c, f, w, , , E]) => !E && !w && c !== 0 && f === ct),
+        B(([[c], , , , , f]) => (f("Upward scrolling compensation", { amount: c }, pe.DEBUG), c))
+      )
+    );
+    function g(c) {
+      c > 0 ? (N(t, { behavior: "auto", top: -c }), N(e, 0)) : (N(e, 0), N(t, { behavior: "auto", top: -c }));
+    }
+    return q(v(T, _(e, i)), ([c, f, w]) => {
+      w && Zn() ? N(e, f - c) : g(-c);
+    }), q(
+      v(
+        ue(me(i, !1), e, z),
+        M(([c, f, w]) => !c && !w && f !== 0),
+        B(([c, f]) => f),
+        Ae(1)
+      ),
+      g
+    ), k(
+      v(
+        x,
+        B((c) => ({ top: -c }))
+      ),
+      t
+    ), q(
+      v(
+        d,
+        _(m, h),
+        B(([c, { groupIndices: f, lastSize: w, sizeTree: E }, b]) => {
+          function F(a) {
+            return a * (w + b);
+          }
+          if (f.length === 0)
+            return F(c);
+          {
+            let a = 0;
+            const p = st(E, 0);
+            let C = 0, R = 0;
+            for (; C < c; ) {
+              C++, a += p;
+              let O = f.length === R + 1 ? 1 / 0 : f[R + 1] - f[R] - 1;
+              C + O > c && (a -= p, O = c - C + 1), C += O, a += F(O), R++;
+            }
+            return a;
+          }
+        })
+      ),
+      (c) => {
+        N(e, c), requestAnimationFrame(() => {
+          N(t, { top: c }), requestAnimationFrame(() => {
+            N(e, 0), N(z, !1);
+          });
+        });
+      }
+    ), { deviation: e };
+  },
+  oe(ge, gt, qe, Me, Ge, _t)
+), Jn = K(
+  ([
+    e,
+    t,
+    o,
+    n,
+    r,
+    i,
+    l,
+    s,
+    u,
+    d,
+    h
+  ]) => ({
+    ...e,
+    ...t,
+    ...o,
+    ...n,
+    ...r,
+    ...i,
+    ...l,
+    ...s,
+    ...u,
+    ...d,
+    ...h
+  }),
+  oe(
+    $t,
+    jn,
+    Ne,
+    Zo,
+    $o,
+    Kn,
+    Gn,
+    qt,
+    Yo,
+    Ge,
+    qo
+  )
+), Jo = K(
+  ([
+    {
+      data: e,
+      defaultItemSize: t,
+      firstItemIndex: o,
+      fixedItemSize: n,
+      fixedGroupSize: r,
+      gap: i,
+      groupIndices: l,
+      heightEstimates: s,
+      itemSize: u,
+      sizeRanges: d,
+      sizes: h,
+      statefulTotalCount: x,
+      totalCount: m,
+      trackItemSizes: I
+    },
+    { initialItemFinalLocationReached: z, initialTopMostItemIndex: T, scrolledToInitialItem: g },
+    c,
+    f,
+    w,
+    E,
+    { scrollToIndex: b },
+    F,
+    { topItemCount: a },
+    { groupCounts: p },
+    C
+  ]) => {
+    const { listState: R, minOverscanItemCount: O, topItemsIndexes: L, rangeChanged: D, ...W } = E;
+    return k(D, C.scrollSeekRangeChanged), k(
+      v(
+        C.windowViewportRect,
+        B((U) => U.visibleHeight)
+      ),
+      c.viewportHeight
+    ), {
+      data: e,
+      defaultItemHeight: t,
+      firstItemIndex: o,
+      fixedItemHeight: n,
+      fixedGroupHeight: r,
+      gap: i,
+      groupCounts: p,
+      heightEstimates: s,
+      initialItemFinalLocationReached: z,
+      initialTopMostItemIndex: T,
+      scrolledToInitialItem: g,
+      sizeRanges: d,
+      topItemCount: a,
+      topItemsIndexes: L,
+      // input
+      totalCount: m,
+      ...w,
+      groupIndices: l,
+      itemSize: u,
+      listState: R,
+      minOverscanItemCount: O,
+      scrollToIndex: b,
+      // output
+      statefulTotalCount: x,
+      trackItemSizes: I,
+      // exported from stateFlagsSystem
+      rangeChanged: D,
+      ...W,
+      // the bag of IO from featureGroup1System
+      ...C,
+      ...c,
+      sizes: h,
+      ...f
+    };
+  },
+  oe(
+    Me,
+    mt,
+    ge,
+    $n,
+    Un,
+    qe,
+    ht,
+    Xn,
+    Yn,
+    _o,
+    Jn
+  )
+);
+function Qn(e, t) {
+  const o = {}, n = {};
+  let r = 0;
+  const i = e.length;
+  for (; r < i; )
+    n[e[r]] = 1, r += 1;
+  for (const l in t)
+    Object.hasOwn(n, l) || (o[l] = t[l]);
+  return o;
+}
+const vt = typeof document < "u" ? H.useLayoutEffect : H.useEffect;
+function Yt(e, t, o) {
+  const n = Object.keys(t.required || {}), r = Object.keys(t.optional || {}), i = Object.keys(t.methods || {}), l = Object.keys(t.events || {}), s = H.createContext({});
+  function u(g, c) {
+    g.propsReady && N(g.propsReady, !1);
+    for (const f of n) {
+      const w = g[t.required[f]];
+      N(w, c[f]);
+    }
+    for (const f of r)
+      if (f in c) {
+        const w = g[t.optional[f]];
+        N(w, c[f]);
+      }
+    g.propsReady && N(g.propsReady, !0);
+  }
+  function d(g) {
+    return i.reduce((c, f) => (c[f] = (w) => {
+      const E = g[t.methods[f]];
+      N(E, w);
+    }, c), {});
+  }
+  function h(g) {
+    return l.reduce((c, f) => (c[f] = pn(g[t.events[f]]), c), {});
+  }
+  const x = H.forwardRef((g, c) => {
+    const { children: f, ...w } = g, [E] = H.useState(() => zt(In(e), (a) => {
+      u(a, w);
+    })), [b] = H.useState(ao(h, E));
+    vt(() => {
+      for (const a of l)
+        a in w && q(b[a], w[a]);
+      return () => {
+        Object.values(b).map(Dt);
+      };
+    }, [w, b, E]), vt(() => {
+      u(E, w);
+    }), H.useImperativeHandle(c, uo(d(E)));
+    const F = o;
+    return /* @__PURE__ */ A(s.Provider, { value: E, children: o ? /* @__PURE__ */ A(F, { ...Qn([...n, ...r, ...l], w), children: f }) : f });
+  }), m = (g) => {
+    const c = H.useContext(s);
+    return H.useCallback(
+      (f) => {
+        N(c[g], f);
+      },
+      [c, g]
+    );
+  }, I = (g) => {
+    const c = H.useContext(s)[g], f = H.useCallback(
+      (w) => q(c, w),
+      [c]
+    );
+    return H.useSyncExternalStore(
+      f,
+      () => ie(c),
+      () => ie(c)
+    );
+  }, z = (g) => {
+    const c = H.useContext(s)[g], [f, w] = H.useState(ao(ie, c));
+    return vt(
+      () => q(c, (E) => {
+        E !== f && w(uo(E));
+      }),
+      [c, f]
+    ), f;
+  }, T = H.version.startsWith("18") ? I : z;
+  return {
+    Component: x,
+    useEmitter: (g, c) => {
+      const f = H.useContext(s)[g];
+      vt(() => q(f, c), [c, f]);
+    },
+    useEmitterValue: T,
+    usePublisher: m
+  };
+}
+const yt = H.createContext(void 0), Qo = H.createContext(void 0), en = typeof document < "u" ? H.useLayoutEffect : H.useEffect;
+function Et(e) {
+  return "self" in e;
+}
+function er(e) {
+  return "body" in e;
+}
+function tn(e, t, o, n = et, r, i) {
+  const l = H.useRef(null), s = H.useRef(null), u = H.useRef(null), d = H.useCallback(
+    (m) => {
+      let I, z, T;
+      const g = m.target;
+      if (er(g) || Et(g)) {
+        const f = Et(g) ? g : g.defaultView;
+        T = i ? f.scrollX : f.scrollY, I = i ? f.document.documentElement.scrollWidth : f.document.documentElement.scrollHeight, z = i ? f.innerWidth : f.innerHeight;
+      } else
+        T = i ? g.scrollLeft : g.scrollTop, I = i ? g.scrollWidth : g.scrollHeight, z = i ? g.offsetWidth : g.offsetHeight;
+      const c = () => {
+        e({
+          scrollHeight: I,
+          scrollTop: Math.max(T, 0),
+          viewportHeight: z
+        });
+      };
+      m.suppressFlushSync ? c() : cn.flushSync(c), s.current !== null && (T === s.current || T <= 0 || T === I - z) && (s.current = null, t(!0), u.current && (clearTimeout(u.current), u.current = null));
+    },
+    [e, t, i]
+  );
+  H.useEffect(() => {
+    const m = r || l.current;
+    return n(r || l.current), d({ suppressFlushSync: !0, target: m }), m.addEventListener("scroll", d, { passive: !0 }), () => {
+      n(null), m.removeEventListener("scroll", d);
+    };
+  }, [l, d, o, n, r]);
+  function h(m) {
+    const I = l.current;
+    if (!I || (i ? "offsetWidth" in I && I.offsetWidth === 0 : "offsetHeight" in I && I.offsetHeight === 0))
+      return;
+    const z = m.behavior === "smooth";
+    let T, g, c;
+    Et(I) ? (g = Math.max(
+      ke(I.document.documentElement, i ? "width" : "height"),
+      i ? I.document.documentElement.scrollWidth : I.document.documentElement.scrollHeight
+    ), T = i ? I.innerWidth : I.innerHeight, c = i ? window.scrollX : window.scrollY) : (g = I[i ? "scrollWidth" : "scrollHeight"], T = ke(I, i ? "width" : "height"), c = I[i ? "scrollLeft" : "scrollTop"]);
+    const f = g - T;
+    if (m.top = Math.ceil(Math.max(Math.min(f, m.top), 0)), jo(T, g) || m.top === c) {
+      e({ scrollHeight: g, scrollTop: c, viewportHeight: T }), z && t(!0);
+      return;
+    }
+    z ? (s.current = m.top, u.current && clearTimeout(u.current), u.current = setTimeout(() => {
+      u.current = null, s.current = null, t(!0);
+    }, 1e3)) : s.current = null, i && (m = { behavior: m.behavior, left: m.top }), I.scrollTo(m);
+  }
+  function x(m) {
+    i && (m = { behavior: m.behavior, left: m.top }), l.current.scrollBy(m);
+  }
+  return { scrollByCallback: x, scrollerRef: l, scrollToCallback: h };
+}
+const kt = "-webkit-sticky", So = "sticky", Zt = Xo(() => {
+  if (typeof document > "u")
+    return So;
+  const e = document.createElement("div");
+  return e.style.position = kt, e.style.position === kt ? kt : So;
+});
+function Xt(e) {
+  return e;
+}
+const tr = /* @__PURE__ */ K(() => {
+  const e = S((s) => `Item ${s}`), t = S((s) => `Group ${s}`), o = S({}), n = S(Xt), r = S("div"), i = S(et), l = (s, u = null) => me(
+    v(
+      o,
+      B((d) => d[s]),
+      ee()
+    ),
+    u
+  );
+  return {
+    components: o,
+    computeItemKey: n,
+    EmptyPlaceholder: l("EmptyPlaceholder"),
+    FooterComponent: l("Footer"),
+    GroupComponent: l("Group", "div"),
+    groupContent: t,
+    HeaderComponent: l("Header"),
+    HeaderFooterTag: r,
+    ItemComponent: l("Item", "div"),
+    itemContent: e,
+    ListComponent: l("List", "div"),
+    ScrollerComponent: l("Scroller", "div"),
+    scrollerRef: i,
+    ScrollSeekPlaceholder: l("ScrollSeekPlaceholder"),
+    TopItemListComponent: l("TopItemList")
+  };
+}), or = /* @__PURE__ */ K(
+  ([e, t]) => ({ ...e, ...t }),
+  oe(Jo, tr)
+), nr = ({ height: e }) => /* @__PURE__ */ A("div", { style: { height: e } }), rr = { overflowAnchor: "none", position: Zt(), zIndex: 1 }, on = { overflowAnchor: "none" }, ir = { ...on, display: "inline-block", height: "100%" }, wo = /* @__PURE__ */ H.memo(function({ showTopList: e = !1 }) {
+  const t = V("listState"), o = Re("sizeRanges"), n = V("useWindowScroll"), r = V("customScrollParent"), i = Re("windowScrollContainerState"), l = Re("scrollContainerState"), s = r || n ? i : l, u = V("itemContent"), d = V("context"), h = V("groupContent"), x = V("trackItemSizes"), m = V("itemSize"), I = V("log"), z = Re("gap"), T = V("horizontalDirection"), { callbackRef: g } = Fo(
+    o,
+    m,
+    x,
+    e ? et : s,
+    I,
+    z,
+    r,
+    T,
+    V("skipAnimationFrameInResizeObserver")
+  ), [c, f] = H.useState(0);
+  eo("deviation", (W) => {
+    c !== W && f(W);
+  });
+  const w = V("EmptyPlaceholder"), E = V("ScrollSeekPlaceholder") || nr, b = V("ListComponent"), F = V("ItemComponent"), a = V("GroupComponent"), p = V("computeItemKey"), C = V("isSeeking"), R = V("groupIndices").length > 0, O = V("alignToBottom"), L = V("initialItemFinalLocationReached"), D = e ? {} : {
+    boxSizing: "border-box",
+    ...T ? {
+      display: "inline-block",
+      height: "100%",
+      marginLeft: c !== 0 ? c : O ? "auto" : 0,
+      paddingLeft: t.offsetTop,
+      paddingRight: t.offsetBottom,
+      whiteSpace: "nowrap"
+    } : {
+      marginTop: c !== 0 ? c : O ? "auto" : 0,
+      paddingBottom: t.offsetBottom,
+      paddingTop: t.offsetTop
+    },
+    ...L ? {} : { visibility: "hidden" }
+  };
+  return !e && t.totalCount === 0 && w ? /* @__PURE__ */ A(w, { ...te(w, d) }) : /* @__PURE__ */ A(
+    b,
+    {
+      ...te(b, d),
+      "data-testid": e ? "virtuoso-top-item-list" : "virtuoso-item-list",
+      ref: g,
+      style: D,
+      children: (e ? t.topItems : t.items).map((W) => {
+        const U = W.originalIndex, Y = p(U + t.firstItemIndex, W.data, d);
+        return C ? /* @__PURE__ */ je(
+          E,
+          {
+            ...te(E, d),
+            height: W.size,
+            index: W.index,
+            key: Y,
+            type: W.type || "item",
+            ...W.type === "group" ? {} : { groupIndex: W.groupIndex }
+          }
+        ) : W.type === "group" ? /* @__PURE__ */ je(
+          a,
+          {
+            ...te(a, d),
+            "data-index": U,
+            "data-item-index": W.index,
+            "data-known-size": W.size,
+            key: Y,
+            style: rr
+          },
+          h(W.index, d)
+        ) : /* @__PURE__ */ je(
+          F,
+          {
+            ...te(F, d),
+            ...nn(F, W.data),
+            "data-index": U,
+            "data-item-group-index": W.groupIndex,
+            "data-item-index": W.index,
+            "data-known-size": W.size,
+            key: Y,
+            style: T ? ir : on
+          },
+          R ? u(W.index, W.groupIndex, W.data, d) : u(W.index, W.data, d)
+        );
+      })
+    }
+  );
+}), lr = {
+  height: "100%",
+  outline: "none",
+  overflowY: "auto",
+  position: "relative",
+  WebkitOverflowScrolling: "touch"
+}, sr = {
+  outline: "none",
+  overflowX: "auto",
+  position: "relative"
+}, tt = (e) => ({
+  height: "100%",
+  position: "absolute",
+  top: 0,
+  width: "100%",
+  ...e ? { display: "flex", flexDirection: "column" } : {}
+}), ur = {
+  position: Zt(),
+  top: 0,
+  width: "100%",
+  zIndex: 1
+};
+function te(e, t) {
+  if (typeof e != "string")
+    return { context: t };
+}
+function nn(e, t) {
+  return { item: typeof e == "string" ? void 0 : t };
+}
+const ar = /* @__PURE__ */ H.memo(function() {
+  const e = V("HeaderComponent"), t = Re("headerHeight"), o = V("HeaderFooterTag"), n = Pe(
+    H.useMemo(
+      () => (i) => {
+        t(ke(i, "height"));
+      },
+      [t]
+    ),
+    !0,
+    V("skipAnimationFrameInResizeObserver")
+  ), r = V("context");
+  return e ? /* @__PURE__ */ A(o, { ref: n, children: /* @__PURE__ */ A(e, { ...te(e, r) }) }) : null;
+}), cr = /* @__PURE__ */ H.memo(function() {
+  const e = V("FooterComponent"), t = Re("footerHeight"), o = V("HeaderFooterTag"), n = Pe(
+    H.useMemo(
+      () => (i) => {
+        t(ke(i, "height"));
+      },
+      [t]
+    ),
+    !0,
+    V("skipAnimationFrameInResizeObserver")
+  ), r = V("context");
+  return e ? /* @__PURE__ */ A(o, { ref: n, children: /* @__PURE__ */ A(e, { ...te(e, r) }) }) : null;
+});
+function Jt({ useEmitter: e, useEmitterValue: t, usePublisher: o }) {
+  return H.memo(function({ children: n, style: r, context: i, ...l }) {
+    const s = o("scrollContainerState"), u = t("ScrollerComponent"), d = o("smoothScrollTargetReached"), h = t("scrollerRef"), x = t("horizontalDirection") || !1, { scrollByCallback: m, scrollerRef: I, scrollToCallback: z } = tn(
+      s,
+      d,
+      u,
+      h,
+      void 0,
+      x
+    );
+    return e("scrollTo", z), e("scrollBy", m), /* @__PURE__ */ A(
+      u,
+      {
+        "data-testid": "virtuoso-scroller",
+        "data-virtuoso-scroller": !0,
+        ref: I,
+        style: { ...x ? sr : lr, ...r },
+        tabIndex: 0,
+        ...l,
+        ...te(u, i),
+        children: n
+      }
+    );
+  });
+}
+function Qt({ useEmitter: e, useEmitterValue: t, usePublisher: o }) {
+  return H.memo(function({ children: n, style: r, context: i, ...l }) {
+    const s = o("windowScrollContainerState"), u = t("ScrollerComponent"), d = o("smoothScrollTargetReached"), h = t("totalListHeight"), x = t("deviation"), m = t("customScrollParent"), I = H.useRef(null), z = t("scrollerRef"), { scrollByCallback: T, scrollerRef: g, scrollToCallback: c } = tn(
+      s,
+      d,
+      u,
+      z,
+      m
+    );
+    return en(() => {
+      var f;
+      return g.current = m || ((f = I.current) == null ? void 0 : f.ownerDocument.defaultView), () => {
+        g.current = null;
+      };
+    }, [g, m]), e("windowScrollTo", c), e("scrollBy", T), /* @__PURE__ */ A(
+      u,
+      {
+        ref: I,
+        "data-virtuoso-scroller": !0,
+        style: { position: "relative", ...r, ...h !== 0 ? { height: h + x } : {} },
+        ...l,
+        ...te(u, i),
+        children: n
+      }
+    );
+  });
+}
+const dr = ({ children: e }) => {
+  const t = H.useContext(yt), o = Re("viewportHeight"), n = Re("fixedItemHeight"), r = V("alignToBottom"), i = V("horizontalDirection"), l = H.useMemo(
+    () => it(o, (u) => ke(u, i ? "width" : "height")),
+    [o, i]
+  ), s = Pe(l, !0, V("skipAnimationFrameInResizeObserver"));
+  return H.useEffect(() => {
+    t && (o(t.viewportHeight), n(t.itemHeight));
+  }, [t, o, n]), /* @__PURE__ */ A("div", { "data-viewport-type": "element", ref: s, style: tt(r), children: e });
+}, fr = ({ children: e }) => {
+  const t = H.useContext(yt), o = Re("windowViewportRect"), n = Re("fixedItemHeight"), r = V("customScrollParent"), i = Nt(
+    o,
+    r,
+    V("skipAnimationFrameInResizeObserver")
+  ), l = V("alignToBottom");
+  return H.useEffect(() => {
+    t && (n(t.itemHeight), o({ offsetTop: 0, visibleHeight: t.viewportHeight, visibleWidth: 100 }));
+  }, [t, o, n]), /* @__PURE__ */ A("div", { "data-viewport-type": "window", ref: i, style: tt(l), children: e });
+}, hr = ({ children: e }) => {
+  const t = V("TopItemListComponent") || "div", o = V("headerHeight"), n = { ...ur, marginTop: `${o}px` }, r = V("context");
+  return /* @__PURE__ */ A(t, { style: n, ...te(t, r), children: e });
+}, mr = /* @__PURE__ */ H.memo(function(e) {
+  const t = V("useWindowScroll"), o = V("topItemsIndexes").length > 0, n = V("customScrollParent"), r = V("context");
+  return /* @__PURE__ */ Ke(n || t ? vr : pr, { ...e, context: r, children: [
+    o && /* @__PURE__ */ A(hr, { children: /* @__PURE__ */ A(wo, { showTopList: !0 }) }),
+    /* @__PURE__ */ Ke(n || t ? fr : dr, { children: [
+      /* @__PURE__ */ A(ar, {}),
+      /* @__PURE__ */ A(wo, {}),
+      /* @__PURE__ */ A(cr, {})
+    ] })
+  ] });
+}), {
+  Component: gr,
+  useEmitter: eo,
+  useEmitterValue: V,
+  usePublisher: Re
+} = /* @__PURE__ */ Yt(
+  or,
+  {
+    required: {},
+    optional: {
+      restoreStateFrom: "restoreStateFrom",
+      context: "context",
+      followOutput: "followOutput",
+      scrollIntoViewOnChange: "scrollIntoViewOnChange",
+      itemContent: "itemContent",
+      groupContent: "groupContent",
+      overscan: "overscan",
+      increaseViewportBy: "increaseViewportBy",
+      minOverscanItemCount: "minOverscanItemCount",
+      totalCount: "totalCount",
+      groupCounts: "groupCounts",
+      topItemCount: "topItemCount",
+      firstItemIndex: "firstItemIndex",
+      initialTopMostItemIndex: "initialTopMostItemIndex",
+      components: "components",
+      atBottomThreshold: "atBottomThreshold",
+      atTopThreshold: "atTopThreshold",
+      computeItemKey: "computeItemKey",
+      defaultItemHeight: "defaultItemHeight",
+      fixedGroupHeight: "fixedGroupHeight",
+      // Must be set above 'fixedItemHeight'
+      fixedItemHeight: "fixedItemHeight",
+      heightEstimates: "heightEstimates",
+      itemSize: "itemSize",
+      scrollSeekConfiguration: "scrollSeekConfiguration",
+      headerFooterTag: "HeaderFooterTag",
+      data: "data",
+      initialItemCount: "initialItemCount",
+      initialScrollTop: "initialScrollTop",
+      alignToBottom: "alignToBottom",
+      useWindowScroll: "useWindowScroll",
+      customScrollParent: "customScrollParent",
+      scrollerRef: "scrollerRef",
+      logLevel: "logLevel",
+      horizontalDirection: "horizontalDirection",
+      skipAnimationFrameInResizeObserver: "skipAnimationFrameInResizeObserver"
+    },
+    methods: {
+      scrollToIndex: "scrollToIndex",
+      scrollIntoView: "scrollIntoView",
+      scrollTo: "scrollTo",
+      scrollBy: "scrollBy",
+      autoscrollToBottom: "autoscrollToBottom",
+      getState: "getState"
+    },
+    events: {
+      isScrolling: "isScrolling",
+      endReached: "endReached",
+      startReached: "startReached",
+      rangeChanged: "rangeChanged",
+      atBottomStateChange: "atBottomStateChange",
+      atTopStateChange: "atTopStateChange",
+      totalListHeightChanged: "totalListHeightChanged",
+      itemsRendered: "itemsRendered",
+      groupIndices: "groupIndices"
+    }
+  },
+  mr
+), pr = /* @__PURE__ */ Jt({ useEmitter: eo, useEmitterValue: V, usePublisher: Re }), vr = /* @__PURE__ */ Qt({ useEmitter: eo, useEmitterValue: V, usePublisher: Re }), $r = gr, Ir = /* @__PURE__ */ K(() => {
+  const e = S((d) => /* @__PURE__ */ Ke("td", { children: [
+    "Item $",
+    d
+  ] })), t = S(null), o = S((d) => /* @__PURE__ */ Ke("td", { colSpan: 1e3, children: [
+    "Group ",
+    d
+  ] })), n = S(null), r = S(null), i = S({}), l = S(Xt), s = S(et), u = (d, h = null) => me(
+    v(
+      i,
+      B((x) => x[d]),
+      ee()
+    ),
+    h
+  );
+  return {
+    components: i,
+    computeItemKey: l,
+    context: t,
+    EmptyPlaceholder: u("EmptyPlaceholder"),
+    FillerRow: u("FillerRow"),
+    fixedFooterContent: r,
+    fixedHeaderContent: n,
+    itemContent: e,
+    groupContent: o,
+    ScrollerComponent: u("Scroller", "div"),
+    scrollerRef: s,
+    ScrollSeekPlaceholder: u("ScrollSeekPlaceholder"),
+    TableBodyComponent: u("TableBody", "tbody"),
+    TableComponent: u("Table", "table"),
+    TableFooterComponent: u("TableFoot", "tfoot"),
+    TableHeadComponent: u("TableHead", "thead"),
+    TableRowComponent: u("TableRow", "tr"),
+    GroupComponent: u("Group", "tr")
+  };
+}), xr = /* @__PURE__ */ K(
+  ([e, t]) => ({ ...e, ...t }),
+  oe(Jo, Ir)
+), Tr = ({ height: e }) => /* @__PURE__ */ A("tr", { children: /* @__PURE__ */ A("td", { style: { height: e } }) }), Sr = ({ height: e }) => /* @__PURE__ */ A("tr", { children: /* @__PURE__ */ A("td", { style: { border: 0, height: e, padding: 0 } }) }), wr = { overflowAnchor: "none" }, Co = { position: Zt(), zIndex: 2, overflowAnchor: "none" }, zo = /* @__PURE__ */ H.memo(function({ showTopList: e = !1 }) {
+  const t = G("listState"), o = G("computeItemKey"), n = G("firstItemIndex"), r = G("context"), i = G("isSeeking"), l = G("fixedHeaderHeight"), s = G("groupIndices").length > 0, u = G("itemContent"), d = G("groupContent"), h = G("ScrollSeekPlaceholder") || Tr, x = G("GroupComponent"), m = G("TableRowComponent"), I = (e ? t.topItems : []).reduce((T, g, c) => (c === 0 ? T.push(g.size) : T.push(T[c - 1] + g.size), T), []), z = (e ? t.topItems : t.items).map((T) => {
+    const g = T.originalIndex, c = o(g + n, T.data, r), f = e ? g === 0 ? 0 : I[g - 1] : 0;
+    return i ? /* @__PURE__ */ je(
+      h,
+      {
+        ...te(h, r),
+        height: T.size,
+        index: T.index,
+        key: c,
+        type: T.type || "item"
+      }
+    ) : T.type === "group" ? /* @__PURE__ */ je(
+      x,
+      {
+        ...te(x, r),
+        "data-index": g,
+        "data-item-index": T.index,
+        "data-known-size": T.size,
+        key: c,
+        style: {
+          ...Co,
+          top: l
+        }
+      },
+      d(T.index, r)
+    ) : /* @__PURE__ */ je(
+      m,
+      {
+        ...te(m, r),
+        ...nn(m, T.data),
+        "data-index": g,
+        "data-item-index": T.index,
+        "data-known-size": T.size,
+        "data-item-group-index": T.groupIndex,
+        key: c,
+        style: e ? { ...Co, top: l + f } : wr
+      },
+      s ? u(T.index, T.groupIndex, T.data, r) : u(T.index, T.data, r)
+    );
+  });
+  return /* @__PURE__ */ A(an, { children: z });
+}), Cr = /* @__PURE__ */ H.memo(function() {
+  const e = G("listState"), t = G("topItemsIndexes").length > 0, o = Be("sizeRanges"), n = G("useWindowScroll"), r = G("customScrollParent"), i = Be("windowScrollContainerState"), l = Be("scrollContainerState"), s = r || n ? i : l, u = G("trackItemSizes"), d = G("itemSize"), h = G("log"), { callbackRef: x, ref: m } = Fo(
+    o,
+    d,
+    u,
+    s,
+    h,
+    void 0,
+    r,
+    !1,
+    G("skipAnimationFrameInResizeObserver")
+  ), [I, z] = H.useState(0);
+  to("deviation", (R) => {
+    I !== R && (m.current.style.marginTop = `${R}px`, z(R));
+  });
+  const T = G("EmptyPlaceholder"), g = G("FillerRow") || Sr, c = G("TableBodyComponent"), f = G("paddingTopAddition"), w = G("statefulTotalCount"), E = G("context");
+  if (w === 0 && T)
+    return /* @__PURE__ */ A(T, { ...te(T, E) });
+  const b = (t ? e.topItems : []).reduce((R, O) => R + O.size, 0), F = e.offsetTop + f + I - b, a = e.offsetBottom, p = F > 0 ? /* @__PURE__ */ A(g, { context: E, height: F }, "padding-top") : null, C = a > 0 ? /* @__PURE__ */ A(g, { context: E, height: a }, "padding-bottom") : null;
+  return /* @__PURE__ */ Ke(c, { "data-testid": "virtuoso-item-list", ref: x, ...te(c, E), children: [
+    p,
+    t && /* @__PURE__ */ A(zo, { showTopList: !0 }),
+    /* @__PURE__ */ A(zo, {}),
+    C
+  ] });
+}), zr = ({ children: e }) => {
+  const t = H.useContext(yt), o = Be("viewportHeight"), n = Be("fixedItemHeight"), r = Pe(
+    H.useMemo(() => it(o, (i) => ke(i, "height")), [o]),
+    !0,
+    G("skipAnimationFrameInResizeObserver")
+  );
+  return H.useEffect(() => {
+    t && (o(t.viewportHeight), n(t.itemHeight));
+  }, [t, o, n]), /* @__PURE__ */ A("div", { "data-viewport-type": "element", ref: r, style: tt(!1), children: e });
+}, Rr = ({ children: e }) => {
+  const t = H.useContext(yt), o = Be("windowViewportRect"), n = Be("fixedItemHeight"), r = G("customScrollParent"), i = Nt(
+    o,
+    r,
+    G("skipAnimationFrameInResizeObserver")
+  );
+  return H.useEffect(() => {
+    t && (n(t.itemHeight), o({ offsetTop: 0, visibleHeight: t.viewportHeight, visibleWidth: 100 }));
+  }, [t, o, n]), /* @__PURE__ */ A("div", { "data-viewport-type": "window", ref: i, style: tt(!1), children: e });
+}, yr = /* @__PURE__ */ H.memo(function(e) {
+  const t = G("useWindowScroll"), o = G("customScrollParent"), n = Be("fixedHeaderHeight"), r = Be("fixedFooterHeight"), i = G("fixedHeaderContent"), l = G("fixedFooterContent"), s = G("context"), u = Pe(
+    H.useMemo(() => it(n, (c) => ke(c, "height")), [n]),
+    !0,
+    G("skipAnimationFrameInResizeObserver")
+  ), d = Pe(
+    H.useMemo(() => it(r, (c) => ke(c, "height")), [r]),
+    !0,
+    G("skipAnimationFrameInResizeObserver")
+  ), h = o || t ? Br : Hr, x = o || t ? Rr : zr, m = G("TableComponent"), I = G("TableHeadComponent"), z = G("TableFooterComponent"), T = i ? /* @__PURE__ */ A(
+    I,
+    {
+      ref: u,
+      style: { position: "sticky", top: 0, zIndex: 2 },
+      ...te(I, s),
+      children: i()
+    },
+    "TableHead"
+  ) : null, g = l ? /* @__PURE__ */ A(
+    z,
+    {
+      ref: d,
+      style: { bottom: 0, position: "sticky", zIndex: 1 },
+      ...te(z, s),
+      children: l()
+    },
+    "TableFoot"
+  ) : null;
+  return /* @__PURE__ */ A(h, { ...e, ...te(h, s), children: /* @__PURE__ */ A(x, { children: /* @__PURE__ */ Ke(m, { style: { borderSpacing: 0, overflowAnchor: "none" }, ...te(m, s), children: [
+    T,
+    /* @__PURE__ */ A(Cr, {}, "TableBody"),
+    g
+  ] }) }) });
+}), {
+  Component: br,
+  useEmitter: to,
+  useEmitterValue: G,
+  usePublisher: Be
+} = /* @__PURE__ */ Yt(
+  xr,
+  {
+    required: {},
+    optional: {
+      restoreStateFrom: "restoreStateFrom",
+      context: "context",
+      followOutput: "followOutput",
+      firstItemIndex: "firstItemIndex",
+      itemContent: "itemContent",
+      groupContent: "groupContent",
+      fixedHeaderContent: "fixedHeaderContent",
+      fixedFooterContent: "fixedFooterContent",
+      overscan: "overscan",
+      increaseViewportBy: "increaseViewportBy",
+      minOverscanItemCount: "minOverscanItemCount",
+      totalCount: "totalCount",
+      topItemCount: "topItemCount",
+      initialTopMostItemIndex: "initialTopMostItemIndex",
+      components: "components",
+      groupCounts: "groupCounts",
+      atBottomThreshold: "atBottomThreshold",
+      atTopThreshold: "atTopThreshold",
+      computeItemKey: "computeItemKey",
+      defaultItemHeight: "defaultItemHeight",
+      fixedGroupHeight: "fixedGroupHeight",
+      // Must be set above 'fixedItemHeight'
+      fixedItemHeight: "fixedItemHeight",
+      itemSize: "itemSize",
+      scrollSeekConfiguration: "scrollSeekConfiguration",
+      data: "data",
+      initialItemCount: "initialItemCount",
+      initialScrollTop: "initialScrollTop",
+      alignToBottom: "alignToBottom",
+      useWindowScroll: "useWindowScroll",
+      customScrollParent: "customScrollParent",
+      scrollerRef: "scrollerRef",
+      logLevel: "logLevel"
+    },
+    methods: {
+      scrollToIndex: "scrollToIndex",
+      scrollIntoView: "scrollIntoView",
+      scrollTo: "scrollTo",
+      scrollBy: "scrollBy",
+      getState: "getState"
+    },
+    events: {
+      isScrolling: "isScrolling",
+      endReached: "endReached",
+      startReached: "startReached",
+      rangeChanged: "rangeChanged",
+      atBottomStateChange: "atBottomStateChange",
+      atTopStateChange: "atTopStateChange",
+      totalListHeightChanged: "totalListHeightChanged",
+      itemsRendered: "itemsRendered",
+      groupIndices: "groupIndices"
+    }
+  },
+  yr
+), Hr = /* @__PURE__ */ Jt({ useEmitter: to, useEmitterValue: G, usePublisher: Be }), Br = /* @__PURE__ */ Qt({ useEmitter: to, useEmitterValue: G, usePublisher: Be }), qr = br, Ro = {
+  bottom: 0,
+  itemHeight: 0,
+  items: [],
+  itemWidth: 0,
+  offsetBottom: 0,
+  offsetTop: 0,
+  top: 0
+}, Er = {
+  bottom: 0,
+  itemHeight: 0,
+  items: [{ index: 0 }],
+  itemWidth: 0,
+  offsetBottom: 0,
+  offsetTop: 0,
+  top: 0
+}, { ceil: yo, floor: wt, max: rt, min: Ot, round: bo } = Math;
+function Ho(e, t, o) {
+  return Array.from({ length: t - e + 1 }).map((n, r) => ({ data: o === null ? null : o[r + e], index: r + e }));
+}
+function kr(e) {
+  return {
+    ...Er,
+    items: e
+  };
+}
+function It(e, t) {
+  return e && e.width === t.width && e.height === t.height;
+}
+function Or(e, t) {
+  return e && e.column === t.column && e.row === t.row;
+}
+const Fr = /* @__PURE__ */ K(
+  ([
+    { increaseViewportBy: e, listBoundary: t, overscan: o, visibleRange: n },
+    { footerHeight: r, headerHeight: i, scrollBy: l, scrollContainerState: s, scrollTo: u, scrollTop: d, smoothScrollTargetReached: h, viewportHeight: x },
+    m,
+    I,
+    { didMount: z, propsReady: T },
+    { customScrollParent: g, useWindowScroll: c, windowScrollContainerState: f, windowScrollTo: w, windowViewportRect: E },
+    b
+  ]) => {
+    const F = S(0), a = S(0), p = S(Ro), C = S({ height: 0, width: 0 }), R = S({ height: 0, width: 0 }), O = j(), L = j(), D = S(0), W = S(null), U = S({ column: 0, row: 0 }), Y = j(), J = j(), ve = S(!1), Ie = S(0), xe = S(!0), Te = S(!1), Oe = S(!1);
+    q(
+      v(
+        z,
+        _(Ie),
+        M(([y, $]) => !!$)
+      ),
+      () => {
+        N(xe, !1);
+      }
+    ), q(
+      v(
+        ue(z, xe, R, C, Ie, Te),
+        M(([y, $, ne, fe, , Ce]) => y && !$ && ne.height !== 0 && fe.height !== 0 && !Ce)
+      ),
+      ([, , , , y]) => {
+        N(Te, !0), jt(1, () => {
+          N(O, y);
+        }), He(v(d), () => {
+          N(t, [0, 0]), N(xe, !0);
+        });
+      }
+    ), k(
+      v(
+        J,
+        M((y) => y != null && y.scrollTop > 0),
+        Fe(0)
+      ),
+      a
+    ), q(
+      v(
+        z,
+        _(J),
+        M(([, y]) => y != null)
+      ),
+      ([, y]) => {
+        y && (N(C, y.viewport), N(R, y.item), N(U, y.gap), y.scrollTop > 0 && (N(ve, !0), He(v(d, $e(1)), ($) => {
+          N(ve, !1);
+        }), N(u, { top: y.scrollTop })));
+      }
+    ), k(
+      v(
+        C,
+        B(({ height: y }) => y)
+      ),
+      x
+    ), k(
+      v(
+        ue(
+          P(C, It),
+          P(R, It),
+          P(U, (y, $) => y && y.column === $.column && y.row === $.row),
+          P(d)
+        ),
+        B(([y, $, ne, fe]) => ({
+          gap: ne,
+          item: $,
+          scrollTop: fe,
+          viewport: y
+        }))
+      ),
+      Y
+    ), k(
+      v(
+        ue(
+          P(F),
+          n,
+          P(U, Or),
+          P(R, It),
+          P(C, It),
+          P(W),
+          P(a),
+          P(ve),
+          P(xe),
+          P(Ie)
+        ),
+        M(([, , , , , , , y]) => !y),
+        B(
+          ([
+            y,
+            [$, ne],
+            fe,
+            Ce,
+            ae,
+            le,
+            de,
+            ,
+            se,
+            Z
+          ]) => {
+            const { column: Q, row: ze } = fe, { height: he, width: bt } = Ce, { width: oo } = ae;
+            if (de === 0 && (y === 0 || oo === 0))
+              return Ro;
+            if (bt === 0) {
+              const so = Kt(Z, y), un = so + Math.max(de - 1, 0);
+              return kr(Ho(so, un, le));
+            }
+            const pt = rn(oo, bt, Q);
+            let Ze, _e;
+            se ? $ === 0 && ne === 0 && de > 0 ? (Ze = 0, _e = de - 1) : (Ze = pt * wt(($ + ze) / (he + ze)), _e = pt * yo((ne + ze) / (he + ze)) - 1, _e = Ot(y - 1, rt(_e, pt - 1)), Ze = Ot(_e, rt(0, Ze))) : (Ze = 0, _e = -1);
+            const no = Ho(Ze, _e, le), { bottom: ro, top: io } = Bo(ae, fe, Ce, no), lo = yo(y / pt), sn = lo * he + (lo - 1) * ze - ro;
+            return { bottom: ro, itemHeight: he, items: no, itemWidth: bt, offsetBottom: sn, offsetTop: io, top: io };
+          }
+        )
+      ),
+      p
+    ), k(
+      v(
+        W,
+        M((y) => y !== null),
+        B((y) => y.length)
+      ),
+      F
+    ), k(
+      v(
+        ue(C, R, p, U),
+        M(([y, $, { items: ne }]) => ne.length > 0 && $.height !== 0 && y.height !== 0),
+        B(([y, $, { items: ne }, fe]) => {
+          const { bottom: Ce, top: ae } = Bo(y, fe, $, ne);
+          return [ae, Ce];
+        }),
+        ee(ut)
+      ),
+      t
+    );
+    const be = S(!1);
+    k(
+      v(
+        d,
+        _(be),
+        B(([y, $]) => $ || y !== 0)
+      ),
+      be
+    );
+    const Ve = we(
+      v(
+        ue(p, F),
+        M(([{ items: y }]) => y.length > 0),
+        _(be),
+        M(([[y, $], ne]) => {
+          const fe = y.items[y.items.length - 1].index === $ - 1;
+          return (ne || y.bottom > 0 && y.itemHeight > 0 && y.offsetBottom === 0 && y.items.length === $) && fe;
+        }),
+        B(([[, y]]) => y - 1),
+        ee()
+      )
+    ), ot = we(
+      v(
+        P(p),
+        M(({ items: y }) => y.length > 0 && y[0].index === 0),
+        Fe(0),
+        ee()
+      )
+    ), Ye = we(
+      v(
+        P(p),
+        _(ve),
+        M(([{ items: y }, $]) => y.length > 0 && !$),
+        B(([{ items: y }]) => ({
+          endIndex: y[y.length - 1].index,
+          startIndex: y[0].index
+        })),
+        ee(Lo),
+        Ae(0)
+      )
+    );
+    k(Ye, I.scrollSeekRangeChanged), k(
+      v(
+        O,
+        _(C, R, F, U),
+        B(([y, $, ne, fe, Ce]) => {
+          const ae = Uo(y), { align: le, behavior: de, offset: se } = ae;
+          let Z = ae.index;
+          Z === "LAST" && (Z = fe - 1), Z = rt(0, Z, Ot(fe - 1, Z));
+          let Q = Vt($, Ce, ne, Z);
+          return le === "end" ? Q = bo(Q - $.height + ne.height) : le === "center" && (Q = bo(Q - $.height / 2 + ne.height / 2)), se && (Q += se), { behavior: de, top: Q };
+        })
+      ),
+      u
+    );
+    const Le = me(
+      v(
+        p,
+        B((y) => y.offsetBottom + y.bottom)
+      ),
+      0
+    );
+    return k(
+      v(
+        E,
+        B((y) => ({ height: y.visibleHeight, width: y.visibleWidth }))
+      ),
+      C
+    ), {
+      customScrollParent: g,
+      // input
+      data: W,
+      deviation: D,
+      footerHeight: r,
+      gap: U,
+      headerHeight: i,
+      increaseViewportBy: e,
+      initialItemCount: a,
+      itemDimensions: R,
+      overscan: o,
+      restoreStateFrom: J,
+      scrollBy: l,
+      scrollContainerState: s,
+      scrollHeight: L,
+      scrollTo: u,
+      scrollToIndex: O,
+      scrollTop: d,
+      smoothScrollTargetReached: h,
+      totalCount: F,
+      useWindowScroll: c,
+      viewportDimensions: C,
+      windowScrollContainerState: f,
+      windowScrollTo: w,
+      windowViewportRect: E,
+      ...I,
+      // output
+      gridState: p,
+      horizontalDirection: Oe,
+      initialTopMostItemIndex: Ie,
+      totalListHeight: Le,
+      ...m,
+      endReached: Ve,
+      propsReady: T,
+      rangeChanged: Ye,
+      startReached: ot,
+      stateChanged: Y,
+      stateRestoreInProgress: ve,
+      ...b
+    };
+  },
+  oe($t, ge, gt, Zo, Ne, qt, Ge)
+);
+function rn(e, t, o) {
+  return rt(1, wt((e + o) / (wt(t) + o)));
+}
+function Bo(e, t, o, n) {
+  const { height: r } = o;
+  if (r === void 0 || n.length === 0)
+    return { bottom: 0, top: 0 };
+  const i = Vt(e, t, o, n[0].index);
+  return { bottom: Vt(e, t, o, n[n.length - 1].index) + r, top: i };
+}
+function Vt(e, t, o, n) {
+  const r = rn(e.width, o.width, t.column), i = wt(n / r), l = i * o.height + rt(0, i - 1) * t.row;
+  return l > 0 ? l + t.row : l;
+}
+const Wr = /* @__PURE__ */ K(() => {
+  const e = S((x) => `Item ${x}`), t = S({}), o = S(null), n = S("virtuoso-grid-item"), r = S("virtuoso-grid-list"), i = S(Xt), l = S("div"), s = S(et), u = (x, m = null) => me(
+    v(
+      t,
+      B((I) => I[x]),
+      ee()
+    ),
+    m
+  ), d = S(!1), h = S(!1);
+  return k(P(h), d), {
+    components: t,
+    computeItemKey: i,
+    context: o,
+    FooterComponent: u("Footer"),
+    HeaderComponent: u("Header"),
+    headerFooterTag: l,
+    itemClassName: n,
+    ItemComponent: u("Item", "div"),
+    itemContent: e,
+    listClassName: r,
+    ListComponent: u("List", "div"),
+    readyStateChanged: d,
+    reportReadyState: h,
+    ScrollerComponent: u("Scroller", "div"),
+    scrollerRef: s,
+    ScrollSeekPlaceholder: u("ScrollSeekPlaceholder", "div")
+  };
+}), Pr = /* @__PURE__ */ K(
+  ([e, t]) => ({ ...e, ...t }),
+  oe(Fr, Wr)
+), Mr = /* @__PURE__ */ H.memo(function() {
+  const e = re("gridState"), t = re("listClassName"), o = re("itemClassName"), n = re("itemContent"), r = re("computeItemKey"), i = re("isSeeking"), l = ye("scrollHeight"), s = re("ItemComponent"), u = re("ListComponent"), d = re("ScrollSeekPlaceholder"), h = re("context"), x = ye("itemDimensions"), m = ye("gap"), I = re("log"), z = re("stateRestoreInProgress"), T = ye("reportReadyState"), g = Pe(
+    H.useMemo(
+      () => (c) => {
+        const f = c.parentElement.parentElement.scrollHeight;
+        l(f);
+        const w = c.firstChild;
+        if (w) {
+          const { height: E, width: b } = w.getBoundingClientRect();
+          x({ height: E, width: b });
+        }
+        m({
+          column: Eo("column-gap", getComputedStyle(c).columnGap, I),
+          row: Eo("row-gap", getComputedStyle(c).rowGap, I)
+        });
+      },
+      [l, x, m, I]
+    ),
+    !0,
+    !1
+  );
+  return en(() => {
+    e.itemHeight > 0 && e.itemWidth > 0 && T(!0);
+  }, [e]), z ? null : /* @__PURE__ */ A(
+    u,
+    {
+      className: t,
+      ref: g,
+      ...te(u, h),
+      "data-testid": "virtuoso-item-list",
+      style: { paddingBottom: e.offsetBottom, paddingTop: e.offsetTop },
+      children: e.items.map((c) => {
+        const f = r(c.index, c.data, h);
+        return i ? /* @__PURE__ */ A(
+          d,
+          {
+            ...te(d, h),
+            height: e.itemHeight,
+            index: c.index,
+            width: e.itemWidth
+          },
+          f
+        ) : /* @__PURE__ */ je(
+          s,
+          {
+            ...te(s, h),
+            className: o,
+            "data-index": c.index,
+            key: f
+          },
+          n(c.index, c.data, h)
+        );
+      })
+    }
+  );
+}), Ar = H.memo(function() {
+  const e = re("HeaderComponent"), t = ye("headerHeight"), o = re("headerFooterTag"), n = Pe(
+    H.useMemo(
+      () => (i) => {
+        t(ke(i, "height"));
+      },
+      [t]
+    ),
+    !0,
+    !1
+  ), r = re("context");
+  return e ? /* @__PURE__ */ A(o, { ref: n, children: /* @__PURE__ */ A(e, { ...te(e, r) }) }) : null;
+}), Vr = H.memo(function() {
+  const e = re("FooterComponent"), t = ye("footerHeight"), o = re("headerFooterTag"), n = Pe(
+    H.useMemo(
+      () => (i) => {
+        t(ke(i, "height"));
+      },
+      [t]
+    ),
+    !0,
+    !1
+  ), r = re("context");
+  return e ? /* @__PURE__ */ A(o, { ref: n, children: /* @__PURE__ */ A(e, { ...te(e, r) }) }) : null;
+}), Lr = ({ children: e }) => {
+  const t = H.useContext(Qo), o = ye("itemDimensions"), n = ye("viewportDimensions"), r = Pe(
+    H.useMemo(
+      () => (i) => {
+        n(i.getBoundingClientRect());
+      },
+      [n]
+    ),
+    !0,
+    !1
+  );
+  return H.useEffect(() => {
+    t && (n({ height: t.viewportHeight, width: t.viewportWidth }), o({ height: t.itemHeight, width: t.itemWidth }));
+  }, [t, n, o]), /* @__PURE__ */ A("div", { ref: r, style: tt(!1), children: e });
+}, Dr = ({ children: e }) => {
+  const t = H.useContext(Qo), o = ye("windowViewportRect"), n = ye("itemDimensions"), r = re("customScrollParent"), i = Nt(o, r, !1);
+  return H.useEffect(() => {
+    t && (n({ height: t.itemHeight, width: t.itemWidth }), o({ offsetTop: 0, visibleHeight: t.viewportHeight, visibleWidth: t.viewportWidth }));
+  }, [t, o, n]), /* @__PURE__ */ A("div", { ref: i, style: tt(!1), children: e });
+}, Gr = /* @__PURE__ */ H.memo(function({ ...e }) {
+  const t = re("useWindowScroll"), o = re("customScrollParent"), n = o || t ? _r : Nr, r = o || t ? Dr : Lr, i = re("context");
+  return /* @__PURE__ */ A(n, { ...e, ...te(n, i), children: /* @__PURE__ */ Ke(r, { children: [
+    /* @__PURE__ */ A(Ar, {}),
+    /* @__PURE__ */ A(Mr, {}),
+    /* @__PURE__ */ A(Vr, {})
+  ] }) });
+}), {
+  useEmitter: ln,
+  useEmitterValue: re,
+  usePublisher: ye
+} = /* @__PURE__ */ Yt(
+  Pr,
+  {
+    optional: {
+      context: "context",
+      totalCount: "totalCount",
+      overscan: "overscan",
+      itemContent: "itemContent",
+      components: "components",
+      computeItemKey: "computeItemKey",
+      data: "data",
+      initialItemCount: "initialItemCount",
+      scrollSeekConfiguration: "scrollSeekConfiguration",
+      headerFooterTag: "headerFooterTag",
+      listClassName: "listClassName",
+      itemClassName: "itemClassName",
+      useWindowScroll: "useWindowScroll",
+      customScrollParent: "customScrollParent",
+      scrollerRef: "scrollerRef",
+      logLevel: "logLevel",
+      restoreStateFrom: "restoreStateFrom",
+      initialTopMostItemIndex: "initialTopMostItemIndex",
+      increaseViewportBy: "increaseViewportBy"
+    },
+    methods: {
+      scrollTo: "scrollTo",
+      scrollBy: "scrollBy",
+      scrollToIndex: "scrollToIndex"
+    },
+    events: {
+      isScrolling: "isScrolling",
+      endReached: "endReached",
+      startReached: "startReached",
+      rangeChanged: "rangeChanged",
+      atBottomStateChange: "atBottomStateChange",
+      atTopStateChange: "atTopStateChange",
+      stateChanged: "stateChanged",
+      readyStateChanged: "readyStateChanged"
+    }
+  },
+  Gr
+), Nr = /* @__PURE__ */ Jt({ useEmitter: ln, useEmitterValue: re, usePublisher: ye }), _r = /* @__PURE__ */ Qt({ useEmitter: ln, useEmitterValue: re, usePublisher: ye });
+function Eo(e, t, o) {
+  return t !== "normal" && !(t != null && t.endsWith("px")) && o(`${e} was not resolved to pixel value correctly`, t, pe.WARN), t === "normal" ? 0 : parseInt(t ?? "0", 10);
+}
+export {
+  qr as X,
+  $r as Y
+};
+//# sourceMappingURL=index-BtlhELJ3.js.map