1mpacto-react-ui 0.0.8 → 0.0.9

package/dist/index39.mjs

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