@ubloimmo/uikit 1.7.9 → 1.8.0

package/dist/node_modules/react-virtuoso/dist/index.js

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