@expofp/floorplan 3.0.0-alpha.3

package/dist/browser/index-CvCRaJEu.js

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