;
! function() {
    try {
        var e = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof global ? global : "undefined" != typeof window ? window : "undefined" != typeof self ? self : {},
            n = (new e.Error).stack;
        n && ((e._debugIds || (e._debugIds = {}))[n] = "f047b870-bf45-cf8c-0455-e867ea8a0f12")
    } catch (e) {}
}();
(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push(["object" == typeof document ? document.currentScript : void 0, 588216, e => {
    "use strict";
    var t = e.i(221628),
        o = e.i(416340),
        n = e.i(149285);

    function r(e) {
        e()
    }

    function i(e, t) {
        return o => e(t(o))
    }

    function l(e) {
        return void 0 !== e
    }

    function s() {}

    function a(e, t) {
        return t(e)
    }

    function u(...e) {
        return e
    }

    function d(e) {
        e(2)
    }

    function c(e) {
        return e(4)
    }

    function f(e, t) {
        return e(1, e => t(0, e))
    }

    function h(e, t) {
        let o = e(1, e => {
            o(), t(e)
        });
        return o
    }

    function m(e) {
        let t, o;
        return n => r => {
            t = r, o && clearTimeout(o), o = setTimeout(() => {
                n(t)
            }, e)
        }
    }

    function g(e, t) {
        return e === t
    }

    function p(e = g) {
        let t;
        return o => n => {
            e(t, n) || (t = n, o(n))
        }
    }

    function x(e) {
        return t => o => {
            e(o) && t(o)
        }
    }

    function v(e) {
        return t => i(t, e)
    }

    function I(e) {
        return t => () => {
            t(e)
        }
    }

    function T(e, ...t) {
        let o = function(...e) {
            return t => e.reduceRight(a, t)
        }(...t);
        return (t, n) => {
            switch (t) {
                case 2:
                    d(e);
                    return;
                case 1:
                    return e(1, o(n))
            }
        }
    }

    function S(e, t) {
        return o => n => {
            o(t = e(t, n))
        }
    }

    function C(e) {
        return t => o => {
            e > 0 ? e-- : t(o)
        }
    }

    function w(e) {
        let t = null,
            o;
        return n => r => {
            t = r, o || (o = setTimeout(() => {
                o = void 0, n(t)
            }, e))
        }
    }

    function H(...e) {
        let t = Array(e.length),
            o = 0,
            n = null,
            r = 2 ** e.length - 1;
        return e.forEach((e, i) => {
            let l = 2 ** i;
            e(1, e => {
                let s = o;
                o |= l, t[i] = e, s !== r && o === r && n && (n(), n = null)
            })
        }), e => i => {
            let l = () => {
                e([i].concat(t))
            };
            o === r ? l() : n = l
        }
    }

    function y(e) {
        let t = e,
            o = b();
        return (e, n) => {
            switch (e) {
                case 0:
                    t = n;
                    break;
                case 1:
                    n(t);
                    break;
                case 4:
                    return t
            }
            return o(e, n)
        }
    }

    function z(e, t) {
        var o;
        return o = y(t), f(e, o), o
    }

    function b() {
        let e = [];
        return (t, o) => {
            switch (t) {
                case 0:
                    e.slice().forEach(e => {
                        e(o)
                    });
                    return;
                case 2:
                    e.splice(0, e.length);
                    return;
                case 1:
                    return e.push(o), () => {
                        let t = e.indexOf(o);
                        t > -1 && e.splice(t, 1)
                    }
            }
        }
    }

    function R(e) {
        var t;
        return t = b(), f(e, t), t
    }

    function E(e, t = [], {
        singleton: o
    } = {
        singleton: !0
    }) {
        return {
            constructor: e,
            dependencies: t,
            id: B(),
            singleton: o
        }
    }
    let B = () => Symbol();

    function k(...e) {
        let t = b(),
            o = Array(e.length),
            n = 0,
            r = 2 ** e.length - 1;
        return e.forEach((e, i) => {
                let l = 2 ** i;
                e(1, e => {
                    o[i] = e, (n |= l) === r && t(0, o)
                })
            }),
            function(e, i) {
                switch (e) {
                    case 2:
                        return void d(t);
                    case 1:
                        return n === r && i(o), t(1, i)
                }
            }
    }

    function O(e, t = g) {
        return T(e, p(t))
    }

    function L(...e) {
        return function(t, o) {
            switch (t) {
                case 2:
                    return;
                case 1:
                    return function(...e) {
                        return () => {
                            e.map(r)
                        }
                    }(...e.map(e => e(1, o)))
            }
        }
    }
    let F = {
            DEBUG: 0,
            INFO: 1,
            WARN: 2,
            ERROR: 3
        },
        W = {
            [F.DEBUG]: "debug",
            [F.ERROR]: "error",
            [F.INFO]: "log",
            [F.WARN]: "warn"
        },
        j = E(() => {
            let e = y(F.ERROR);
            return {
                log: y((t, o, n = F.INFO) => {
                    n >= ((typeof globalThis > "u" ? window : globalThis).VIRTUOSO_LOG_LEVEL ? ? c(e)) && console[W[n]]("%creact-virtuoso: %c%s %o", "color: #0253b3; font-weight: bold", "color: initial", t, o)
                }),
                logLevel: e
            }
        }, [], {
            singleton: !0
        }),
        P = new WeakMap;

    function M(e) {
        return "self" in e ? e.document.documentElement : e
    }

    function A(e) {
        P.delete(M(e))
    }

    function V(e, t) {
        return ! function(e) {
            let t = M(e),
                o = P.get(t);
            if (void 0 !== o) return o;
            let n = "rtl" === t.ownerDocument.defaultView.getComputedStyle(t).direction;
            return P.set(t, n), n
        }(e) ? t : -t
    }

    function D(e, t, o) {
        return G(e, t, o).callbackRef
    }

    function G(e, t, n) {
        let r = o.default.useRef(null),
            i = o.default.useMemo(() => "u" > typeof ResizeObserver ? new ResizeObserver(t => {
                let o = () => {
                    let o = t[0].target;
                    null !== o.offsetParent && e(o)
                };
                n ? o() : requestAnimationFrame(o)
            }) : null, [e, n]);
        return {
            callbackRef: e => {
                e && t ? (i ? .observe(e), r.current = e) : (r.current && i ? .unobserve(r.current), r.current = null)
            },
            ref: r
        }
    }

    function N(e, t, n, r, i, l, s, a, u) {
        return G(o.default.useCallback(o => {
            let n, u = function(e, t, o, n) {
                    let r = e.length;
                    if (0 === r) return null;
                    let i = [];
                    for (let l = 0; l < r; l++) {
                        let r = e.item(l);
                        if (void 0 === r.dataset.index) continue;
                        let s = parseInt(r.dataset.index),
                            a = parseFloat(r.dataset.knownSize),
                            u = t(r, o);
                        if (0 === u && n("Zero-sized element, this should not happen", {
                                child: r
                            }, F.ERROR), u === a) continue;
                        let d = i[i.length - 1];
                        0 === i.length || d.size !== u || d.endIndex !== s - 1 ? i.push({
                            endIndex: s,
                            size: u,
                            startIndex: s
                        }) : i[i.length - 1].endIndex++
                    }
                    return i
                }(o.children, t, a ? "offsetWidth" : "offsetHeight", i),
                d = o.parentElement;
            for (; void 0 === d.dataset.virtuosoScroller;) d = d.parentElement;
            let c = "window" === d.lastElementChild.dataset.viewportType;
            c && (n = d.ownerDocument.defaultView);
            let f = s ? a ? s.scrollWidth : s.scrollHeight : c ? a ? n.document.documentElement.scrollWidth : n.document.documentElement.scrollHeight : a ? d.scrollWidth : d.scrollHeight,
                h = s ? a ? s.offsetWidth : s.offsetHeight : c ? a ? n.innerWidth : n.innerHeight : a ? d.offsetWidth : d.offsetHeight;
            r({
                scrollHeight: f,
                scrollTop: Math.max(s ? a ? V(s, s.scrollLeft) : s.scrollTop : c ? a ? V(n, n.scrollX || n.document.documentElement.scrollLeft) : n.scrollY || n.document.documentElement.scrollTop : a ? V(d, d.scrollLeft) : d.scrollTop, 0),
                viewportHeight: h
            }), l ? .(a ? U("column-gap", getComputedStyle(o).columnGap, i) : U("row-gap", getComputedStyle(o).rowGap, i)), null !== u && e(u)
        }, [e, t, i, l, s, r, a]), n, u)
    }

    function U(e, t, o) {
        return "normal" !== t && t ? .endsWith("px") !== !0 && o(`${e} was not resolved to pixel value correctly`, t, F.WARN), "normal" === t ? 0 : parseInt(t ? ? "0", 10)
    }

    function _(e, t, n) {
        let r = o.default.useRef(null),
            i = o.default.useCallback(o => {
                let n, i;
                if (!o ? .offsetParent) return;
                let l = o.getBoundingClientRect(),
                    a = l.width;
                if (t) {
                    let e = t.getBoundingClientRect(),
                        o = l.top - e.top;
                    i = e.height - Math.max(0, o), n = o + t.scrollTop
                } else {
                    let e = s.current.ownerDocument.defaultView;
                    i = e.innerHeight - Math.max(0, l.top), n = l.top + e.scrollY
                }
                r.current = {
                    listHeight: l.height,
                    offsetTop: n,
                    visibleHeight: i,
                    visibleWidth: a
                }, e(r.current)
            }, [e, t]),
            {
                callbackRef: l,
                ref: s
            } = G(i, !0, n),
            a = o.default.useCallback(() => {
                i(s.current)
            }, [i, s]);
        return o.default.useEffect(() => {
            if (t) {
                t.addEventListener("scroll", a);
                let e = new ResizeObserver(() => {
                    requestAnimationFrame(a)
                });
                return e.observe(t), () => {
                    t.removeEventListener("scroll", a), e.unobserve(t)
                }
            }
            let e = s.current ? .ownerDocument.defaultView;
            return e ? .addEventListener("scroll", a), e ? .addEventListener("resize", a), () => {
                e ? .removeEventListener("scroll", a), e ? .removeEventListener("resize", a)
            }
        }, [a, t, s]), l
    }
    let K = E(() => {
            let e = b(),
                t = b(),
                o = y(0),
                n = b(),
                r = y(0),
                i = b(),
                l = b(),
                s = y(0),
                a = y(0),
                u = y(0),
                d = y(0),
                c = b(),
                h = b(),
                m = y(!1),
                g = y(!1),
                p = y(!1);
            return f(T(e, v(({
                scrollTop: e
            }) => e)), t), f(T(e, v(({
                scrollHeight: e
            }) => e)), l), f(t, r), {
                deviation: o,
                fixedFooterHeight: u,
                fixedHeaderHeight: a,
                footerHeight: d,
                headerHeight: s,
                horizontalDirection: g,
                scrollBy: h,
                scrollContainerState: e,
                scrollHeight: l,
                scrollingInProgress: m,
                scrollTo: c,
                scrollTop: t,
                skipAnimationFrameInResizeObserver: p,
                smoothScrollTargetReached: n,
                statefulScrollTop: r,
                viewportHeight: i
            }
        }, [], {
            singleton: !0
        }),
        q = {
            lvl: 0
        };

    function $(e, t) {
        let o = e.length;
        if (0 === o) return [];
        let {
            index: n,
            value: r
        } = t(e[0]), i = [];
        for (let l = 1; l < o; l++) {
            let {
                index: o,
                value: s
            } = t(e[l]);
            i.push({
                end: o - 1,
                start: n,
                value: r
            }), n = o, r = s
        }
        return i.push({
            end: 1 / 0,
            start: n,
            value: r
        }), i
    }

    function Y(e) {
        return e === q
    }

    function X(e, t) {
        if (!Y(e)) return t === e.k ? e.v : t < e.k ? X(e.l, t) : X(e.r, t)
    }

    function Z(e, t, o = "k") {
        if (Y(e)) return [-1 / 0, void 0];
        if (Number(e[o]) === t) return [e.k, e.v];
        if (Number(e[o]) < t) {
            let n = Z(e.r, t, o);
            return n[0] === -1 / 0 ? [e.k, e.v] : n
        }
        return Z(e.l, t, o)
    }

    function J(e, t, o) {
        return Y(e) ? er(t, o, 1) : t === e.k ? eo(e, {
            k: t,
            v: o
        }) : t < e.k ? el(ei(eo(e, {
            l: J(e.l, t, o)
        }))) : el(ei(eo(e, {
            r: J(e.r, t, o)
        })))
    }

    function Q(e, t, o) {
        if (Y(e)) return [];
        let n = Z(e, t)[0];
        return $(function e(t, o, n) {
            if (Y(t)) return [];
            let {
                k: r,
                l: i,
                r: l,
                v: s
            } = t, a = [];
            return r > o && (a = a.concat(e(i, o, n))), r >= o && r <= n && a.push({
                k: r,
                v: s
            }), r <= n && (a = a.concat(e(l, o, n))), a
        }(e, n, o), ({
            k: e,
            v: t
        }) => ({
            index: e,
            value: t
        }))
    }

    function ee(e) {
        return Y(e) ? [] : [...ee(e.l), {
            k: e.k,
            v: e.v
        }, ...ee(e.r)]
    }

    function et(e) {
        let {
            l: t,
            lvl: o,
            r: n
        } = e;
        if (n.lvl >= o - 1 && t.lvl >= o - 1) return e;
        if (o > n.lvl + 1) {
            if (en(t)) return ei(eo(e, {
                lvl: o - 1
            }));
            if (!Y(t) && !Y(t.r)) return eo(t.r, {
                l: eo(t, {
                    r: t.r.l
                }),
                lvl: o,
                r: eo(e, {
                    l: t.r.r,
                    lvl: o - 1
                })
            });
            throw Error("Unexpected empty nodes")
        }
        if (en(e)) return el(eo(e, {
            lvl: o - 1
        }));
        if (!Y(n) && !Y(n.l)) {
            let t = n.l,
                r = en(t) ? n.lvl - 1 : n.lvl;
            return eo(t, {
                l: eo(e, {
                    lvl: o - 1,
                    r: t.l
                }),
                lvl: t.lvl + 1,
                r: el(eo(n, {
                    l: t.r,
                    lvl: r
                }))
            })
        }
        throw Error("Unexpected empty nodes")
    }

    function eo(e, t) {
        return er(void 0 !== t.k ? t.k : e.k, void 0 !== t.v ? t.v : e.v, void 0 !== t.lvl ? t.lvl : e.lvl, void 0 !== t.l ? t.l : e.l, void 0 !== t.r ? t.r : e.r)
    }

    function en(e) {
        return Y(e) || e.lvl > e.r.lvl
    }

    function er(e, t, o, n = q, r = q) {
        return {
            k: e,
            l: n,
            lvl: o,
            r,
            v: t
        }
    }

    function ei(e) {
        let {
            l: t
        } = e;
        return Y(t) || t.lvl !== e.lvl ? e : eo(t, {
            r: eo(e, {
                l: t.r
            })
        })
    }

    function el(e) {
        let {
            lvl: t,
            r: o
        } = e;
        return Y(o) || Y(o.r) || o.lvl !== t || o.r.lvl !== t ? e : eo(o, {
            l: eo(e, {
                r: o.l
            }),
            lvl: t + 1
        })
    }

    function es(e, t) {
        return !!(e && e.startIndex === t.startIndex && e.endIndex === t.endIndex)
    }

    function ea(e, t) {
        return !!(e && e[0] === t[0] && e[1] === t[1])
    }
    let eu = E(() => ({
        recalcInProgress: y(!1)
    }), [], {
        singleton: !0
    });

    function ed(e, t, o, n = 0) {
        let r = e.length - 1;
        for (; n <= r;) {
            let i = Math.floor((n + r) / 2),
                l = o(e[i], t);
            if (0 === l) return i;
            if (-1 === l) {
                if (r - n < 2) return i - 1;
                r = i - 1
            } else {
                if (r === n) return i;
                n = i + 1
            }
        }
        throw Error(`Failed binary finding record in array - ${e.join(",")}, searched for ${t}`)
    }

    function ec(e, t) {
        return Math.round(e.getBoundingClientRect()[t])
    }

    function ef(e) {
        return !Y(e.groupOffsetTree)
    }

    function eh({
        index: e
    }, t) {
        return t === e ? 0 : t < e ? -1 : 1
    }

    function em({
        offset: e
    }, t) {
        return t === e ? 0 : t < e ? -1 : 1
    }

    function eg(e, t, o) {
        if (0 === t.length) return 0;
        let {
            index: n,
            offset: r,
            size: i
        } = t[ed(t, e, eh)], l = e - n, s = i * l + (l - 1) * o + r;
        return s > 0 ? s + o : s
    }

    function ep(e, t) {
        if (!ef(t)) return e;
        let o = 0;
        for (; t.groupIndices[o] <= e + o;) o++;
        return e + o
    }

    function ex(e, t, o) {
        if ("u" > typeof e.groupIndex) return t.groupIndices[e.groupIndex] + 1;
        let n = ep("LAST" === e.index ? o : e.index, t);
        return Math.max(0, n, Math.min(o, n))
    }

    function ev(e, [t, o, n, r]) {
        t.length > 0 && n("received item sizes", t, F.DEBUG);
        let i = e.sizeTree,
            l = i,
            s = 0;
        if (o.length > 0 && Y(i) && 2 === t.length) {
            let e = t[0].size,
                n = t[1].size;
            l = o.reduce((t, o) => J(J(t, o, e), o + 1, n), l)
        } else [l, s] = function(e, t) {
            let o = Y(e) ? 0 : 1 / 0;
            for (let n of t) {
                let {
                    endIndex: t,
                    size: r,
                    startIndex: i
                } = n;
                if (o = Math.min(o, i), Y(e)) {
                    e = J(e, 0, r);
                    continue
                }
                let l = Q(e, i - 1, t + 1);
                if (l.some(function(e) {
                        let {
                            endIndex: t,
                            size: o,
                            startIndex: n
                        } = e;
                        return e => e.start === n && (e.end === t || e.end === 1 / 0) && e.value === o
                    }(n))) continue;
                let s = !1,
                    a = !1;
                for (let {
                        end: o,
                        start: n,
                        value: i
                    } of l) s ? (t >= n || r === i) && (e = function e(t, o) {
                    if (Y(t)) return q;
                    let {
                        k: n,
                        l: r,
                        r: i
                    } = t;
                    if (o === n) {
                        if (Y(r)) return i;
                        if (Y(i)) return r;
                        let [e, o] = function e(t) {
                            return Y(t.r) ? [t.k, t.v] : e(t.r)
                        }(r);
                        return et(eo(t, {
                            k: e,
                            l: function e(t) {
                                return Y(t.r) ? t.l : et(eo(t, {
                                    r: e(t.r)
                                }))
                            }(r),
                            v: o
                        }))
                    }
                    return o < n ? et(eo(t, {
                        l: e(r, o)
                    })) : et(eo(t, {
                        r: e(i, o)
                    }))
                }(e, n)) : (a = i !== r, s = !0), o > t && t >= n && i !== r && (e = J(e, t + 1, i));
                a && (e = J(e, i, r))
            }
            return [e, o]
        }(l, t);
        if (l === i) return e;
        let {
            lastIndex: a,
            lastOffset: u,
            lastSize: d,
            offsetTree: c
        } = eT(e.offsetTree, s, l, r);
        return {
            groupIndices: o,
            groupOffsetTree: o.reduce((e, t) => J(e, t, eg(t, c, r)), q),
            lastIndex: a,
            lastOffset: u,
            lastSize: d,
            offsetTree: c,
            sizeTree: l
        }
    }

    function eI(e, t) {
        let o = 0,
            n = 0;
        for (; o < e;) o += t[n + 1] - t[n] - 1, n++;
        return n - (o !== e)
    }

    function eT(e, t, o, n) {
        let r = e,
            i = 0,
            l = 0,
            s = 0,
            a = 0;
        if (0 !== t) {
            a = ed(r, t - 1, eh), s = r[a].offset;
            let e = Z(o, t - 1);
            i = e[0], l = e[1], r.length && r[a].size === Z(o, t)[1] && (a -= 1), r = r.slice(0, a + 1)
        } else r = [];
        for (let {
                start: e,
                value: a
            } of Q(o, t, 1 / 0)) {
            let t = e - i,
                o = t * l + s + t * n;
            r.push({
                index: e,
                offset: o,
                size: a
            }), i = e, s = o, l = a
        }
        return {
            lastIndex: i,
            lastOffset: s,
            lastSize: l,
            offsetTree: r
        }
    }

    function eS(e) {
        return {
            index: e.index,
            value: e
        }
    }
    let eC = {
            offsetHeight: "height",
            offsetWidth: "width"
        },
        ew = E(([{
            log: e
        }, {
            recalcInProgress: t
        }]) => {
            let o = b(),
                n = b(),
                r = z(n, 0),
                i = b(),
                l = b(),
                s = y(0),
                a = y([]),
                u = y(void 0),
                d = y(void 0),
                h = y(void 0),
                m = y(void 0),
                g = y((e, t) => ec(e, eC[t])),
                I = y(void 0),
                C = y(0),
                w = {
                    groupIndices: [],
                    groupOffsetTree: q,
                    lastIndex: 0,
                    lastOffset: 0,
                    lastSize: 0,
                    offsetTree: [],
                    sizeTree: q
                },
                E = z(T(o, H(a, e, C), S(ev, w), p()), w),
                B = z(T(a, p(), S((e, t) => ({
                    current: t,
                    prev: e.current
                }), {
                    current: [],
                    prev: []
                }), v(({
                    prev: e
                }) => e)), []);
            f(T(a, x(e => e.length > 0), H(E, C), v(([e, t, o]) => {
                let n = e.reduce((e, n, r) => J(e, n, eg(n, t.offsetTree, o) || r), q);
                return { ...t,
                    groupIndices: e,
                    groupOffsetTree: n
                }
            })), E), f(T(n, H(E), x(([e, {
                lastIndex: t
            }]) => e < t), v(([e, {
                lastIndex: t,
                lastSize: o
            }]) => [{
                endIndex: t,
                size: o,
                startIndex: e
            }])), o), f(u, d);
            let k = z(T(u, v(e => void 0 === e)), !0);
            f(T(d, x(e => void 0 !== e && Y(c(E).sizeTree)), v(e => {
                let t = c(h),
                    o = c(a).length > 0;
                return void 0 !== t && 0 !== t ? o ? [{
                    endIndex: 0,
                    size: t,
                    startIndex: 0
                }, {
                    endIndex: 1,
                    size: e,
                    startIndex: 1
                }] : [] : [{
                    endIndex: 0,
                    size: e,
                    startIndex: 0
                }]
            })), o), f(T(m, x(e => void 0 !== e && e.length > 0 && Y(c(E).sizeTree)), v(e => {
                let t = [],
                    o = e[0],
                    n = 0;
                for (let r = 1; r < e.length; r++) {
                    let i = e[r];
                    i !== o && (t.push({
                        endIndex: r - 1,
                        size: o,
                        startIndex: n
                    }), o = i, n = r)
                }
                return t.push({
                    endIndex: e.length - 1,
                    size: o,
                    startIndex: n
                }), t
            })), o), f(T(a, H(h, d), x(([, e, t]) => void 0 !== e && void 0 !== t), v(([e, t, o]) => {
                let n = [];
                for (let r = 0; r < e.length; r++) {
                    let i = e[r],
                        l = e[r + 1];
                    n.push({
                        startIndex: i,
                        endIndex: i,
                        size: t
                    }), void 0 !== l && n.push({
                        startIndex: i + 1,
                        endIndex: l - 1,
                        size: o
                    })
                }
                return n
            })), o);
            let O = R(T(o, H(E), S(({
                sizes: e
            }, [t, o]) => ({
                changed: o !== e,
                sizes: o
            }), {
                changed: !1,
                sizes: w
            }), v(e => e.changed)));
            T(s, S((e, t) => ({
                diff: e.prev - t,
                prev: t
            }), {
                diff: 0,
                prev: 0
            }), v(e => e.diff))(1, e => {
                let {
                    groupIndices: o
                } = c(E);
                if (e > 0) t(0, !0), i(0, e + eI(e, o));
                else if (e < 0) {
                    let t = c(B);
                    t.length > 0 && (e -= eI(-e, t)), l(0, e)
                }
            }), T(s, H(e))(1, ([e, t]) => {
                e < 0 && t("`firstItemIndex` prop should not be set to less than zero. If you don't know the total count, just use a very high value", {
                    firstItemIndex: s
                }, F.ERROR)
            });
            let L = R(i);
            f(T(i, H(E), v(([e, t]) => {
                let o = t.groupIndices.length > 0,
                    n = [],
                    r = t.lastSize;
                if (o) {
                    let o = X(t.sizeTree, 0),
                        i = 0,
                        l = 0;
                    for (; i < e;) {
                        let e = t.groupIndices[l],
                            s = t.groupIndices.length === l + 1 ? 1 / 0 : t.groupIndices[l + 1] - e - 1;
                        n.push({
                            endIndex: e,
                            size: o,
                            startIndex: e
                        }), n.push({
                            endIndex: e + 1 + s - 1,
                            size: r,
                            startIndex: e + 1
                        }), l++, i += s + 1
                    }
                    let s = ee(t.sizeTree);
                    return i !== e && s.shift(), s.reduce((t, {
                        k: o,
                        v: n
                    }) => {
                        let r = t.ranges;
                        return 0 !== t.prevSize && (r = [...t.ranges, {
                            endIndex: o + e - 1,
                            size: t.prevSize,
                            startIndex: t.prevIndex
                        }]), {
                            prevIndex: o + e,
                            prevSize: n,
                            ranges: r
                        }
                    }, {
                        prevIndex: e,
                        prevSize: 0,
                        ranges: n
                    }).ranges
                }
                return ee(t.sizeTree).reduce((t, {
                    k: o,
                    v: n
                }) => ({
                    prevIndex: o + e,
                    prevSize: n,
                    ranges: [...t.ranges, {
                        endIndex: o + e - 1,
                        size: t.prevSize,
                        startIndex: t.prevIndex
                    }]
                }), {
                    prevIndex: 0,
                    prevSize: r,
                    ranges: []
                }).ranges
            })), o);
            let W = R(T(l, H(E, C), v(([e, {
                offsetTree: t
            }, o]) => eg(-e, t, o))));
            return f(T(l, H(E, C), v(([e, t, o]) => {
                if (t.groupIndices.length > 0) {
                    if (Y(t.sizeTree)) return t;
                    let n = q,
                        r = c(B),
                        i = 0,
                        l = 0,
                        s = 0;
                    for (; i < -e;) {
                        s = r[l];
                        let e = r[l + 1] - s - 1;
                        l++, i += e + 1
                    }
                    return n = ee(t.sizeTree).reduce((t, {
                        k: o,
                        v: n
                    }) => J(t, Math.max(0, o + e), n), n), i !== -e && (n = J(n, 0, X(t.sizeTree, s)), n = J(n, 1, Z(t.sizeTree, -e + 1)[1])), { ...t,
                        sizeTree: n,
                        ...eT(t.offsetTree, 0, n, o)
                    }
                }
                let n = ee(t.sizeTree).reduce((t, {
                    k: o,
                    v: n
                }) => J(t, Math.max(0, o + e), n), q);
                return { ...t,
                    sizeTree: n,
                    ...eT(t.offsetTree, 0, n, o)
                }
            })), E), {
                beforeUnshiftWith: L,
                data: I,
                defaultItemSize: d,
                firstItemIndex: s,
                fixedItemSize: u,
                fixedGroupSize: h,
                gap: C,
                groupIndices: a,
                heightEstimates: m,
                itemSize: g,
                listRefresh: O,
                shiftWith: l,
                shiftWithOffset: W,
                sizeRanges: o,
                sizes: E,
                statefulTotalCount: r,
                totalCount: n,
                trackItemSizes: k,
                unshiftWith: i
            }
        }, u(j, eu), {
            singleton: !0
        });

    function eH(e) {
        return e.reduce((e, t) => (e.groupIndices.push(e.totalCount), e.totalCount += t + 1, e), {
            groupIndices: [],
            totalCount: 0
        })
    }
    let ey = E(([{
            groupIndices: e,
            sizes: t,
            totalCount: o
        }, {
            headerHeight: n,
            scrollTop: r
        }]) => {
            let i = b(),
                l = b(),
                s = R(T(i, v(eH)));
            return f(T(s, v(e => e.totalCount)), o), f(T(s, v(e => e.groupIndices)), e), f(T(k(r, t, n), x(([e, t]) => ef(t)), v(([e, t, o]) => Z(t.groupOffsetTree, Math.max(e - o, 0), "v")[0]), p(), v(e => [e])), l), {
                groupCounts: i,
                topItemsIndexes: l
            }
        }, u(ew, K)),
        ez = E(([{
            log: e
        }]) => {
            let t = y(!1),
                o = R(T(t, x(e => e), p()));
            return t(1, t => {
                t && c(e)("props updated", {}, F.DEBUG)
            }), {
                didMount: o,
                propsReady: t
            }
        }, u(j), {
            singleton: !0
        }),
        eb = "u" > typeof document && "scrollBehavior" in document.documentElement.style;

    function eR(e) {
        let t = "number" == typeof e ? {
            index: e
        } : e;
        return t.align || (t.align = "start"), t.behavior && eb || (t.behavior = "auto"), void 0 === t.offset && (t.offset = 0), t
    }
    let eE = E(([{
        gap: e,
        listRefresh: t,
        sizes: o,
        totalCount: n
    }, {
        fixedFooterHeight: r,
        fixedHeaderHeight: i,
        footerHeight: l,
        headerHeight: s,
        scrollingInProgress: a,
        scrollTo: u,
        smoothScrollTargetReached: d,
        viewportHeight: c
    }, {
        log: m
    }]) => {
        let g = b(),
            p = b(),
            x = y(0),
            I = null,
            S = null,
            C = null;

        function w() {
            null !== I && (I(), I = null), null !== C && (C(), C = null), S && (clearTimeout(S), S = null), a(0, !1)
        }
        return f(T(g, H(o, c, n, x, s, l, m), H(e, i, r), v(([
            [e, o, n, r, i, l, s, u], c, f, m
        ]) => {
            let x = eR(e),
                {
                    align: v,
                    behavior: H,
                    offset: y
                } = x,
                z = r - 1,
                b = ex(x, o, z),
                R = eg(b, o.offsetTree, c) + l;
            "end" === v ? (R += f + Z(o.sizeTree, b)[1] - n + m, b === z && (R += s)) : "center" === v ? R += (f + Z(o.sizeTree, b)[1] - n + m) / 2 : R -= i, void 0 !== y && 0 !== y && (R += y);
            let E = t => {
                w(), t ? (u("retrying to scroll to", {
                    location: e
                }, F.DEBUG), g(0, e)) : (p(0, !0), u("list did not change, scroll successful", {}, F.DEBUG))
            };
            if (w(), "smooth" === H) {
                let e = !1;
                C = t(1, t => {
                    e = e || t
                }), I = h(d, () => {
                    E(e)
                })
            } else I = h(T(t, e => {
                let t = setTimeout(() => {
                    e(!1)
                }, 150);
                return o => {
                    o && (e(!0), clearTimeout(t))
                }
            }), E);
            return S = setTimeout(() => {
                w()
            }, 1200), a(0, !0), u("scrolling from index to", {
                behavior: H,
                index: b,
                top: R
            }, F.DEBUG), {
                behavior: H,
                top: R
            }
        })), u), {
            scrollTargetReached: p,
            scrollToIndex: g,
            topListHeight: x
        }
    }, u(ew, K, j), {
        singleton: !0
    });

    function eB(e, t) {
        0 === e ? t() : requestAnimationFrame(() => {
            eB(e - 1, t)
        })
    }

    function ek(e, t) {
        return "number" == typeof e ? e : "LAST" === e.index ? t - 1 : e.index
    }
    let eO = E(([{
        defaultItemSize: e,
        listRefresh: t,
        sizes: o
    }, {
        scrollTop: n
    }, {
        scrollTargetReached: r,
        scrollToIndex: i
    }, {
        didMount: s
    }]) => {
        let a = y(!0),
            u = y(0),
            d = y(!0);
        return f(T(s, H(u), x(([e, t]) => 0 !== t), I(!1)), a), f(T(s, H(u), x(([e, t]) => 0 !== t), I(!1)), d), T(k(t, s), H(a, o, e, d), x(([
            [, e], t, {
                sizeTree: o
            },
            n, r
        ]) => e && (!Y(o) || l(n)) && !t && !r), H(u))(1, ([, e]) => {
            h(r, () => {
                d(0, !0)
            }), eB(4, () => {
                h(n, () => {
                    a(0, !0)
                }), i(0, e)
            })
        }), {
            initialItemFinalLocationReached: d,
            initialTopMostItemIndex: u,
            scrolledToInitialItem: a
        }
    }, u(ew, K, eE, ez), {
        singleton: !0
    });

    function eL(e, t) {
        return 1.01 > Math.abs(e - t)
    }
    let eF = "down",
        eW = {
            atBottom: !1,
            notAtBottomBecause: "NOT_SHOWING_LAST_ITEM",
            state: {
                offsetBottom: 0,
                scrollHeight: 0,
                scrollTop: 0,
                viewportHeight: 0
            }
        },
        ej = E(([{
            footerHeight: e,
            headerHeight: t,
            scrollBy: o,
            scrollContainerState: n,
            scrollTop: r,
            viewportHeight: i
        }]) => {
            let l = y(!1),
                s = y(!0),
                a = b(),
                u = b(),
                d = y(4),
                h = y(0),
                g = z(T(L(T(O(r), C(1), I(!0)), T(O(r), C(1), I(!1), m(100))), p()), !1),
                E = z(T(L(T(o, I(!0)), T(o, I(!1), m(200))), p()), !1);
            f(T(k(O(r), O(h)), v(([e, t]) => e <= t), p()), s), f(T(s, w(50)), u);
            let B = R(T(k(n, O(i), O(t), O(e), O(d)), S((e, [{
                    scrollHeight: t,
                    scrollTop: o
                }, n, r, i, l]) => {
                    let s = {
                        scrollHeight: t,
                        scrollTop: o,
                        viewportHeight: n
                    };
                    if (o + n - t > -l) {
                        let t, n;
                        return o > e.state.scrollTop ? (t = "SCROLLED_DOWN", n = e.state.scrollTop - o) : (t = "SIZE_DECREASED", n = e.state.scrollTop - o || e.scrollTopDelta), {
                            atBottom: !0,
                            atBottomBecause: t,
                            scrollTopDelta: n,
                            state: s
                        }
                    }
                    return {
                        atBottom: !1,
                        notAtBottomBecause: s.scrollHeight > e.state.scrollHeight ? "SIZE_INCREASED" : n < e.state.viewportHeight ? "VIEWPORT_HEIGHT_DECREASING" : o < e.state.scrollTop ? "SCROLLING_UPWARDS" : "NOT_FULLY_SCROLLED_TO_LAST_ITEM_BOTTOM",
                        state: s
                    }
                }, eW), p((e, t) => void 0 !== e && e.atBottom === t.atBottom))),
                F = z(T(n, S((e, {
                    scrollHeight: t,
                    scrollTop: o,
                    viewportHeight: n
                }) => {
                    if (!eL(e.scrollHeight, t)) {
                        let r = t - (o + n) < 1;
                        return e.scrollTop !== o && r ? {
                            changed: !0,
                            jump: e.scrollTop - o,
                            scrollHeight: t,
                            scrollTop: o
                        } : {
                            changed: !0,
                            jump: 0,
                            scrollHeight: t,
                            scrollTop: o
                        }
                    }
                    return {
                        changed: !1,
                        jump: 0,
                        scrollHeight: t,
                        scrollTop: o
                    }
                }, {
                    changed: !1,
                    jump: 0,
                    scrollHeight: 0,
                    scrollTop: 0
                }), x(e => e.changed), v(e => e.jump)), 0);
            f(T(B, v(e => e.atBottom)), l), f(T(l, w(50)), a);
            let W = y(eF);
            f(T(n, v(({
                scrollTop: e
            }) => e), p(), S((e, t) => c(E) ? {
                direction: e.direction,
                prevScrollTop: t
            } : {
                direction: t < e.prevScrollTop ? "up" : eF,
                prevScrollTop: t
            }, {
                direction: eF,
                prevScrollTop: 0
            }), v(e => e.direction)), W), f(T(n, w(50), I("none")), W);
            let j = y(0);
            return f(T(g, x(e => !e), I(0)), j), f(T(r, w(100), H(g), x(([e, t]) => t), S(([e, t], [o]) => [t, o], [0, 0]), v(([e, t]) => t - e)), j), {
                atBottomState: B,
                atBottomStateChange: a,
                atBottomThreshold: d,
                atTopStateChange: u,
                atTopThreshold: h,
                isAtBottom: l,
                isAtTop: s,
                isScrolling: g,
                lastJumpDueToItemResize: F,
                scrollDirection: W,
                scrollVelocity: j
            }
        }, u(K)),
        eP = "bottom",
        eM = "none";

    function eA(e, t, o) {
        return "number" == typeof e ? "up" === o && "top" === t || o === eF && t === eP ? e : 0 : "up" === o ? "top" === t ? e.main : e.reverse : t === eP ? e.main : e.reverse
    }

    function eV(e, t) {
        return "number" == typeof e ? e : e[t] ? ? 0
    }
    let eD = E(([{
            deviation: e,
            fixedHeaderHeight: t,
            headerHeight: o,
            scrollTop: n,
            viewportHeight: r
        }]) => {
            let i = b(),
                l = y(0),
                s = y(0),
                a = y(0),
                u = z(T(k(O(n), O(r), O(o), O(i, ea), O(a), O(l), O(t), O(e), O(s)), v(([e, t, o, [n, r], i, l, s, a, u]) => {
                    let d = e - a,
                        c = Math.max(o - d, 0),
                        f = eM,
                        h = eV(u, "top"),
                        m = eV(u, eP);
                    return n -= a, n += o + s, r += o + s, n > e + (l + s) - h && (f = "up"), (r -= a) < e - c + t + m && (f = eF), f !== eM ? [Math.max(d - o - eA(i, "top", f) - h, 0), d - c - s + t + eA(i, eP, f) + m] : null
                }), x(e => null !== e), p(ea)), [0, 0]);
            return {
                increaseViewportBy: s,
                listBoundary: i,
                overscan: a,
                topListHeight: l,
                visibleRange: u
            }
        }, u(K), {
            singleton: !0
        }),
        eG = {
            bottom: 0,
            firstItemIndex: 0,
            items: [],
            offsetBottom: 0,
            offsetTop: 0,
            top: 0,
            topItems: [],
            topListHeight: 0,
            totalCount: 0
        };

    function eN(e, t, o, n, r, i) {
        let {
            lastIndex: l,
            lastOffset: s,
            lastSize: a
        } = r, u = 0, d = 0;
        if (e.length > 0) {
            u = e[0].offset;
            let t = e[e.length - 1];
            d = t.offset + t.size
        }
        let c = o - l,
            f = u,
            h = s + c * a + (c - 1) * n - d;
        return {
            bottom: d,
            firstItemIndex: i,
            items: e_(e, r, i),
            offsetBottom: h,
            offsetTop: u,
            top: f,
            topItems: e_(t, r, i),
            topListHeight: t.reduce((e, t) => t.size + e, 0),
            totalCount: o
        }
    }

    function eU(e, t, o, n, r, i) {
        let l = 0;
        if (o.groupIndices.length > 0)
            for (let t of o.groupIndices) {
                if (t - l >= e) break;
                l++
            }
        let s = e + l,
            a = ek(t, s);
        return eN(Array.from({
            length: s
        }).map((e, t) => ({
            data: i[t + a],
            index: t + a,
            offset: 0,
            size: 0
        })), [], s, r, o, n)
    }

    function e_(e, t, o) {
        if (0 === e.length) return [];
        if (!ef(t)) return e.map(e => ({ ...e,
            index: e.index + o,
            originalIndex: e.index
        }));
        let n = e[0].index,
            r = e[e.length - 1].index,
            i = [],
            l = Q(t.groupOffsetTree, n, r),
            s, a = 0;
        for (let n of e) {
            let e;
            (!s || s.end < n.index) && (s = l.shift(), a = t.groupIndices.indexOf(s.start)), e = n.index === s.start ? {
                index: a,
                type: "group"
            } : {
                groupIndex: a,
                index: n.index - (a + 1) + o
            }, i.push({ ...e,
                data: n.data,
                offset: n.offset,
                originalIndex: n.index,
                size: n.size
            })
        }
        return i
    }

    function eK(e, t) {
        return void 0 === e ? 0 : "number" == typeof e ? e : e[t] ? ? 0
    }
    let eq = E(([{
            data: e,
            firstItemIndex: t,
            gap: o,
            sizes: n,
            totalCount: r
        }, i, {
            listBoundary: s,
            topListHeight: a,
            visibleRange: u
        }, {
            initialTopMostItemIndex: d,
            scrolledToInitialItem: h
        }, {
            topListHeight: m
        }, g, {
            didMount: I
        }, {
            recalcInProgress: S
        }]) => {
            let C = y([]),
                E = y(0),
                B = b(),
                L = y(0);
            f(i.topItemsIndexes, C);
            let F = z(T(k(I, S, O(u, ea), O(r), O(n), O(d), h, O(C), O(t), O(o), O(L), e), x(([e, t, , o, , , , , , , , n]) => {
                let r = void 0 !== n && n.length !== o;
                return e && !t && !r
            }), v(([, , [e, t], o, n, r, i, l, s, a, u, d]) => {
                var f;
                let {
                    offsetTree: h,
                    sizeTree: m
                } = n, g = c(E);
                if (0 === o) return { ...eG,
                    totalCount: o
                };
                if (0 === e && 0 === t) return 0 === g ? { ...eG,
                    totalCount: o
                } : eU(g, r, n, s, a, d || []);
                if (Y(m)) return g > 0 ? null : eN(function(e, t, o) {
                    if (ef(t)) {
                        let n = ep(e, t);
                        return [{
                            index: Z(t.groupOffsetTree, n)[0],
                            offset: 0,
                            size: 0
                        }, {
                            data: o ? .[0],
                            index: n,
                            offset: 0,
                            size: 0
                        }]
                    }
                    return [{
                        data: o ? .[0],
                        index: e,
                        offset: 0,
                        size: 0
                    }]
                }(ek(r, o), n, d), [], o, a, n, s);
                let p = [];
                if (l.length > 0) {
                    let e = l[0],
                        t = l[l.length - 1],
                        o = 0;
                    for (let n of Q(m, e, t)) {
                        let r = n.value,
                            i = Math.max(n.start, e),
                            l = Math.min(n.end, t);
                        for (let e = i; e <= l; e++) p.push({
                            data: d ? .[e],
                            index: e,
                            offset: o,
                            size: r
                        }), o += r
                    }
                }
                if (!i) return eN([], p, o, a, n, s);
                let x = l.length > 0 ? l[l.length - 1] + 1 : 0,
                    v = function(e, t, o, n = 0) {
                        let r, i;
                        return n > 0 && (t = Math.max(t, e[ed(e, n, eh)].offset)), $((r = ed(e, t, em), i = ed(e, o, em, r), e.slice(r, i + 1)), eS)
                    }(h, e, t, x);
                if (0 === v.length) return null;
                let I = o - 1,
                    T = ((o => {
                        for (let n of v) {
                            let r = n.value,
                                i = r.offset,
                                l = n.start,
                                s = r.size;
                            if (r.offset < e) {
                                let t = (l += Math.floor((e - r.offset + a) / (s + a))) - n.start;
                                i += t * s + t * a
                            }
                            l < x && (i += (x - l) * s, l = x);
                            let u = Math.min(n.end, I);
                            for (let e = l; e <= u && !(i >= t); e++) o.push({
                                data: d ? .[e],
                                index: e,
                                offset: i,
                                size: s
                            }), i += s + a
                        }
                    })(f = []), f),
                    S = eK(u, "top"),
                    C = eK(u, eP);
                if (T.length > 0 && (S > 0 || C > 0)) {
                    let e = T[0],
                        t = T[T.length - 1];
                    if (S > 0 && e.index > x) {
                        let t = Math.min(S, e.index - x),
                            o = [],
                            n = e.offset;
                        for (let r = e.index - 1; r >= e.index - t; r--) {
                            let t = Q(m, r, r)[0] ? .value ? ? e.size;
                            n -= t + a, o.unshift({
                                data: d ? .[r],
                                index: r,
                                offset: n,
                                size: t
                            })
                        }
                        T.unshift(...o)
                    }
                    if (C > 0 && t.index < I) {
                        let e = Math.min(C, I - t.index),
                            o = t.offset + t.size + a;
                        for (let n = t.index + 1; n <= t.index + e; n++) {
                            let e = Q(m, n, n)[0] ? .value ? ? t.size;
                            T.push({
                                data: d ? .[n],
                                index: n,
                                offset: o,
                                size: e
                            }), o += e + a
                        }
                    }
                }
                return eN(T, p, o, a, n, s)
            }), x(e => null !== e), p()), eG);
            f(T(e, x(l), v(e => e ? .length)), r), f(T(F, v(e => e.topListHeight)), m), f(m, a), f(T(F, v(e => [e.top, e.bottom])), s), f(T(F, v(e => e.items)), B);
            let W = R(T(F, x(({
                    items: e
                }) => e.length > 0), H(r, e), x(([{
                    items: e
                }, t]) => e[e.length - 1].originalIndex === t - 1), v(([, e, t]) => [e - 1, t]), p(ea), v(([e]) => e))),
                j = R(T(F, w(200), x(({
                    items: e,
                    topItems: t
                }) => e.length > 0 && e[0].originalIndex === t.length), v(({
                    items: e
                }) => e[0].index), p())),
                P = R(T(F, x(({
                    items: e
                }) => e.length > 0), v(({
                    items: e
                }) => {
                    let t = 0,
                        o = e.length - 1;
                    for (;
                        "group" === e[t].type && t < o;) t++;
                    for (;
                        "group" === e[o].type && o > t;) o--;
                    return {
                        endIndex: e[o].index,
                        startIndex: e[t].index
                    }
                }), p(es)));
            return {
                endReached: W,
                initialItemCount: E,
                itemsRendered: B,
                listState: F,
                minOverscanItemCount: L,
                rangeChanged: P,
                startReached: j,
                topItemsIndexes: C,
                ...g
            }
        }, u(ew, ey, eD, eO, eE, ej, ez, eu), {
            singleton: !0
        }),
        e$ = E(([{
            fixedFooterHeight: e,
            fixedHeaderHeight: t,
            footerHeight: o,
            headerHeight: n
        }, {
            listState: r
        }]) => {
            let i = b(),
                l = z(T(k(o, e, n, t, r), v(([e, t, o, n, r]) => e + t + o + n + r.offsetBottom + r.bottom)), 0);
            return f(O(l), i), {
                totalListHeight: l,
                totalListHeightChanged: i
            }
        }, u(K, eq), {
            singleton: !0
        }),
        eY = E(([{
            viewportHeight: e
        }, {
            totalListHeight: t
        }]) => {
            let o = y(!1),
                n = z(T(k(o, e, t), x(([e]) => e), v(([, e, t]) => Math.max(0, e - t)), w(0), p()), 0);
            return {
                alignToBottom: o,
                paddingTopAddition: n
            }
        }, u(K, e$), {
            singleton: !0
        }),
        eX = E(() => ({
            context: y(null)
        })),
        eZ = ({
            itemBottom: e,
            itemTop: t,
            locationParams: {
                align: o,
                behavior: n,
                ...r
            },
            viewportBottom: i,
            viewportTop: l
        }) => t < l ? { ...r,
            align: o ? ? "start",
            ...void 0 !== n ? {
                behavior: n
            } : {}
        } : e > i ? { ...r,
            align: o ? ? "end",
            ...void 0 !== n ? {
                behavior: n
            } : {}
        } : null,
        eJ = E(([{
            gap: e,
            sizes: t,
            totalCount: o
        }, {
            fixedFooterHeight: n,
            fixedHeaderHeight: r,
            headerHeight: i,
            scrollingInProgress: l,
            scrollTop: s,
            viewportHeight: a
        }, {
            scrollToIndex: u
        }]) => {
            let d = b();
            return f(T(d, H(t, a, o, i, r, n, s), H(e), v(([
                [e, t, o, n, r, i, s, a], u
            ]) => {
                let {
                    calculateViewLocation: d = eZ,
                    done: f,
                    ...m
                } = e, g = ex(e, t, n - 1), p = eg(g, t.offsetTree, u) + r + i, v = d({
                    itemBottom: p + Z(t.sizeTree, g)[1],
                    itemTop: p,
                    locationParams: m,
                    viewportBottom: a + o - s,
                    viewportTop: a + i
                });
                return null !== v ? f && h(T(l, x(e => !e), C(c(l) ? 1 : 2)), f) : f ? .(), v
            }), x(e => null !== e)), u), {
                scrollIntoView: d
            }
        }, u(ew, K, eE, eq, j), {
            singleton: !0
        });

    function eQ(e) {
        return !1 !== e && ("smooth" === e ? "smooth" : "auto")
    }
    let e0 = E(([{
            listRefresh: e,
            totalCount: t,
            fixedItemSize: o,
            data: n
        }, {
            atBottomState: r,
            isAtBottom: i
        }, {
            scrollToIndex: l
        }, {
            scrolledToInitialItem: s
        }, {
            didMount: a,
            propsReady: u
        }, {
            log: d
        }, {
            scrollingInProgress: m
        }, {
            context: g
        }, {
            scrollIntoView: p
        }]) => {
            let I = y(!1),
                z = b(),
                R = null;

            function E(e) {
                l(0, {
                    align: "end",
                    behavior: e,
                    index: "LAST"
                })
            }

            function B(e) {
                setTimeout(h(r, t => {
                    e && !t.atBottom && "SIZE_INCREASED" === t.notAtBottomBecause && null === R && (c(d)("scrolling to bottom due to increased size", {}, F.DEBUG), E("auto"))
                }), 100)
            }
            T(k(T(O(t), C(1)), a), H(O(I), i, s, m), v(([
                [e, t], o, n, r, i
            ]) => {
                let l, s = t && r,
                    a = "auto";
                return s && (l = n || i, a = "function" == typeof o ? eQ(o(l)) : l && eQ(o), s = s && !1 !== a), {
                    followOutputBehavior: a,
                    shouldFollow: s,
                    totalCount: e
                }
            }), x(({
                shouldFollow: e
            }) => e))(1, ({
                followOutputBehavior: t,
                totalCount: n
            }) => {
                null !== R && (R(), R = null), void 0 !== c(o) ? requestAnimationFrame(() => {
                    c(d)("following output to ", {
                        totalCount: n
                    }, F.DEBUG), E(t)
                }) : R = h(e, () => {
                    c(d)("following output to ", {
                        totalCount: n
                    }, F.DEBUG), E(t), R = null
                })
            }), T(k(O(I), t, u), x(([e, , t]) => !1 !== e && t), S(({
                value: e
            }, [, t]) => ({
                refreshed: e === t,
                value: t
            }), {
                refreshed: !1,
                value: 0
            }), x(({
                refreshed: e
            }) => e), H(I, t))(1, ([, e]) => {
                c(s) && B(!1 !== e)
            }), z(1, () => {
                B(!1 !== c(I))
            }), k(O(I), r)(1, ([e, t]) => {
                !1 === e || t.atBottom || "VIEWPORT_HEIGHT_DECREASING" !== t.notAtBottomBecause || E("auto")
            });
            let W = y(null),
                j = b();
            return f(L(T(O(n), v(e => e ? .length ? ? 0)), T(O(t))), j), T(k(T(j, C(1)), a), H(O(W), s, m, g), v(([
                [e, t], o, n, r, i
            ]) => t && n && o ? .({
                context: i,
                totalCount: e,
                scrollingInProgress: r
            })), x(e => !!e), w(0))(1, t => {
                null !== R && (R(), R = null), void 0 !== c(o) ? requestAnimationFrame(() => {
                    c(d)("scrolling into view", {}), p(0, t)
                }) : R = h(e, () => {
                    c(d)("scrolling into view", {}), p(0, t), R = null
                })
            }), {
                autoscrollToBottom: z,
                followOutput: I,
                scrollIntoViewOnChange: W
            }
        }, u(ew, ej, eE, eO, ez, j, K, eX, eJ)),
        e1 = E(([{
            data: e,
            firstItemIndex: t,
            gap: o,
            sizes: n
        }, {
            initialTopMostItemIndex: r
        }, {
            initialItemCount: i,
            listState: l
        }, {
            didMount: s
        }]) => (f(T(s, H(i), x(([, e]) => 0 !== e), H(r, n, t, o, e), v(([
            [, e], t, o, n, r, i = []
        ]) => eU(e, t, o, n, r, i))), l), {}), u(ew, eO, eq, ez), {
            singleton: !0
        }),
        e2 = E(([{
            didMount: e
        }, {
            scrollTo: t
        }, {
            listState: o
        }]) => {
            let n = y(0);
            return T(e, H(n), x(([, e]) => 0 !== e), v(([, e]) => ({
                top: e
            })))(1, e => {
                h(T(o, C(1), x(e => e.items.length > 1)), () => {
                    requestAnimationFrame(() => {
                        t(0, e)
                    })
                })
            }), {
                initialScrollTop: n
            }
        }, u(ez, K, eq), {
            singleton: !0
        }),
        e4 = E(([{
            scrollVelocity: e
        }]) => {
            let t = y(!1),
                o = b(),
                n = y(!1);
            return f(T(e, H(n, t, o), x(([e, t]) => !1 !== t && void 0 !== t), v(([e, t, o, n]) => {
                let {
                    enter: r,
                    exit: i
                } = t;
                if (o) {
                    if (i(e, n)) return !1
                } else if (r(e, n)) return !0;
                return o
            }), p()), t), T(k(t, e, o), H(n))(1, ([
                [e, t, o], n
            ]) => {
                e && !1 !== n && void 0 !== n && n.change && n.change(t, o)
            }), {
                isSeeking: t,
                scrollSeekConfiguration: n,
                scrollSeekRangeChanged: o,
                scrollVelocity: e
            }
        }, u(ej), {
            singleton: !0
        }),
        e5 = E(([{
            scrollContainerState: e,
            scrollTo: t
        }]) => {
            let o = b(),
                n = b(),
                r = b(),
                i = y(!1),
                l = y(void 0);
            return f(T(k(o, n), v(([{
                scrollTop: e,
                viewportHeight: t
            }, {
                offsetTop: o,
                listHeight: n
            }]) => ({
                scrollHeight: n,
                scrollTop: Math.max(0, e - o),
                viewportHeight: t
            }))), e), f(T(t, H(n), v(([e, {
                offsetTop: t
            }]) => ({ ...e,
                top: e.top + t
            }))), r), {
                customScrollParent: l,
                useWindowScroll: i,
                windowScrollContainerState: o,
                windowScrollTo: r,
                windowViewportRect: n
            }
        }, u(K)),
        e3 = E(([{
            sizeRanges: e,
            sizes: t
        }, {
            headerHeight: o,
            scrollTop: n
        }, {
            initialTopMostItemIndex: r
        }, {
            didMount: i
        }, {
            useWindowScroll: s,
            windowScrollContainerState: a,
            windowViewportRect: u
        }]) => {
            let d = b(),
                c = y(void 0),
                h = y(null),
                m = y(null);
            return f(a, h), f(u, m), T(d, H(t, n, s, h, m, o))(1, ([e, t, o, n, r, i, l]) => {
                let s = ee(t.sizeTree).map(({
                    k: e,
                    v: t
                }, o, n) => {
                    let r = n[o + 1];
                    return {
                        endIndex: void 0 !== r ? r.k - 1 : 1 / 0,
                        size: t,
                        startIndex: e
                    }
                });
                n && null !== r && null !== i && (o = r.scrollTop - i.offsetTop), e({
                    ranges: s,
                    scrollTop: o -= l
                })
            }), f(T(c, x(l), v(e8)), r), f(T(i, H(c), x(([, e]) => void 0 !== e), p(), v(([, e]) => e.ranges)), e), {
                getState: d,
                restoreStateFrom: c
            }
        }, u(ew, K, eO, ez, e5));

    function e8(e) {
        return {
            align: "start",
            index: 0,
            offset: e.scrollTop
        }
    }
    let e6 = E(([{
        topItemsIndexes: e
    }]) => {
        let t = y(0);
        return f(T(t, x(e => e >= 0), v(e => Array.from({
            length: e
        }).map((e, t) => t))), e), {
            topItemCount: t
        }
    }, u(eq));

    function e9(e) {
        let t = !1,
            o;
        return () => (t || (t = !0, o = e()), o)
    }
    let e7 = e9(() => /iP(ad|od|hone)/i.test(navigator.userAgent) && /WebKit/i.test(navigator.userAgent)),
        te = E(([{
            deviation: e,
            scrollBy: t,
            scrollingInProgress: o,
            scrollTop: n
        }, {
            isAtBottom: r,
            isScrolling: i,
            lastJumpDueToItemResize: l,
            scrollDirection: s
        }, {
            listState: a
        }, {
            beforeUnshiftWith: u,
            gap: d,
            shiftWithOffset: c,
            sizes: h
        }, {
            log: m
        }, {
            recalcInProgress: g
        }]) => {
            let p = R(T(a, H(l), S(([, e, t, o], [{
                bottom: n,
                items: r,
                offsetBottom: i,
                totalCount: l
            }, s]) => {
                let a = n + i,
                    u = 0;
                return t === l && e.length > 0 && r.length > 0 && (0 === r[0].originalIndex && 0 === e[0].originalIndex || 0 != (u = a - o) && (u += s)), [u, r, l, a]
            }, [0, [], 0, 0]), x(([e]) => 0 !== e), H(n, s, o, r, m, g), x(([, e, t, o, , , n]) => !n && !o && 0 !== e && "up" === t), v(([
                [e], , , , , t
            ]) => (t("Upward scrolling compensation", {
                amount: e
            }, F.DEBUG), e))));

            function I(o) {
                o > 0 ? (t(0, {
                    behavior: "auto",
                    top: -o
                }), e(0, 0)) : (e(0, 0), t(0, {
                    behavior: "auto",
                    top: -o
                }))
            }
            return T(p, H(e, i))(1, ([t, o, n]) => {
                n && e7() ? e(0, o - t) : I(-t)
            }), T(k(z(i, !1), e, g), x(([e, t, o]) => !e && !o && 0 !== t), v(([e, t]) => t), w(1))(1, I), f(T(c, v(e => ({
                top: -e
            }))), t), T(u, H(h, d), v(([e, {
                groupIndices: t,
                lastSize: o,
                sizeTree: n
            }, r]) => {
                if (0 === t.length) return e * (o + r);
                let i = 0,
                    l = X(n, 0),
                    s = 0,
                    a = 0;
                for (; s < e;) {
                    s++, i += l;
                    let n = t.length === a + 1 ? 1 / 0 : t[a + 1] - t[a] - 1;
                    s + n > e && (i -= l, n = e - s + 1), s += n, i += n * (o + r), a++
                }
                return i
            }))(1, o => {
                e(0, o), requestAnimationFrame(() => {
                    t(0, {
                        top: o
                    }), requestAnimationFrame(() => {
                        e(0, 0), g(0, !1)
                    })
                })
            }), {
                deviation: e
            }
        }, u(K, ej, eq, ew, j, eu)),
        tt = E(([e, t, o, n, r, i, l, s, a, u, d]) => ({ ...e,
            ...t,
            ...o,
            ...n,
            ...r,
            ...i,
            ...l,
            ...s,
            ...a,
            ...u,
            ...d
        }), u(eD, e1, ez, e4, e$, e2, eY, e5, eJ, j, eX)),
        to = E(([{
            data: e,
            defaultItemSize: t,
            firstItemIndex: o,
            fixedItemSize: n,
            fixedGroupSize: r,
            gap: i,
            groupIndices: l,
            heightEstimates: s,
            itemSize: a,
            sizeRanges: u,
            sizes: d,
            statefulTotalCount: c,
            totalCount: h,
            trackItemSizes: m
        }, {
            initialItemFinalLocationReached: g,
            initialTopMostItemIndex: p,
            scrolledToInitialItem: x
        }, I, S, C, w, {
            scrollToIndex: H
        }, y, {
            topItemCount: z
        }, {
            groupCounts: b
        }, R]) => {
            let {
                listState: E,
                minOverscanItemCount: B,
                topItemsIndexes: k,
                rangeChanged: O,
                ...L
            } = w;
            return f(O, R.scrollSeekRangeChanged), f(T(R.windowViewportRect, v(e => e.visibleHeight)), I.viewportHeight), {
                data: e,
                defaultItemHeight: t,
                firstItemIndex: o,
                fixedItemHeight: n,
                fixedGroupHeight: r,
                gap: i,
                groupCounts: b,
                heightEstimates: s,
                initialItemFinalLocationReached: g,
                initialTopMostItemIndex: p,
                scrolledToInitialItem: x,
                sizeRanges: u,
                topItemCount: z,
                topItemsIndexes: k,
                totalCount: h,
                ...C,
                groupIndices: l,
                itemSize: a,
                listState: E,
                minOverscanItemCount: B,
                scrollToIndex: H,
                statefulTotalCount: c,
                trackItemSizes: m,
                rangeChanged: O,
                ...L,
                ...R,
                ...I,
                sizes: d,
                ...S
            }
        }, u(ew, eO, K, e3, e0, eq, eE, te, e6, ey, tt)),
        tn = "u" > typeof document ? o.default.useLayoutEffect : o.default.useEffect;

    function tr(e, n, r) {
        let i = Object.keys(n.required || {}),
            l = Object.keys(n.optional || {}),
            a = Object.keys(n.methods || {}),
            u = Object.keys(n.events || {}),
            f = o.default.createContext({});

        function h(e, t) {
            for (let o of (void 0 !== e.propsReady && (0, e.propsReady)(0, !1), i))(0, e[n.required[o]])(0, t[o]);
            for (let o of l) o in t && (0, e[n.optional[o]])(0, t[o]);
            void 0 !== e.propsReady && (0, e.propsReady)(0, !0)
        }

        function m(e) {
            return u.reduce((t, o) => {
                var r;
                let i, l, a;
                return t[o] = (r = e[n.events[o]], a = () => i ? .(), function(e, t) {
                    switch (e) {
                        case 1:
                            return t ? l === t ? void 0 : (a(), l = t, i = r(1, t)) : (a(), s);
                        case 2:
                            a(), l = null;
                            return
                    }
                }), t
            }, {})
        }
        return {
            Component: o.default.forwardRef(function(s, c) {
                var g;
                let {
                    children: p,
                    ...x
                } = s, [v] = o.default.useState(() => {
                    var t;
                    let o, n;
                    return o = new Map, h(t = (n = ({
                        constructor: e,
                        dependencies: t,
                        id: r,
                        singleton: i
                    }) => {
                        if (i && o.has(r)) return o.get(r);
                        let l = e(t.map(e => n(e)));
                        return i && o.set(r, l), l
                    })(e), x), t
                }), [I] = o.default.useState(() => m(v));
                return tn(() => {
                    for (let e of u) e in x && (0, I[e])(1, x[e]);
                    return () => {
                        Object.values(I).map(d)
                    }
                }, [x, I, v]), tn(() => {
                    h(v, x)
                }), o.default.useImperativeHandle(c, (g = a.reduce((e, t) => (e[t] = e => {
                    (0, v[n.methods[t]])(0, e)
                }, e), {}), () => g)), (0, t.jsx)(f.Provider, {
                    value: v,
                    children: void 0 !== r ? (0, t.jsx)(r, { ... function(e, t) {
                            let o = {},
                                n = {},
                                r = 0,
                                i = e.length;
                            for (; r < i;) n[e[r]] = 1, r += 1;
                            for (let e in t) Object.hasOwn(n, e) || (o[e] = t[e]);
                            return o
                        }([...i, ...l, ...u], x),
                        children: p
                    }) : p
                })
            }),
            useEmitter: (e, t) => {
                let n = o.default.useContext(f)[e];
                tn(() => n(1, t), [t, n])
            },
            useEmitterValue: parseInt(o.default.version) >= 18 ? e => {
                let t = o.default.useContext(f)[e],
                    n = o.default.useCallback(e => t(1, e), [t]);
                return o.default.useSyncExternalStore(n, () => c(t), () => c(t))
            } : e => {
                let t = o.default.useContext(f)[e],
                    [n, r] = o.default.useState(() => c(t));
                return tn(() => t(1, e => {
                    e !== n && r(() => e)
                }), [t, n]), n
            },
            usePublisher: e => {
                let t = o.default.useContext(f);
                return o.default.useCallback(o => {
                    (0, t[e])(0, o)
                }, [t, e])
            }
        }
    }
    let ti = o.default.createContext(void 0),
        tl = o.default.createContext(void 0),
        ts = "-webkit-sticky",
        ta = "sticky",
        tu = e9(() => {
            if (typeof document > "u") return ta;
            let e = document.createElement("div");
            return e.style.position = ts, e.style.position === ts ? ts : ta
        }),
        td = "u" > typeof document ? o.default.useLayoutEffect : o.default.useEffect;

    function tc(e) {
        return "self" in e
    }

    function tf(e, t, r, i = s, l, a) {
        let u = o.default.useRef(null),
            d = o.default.useRef(null),
            c = o.default.useRef(null),
            f = o.default.useCallback(o => {
                let r, i, l, s = o.target;
                if ("body" in s || tc(s)) {
                    let e = tc(s) ? s : s.defaultView;
                    l = !0 === a ? V(e, e.scrollX) : e.scrollY, r = !0 === a ? e.document.documentElement.scrollWidth : e.document.documentElement.scrollHeight, i = !0 === a ? e.innerWidth : e.innerHeight
                } else l = !0 === a ? V(s, s.scrollLeft) : s.scrollTop, r = !0 === a ? s.scrollWidth : s.scrollHeight, i = !0 === a ? s.offsetWidth : s.offsetHeight;
                let u = () => {
                    e({
                        scrollHeight: r,
                        scrollTop: Math.max(l, 0),
                        viewportHeight: i
                    })
                };
                !0 === o.suppressFlushSync ? u() : n.default.flushSync(u), null !== d.current && (l === d.current || l <= 0 || l === r - i) && (d.current = null, t(!0), c.current && (clearTimeout(c.current), c.current = null))
            }, [e, t, a]);
        return o.default.useEffect(() => {
            let e = l || u.current;
            return A(e), i(l || u.current), f({
                suppressFlushSync: !0,
                target: e
            }), e.addEventListener("scroll", f, {
                passive: !0
            }), () => {
                A(e), i(null), e.removeEventListener("scroll", f)
            }
        }, [u, f, r, i, l]), {
            scrollByCallback: function(e) {
                !0 === a && (e = { ...void 0 !== e.behavior ? {
                        behavior: e.behavior
                    } : {},
                    ...void 0 !== e.top ? {
                        left: V(u.current, e.top)
                    } : {}
                }), u.current.scrollBy(e)
            },
            scrollerRef: u,
            scrollToCallback: function(o) {
                let n, r, i, l = u.current;
                if (!l || (!0 === a ? "offsetWidth" in l && 0 === l.offsetWidth : "offsetHeight" in l && 0 === l.offsetHeight)) return;
                let s = "smooth" === o.behavior;
                tc(l) ? (r = Math.max(ec(l.document.documentElement, !0 === a ? "width" : "height"), !0 === a ? l.document.documentElement.scrollWidth : l.document.documentElement.scrollHeight), n = !0 === a ? l.innerWidth : l.innerHeight, i = !0 === a ? V(l, l.scrollX) : l.scrollY) : (r = l[!0 === a ? "scrollWidth" : "scrollHeight"], n = ec(l, !0 === a ? "width" : "height"), i = !0 === a ? V(l, l.scrollLeft) : l.scrollTop);
                let f = r - n;
                if (void 0 === o.top) return void l.scrollTo(o);
                let h = Math.ceil(Math.max(Math.min(f, o.top), 0));
                if (o.top = h, eL(n, r) || h === i) {
                    e({
                        scrollHeight: r,
                        scrollTop: i,
                        viewportHeight: n
                    }), s && t(!0);
                    return
                }
                s ? (d.current = h, c.current && clearTimeout(c.current), c.current = setTimeout(() => {
                    c.current = null, d.current = null, t(!0)
                }, 1e3)) : d.current = null, !0 === a && (o = { ...void 0 !== o.behavior ? {
                        behavior: o.behavior
                    } : {},
                    left: V(l, h)
                }), l.scrollTo(o)
            }
        }
    }

    function th(e) {
        return e
    }
    let tm = E(() => {
            let e = y(e => `Item ${e}`),
                t = y(e => `Group ${e}`),
                o = y({}),
                n = y(th),
                r = y("div"),
                i = y(s),
                l = (e, t = null) => z(T(o, v(t => t[e]), p()), t);
            return {
                components: o,
                computeItemKey: n,
                EmptyPlaceholder: l("EmptyPlaceholder"),
                FooterComponent: l("Footer"),
                GroupComponent: l("Group", "div"),
                groupContent: t,
                HeaderComponent: l("Header"),
                HeaderFooterTag: r,
                ItemComponent: l("Item", "div"),
                itemContent: e,
                ListComponent: l("List", "div"),
                ScrollerComponent: l("Scroller", "div"),
                scrollerRef: i,
                ScrollSeekPlaceholder: l("ScrollSeekPlaceholder"),
                TopItemListComponent: l("TopItemList")
            }
        }),
        tg = E(([e, t]) => ({ ...e,
            ...t
        }), u(to, tm)),
        tp = ({
            height: e
        }) => (0, t.jsx)("div", {
            style: {
                height: e
            }
        }),
        tx = {
            overflowAnchor: "none",
            position: tu(),
            zIndex: 1
        },
        tv = {
            overflowAnchor: "none"
        },
        tI = { ...tv,
            display: "inline-block",
            height: "100%"
        },
        tT = o.default.memo(function({
            showTopList: e = !1
        }) {
            let n = tP("listState"),
                r = tM("sizeRanges"),
                i = tP("useWindowScroll"),
                l = tP("customScrollParent"),
                a = tM("windowScrollContainerState"),
                u = tM("scrollContainerState"),
                d = tP("itemContent"),
                c = tP("context"),
                f = tP("groupContent"),
                h = tP("trackItemSizes"),
                m = tP("itemSize"),
                g = tP("log"),
                p = tM("gap"),
                x = tP("horizontalDirection"),
                {
                    callbackRef: v
                } = N(r, m, h, e ? s : l || i ? a : u, g, p, l, x, tP("skipAnimationFrameInResizeObserver")),
                [I, T] = o.default.useState(0);
            tj("deviation", e => {
                I !== e && T(e)
            });
            let S = tP("EmptyPlaceholder"),
                C = tP("ScrollSeekPlaceholder") ? ? tp,
                w = tP("ListComponent"),
                H = tP("ItemComponent"),
                y = tP("GroupComponent"),
                z = tP("computeItemKey"),
                b = tP("isSeeking"),
                R = tP("groupIndices").length > 0,
                E = tP("alignToBottom"),
                B = tP("initialItemFinalLocationReached"),
                k = e ? {} : {
                    boxSizing: "border-box",
                    ...x ? {
                        display: "inline-block",
                        height: "100%",
                        marginInlineStart: 0 !== I ? I : E ? "auto" : 0,
                        paddingInlineEnd: n.offsetBottom,
                        paddingInlineStart: n.offsetTop,
                        whiteSpace: "nowrap"
                    } : {
                        marginTop: 0 !== I ? I : E ? "auto" : 0,
                        paddingBottom: n.offsetBottom,
                        paddingTop: n.offsetTop
                    },
                    ...B ? {} : {
                        visibility: "hidden"
                    }
                };
            return e || 0 !== n.totalCount || null == S ? (0, t.jsx)(w, { ...tz(w, c),
                "data-testid": e ? "virtuoso-top-item-list" : "virtuoso-item-list",
                ref: v,
                style: k,
                children: (e ? n.topItems : n.items).map(e => {
                    let t = e.originalIndex,
                        r = z(t + n.firstItemIndex, e.data, c);
                    return b ? (0, o.createElement)(C, { ...tz(C, c),
                        height: e.size,
                        index: e.index,
                        key: r,
                        type: e.type || "item",
                        ..."group" === e.type ? {} : {
                            groupIndex: e.groupIndex
                        }
                    }) : "group" === e.type ? (0, o.createElement)(y, { ...tz(y, c),
                        "data-index": t,
                        "data-item-index": e.index,
                        "data-known-size": e.size,
                        key: r,
                        style: tx
                    }, f(e.index, c)) : (0, o.createElement)(H, { ...tz(H, c),
                        ...tb(H, e.data),
                        "data-index": t,
                        "data-item-group-index": e.groupIndex,
                        "data-item-index": e.index,
                        "data-known-size": e.size,
                        key: r,
                        style: x ? tI : tv
                    }, R ? d(e.index, e.groupIndex, e.data, c) : d(e.index, e.data, c))
                })
            }) : (0, t.jsx)(S, { ...tz(S, c)
            })
        }),
        tS = {
            height: "100%",
            outline: "none",
            overflowY: "auto",
            position: "relative",
            WebkitOverflowScrolling: "touch"
        },
        tC = {
            outline: "none",
            overflowX: "auto",
            position: "relative"
        },
        tw = e => ({
            height: "100%",
            position: "absolute",
            top: 0,
            width: "100%",
            ...e ? {
                display: "flex",
                flexDirection: "column"
            } : void 0
        }),
        tH = (e, t, o = 0) => ({ ...tw(e),
            position: t ? "relative" : "absolute",
            top: t ? -o : 0
        }),
        ty = {
            position: tu(),
            top: 0,
            width: "100%",
            zIndex: 1
        };

    function tz(e, t) {
        if ("string" != typeof e) return {
            context: t
        }
    }

    function tb(e, t) {
        return {
            item: "string" == typeof e ? void 0 : t
        }
    }
    let tR = o.default.memo(function() {
            let e = tP("HeaderComponent"),
                n = tM("headerHeight"),
                r = tP("HeaderFooterTag"),
                i = D(o.default.useMemo(() => e => {
                    n(ec(e, "height"))
                }, [n]), !0, tP("skipAnimationFrameInResizeObserver")),
                l = tP("context");
            return null != e ? (0, t.jsx)(r, {
                ref: i,
                children: (0, t.jsx)(e, { ...tz(e, l)
                })
            }) : null
        }),
        tE = o.default.memo(function() {
            let e = tP("FooterComponent"),
                n = tM("footerHeight"),
                r = tP("HeaderFooterTag"),
                i = D(o.default.useMemo(() => e => {
                    n(ec(e, "height"))
                }, [n]), !0, tP("skipAnimationFrameInResizeObserver")),
                l = tP("context");
            return null != e ? (0, t.jsx)(r, {
                ref: i,
                children: (0, t.jsx)(e, { ...tz(e, l)
                })
            }) : null
        });

    function tB({
        useEmitter: e,
        useEmitterValue: n,
        usePublisher: r
    }) {
        return o.default.memo(function({
            children: o,
            style: i,
            context: l,
            ...s
        }) {
            let a = r("scrollContainerState"),
                u = n("ScrollerComponent"),
                d = r("smoothScrollTargetReached"),
                c = n("scrollerRef"),
                f = n("horizontalDirection") || !1,
                {
                    scrollByCallback: h,
                    scrollerRef: m,
                    scrollToCallback: g
                } = tf(a, d, u, c, void 0, f);
            return e("scrollTo", g), e("scrollBy", h), (0, t.jsx)(u, {
                "data-testid": "virtuoso-scroller",
                "data-virtuoso-scroller": !0,
                ref: m,
                style: { ...f ? tC : tS,
                    ...i
                },
                tabIndex: 0,
                ...s,
                ...tz(u, l),
                children: o
            })
        })
    }

    function tk({
        useEmitter: e,
        useEmitterValue: n,
        usePublisher: r
    }) {
        return o.default.memo(function({
            children: i,
            style: l,
            context: s,
            ...a
        }) {
            let u = r("windowScrollContainerState"),
                d = n("ScrollerComponent"),
                c = r("smoothScrollTargetReached"),
                f = n("totalListHeight"),
                h = n("deviation"),
                m = n("customScrollParent"),
                g = o.default.useRef(null),
                {
                    scrollByCallback: p,
                    scrollerRef: x,
                    scrollToCallback: v
                } = tf(u, c, d, n("scrollerRef"), m);
            return td(() => (x.current = m || g.current ? .ownerDocument.defaultView, () => {
                x.current = null
            }), [x, m]), e("windowScrollTo", v), e("scrollBy", p), (0, t.jsx)(d, {
                ref: g,
                "data-virtuoso-scroller": !0,
                style: {
                    position: "relative",
                    ...l,
                    ...0 !== f ? {
                        height: f + h
                    } : void 0
                },
                ...a,
                ...tz(d, s),
                children: i
            })
        })
    }
    let tO = ({
            children: e
        }) => {
            let n = o.default.useContext(ti),
                r = tM("viewportHeight"),
                l = tM("fixedItemHeight"),
                s = tP("alignToBottom"),
                a = tP("horizontalDirection"),
                u = D(o.default.useMemo(() => i(r, e => ec(e, a ? "width" : "height")), [r, a]), !0, tP("skipAnimationFrameInResizeObserver"));
            return o.default.useEffect(() => {
                n && (r(n.viewportHeight), l(n.itemHeight))
            }, [n, r, l]), (0, t.jsx)("div", {
                "data-viewport-type": "element",
                ref: u,
                style: tw(s),
                children: e
            })
        },
        tL = ({
            children: e
        }) => {
            let n = o.default.useContext(ti),
                r = tM("windowViewportRect"),
                i = tM("fixedItemHeight"),
                l = tP("customScrollParent"),
                s = tP("useWindowScroll"),
                a = tP("topListHeight"),
                u = _(r, l, tP("skipAnimationFrameInResizeObserver")),
                d = tP("alignToBottom");
            return o.default.useEffect(() => {
                n && (i(n.itemHeight), r({
                    listHeight: 0,
                    offsetTop: 0,
                    visibleHeight: n.viewportHeight,
                    visibleWidth: 100
                }))
            }, [n, r, i]), (0, t.jsx)("div", {
                "data-viewport-type": "window",
                ref: u,
                style: tH(d, s, a),
                children: e
            })
        },
        tF = ({
            children: e
        }) => {
            let o = tP("TopItemListComponent") ? ? "div",
                n = tP("headerHeight"),
                r = { ...ty,
                    marginTop: `${n}px`
                },
                i = tP("context");
            return (0, t.jsx)(o, {
                style: r,
                ...tz(o, i),
                children: e
            })
        },
        {
            Component: tW,
            useEmitter: tj,
            useEmitterValue: tP,
            usePublisher: tM
        } = tr(tg, {
            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",
                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"
            }
        }, o.default.memo(function(e) {
            let o = tP("useWindowScroll"),
                n = tP("topItemsIndexes").length > 0,
                r = tP("customScrollParent"),
                i = tP("context");
            return (0, t.jsxs)(r || o ? tV : tA, { ...e,
                context: i,
                children: [n && (0, t.jsx)(tF, {
                    children: (0, t.jsx)(tT, {
                        showTopList: !0
                    })
                }), (0, t.jsxs)(r || o ? tL : tO, {
                    children: [(0, t.jsx)(tR, {}), (0, t.jsx)(tT, {}), (0, t.jsx)(tE, {})]
                })]
            })
        })),
        tA = tB({
            useEmitter: tj,
            useEmitterValue: tP,
            usePublisher: tM
        }),
        tV = tk({
            useEmitter: tj,
            useEmitterValue: tP,
            usePublisher: tM
        }),
        tD = E(() => {
            let e = y(e => (0, t.jsxs)("td", {
                    children: ["Item $", e]
                })),
                o = y(null),
                n = y(e => (0, t.jsxs)("td", {
                    colSpan: 1e3,
                    children: ["Group ", e]
                })),
                r = y(null),
                i = y(null),
                l = y({}),
                a = y(th),
                u = y(s),
                d = (e, t = null) => z(T(l, v(t => t[e]), p()), t);
            return {
                components: l,
                computeItemKey: a,
                context: o,
                EmptyPlaceholder: d("EmptyPlaceholder"),
                FillerRow: d("FillerRow"),
                fixedFooterContent: i,
                fixedHeaderContent: r,
                itemContent: e,
                groupContent: n,
                ScrollerComponent: d("Scroller", "div"),
                scrollerRef: u,
                ScrollSeekPlaceholder: d("ScrollSeekPlaceholder"),
                TableBodyComponent: d("TableBody", "tbody"),
                TableComponent: d("Table", "table"),
                TableFooterComponent: d("TableFoot", "tfoot"),
                TableHeadComponent: d("TableHead", "thead"),
                TableRowComponent: d("TableRow", "tr"),
                GroupComponent: d("Group", "tr")
            }
        }),
        tG = E(([e, t]) => ({ ...e,
            ...t
        }), u(to, tD)),
        tN = ({
            height: e
        }) => (0, t.jsx)("tr", {
            children: (0, t.jsx)("td", {
                style: {
                    height: e
                }
            })
        }),
        tU = ({
            height: e
        }) => (0, t.jsx)("tr", {
            children: (0, t.jsx)("td", {
                style: {
                    border: 0,
                    height: e,
                    padding: 0
                }
            })
        }),
        t_ = {
            overflowAnchor: "none"
        },
        tK = {
            position: tu(),
            zIndex: 2,
            overflowAnchor: "none"
        },
        tq = o.default.memo(function({
            showTopList: e = !1
        }) {
            let t = tJ("listState"),
                n = tJ("computeItemKey"),
                r = tJ("firstItemIndex"),
                i = tJ("context"),
                l = tJ("isSeeking"),
                s = tJ("fixedHeaderHeight"),
                a = tJ("groupIndices").length > 0,
                u = tJ("itemContent"),
                d = tJ("groupContent"),
                c = tJ("ScrollSeekPlaceholder") ? ? tN,
                f = tJ("GroupComponent"),
                h = tJ("TableRowComponent"),
                m = (e ? t.topItems : []).reduce((e, t, o) => (0 === o ? e.push(t.size) : e.push(e[o - 1] + t.size), e), []);
            return (e ? t.topItems : t.items).map(t => {
                let g = t.originalIndex,
                    p = n(g + r, t.data, i),
                    x = e ? 0 === g ? 0 : m[g - 1] : 0;
                return l ? (0, o.createElement)(c, { ...tz(c, i),
                    height: t.size,
                    index: t.index,
                    key: p,
                    type: t.type || "item"
                }) : "group" === t.type ? (0, o.createElement)(f, { ...tz(f, i),
                    "data-index": g,
                    "data-item-index": t.index,
                    "data-known-size": t.size,
                    key: p,
                    style: { ...tK,
                        top: s
                    }
                }, d(t.index, i)) : (0, o.createElement)(h, { ...tz(h, i),
                    ...tb(h, t.data),
                    "data-index": g,
                    "data-item-index": t.index,
                    "data-known-size": t.size,
                    "data-item-group-index": t.groupIndex,
                    key: p,
                    style: e ? { ...tK,
                        top: s + x
                    } : t_
                }, a ? u(t.index, t.groupIndex, t.data, i) : u(t.index, t.data, i))
            })
        }),
        t$ = o.default.memo(function() {
            let e = tJ("listState"),
                n = tJ("topItemsIndexes").length > 0,
                r = tQ("sizeRanges"),
                i = tJ("useWindowScroll"),
                l = tJ("customScrollParent"),
                s = tQ("windowScrollContainerState"),
                a = tQ("scrollContainerState"),
                u = tJ("trackItemSizes"),
                {
                    callbackRef: d,
                    ref: c
                } = N(r, tJ("itemSize"), u, l || i ? s : a, tJ("log"), void 0, l, !1, tJ("skipAnimationFrameInResizeObserver")),
                [f, h] = o.default.useState(0);
            tZ("deviation", e => {
                f !== e && (c.current.style.marginTop = `${e}px`, h(e))
            });
            let m = tJ("EmptyPlaceholder"),
                g = tJ("FillerRow") ? ? tU,
                p = tJ("TableBodyComponent"),
                x = tJ("paddingTopAddition"),
                v = tJ("statefulTotalCount"),
                I = tJ("context");
            if (0 === v && null != m) return (0, t.jsx)(m, { ...tz(m, I)
            });
            let T = (n ? e.topItems : []).reduce((e, t) => e + t.size, 0),
                S = e.offsetTop + x + f - T,
                C = e.offsetBottom,
                w = S > 0 ? (0, t.jsx)(g, {
                    context: I,
                    height: S
                }, "padding-top") : null,
                H = C > 0 ? (0, t.jsx)(g, {
                    context: I,
                    height: C
                }, "padding-bottom") : null;
            return (0, t.jsxs)(p, {
                "data-testid": "virtuoso-item-list",
                ref: d,
                ...tz(p, I),
                children: [w, n && (0, t.jsx)(tq, {
                    showTopList: !0
                }), (0, t.jsx)(tq, {}), H]
            })
        }),
        tY = ({
            children: e
        }) => {
            let n = o.default.useContext(ti),
                r = tQ("viewportHeight"),
                l = tQ("fixedItemHeight"),
                s = D(o.default.useMemo(() => i(r, e => ec(e, "height")), [r]), !0, tJ("skipAnimationFrameInResizeObserver"));
            return o.default.useEffect(() => {
                n && (r(n.viewportHeight), l(n.itemHeight))
            }, [n, r, l]), (0, t.jsx)("div", {
                "data-viewport-type": "element",
                ref: s,
                style: tw(!1),
                children: e
            })
        },
        tX = ({
            children: e
        }) => {
            let n = o.default.useContext(ti),
                r = tQ("windowViewportRect"),
                i = tQ("fixedItemHeight"),
                l = tJ("customScrollParent"),
                s = tJ("useWindowScroll"),
                a = _(r, l, tJ("skipAnimationFrameInResizeObserver"));
            return o.default.useEffect(() => {
                n && (i(n.itemHeight), r({
                    listHeight: 0,
                    offsetTop: 0,
                    visibleHeight: n.viewportHeight,
                    visibleWidth: 100
                }))
            }, [n, r, i]), (0, t.jsx)("div", {
                "data-viewport-type": "window",
                ref: a,
                style: tH(!1, s),
                children: e
            })
        },
        {
            useEmitter: tZ,
            useEmitterValue: tJ,
            usePublisher: tQ
        } = tr(tG, {
            optional: {
                restoreStateFrom: "restoreStateFrom",
                context: "context",
                followOutput: "followOutput",
                firstItemIndex: "firstItemIndex",
                itemContent: "itemContent",
                groupContent: "groupContent",
                fixedHeaderContent: "fixedHeaderContent",
                fixedFooterContent: "fixedFooterContent",
                overscan: "overscan",
                increaseViewportBy: "increaseViewportBy",
                minOverscanItemCount: "minOverscanItemCount",
                totalCount: "totalCount",
                topItemCount: "topItemCount",
                initialTopMostItemIndex: "initialTopMostItemIndex",
                components: "components",
                groupCounts: "groupCounts",
                atBottomThreshold: "atBottomThreshold",
                atTopThreshold: "atTopThreshold",
                computeItemKey: "computeItemKey",
                defaultItemHeight: "defaultItemHeight",
                fixedGroupHeight: "fixedGroupHeight",
                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"
            }
        }, o.default.memo(function(e) {
            let n = tJ("useWindowScroll"),
                r = tJ("customScrollParent"),
                l = tQ("fixedHeaderHeight"),
                s = tQ("fixedFooterHeight"),
                a = tJ("fixedHeaderContent"),
                u = tJ("fixedFooterContent"),
                d = tJ("context"),
                c = D(o.default.useMemo(() => i(l, e => ec(e, "height")), [l]), !0, tJ("skipAnimationFrameInResizeObserver")),
                f = D(o.default.useMemo(() => i(s, e => ec(e, "height")), [s]), !0, tJ("skipAnimationFrameInResizeObserver")),
                h = r || n ? t1 : t0,
                m = r || n ? tX : tY,
                g = tJ("TableComponent"),
                p = tJ("TableHeadComponent"),
                x = tJ("TableFooterComponent"),
                v = a ? (0, t.jsx)(p, {
                    ref: c,
                    style: {
                        position: "sticky",
                        top: 0,
                        zIndex: 2
                    },
                    ...tz(p, d),
                    children: a()
                }, "TableHead") : null,
                I = u ? (0, t.jsx)(x, {
                    ref: f,
                    style: {
                        bottom: 0,
                        position: "sticky",
                        zIndex: 1
                    },
                    ...tz(x, d),
                    children: u()
                }, "TableFoot") : null;
            return (0, t.jsx)(h, { ...e,
                ...tz(h, d),
                children: (0, t.jsx)(m, {
                    children: (0, t.jsxs)(g, {
                        style: {
                            borderSpacing: 0,
                            overflowAnchor: "none"
                        },
                        ...tz(g, d),
                        children: [v, (0, t.jsx)(t$, {}, "TableBody"), I]
                    })
                })
            })
        })),
        t0 = tB({
            useEmitter: tZ,
            useEmitterValue: tJ,
            usePublisher: tQ
        }),
        t1 = tk({
            useEmitter: tZ,
            useEmitterValue: tJ,
            usePublisher: tQ
        }),
        t2 = {
            bottom: 0,
            itemHeight: 0,
            items: [],
            itemWidth: 0,
            offsetBottom: 0,
            offsetTop: 0,
            top: 0
        },
        t4 = {
            bottom: 0,
            itemHeight: 0,
            items: [{
                index: 0
            }],
            itemWidth: 0,
            offsetBottom: 0,
            offsetTop: 0,
            top: 0
        },
        {
            ceil: t5,
            floor: t3,
            max: t8,
            min: t6,
            round: t9
        } = Math;

    function t7(e, t, o) {
        return Array.from({
            length: t - e + 1
        }).map((t, n) => ({
            data: null === o ? null : o[n + e],
            index: n + e
        }))
    }

    function oe(e, t) {
        return void 0 !== e && e.width === t.width && e.height === t.height
    }

    function ot(e, t) {
        return void 0 !== e && e.column === t.column && e.row === t.row
    }
    let oo = E(([{
        increaseViewportBy: e,
        listBoundary: t,
        overscan: o,
        visibleRange: n
    }, {
        footerHeight: r,
        headerHeight: i,
        scrollBy: l,
        scrollContainerState: s,
        scrollTo: a,
        scrollTop: u,
        smoothScrollTargetReached: d,
        viewportHeight: c
    }, m, g, {
        didMount: S,
        propsReady: E
    }, {
        customScrollParent: B,
        useWindowScroll: L,
        windowScrollContainerState: F,
        windowScrollTo: W,
        windowViewportRect: j
    }, P]) => {
        let M = y(0),
            A = y(0),
            V = y(t2),
            D = y({
                height: 0,
                width: 0
            }),
            G = y({
                height: 0,
                width: 0
            }),
            N = b(),
            U = b(),
            _ = y(0),
            K = y(null),
            q = y({
                column: 0,
                row: 0
            }),
            $ = b(),
            Y = b(),
            X = y(!1),
            Z = y(0),
            J = y(!0),
            Q = y(!1),
            ee = y(!1);
        T(S, H(Z), x(([e, t]) => 0 !== t))(1, () => {
            J(0, !1)
        }), T(k(S, J, G, D, Z, Q), x(([e, t, o, n, , r]) => e && !t && 0 !== o.height && 0 !== n.height && !r))(1, ([, , , , e]) => {
            Q(0, !0), eB(1, () => {
                N(0, e)
            }), h(T(u), () => {
                t(0, [0, 0]), J(0, !0)
            })
        }), f(T(Y, x(e => null != e && e.scrollTop > 0), I(0)), A), T(S, H(Y), x(([, e]) => null != e))(1, ([, e]) => {
            e && (D(0, e.viewport), G(0, e.item), q(0, e.gap), e.scrollTop > 0 && (X(0, !0), h(T(u, C(1)), e => {
                X(0, !1)
            }), a(0, {
                top: e.scrollTop
            })))
        }), f(T(D, v(({
            height: e
        }) => e)), c), f(T(k(O(D, oe), O(G, oe), O(q, (e, t) => void 0 !== e && e.column === t.column && e.row === t.row), O(u)), v(([e, t, o, n]) => ({
            gap: o,
            item: t,
            scrollTop: n,
            viewport: e
        }))), $), f(T(k(O(M), n, O(q, ot), O(G, oe), O(D, oe), O(K), O(A), O(X), O(J), O(Z)), x(([, , , , , , , e]) => !e), v(([e, [t, o], n, r, i, l, s, , a, u]) => {
            let d, c, {
                    column: f,
                    row: h
                } = n,
                {
                    height: m,
                    width: g
                } = r,
                {
                    width: p
                } = i;
            if (0 === s && (0 === e || 0 === p)) return t2;
            if (0 === g) {
                var x;
                let t = ek(u, e),
                    o = t + Math.max(s - 1, 0);
                return x = t7(t, o, l), { ...t4,
                    items: x
                }
            }
            let v = on(p, g, f);
            a ? 0 === t && 0 === o && s > 0 ? (d = 0, c = s - 1) : (d = v * t3((t + h) / (m + h)), c = t6(e - 1, t8(c = v * t5((o + h) / (m + h)) - 1, v - 1)), d = t6(c, t8(0, d))) : (d = 0, c = -1);
            let I = t7(d, c, l),
                {
                    bottom: T,
                    top: S
                } = or(i, n, r, I),
                C = t5(e / v);
            return {
                bottom: T,
                itemHeight: m,
                items: I,
                itemWidth: g,
                offsetBottom: C * m + (C - 1) * h - T,
                offsetTop: S,
                top: S
            }
        })), V), f(T(K, x(e => null !== e), v(e => e.length)), M), f(T(k(D, G, V, q), x(([e, t, {
            items: o
        }]) => o.length > 0 && 0 !== t.height && 0 !== e.height), v(([e, t, {
            items: o
        }, n]) => {
            let {
                bottom: r,
                top: i
            } = or(e, n, t, o);
            return [i, r]
        }), p(ea)), t);
        let et = y(!1);
        f(T(u, H(et), v(([e, t]) => t || 0 !== e)), et);
        let eo = R(T(k(V, M), x(([{
                items: e
            }]) => e.length > 0), H(et), x(([
                [e, t], o
            ]) => {
                let n = e.items[e.items.length - 1].index === t - 1;
                return (o || e.bottom > 0 && e.itemHeight > 0 && 0 === e.offsetBottom && e.items.length === t) && n
            }), v(([
                [, e]
            ]) => e - 1), p())),
            en = R(T(O(V), x(({
                items: e
            }) => e.length > 0 && 0 === e[0].index), I(0), p())),
            er = R(T(O(V), H(X), x(([{
                items: e
            }, t]) => e.length > 0 && !t), v(([{
                items: e
            }]) => ({
                endIndex: e[e.length - 1].index,
                startIndex: e[0].index
            })), p(es), w(0)));
        f(er, g.scrollSeekRangeChanged), f(T(N, H(D, G, M, q), v(([e, t, o, n, r]) => {
            let i = eR(e),
                {
                    align: l,
                    behavior: s,
                    offset: a
                } = i,
                u = i.index;
            "LAST" === u && (u = n - 1);
            let d = oi(t, r, o, u = t8(0, u, t6(n - 1, u)));
            return "end" === l ? d = t9(d - t.height + o.height) : "center" === l && (d = t9(d - t.height / 2 + o.height / 2)), void 0 !== a && 0 !== a && (d += a), {
                behavior: s,
                top: d
            }
        })), a);
        let ei = z(T(V, v(e => e.offsetBottom + e.bottom)), 0);
        return f(T(j, v(e => ({
            height: e.visibleHeight,
            width: e.visibleWidth
        }))), D), {
            customScrollParent: B,
            data: K,
            deviation: _,
            footerHeight: r,
            gap: q,
            headerHeight: i,
            increaseViewportBy: e,
            initialItemCount: A,
            itemDimensions: G,
            overscan: o,
            restoreStateFrom: Y,
            scrollBy: l,
            scrollContainerState: s,
            scrollHeight: U,
            scrollTo: a,
            scrollToIndex: N,
            scrollTop: u,
            smoothScrollTargetReached: d,
            totalCount: M,
            useWindowScroll: L,
            viewportDimensions: D,
            windowScrollContainerState: F,
            windowScrollTo: W,
            windowViewportRect: j,
            ...g,
            gridState: V,
            horizontalDirection: ee,
            initialTopMostItemIndex: Z,
            totalListHeight: ei,
            ...m,
            endReached: eo,
            propsReady: E,
            rangeChanged: er,
            startReached: en,
            stateChanged: $,
            stateRestoreInProgress: X,
            ...P
        }
    }, u(eD, K, ej, e4, ez, e5, j));

    function on(e, t, o) {
        return t8(1, t3((e + o) / (t3(t) + o)))
    }

    function or(e, t, o, n) {
        let {
            height: r
        } = o;
        if (void 0 === r || 0 === n.length) return {
            bottom: 0,
            top: 0
        };
        let i = oi(e, t, o, n[0].index);
        return {
            bottom: oi(e, t, o, n[n.length - 1].index) + r,
            top: i
        }
    }

    function oi(e, t, o, n) {
        let r = t3(n / on(e.width, o.width, t.column)),
            i = r * o.height + t8(0, r - 1) * t.row;
        return i > 0 ? i + t.row : i
    }
    let ol = E(() => {
            let e = y(e => `Item ${e}`),
                t = y({}),
                o = y(null),
                n = y("virtuoso-grid-item"),
                r = y("virtuoso-grid-list"),
                i = y(th),
                l = y("div"),
                a = y(s),
                u = (e, o = null) => z(T(t, v(t => t[e]), p()), o),
                d = y(!1),
                c = y(!1);
            return f(O(c), d), {
                components: t,
                computeItemKey: i,
                context: o,
                FooterComponent: u("Footer"),
                HeaderComponent: u("Header"),
                headerFooterTag: l,
                itemClassName: n,
                ItemComponent: u("Item", "div"),
                itemContent: e,
                listClassName: r,
                ListComponent: u("List", "div"),
                readyStateChanged: d,
                reportReadyState: c,
                ScrollerComponent: u("Scroller", "div"),
                scrollerRef: a,
                ScrollSeekPlaceholder: u("ScrollSeekPlaceholder", "div")
            }
        }),
        os = E(([e, t]) => ({ ...e,
            ...t
        }), u(oo, ol)),
        oa = o.default.memo(function() {
            let e = og("gridState"),
                n = og("listClassName"),
                r = og("itemClassName"),
                i = og("itemContent"),
                l = og("computeItemKey"),
                s = og("isSeeking"),
                a = op("scrollHeight"),
                u = og("ItemComponent"),
                d = og("ListComponent"),
                c = og("ScrollSeekPlaceholder"),
                f = og("context"),
                h = op("itemDimensions"),
                m = op("gap"),
                g = og("log"),
                p = og("stateRestoreInProgress"),
                x = op("reportReadyState"),
                v = D(o.default.useMemo(() => e => {
                    a(e.parentElement.parentElement.scrollHeight);
                    let t = e.firstChild;
                    if (null !== t) {
                        let {
                            height: e,
                            width: o
                        } = t.getBoundingClientRect();
                        h({
                            height: e,
                            width: o
                        })
                    }
                    m({
                        column: oI("column-gap", getComputedStyle(e).columnGap, g),
                        row: oI("row-gap", getComputedStyle(e).rowGap, g)
                    })
                }, [a, h, m, g]), !0, !1);
            return td(() => {
                e.itemHeight > 0 && e.itemWidth > 0 && x(!0)
            }, [e]), p ? null : (0, t.jsx)(d, {
                className: n,
                ref: v,
                ...tz(d, f),
                "data-testid": "virtuoso-item-list",
                style: {
                    paddingBottom: e.offsetBottom,
                    paddingTop: e.offsetTop
                },
                children: e.items.map(n => {
                    let a = l(n.index, n.data, f);
                    return s ? (0, t.jsx)(c, { ...tz(c, f),
                        height: e.itemHeight,
                        index: n.index,
                        width: e.itemWidth
                    }, a) : (0, o.createElement)(u, { ...tz(u, f),
                        className: r,
                        "data-index": n.index,
                        key: a
                    }, i(n.index, n.data, f))
                })
            })
        }),
        ou = o.default.memo(function() {
            let e = og("HeaderComponent"),
                n = op("headerHeight"),
                r = og("headerFooterTag"),
                i = D(o.default.useMemo(() => e => {
                    n(ec(e, "height"))
                }, [n]), !0, !1),
                l = og("context");
            return null != e ? (0, t.jsx)(r, {
                ref: i,
                children: (0, t.jsx)(e, { ...tz(e, l)
                })
            }) : null
        }),
        od = o.default.memo(function() {
            let e = og("FooterComponent"),
                n = op("footerHeight"),
                r = og("headerFooterTag"),
                i = D(o.default.useMemo(() => e => {
                    n(ec(e, "height"))
                }, [n]), !0, !1),
                l = og("context");
            return null != e ? (0, t.jsx)(r, {
                ref: i,
                children: (0, t.jsx)(e, { ...tz(e, l)
                })
            }) : null
        }),
        oc = ({
            children: e
        }) => {
            let n = o.default.useContext(tl),
                r = op("itemDimensions"),
                i = op("viewportDimensions"),
                l = D(o.default.useMemo(() => e => {
                    i(e.getBoundingClientRect())
                }, [i]), !0, !1);
            return o.default.useEffect(() => {
                n && (i({
                    height: n.viewportHeight,
                    width: n.viewportWidth
                }), r({
                    height: n.itemHeight,
                    width: n.itemWidth
                }))
            }, [n, i, r]), (0, t.jsx)("div", {
                ref: l,
                style: tw(!1),
                children: e
            })
        },
        of = ({
            children: e
        }) => {
            let n = o.default.useContext(tl),
                r = op("windowViewportRect"),
                i = op("itemDimensions"),
                l = og("customScrollParent"),
                s = og("useWindowScroll"),
                a = _(r, l, !1);
            return o.default.useEffect(() => {
                n && (i({
                    height: n.itemHeight,
                    width: n.itemWidth
                }), r({
                    listHeight: 0,
                    offsetTop: 0,
                    visibleHeight: n.viewportHeight,
                    visibleWidth: n.viewportWidth
                }))
            }, [n, r, i]), (0, t.jsx)("div", {
                ref: a,
                style: tH(!1, s),
                children: e
            })
        },
        {
            Component: oh,
            useEmitter: om,
            useEmitterValue: og,
            usePublisher: op
        } = tr(os, {
            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"
            }
        }, o.default.memo(function({ ...e
        }) {
            let o = og("useWindowScroll"),
                n = og("customScrollParent"),
                r = n || o ? ov : ox,
                i = n || o ? of : oc,
                l = og("context");
            return (0, t.jsx)(r, { ...e,
                ...tz(r, l),
                children: (0, t.jsxs)(i, {
                    children: [(0, t.jsx)(ou, {}), (0, t.jsx)(oa, {}), (0, t.jsx)(od, {})]
                })
            })
        })),
        ox = tB({
            useEmitter: om,
            useEmitterValue: og,
            usePublisher: op
        }),
        ov = tk({
            useEmitter: om,
            useEmitterValue: og,
            usePublisher: op
        });

    function oI(e, t, o) {
        return "normal" !== t && t ? .endsWith("px") !== !0 && o(`${e} was not resolved to pixel value correctly`, t, F.WARN), "normal" === t ? 0 : parseInt(t ? ? "0", 10)
    }
    e.s(["LogLevel", 0, F, "Virtuoso", 0, tW, "VirtuosoGrid", 0, oh])
}]);

//# debugId=f047b870-bf45-cf8c-0455-e867ea8a0f12