@cagatayfdn/flora-components 0.0.148 → 0.0.149

package/dist/RealtimeLogModal-gZOv7y-z.js

@@ -0,0 +1,3632 @@
+import { j as k } from "./jsx-runtime-BcAkpsdy.js";
+import j, { createElement as It, useRef as _t, useState as ot, useEffect as lo } from "react";
+import gn from "react-dom";
+import { d as Bt } from "./helper-1SQ9SI45.js";
+import { c as Lt } from "./index-BHf7G3IG.js";
+import co from "./utils/date.js";
+import { startFetcher as pn } from "./utils/fetcher.js";
+import Je, { t as gt } from "./locales/i18n.js";
+import "./utils/yup.js";
+import { N as xn } from "./index-H7XbDVmH.js";
+import "./hooks/useAauth.js";
+import "./assets/images/500_error_2x.gif";
+import { FloraIcons as Qe } from "./assets/icons/flora-icons.js";
+import "./components/Tooltip/Tooltip.js";
+import "./react-toastify.esm-BUWNP7Nm.js";
+import vn from "./components/Input/Input.js";
+import "./components/Charts/index.js";
+import "./components/Checkbox/Checkbox.js";
+import "./components/Confirm/Confirm.js";
+import "./components/Datepicker/Datepicker.js";
+import "./components/Drawer/Provider.js";
+import "./components/FileUpload/FileUpload.js";
+import pt from "./components/IconBox/IconBox.js";
+import In from "./components/InfoDate/InfoDate.js";
+import Tn from "./hooks/useNiceModal.js";
+import wn from "./components/Modal/Modal.js";
+import ze from "./components/Icon/index.js";
+import { S as Cn } from "./Select-nhp2PiJK.js";
+import { AppearanceButton as ao, NotificationAppearanceType as Sn } from "./enums/appearance.js";
+import uo from "./components/Button/Button.js";
+import { Notification as yn } from "./components/Notification/Notification.js";
+import bn from "./components/StatusTag/StatusTag.js";
+import "./components/Switch/Switch.js";
+import "./components/Textarea/Textarea.js";
+import './ReactToastify.css';import './RealtimeLogModal.css';/* empty css                       */
+const Ht = 0, Ge = 1, tt = 2, Lo = 4;
+function mo(e) {
+  return () => e;
+}
+function Hn(e) {
+  e();
+}
+function jo(e, t) {
+  return (o) => e(t(o));
+}
+function fo(e, t) {
+  return () => e(t);
+}
+function kn(e, t) {
+  return (o) => e(t, o);
+}
+function $t(e) {
+  return e !== void 0;
+}
+function Rn(...e) {
+  return () => {
+    e.map(Hn);
+  };
+}
+function ut() {
+}
+function kt(e, t) {
+  return t(e), e;
+}
+function En(e, t) {
+  return t(e);
+}
+function ie(...e) {
+  return e;
+}
+function Z(e, t) {
+  return e(Ge, t);
+}
+function F(e, t) {
+  e(Ht, t);
+}
+function qt(e) {
+  e(tt);
+}
+function le(e) {
+  return e(Lo);
+}
+function W(e, t) {
+  return Z(e, kn(t, Ht));
+}
+function _e(e, t) {
+  const o = e(Ge, (n) => {
+    o(), t(n);
+  });
+  return o;
+}
+function ho(e) {
+  let t, o;
+  return (n) => (r) => {
+    t = r, o && clearTimeout(o), o = setTimeout(() => {
+      n(t);
+    }, e);
+  };
+}
+function Mo(e, t) {
+  return e === t;
+}
+function re(e = Mo) {
+  let t;
+  return (o) => (n) => {
+    e(t, n) || (t = n, o(n));
+  };
+}
+function N(e) {
+  return (t) => (o) => {
+    e(o) && t(o);
+  };
+}
+function z(e) {
+  return (t) => jo(t, e);
+}
+function We(e) {
+  return (t) => () => {
+    t(e);
+  };
+}
+function v(e, ...t) {
+  const o = zn(...t);
+  return (n, r) => {
+    switch (n) {
+      case tt:
+        qt(e);
+        return;
+      case Ge:
+        return Z(e, o(r));
+    }
+  };
+}
+function Ae(e, t) {
+  return (o) => (n) => {
+    o(t = e(t, n));
+  };
+}
+function Ke(e) {
+  return (t) => (o) => {
+    e > 0 ? e-- : t(o);
+  };
+}
+function Pe(e) {
+  let t = null, o;
+  return (n) => (r) => {
+    t = r, !o && (o = setTimeout(() => {
+      o = void 0, n(t);
+    }, e));
+  };
+}
+function $(...e) {
+  const t = new Array(e.length);
+  let o = 0, n = null;
+  const r = Math.pow(2, e.length) - 1;
+  return e.forEach((i, s) => {
+    const l = Math.pow(2, s);
+    Z(i, (c) => {
+      const u = o;
+      o = o | l, t[s] = c, u !== r && o === r && n && (n(), n = null);
+    });
+  }), (i) => (s) => {
+    const l = () => {
+      i([s].concat(t));
+    };
+    o === r ? l() : n = l;
+  };
+}
+function zn(...e) {
+  return (t) => e.reduceRight(En, t);
+}
+function _n(e) {
+  let t, o;
+  const n = () => t == null ? void 0 : t();
+  return function(r, i) {
+    switch (r) {
+      case Ge:
+        return i ? o === i ? void 0 : (n(), o = i, t = Z(e, i), t) : (n(), ut);
+      case tt:
+        n(), o = null;
+        return;
+    }
+  };
+}
+function b(e) {
+  let t = e;
+  const o = K();
+  return (n, r) => {
+    switch (n) {
+      case Ht:
+        t = r;
+        break;
+      case Ge: {
+        r(t);
+        break;
+      }
+      case Lo:
+        return t;
+    }
+    return o(n, r);
+  };
+}
+function pe(e, t) {
+  return kt(b(t), (o) => W(e, o));
+}
+function K() {
+  const e = [];
+  return (t, o) => {
+    switch (t) {
+      case Ht:
+        e.slice().forEach((n) => {
+          n(o);
+        });
+        return;
+      case tt:
+        e.splice(0, e.length);
+        return;
+      case Ge:
+        return e.push(o), () => {
+          const n = e.indexOf(o);
+          n > -1 && e.splice(n, 1);
+        };
+    }
+  };
+}
+function He(e) {
+  return kt(K(), (t) => W(e, t));
+}
+function J(e, t = [], { singleton: o } = { singleton: !0 }) {
+  return {
+    constructor: e,
+    dependencies: t,
+    id: Bn(),
+    singleton: o
+  };
+}
+const Bn = () => Symbol();
+function Ln(e) {
+  const t = /* @__PURE__ */ new Map(), o = ({ constructor: n, dependencies: r, id: i, singleton: s }) => {
+    if (s && t.has(i))
+      return t.get(i);
+    const l = n(r.map((c) => o(c)));
+    return s && t.set(i, l), l;
+  };
+  return o(e);
+}
+function ae(...e) {
+  const t = K(), o = new Array(e.length);
+  let n = 0;
+  const r = Math.pow(2, e.length) - 1;
+  return e.forEach((i, s) => {
+    const l = Math.pow(2, s);
+    Z(i, (c) => {
+      o[s] = c, n = n | l, n === r && F(t, o);
+    });
+  }), function(i, s) {
+    switch (i) {
+      case tt: {
+        qt(t);
+        return;
+      }
+      case Ge:
+        return n === r && s(o), Z(t, s);
+    }
+  };
+}
+function A(e, t = Mo) {
+  return v(e, re(t));
+}
+function Nt(...e) {
+  return function(t, o) {
+    switch (t) {
+      case tt:
+        return;
+      case Ge:
+        return Rn(...e.map((n) => Z(n, o)));
+    }
+  };
+}
+var Te = /* @__PURE__ */ ((e) => (e[e.DEBUG = 0] = "DEBUG", e[e.INFO = 1] = "INFO", e[e.WARN = 2] = "WARN", e[e.ERROR = 3] = "ERROR", e))(Te || {});
+const jn = {
+  0: "debug",
+  3: "error",
+  1: "log",
+  2: "warn"
+}, Mn = () => typeof globalThis > "u" ? window : globalThis, Fe = J(
+  () => {
+    const e = b(
+      3
+      /* ERROR */
+    );
+    return {
+      log: b((t, o, n = 1) => {
+        var r;
+        const i = (r = Mn().VIRTUOSO_LOG_LEVEL) != null ? r : le(e);
+        n >= i && console[jn[n]](
+          "%creact-virtuoso: %c%s %o",
+          "color: #0253b3; font-weight: bold",
+          "color: initial",
+          t,
+          o
+        );
+      }),
+      logLevel: e
+    };
+  },
+  [],
+  { singleton: !0 }
+);
+function Ye(e, t, o) {
+  return Ut(e, t, o).callbackRef;
+}
+function Ut(e, t, o) {
+  const n = j.useRef(null);
+  let r = (s) => {
+  };
+  const i = j.useMemo(() => typeof ResizeObserver < "u" ? new ResizeObserver((s) => {
+    const l = () => {
+      const c = s[0].target;
+      c.offsetParent !== null && e(c);
+    };
+    o ? l() : requestAnimationFrame(l);
+  }) : null, [e, o]);
+  return r = (s) => {
+    s && t ? (i == null || i.observe(s), n.current = s) : (n.current && (i == null || i.unobserve(n.current)), n.current = null);
+  }, { callbackRef: r, ref: n };
+}
+function Wn(e, t, o, n, r, i, s, l, c) {
+  const u = j.useCallback(
+    (h) => {
+      const T = An(h.children, t, l ? "offsetWidth" : "offsetHeight", r);
+      let g = h.parentElement;
+      for (; !g.dataset.virtuosoScroller; )
+        g = g.parentElement;
+      const p = g.lastElementChild.dataset.viewportType === "window";
+      let H;
+      p && (H = g.ownerDocument.defaultView);
+      const y = s ? l ? s.scrollLeft : s.scrollTop : p ? l ? H.scrollX || H.document.documentElement.scrollLeft : H.scrollY || H.document.documentElement.scrollTop : l ? g.scrollLeft : g.scrollTop, x = s ? l ? s.scrollWidth : s.scrollHeight : p ? l ? H.document.documentElement.scrollWidth : H.document.documentElement.scrollHeight : l ? g.scrollWidth : g.scrollHeight, f = s ? l ? s.offsetWidth : s.offsetHeight : p ? l ? H.innerWidth : H.innerHeight : l ? g.offsetWidth : g.offsetHeight;
+      n({
+        scrollHeight: x,
+        scrollTop: Math.max(y, 0),
+        viewportHeight: f
+      }), i == null || i(
+        l ? go("column-gap", getComputedStyle(h).columnGap, r) : go("row-gap", getComputedStyle(h).rowGap, r)
+      ), T !== null && e(T);
+    },
+    [e, t, r, i, s, n, l]
+  );
+  return Ut(u, o, c);
+}
+function An(e, t, o, n) {
+  const r = e.length;
+  if (r === 0)
+    return null;
+  const i = [];
+  for (let s = 0; s < r; s++) {
+    const l = e.item(s);
+    if (l.dataset.index === void 0)
+      continue;
+    const c = parseInt(l.dataset.index), u = parseFloat(l.dataset.knownSize), h = t(l, o);
+    if (h === 0 && n("Zero-sized element, this should not happen", { child: l }, Te.ERROR), h === u)
+      continue;
+    const T = i[i.length - 1];
+    i.length === 0 || T.size !== h || T.endIndex !== c - 1 ? i.push({ endIndex: c, size: h, startIndex: c }) : i[i.length - 1].endIndex++;
+  }
+  return i;
+}
+function go(e, t, o) {
+  return t !== "normal" && !(t != null && t.endsWith("px")) && o(`${e} was not resolved to pixel value correctly`, t, Te.WARN), t === "normal" ? 0 : parseInt(t ?? "0", 10);
+}
+function Wo(e, t, o) {
+  const n = j.useRef(null), r = j.useCallback(
+    (c) => {
+      if (!(c != null && c.offsetParent))
+        return;
+      const u = c.getBoundingClientRect(), h = u.width;
+      let T, g;
+      if (t) {
+        const p = t.getBoundingClientRect(), H = u.top - p.top;
+        g = p.height - Math.max(0, H), T = H + t.scrollTop;
+      } else {
+        const p = s.current.ownerDocument.defaultView;
+        g = p.innerHeight - Math.max(0, u.top), T = u.top + p.scrollY;
+      }
+      n.current = {
+        offsetTop: T,
+        visibleHeight: g,
+        visibleWidth: h
+      }, e(n.current);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e, t]
+  ), { callbackRef: i, ref: s } = Ut(r, !0, o), l = j.useCallback(() => {
+    r(s.current);
+  }, [r, s]);
+  return j.useEffect(() => {
+    var c;
+    if (t) {
+      t.addEventListener("scroll", l);
+      const u = new ResizeObserver(() => {
+        requestAnimationFrame(l);
+      });
+      return u.observe(t), () => {
+        t.removeEventListener("scroll", l), u.unobserve(t);
+      };
+    } else {
+      const u = (c = s.current) == null ? void 0 : c.ownerDocument.defaultView;
+      return u == null || u.addEventListener("scroll", l), u == null || u.addEventListener("resize", l), () => {
+        u == null || u.removeEventListener("scroll", l), u == null || u.removeEventListener("resize", l);
+      };
+    }
+  }, [l, t, s]), i;
+}
+const xe = J(
+  () => {
+    const e = K(), t = K(), o = b(0), n = K(), r = b(0), i = K(), s = K(), l = b(0), c = b(0), u = b(0), h = b(0), T = K(), g = K(), p = b(!1), H = b(!1), y = b(!1);
+    return W(
+      v(
+        e,
+        z(({ scrollTop: x }) => x)
+      ),
+      t
+    ), W(
+      v(
+        e,
+        z(({ scrollHeight: x }) => x)
+      ),
+      s
+    ), W(t, r), {
+      deviation: o,
+      fixedFooterHeight: u,
+      fixedHeaderHeight: c,
+      footerHeight: h,
+      headerHeight: l,
+      horizontalDirection: H,
+      scrollBy: g,
+      // input
+      scrollContainerState: e,
+      scrollHeight: s,
+      scrollingInProgress: p,
+      // signals
+      scrollTo: T,
+      scrollTop: t,
+      skipAnimationFrameInResizeObserver: y,
+      smoothScrollTargetReached: n,
+      // state
+      statefulScrollTop: r,
+      viewportHeight: i
+    };
+  },
+  [],
+  { singleton: !0 }
+), it = { lvl: 0 };
+function Ao(e, t) {
+  const o = e.length;
+  if (o === 0)
+    return [];
+  let { index: n, value: r } = t(e[0]);
+  const i = [];
+  for (let s = 1; s < o; s++) {
+    const { index: l, value: c } = t(e[s]);
+    i.push({ end: l - 1, start: n, value: r }), n = l, r = c;
+  }
+  return i.push({ end: 1 / 0, start: n, value: r }), i;
+}
+function ee(e) {
+  return e === it;
+}
+function st(e, t) {
+  if (!ee(e))
+    return t === e.k ? e.v : t < e.k ? st(e.l, t) : st(e.r, t);
+}
+function Be(e, t, o = "k") {
+  if (ee(e))
+    return [-1 / 0, void 0];
+  if (Number(e[o]) === t)
+    return [e.k, e.v];
+  if (Number(e[o]) < t) {
+    const n = Be(e.r, t, o);
+    return n[0] === -1 / 0 ? [e.k, e.v] : n;
+  }
+  return Be(e.l, t, o);
+}
+function be(e, t, o) {
+  return ee(e) ? Po(t, o, 1) : t === e.k ? me(e, { k: t, v: o }) : t < e.k ? po(me(e, { l: be(e.l, t, o) })) : po(me(e, { r: be(e.r, t, o) }));
+}
+function et() {
+  return it;
+}
+function Rt(e, t, o) {
+  if (ee(e))
+    return [];
+  const n = Be(e, t)[0];
+  return On(Dt(e, n, o));
+}
+function Pt(e, t) {
+  if (ee(e))
+    return it;
+  const { k: o, l: n, r } = e;
+  if (t === o) {
+    if (ee(n))
+      return r;
+    if (ee(r))
+      return n;
+    {
+      const [i, s] = No(n);
+      return Tt(me(e, { k: i, l: Oo(n), v: s }));
+    }
+  } else
+    return t < o ? Tt(me(e, { l: Pt(n, t) })) : Tt(me(e, { r: Pt(r, t) }));
+}
+function Ue(e) {
+  return ee(e) ? [] : [...Ue(e.l), { k: e.k, v: e.v }, ...Ue(e.r)];
+}
+function Dt(e, t, o) {
+  if (ee(e))
+    return [];
+  const { k: n, l: r, r: i, v: s } = e;
+  let l = [];
+  return n > t && (l = l.concat(Dt(r, t, o))), n >= t && n <= o && l.push({ k: n, v: s }), n <= o && (l = l.concat(Dt(i, t, o))), l;
+}
+function Tt(e) {
+  const { l: t, lvl: o, r: n } = e;
+  if (n.lvl >= o - 1 && t.lvl >= o - 1)
+    return e;
+  if (o > n.lvl + 1) {
+    if (jt(t))
+      return Do(me(e, { lvl: o - 1 }));
+    if (!ee(t) && !ee(t.r))
+      return me(t.r, {
+        l: me(t, { r: t.r.l }),
+        lvl: o,
+        r: me(e, {
+          l: t.r.r,
+          lvl: o - 1
+        })
+      });
+    throw new Error("Unexpected empty nodes");
+  } else {
+    if (jt(e))
+      return Vt(me(e, { lvl: o - 1 }));
+    if (!ee(n) && !ee(n.l)) {
+      const r = n.l, i = jt(r) ? n.lvl - 1 : n.lvl;
+      return me(r, {
+        l: me(e, {
+          lvl: o - 1,
+          r: r.l
+        }),
+        lvl: r.lvl + 1,
+        r: Vt(me(n, { l: r.r, lvl: i }))
+      });
+    } else
+      throw new Error("Unexpected empty nodes");
+  }
+}
+function me(e, t) {
+  return Po(
+    t.k !== void 0 ? t.k : e.k,
+    t.v !== void 0 ? t.v : e.v,
+    t.lvl !== void 0 ? t.lvl : e.lvl,
+    t.l !== void 0 ? t.l : e.l,
+    t.r !== void 0 ? t.r : e.r
+  );
+}
+function Oo(e) {
+  return ee(e.r) ? e.l : Tt(me(e, { r: Oo(e.r) }));
+}
+function jt(e) {
+  return ee(e) || e.lvl > e.r.lvl;
+}
+function No(e) {
+  return ee(e.r) ? [e.k, e.v] : No(e.r);
+}
+function Po(e, t, o, n = it, r = it) {
+  return { k: e, l: n, lvl: o, r, v: t };
+}
+function po(e) {
+  return Vt(Do(e));
+}
+function Do(e) {
+  const { l: t } = e;
+  return !ee(t) && t.lvl === e.lvl ? me(t, { r: me(e, { l: t.r }) }) : e;
+}
+function Vt(e) {
+  const { lvl: t, r: o } = e;
+  return !ee(o) && !ee(o.r) && o.lvl === t && o.r.lvl === t ? me(o, { l: me(e, { r: o.l }), lvl: t + 1 }) : e;
+}
+function On(e) {
+  return Ao(e, ({ k: t, v: o }) => ({ index: t, value: o }));
+}
+function Vo(e, t) {
+  return !!(e && e.startIndex === t.startIndex && e.endIndex === t.endIndex);
+}
+function lt(e, t) {
+  return !!(e && e[0] === t[0] && e[1] === t[1]);
+}
+const Kt = J(
+  () => ({ recalcInProgress: b(!1) }),
+  [],
+  { singleton: !0 }
+);
+function Go(e, t, o) {
+  return e[Ct(e, t, o)];
+}
+function Ct(e, t, o, n = 0) {
+  let r = e.length - 1;
+  for (; n <= r; ) {
+    const i = Math.floor((n + r) / 2), s = e[i], l = o(s, t);
+    if (l === 0)
+      return i;
+    if (l === -1) {
+      if (r - n < 2)
+        return i - 1;
+      r = i - 1;
+    } else {
+      if (r === n)
+        return i;
+      n = i + 1;
+    }
+  }
+  throw new Error(`Failed binary finding record in array - ${e.join(",")}, searched for ${t}`);
+}
+function Nn(e, t, o, n) {
+  const r = Ct(e, t, n), i = Ct(e, o, n, r);
+  return e.slice(r, i + 1);
+}
+function Ve(e, t) {
+  return Math.round(e.getBoundingClientRect()[t]);
+}
+function Et(e) {
+  return !ee(e.groupOffsetTree);
+}
+function Yt({ index: e }, t) {
+  return t === e ? 0 : t < e ? -1 : 1;
+}
+function Pn() {
+  return {
+    groupIndices: [],
+    groupOffsetTree: et(),
+    lastIndex: 0,
+    lastOffset: 0,
+    lastSize: 0,
+    offsetTree: [],
+    sizeTree: et()
+  };
+}
+function Dn(e, t) {
+  let o = ee(e) ? 0 : 1 / 0;
+  for (const n of t) {
+    const { endIndex: r, size: i, startIndex: s } = n;
+    if (o = Math.min(o, s), ee(e)) {
+      e = be(e, 0, i);
+      continue;
+    }
+    const l = Rt(e, s - 1, r + 1);
+    if (l.some(Kn(n)))
+      continue;
+    let c = !1, u = !1;
+    for (const { end: h, start: T, value: g } of l)
+      c ? (r >= T || i === g) && (e = Pt(e, T)) : (u = g !== i, c = !0), h > r && r >= T && g !== i && (e = be(e, r + 1, g));
+    u && (e = be(e, s, i));
+  }
+  return [e, o];
+}
+function Vn(e) {
+  return typeof e.groupIndex < "u";
+}
+function Gn({ offset: e }, t) {
+  return t === e ? 0 : t < e ? -1 : 1;
+}
+function ct(e, t, o) {
+  if (t.length === 0)
+    return 0;
+  const { index: n, offset: r, size: i } = Go(t, e, Yt), s = e - n, l = i * s + (s - 1) * o + r;
+  return l > 0 ? l + o : l;
+}
+function Fo(e, t) {
+  if (!Et(t))
+    return e;
+  let o = 0;
+  for (; t.groupIndices[o] <= e + o; )
+    o++;
+  return e + o;
+}
+function $o(e, t, o) {
+  if (Vn(e))
+    return t.groupIndices[e.groupIndex] + 1;
+  {
+    const n = e.index === "LAST" ? o : e.index;
+    let r = Fo(n, t);
+    return r = Math.max(0, r, Math.min(o, r)), r;
+  }
+}
+function Fn(e, t, o, n = 0) {
+  return n > 0 && (t = Math.max(t, Go(e, n, Yt).offset)), Ao(Nn(e, t, o, Gn), Un);
+}
+function $n(e, [t, o, n, r]) {
+  t.length > 0 && n("received item sizes", t, Te.DEBUG);
+  const i = e.sizeTree;
+  let s = i, l = 0;
+  if (o.length > 0 && ee(i) && t.length === 2) {
+    const g = t[0].size, p = t[1].size;
+    s = o.reduce((H, y) => be(be(H, y, g), y + 1, p), s);
+  } else
+    [s, l] = Dn(s, t);
+  if (s === i)
+    return e;
+  const { lastIndex: c, lastOffset: u, lastSize: h, offsetTree: T } = Gt(e.offsetTree, l, s, r);
+  return {
+    groupIndices: o,
+    groupOffsetTree: o.reduce((g, p) => be(g, p, ct(p, T, r)), et()),
+    lastIndex: c,
+    lastOffset: u,
+    lastSize: h,
+    offsetTree: T,
+    sizeTree: s
+  };
+}
+function qn(e) {
+  return Ue(e).map(({ k: t, v: o }, n, r) => {
+    const i = r[n + 1];
+    return { endIndex: i ? i.k - 1 : 1 / 0, size: o, startIndex: t };
+  });
+}
+function xo(e, t) {
+  let o = 0, n = 0;
+  for (; o < e; )
+    o += t[n + 1] - t[n] - 1, n++;
+  return n - (o === e ? 0 : 1);
+}
+function Gt(e, t, o, n) {
+  let r = e, i = 0, s = 0, l = 0, c = 0;
+  if (t !== 0) {
+    c = Ct(r, t - 1, Yt), l = r[c].offset;
+    const u = Be(o, t - 1);
+    i = u[0], s = u[1], r.length && r[c].size === Be(o, t)[1] && (c -= 1), r = r.slice(0, c + 1);
+  } else
+    r = [];
+  for (const { start: u, value: h } of Rt(o, t, 1 / 0)) {
+    const T = u - i, g = T * s + l + T * n;
+    r.push({
+      index: u,
+      offset: g,
+      size: h
+    }), i = u, l = g, s = h;
+  }
+  return {
+    lastIndex: i,
+    lastOffset: l,
+    lastSize: s,
+    offsetTree: r
+  };
+}
+function Un(e) {
+  return { index: e.index, value: e };
+}
+function Kn(e) {
+  const { endIndex: t, size: o, startIndex: n } = e;
+  return (r) => r.start === n && (r.end === t || r.end === 1 / 0) && r.value === o;
+}
+const Yn = {
+  offsetHeight: "height",
+  offsetWidth: "width"
+}, Oe = J(
+  ([{ log: e }, { recalcInProgress: t }]) => {
+    const o = K(), n = K(), r = pe(n, 0), i = K(), s = K(), l = b(0), c = b([]), u = b(void 0), h = b(void 0), T = b((a, d) => Ve(a, Yn[d])), g = b(void 0), p = b(0), H = Pn(), y = pe(
+      v(o, $(c, e, p), Ae($n, H), re()),
+      H
+    ), x = pe(
+      v(
+        c,
+        re(),
+        Ae((a, d) => ({ current: d, prev: a.current }), {
+          current: [],
+          prev: []
+        }),
+        z(({ prev: a }) => a)
+      ),
+      []
+    );
+    W(
+      v(
+        c,
+        N((a) => a.length > 0),
+        $(y, p),
+        z(([a, d, w]) => {
+          const R = a.reduce((B, M, O) => be(B, M, ct(M, d.offsetTree, w) || O), et());
+          return {
+            ...d,
+            groupIndices: a,
+            groupOffsetTree: R
+          };
+        })
+      ),
+      y
+    ), W(
+      v(
+        n,
+        $(y),
+        N(([a, { lastIndex: d }]) => a < d),
+        z(([a, { lastIndex: d, lastSize: w }]) => [
+          {
+            endIndex: d,
+            size: w,
+            startIndex: a
+          }
+        ])
+      ),
+      o
+    ), W(u, h);
+    const f = pe(
+      v(
+        u,
+        z((a) => a === void 0)
+      ),
+      !0
+    );
+    W(
+      v(
+        h,
+        N((a) => a !== void 0 && ee(le(y).sizeTree)),
+        z((a) => [{ endIndex: 0, size: a, startIndex: 0 }])
+      ),
+      o
+    );
+    const m = He(
+      v(
+        o,
+        $(y),
+        Ae(
+          ({ sizes: a }, [d, w]) => ({
+            changed: w !== a,
+            sizes: w
+          }),
+          { changed: !1, sizes: H }
+        ),
+        z((a) => a.changed)
+      )
+    );
+    Z(
+      v(
+        l,
+        Ae(
+          (a, d) => ({ diff: a.prev - d, prev: d }),
+          { diff: 0, prev: 0 }
+        ),
+        z((a) => a.diff)
+      ),
+      (a) => {
+        const { groupIndices: d } = le(y);
+        if (a > 0)
+          F(t, !0), F(i, a + xo(a, d));
+        else if (a < 0) {
+          const w = le(x);
+          w.length > 0 && (a -= xo(-a, w)), F(s, a);
+        }
+      }
+    ), Z(v(l, $(e)), ([a, d]) => {
+      a < 0 && d(
+        "`firstItemIndex` prop should not be set to less than zero. If you don't know the total count, just use a very high value",
+        { firstItemIndex: l },
+        Te.ERROR
+      );
+    });
+    const C = He(i);
+    W(
+      v(
+        i,
+        $(y),
+        z(([a, d]) => {
+          const w = d.groupIndices.length > 0, R = [], B = d.lastSize;
+          if (w) {
+            const M = st(d.sizeTree, 0);
+            let O = 0, U = 0;
+            for (; O < a; ) {
+              const L = d.groupIndices[U], P = d.groupIndices.length === U + 1 ? 1 / 0 : d.groupIndices[U + 1] - L - 1;
+              R.push({
+                endIndex: L,
+                size: M,
+                startIndex: L
+              }), R.push({
+                endIndex: L + 1 + P - 1,
+                size: B,
+                startIndex: L + 1
+              }), U++, O += P + 1;
+            }
+            const Q = Ue(d.sizeTree);
+            return O !== a && Q.shift(), Q.reduce(
+              (L, { k: P, v: ue }) => {
+                let ve = L.ranges;
+                return L.prevSize !== 0 && (ve = [
+                  ...L.ranges,
+                  {
+                    endIndex: P + a - 1,
+                    size: L.prevSize,
+                    startIndex: L.prevIndex
+                  }
+                ]), {
+                  prevIndex: P + a,
+                  prevSize: ue,
+                  ranges: ve
+                };
+              },
+              {
+                prevIndex: a,
+                prevSize: 0,
+                ranges: R
+              }
+            ).ranges;
+          }
+          return Ue(d.sizeTree).reduce(
+            (M, { k: O, v: U }) => ({
+              prevIndex: O + a,
+              prevSize: U,
+              ranges: [...M.ranges, { endIndex: O + a - 1, size: M.prevSize, startIndex: M.prevIndex }]
+            }),
+            {
+              prevIndex: 0,
+              prevSize: B,
+              ranges: []
+            }
+          ).ranges;
+        })
+      ),
+      o
+    );
+    const _ = He(
+      v(
+        s,
+        $(y, p),
+        z(([a, { offsetTree: d }, w]) => {
+          const R = -a;
+          return ct(R, d, w);
+        })
+      )
+    );
+    return W(
+      v(
+        s,
+        $(y, p),
+        z(([a, d, w]) => {
+          if (d.groupIndices.length > 0) {
+            if (ee(d.sizeTree))
+              return d;
+            let R = et();
+            const B = le(x);
+            let M = 0, O = 0, U = 0;
+            for (; M < -a; ) {
+              U = B[O];
+              const Q = B[O + 1] - U - 1;
+              O++, M += Q + 1;
+            }
+            if (R = Ue(d.sizeTree).reduce((Q, { k: L, v: P }) => be(Q, Math.max(0, L + a), P), R), M !== -a) {
+              const Q = st(d.sizeTree, U);
+              R = be(R, 0, Q);
+              const L = Be(d.sizeTree, -a + 1)[1];
+              R = be(R, 1, L);
+            }
+            return {
+              ...d,
+              sizeTree: R,
+              ...Gt(d.offsetTree, 0, R, w)
+            };
+          } else {
+            const R = Ue(d.sizeTree).reduce((B, { k: M, v: O }) => be(B, Math.max(0, M + a), O), et());
+            return {
+              ...d,
+              sizeTree: R,
+              ...Gt(d.offsetTree, 0, R, w)
+            };
+          }
+        })
+      ),
+      y
+    ), {
+      beforeUnshiftWith: C,
+      // input
+      data: g,
+      defaultItemSize: h,
+      firstItemIndex: l,
+      fixedItemSize: u,
+      gap: p,
+      groupIndices: c,
+      itemSize: T,
+      listRefresh: m,
+      shiftWith: s,
+      shiftWithOffset: _,
+      sizeRanges: o,
+      // output
+      sizes: y,
+      statefulTotalCount: r,
+      totalCount: n,
+      trackItemSizes: f,
+      unshiftWith: i
+    };
+  },
+  ie(Fe, Kt),
+  { singleton: !0 }
+);
+function Xn(e) {
+  return e.reduce(
+    (t, o) => (t.groupIndices.push(t.totalCount), t.totalCount += o + 1, t),
+    {
+      groupIndices: [],
+      totalCount: 0
+    }
+  );
+}
+const qo = J(
+  ([{ groupIndices: e, sizes: t, totalCount: o }, { headerHeight: n, scrollTop: r }]) => {
+    const i = K(), s = K(), l = He(v(i, z(Xn)));
+    return W(
+      v(
+        l,
+        z((c) => c.totalCount)
+      ),
+      o
+    ), W(
+      v(
+        l,
+        z((c) => c.groupIndices)
+      ),
+      e
+    ), W(
+      v(
+        ae(r, t, n),
+        N(([c, u]) => Et(u)),
+        z(([c, u, h]) => Be(u.groupOffsetTree, Math.max(c - h, 0), "v")[0]),
+        re(),
+        z((c) => [c])
+      ),
+      s
+    ), { groupCounts: i, topItemsIndexes: s };
+  },
+  ie(Oe, xe)
+), $e = J(
+  ([{ log: e }]) => {
+    const t = b(!1), o = He(
+      v(
+        t,
+        N((n) => n),
+        re()
+      )
+    );
+    return Z(t, (n) => {
+      n && le(e)("props updated", {}, Te.DEBUG);
+    }), { didMount: o, propsReady: t };
+  },
+  ie(Fe),
+  { singleton: !0 }
+), Zn = typeof document < "u" && "scrollBehavior" in document.documentElement.style;
+function Uo(e) {
+  const t = typeof e == "number" ? { index: e } : e;
+  return t.align || (t.align = "start"), (!t.behavior || !Zn) && (t.behavior = "auto"), t.offset || (t.offset = 0), t;
+}
+const dt = J(
+  ([
+    { gap: e, listRefresh: t, sizes: o, totalCount: n },
+    {
+      fixedFooterHeight: r,
+      fixedHeaderHeight: i,
+      footerHeight: s,
+      headerHeight: l,
+      scrollingInProgress: c,
+      scrollTo: u,
+      smoothScrollTargetReached: h,
+      viewportHeight: T
+    },
+    { log: g }
+  ]) => {
+    const p = K(), H = K(), y = b(0);
+    let x = null, f = null, m = null;
+    function C() {
+      x && (x(), x = null), m && (m(), m = null), f && (clearTimeout(f), f = null), F(c, !1);
+    }
+    return W(
+      v(
+        p,
+        $(o, T, n, y, l, s, g),
+        $(e, i, r),
+        z(
+          ([
+            [_, a, d, w, R, B, M, O],
+            U,
+            Q,
+            L
+          ]) => {
+            const P = Uo(_), { align: ue, behavior: ve, offset: we } = P, Ce = w - 1, he = $o(P, a, Ce);
+            let de = ct(he, a.offsetTree, U) + B;
+            ue === "end" ? (de += Q + Be(a.sizeTree, he)[1] - d + L, he === Ce && (de += M)) : ue === "center" ? de += (Q + Be(a.sizeTree, he)[1] - d + L) / 2 : de -= R, we && (de += we);
+            const Ne = (Ie) => {
+              C(), Ie ? (O("retrying to scroll to", { location: _ }, Te.DEBUG), F(p, _)) : (F(H, !0), O("list did not change, scroll successful", {}, Te.DEBUG));
+            };
+            if (C(), ve === "smooth") {
+              let Ie = !1;
+              m = Z(t, (Le) => {
+                Ie = Ie || Le;
+              }), x = _e(h, () => {
+                Ne(Ie);
+              });
+            } else
+              x = _e(v(t, Jn(150)), Ne);
+            return f = setTimeout(() => {
+              C();
+            }, 1200), F(c, !0), O("scrolling from index to", { behavior: ve, index: he, top: de }, Te.DEBUG), { behavior: ve, top: de };
+          }
+        )
+      ),
+      u
+    ), {
+      scrollTargetReached: H,
+      scrollToIndex: p,
+      topListHeight: y
+    };
+  },
+  ie(Oe, xe, Fe),
+  { singleton: !0 }
+);
+function Jn(e) {
+  return (t) => {
+    const o = setTimeout(() => {
+      t(!1);
+    }, e);
+    return (n) => {
+      n && (t(!0), clearTimeout(o));
+    };
+  };
+}
+function Xt(e, t) {
+  e == 0 ? t() : requestAnimationFrame(() => {
+    Xt(e - 1, t);
+  });
+}
+function Zt(e, t) {
+  const o = t - 1;
+  return typeof e == "number" ? e : e.index === "LAST" ? o : e.index;
+}
+const mt = J(
+  ([{ defaultItemSize: e, listRefresh: t, sizes: o }, { scrollTop: n }, { scrollTargetReached: r, scrollToIndex: i }, { didMount: s }]) => {
+    const l = b(!0), c = b(0), u = b(!0);
+    return W(
+      v(
+        s,
+        $(c),
+        N(([h, T]) => !!T),
+        We(!1)
+      ),
+      l
+    ), W(
+      v(
+        s,
+        $(c),
+        N(([h, T]) => !!T),
+        We(!1)
+      ),
+      u
+    ), Z(
+      v(
+        ae(t, s),
+        $(l, o, e, u),
+        N(([[, h], T, { sizeTree: g }, p, H]) => h && (!ee(g) || $t(p)) && !T && !H),
+        $(c)
+      ),
+      ([, h]) => {
+        _e(r, () => {
+          F(u, !0);
+        }), Xt(4, () => {
+          _e(n, () => {
+            F(l, !0);
+          }), F(i, h);
+        });
+      }
+    ), {
+      initialItemFinalLocationReached: u,
+      initialTopMostItemIndex: c,
+      scrolledToInitialItem: l
+    };
+  },
+  ie(Oe, xe, dt, $e),
+  { singleton: !0 }
+);
+function Ko(e, t) {
+  return Math.abs(e - t) < 1.01;
+}
+const at = "up", nt = "down", Qn = "none", er = {
+  atBottom: !1,
+  notAtBottomBecause: "NOT_SHOWING_LAST_ITEM",
+  state: {
+    offsetBottom: 0,
+    scrollHeight: 0,
+    scrollTop: 0,
+    viewportHeight: 0
+  }
+}, tr = 0, ft = J(([{ footerHeight: e, headerHeight: t, scrollBy: o, scrollContainerState: n, scrollTop: r, viewportHeight: i }]) => {
+  const s = b(!1), l = b(!0), c = K(), u = K(), h = b(4), T = b(tr), g = pe(
+    v(
+      Nt(v(A(r), Ke(1), We(!0)), v(A(r), Ke(1), We(!1), ho(100))),
+      re()
+    ),
+    !1
+  ), p = pe(
+    v(Nt(v(o, We(!0)), v(o, We(!1), ho(200))), re()),
+    !1
+  );
+  W(
+    v(
+      ae(A(r), A(T)),
+      z(([m, C]) => m <= C),
+      re()
+    ),
+    l
+  ), W(v(l, Pe(50)), u);
+  const H = He(
+    v(
+      ae(n, A(i), A(t), A(e), A(h)),
+      Ae((m, [{ scrollHeight: C, scrollTop: _ }, a, d, w, R]) => {
+        const B = _ + a - C > -R, M = {
+          scrollHeight: C,
+          scrollTop: _,
+          viewportHeight: a
+        };
+        if (B) {
+          let U, Q;
+          return _ > m.state.scrollTop ? (U = "SCROLLED_DOWN", Q = m.state.scrollTop - _) : (U = "SIZE_DECREASED", Q = m.state.scrollTop - _ || m.scrollTopDelta), {
+            atBottom: !0,
+            atBottomBecause: U,
+            scrollTopDelta: Q,
+            state: M
+          };
+        }
+        let O;
+        return M.scrollHeight > m.state.scrollHeight ? O = "SIZE_INCREASED" : a < m.state.viewportHeight ? O = "VIEWPORT_HEIGHT_DECREASING" : _ < m.state.scrollTop ? O = "SCROLLING_UPWARDS" : O = "NOT_FULLY_SCROLLED_TO_LAST_ITEM_BOTTOM", {
+          atBottom: !1,
+          notAtBottomBecause: O,
+          state: M
+        };
+      }, er),
+      re((m, C) => m && m.atBottom === C.atBottom)
+    )
+  ), y = pe(
+    v(
+      n,
+      Ae(
+        (m, { scrollHeight: C, scrollTop: _, viewportHeight: a }) => {
+          if (Ko(m.scrollHeight, C))
+            return {
+              changed: !1,
+              jump: 0,
+              scrollHeight: C,
+              scrollTop: _
+            };
+          {
+            const d = C - (_ + a) < 1;
+            return m.scrollTop !== _ && d ? {
+              changed: !0,
+              jump: m.scrollTop - _,
+              scrollHeight: C,
+              scrollTop: _
+            } : {
+              changed: !0,
+              jump: 0,
+              scrollHeight: C,
+              scrollTop: _
+            };
+          }
+        },
+        { changed: !1, jump: 0, scrollHeight: 0, scrollTop: 0 }
+      ),
+      N((m) => m.changed),
+      z((m) => m.jump)
+    ),
+    0
+  );
+  W(
+    v(
+      H,
+      z((m) => m.atBottom)
+    ),
+    s
+  ), W(v(s, Pe(50)), c);
+  const x = b(nt);
+  W(
+    v(
+      n,
+      z(({ scrollTop: m }) => m),
+      re(),
+      Ae(
+        (m, C) => le(p) ? { direction: m.direction, prevScrollTop: C } : { direction: C < m.prevScrollTop ? at : nt, prevScrollTop: C },
+        { direction: nt, prevScrollTop: 0 }
+      ),
+      z((m) => m.direction)
+    ),
+    x
+  ), W(v(n, Pe(50), We(Qn)), x);
+  const f = b(0);
+  return W(
+    v(
+      g,
+      N((m) => !m),
+      We(0)
+    ),
+    f
+  ), W(
+    v(
+      r,
+      Pe(100),
+      $(g),
+      N(([m, C]) => !!C),
+      Ae(([m, C], [_]) => [C, _], [0, 0]),
+      z(([m, C]) => C - m)
+    ),
+    f
+  ), {
+    atBottomState: H,
+    atBottomStateChange: c,
+    atBottomThreshold: h,
+    atTopStateChange: u,
+    atTopThreshold: T,
+    isAtBottom: s,
+    isAtTop: l,
+    isScrolling: g,
+    lastJumpDueToItemResize: y,
+    scrollDirection: x,
+    scrollVelocity: f
+  };
+}, ie(xe)), St = "top", yt = "bottom", vo = "none";
+function Io(e, t, o) {
+  return typeof e == "number" ? o === at && t === St || o === nt && t === yt ? e : 0 : o === at ? t === St ? e.main : e.reverse : t === yt ? e.main : e.reverse;
+}
+function To(e, t) {
+  var o;
+  return typeof e == "number" ? e : (o = e[t]) != null ? o : 0;
+}
+const Jt = J(
+  ([{ deviation: e, fixedHeaderHeight: t, headerHeight: o, scrollTop: n, viewportHeight: r }]) => {
+    const i = K(), s = b(0), l = b(0), c = b(0), u = pe(
+      v(
+        ae(
+          A(n),
+          A(r),
+          A(o),
+          A(i, lt),
+          A(c),
+          A(s),
+          A(t),
+          A(e),
+          A(l)
+        ),
+        z(
+          ([
+            h,
+            T,
+            g,
+            [p, H],
+            y,
+            x,
+            f,
+            m,
+            C
+          ]) => {
+            const _ = h - m, a = x + f, d = Math.max(g - _, 0);
+            let w = vo;
+            const R = To(C, St), B = To(C, yt);
+            return p -= m, p += g + f, H += g + f, H -= m, p > h + a - R && (w = at), H < h - d + T + B && (w = nt), w !== vo ? [
+              Math.max(_ - g - Io(y, St, w) - R, 0),
+              _ - d - f + T + Io(y, yt, w) + B
+            ] : null;
+          }
+        ),
+        N((h) => h != null),
+        re(lt)
+      ),
+      [0, 0]
+    );
+    return {
+      increaseViewportBy: l,
+      // input
+      listBoundary: i,
+      overscan: c,
+      topListHeight: s,
+      // output
+      visibleRange: u
+    };
+  },
+  ie(xe),
+  { singleton: !0 }
+);
+function or(e, t, o) {
+  if (Et(t)) {
+    const n = Fo(e, t);
+    return [
+      { index: Be(t.groupOffsetTree, n)[0], offset: 0, size: 0 },
+      { data: o == null ? void 0 : o[0], index: n, offset: 0, size: 0 }
+    ];
+  }
+  return [{ data: o == null ? void 0 : o[0], index: e, offset: 0, size: 0 }];
+}
+const Mt = {
+  bottom: 0,
+  firstItemIndex: 0,
+  items: [],
+  offsetBottom: 0,
+  offsetTop: 0,
+  top: 0,
+  topItems: [],
+  topListHeight: 0,
+  totalCount: 0
+};
+function wt(e, t, o, n, r, i) {
+  const { lastIndex: s, lastOffset: l, lastSize: c } = r;
+  let u = 0, h = 0;
+  if (e.length > 0) {
+    u = e[0].offset;
+    const y = e[e.length - 1];
+    h = y.offset + y.size;
+  }
+  const T = o - s, g = l + T * c + (T - 1) * n, p = u, H = g - h;
+  return {
+    bottom: h,
+    firstItemIndex: i,
+    items: wo(e, r, i),
+    offsetBottom: H,
+    offsetTop: u,
+    top: p,
+    topItems: wo(t, r, i),
+    topListHeight: t.reduce((y, x) => x.size + y, 0),
+    totalCount: o
+  };
+}
+function Yo(e, t, o, n, r, i) {
+  let s = 0;
+  if (o.groupIndices.length > 0)
+    for (const h of o.groupIndices) {
+      if (h - s >= e)
+        break;
+      s++;
+    }
+  const l = e + s, c = Zt(t, l), u = Array.from({ length: l }).map((h, T) => ({
+    data: i[T + c],
+    index: T + c,
+    offset: 0,
+    size: 0
+  }));
+  return wt(u, [], l, r, o, n);
+}
+function wo(e, t, o) {
+  if (e.length === 0)
+    return [];
+  if (!Et(t))
+    return e.map((u) => ({ ...u, index: u.index + o, originalIndex: u.index }));
+  const n = e[0].index, r = e[e.length - 1].index, i = [], s = Rt(t.groupOffsetTree, n, r);
+  let l, c = 0;
+  for (const u of e) {
+    (!l || l.end < u.index) && (l = s.shift(), c = t.groupIndices.indexOf(l.start));
+    let h;
+    u.index === l.start ? h = {
+      index: c,
+      type: "group"
+    } : h = {
+      groupIndex: c,
+      index: u.index - (c + 1) + o
+    }, i.push({
+      ...h,
+      data: u.data,
+      offset: u.offset,
+      originalIndex: u.index,
+      size: u.size
+    });
+  }
+  return i;
+}
+const Xe = J(
+  ([
+    { data: e, firstItemIndex: t, gap: o, sizes: n, totalCount: r },
+    i,
+    { listBoundary: s, topListHeight: l, visibleRange: c },
+    { initialTopMostItemIndex: u, scrolledToInitialItem: h },
+    { topListHeight: T },
+    g,
+    { didMount: p },
+    { recalcInProgress: H }
+  ]) => {
+    const y = b([]), x = b(0), f = K();
+    W(i.topItemsIndexes, y);
+    const m = pe(
+      v(
+        ae(
+          p,
+          H,
+          A(c, lt),
+          A(r),
+          A(n),
+          A(u),
+          h,
+          A(y),
+          A(t),
+          A(o),
+          e
+        ),
+        N(([d, w, , R, , , , , , , B]) => {
+          const M = B && B.length !== R;
+          return d && !w && !M;
+        }),
+        z(
+          ([
+            ,
+            ,
+            [d, w],
+            R,
+            B,
+            M,
+            O,
+            U,
+            Q,
+            L,
+            P
+          ]) => {
+            const ue = B, { offsetTree: ve, sizeTree: we } = ue, Ce = le(x);
+            if (R === 0)
+              return { ...Mt, totalCount: R };
+            if (d === 0 && w === 0)
+              return Ce === 0 ? { ...Mt, totalCount: R } : Yo(Ce, M, B, Q, L, P || []);
+            if (ee(we))
+              return Ce > 0 ? null : wt(
+                or(Zt(M, R), ue, P),
+                [],
+                R,
+                L,
+                ue,
+                Q
+              );
+            const he = [];
+            if (U.length > 0) {
+              const De = U[0], Se = U[U.length - 1];
+              let ce = 0;
+              for (const I of Rt(we, De, Se)) {
+                const G = I.value, te = Math.max(I.start, De), S = Math.min(I.end, Se);
+                for (let E = te; E <= S; E++)
+                  he.push({ data: P == null ? void 0 : P[E], index: E, offset: ce, size: G }), ce += G;
+              }
+            }
+            if (!O)
+              return wt([], he, R, L, ue, Q);
+            const de = U.length > 0 ? U[U.length - 1] + 1 : 0, Ne = Fn(ve, d, w, de);
+            if (Ne.length === 0)
+              return null;
+            const Ie = R - 1, Le = kt([], (De) => {
+              for (const Se of Ne) {
+                const ce = Se.value;
+                let I = ce.offset, G = Se.start;
+                const te = ce.size;
+                if (ce.offset < d) {
+                  G += Math.floor((d - ce.offset + L) / (te + L));
+                  const E = G - Se.start;
+                  I += E * te + E * L;
+                }
+                G < de && (I += (de - G) * te, G = de);
+                const S = Math.min(Se.end, Ie);
+                for (let E = G; E <= S && !(I >= w); E++)
+                  De.push({ data: P == null ? void 0 : P[E], index: E, offset: I, size: te }), I += te + L;
+              }
+            });
+            return wt(Le, he, R, L, ue, Q);
+          }
+        ),
+        //@ts-expect-error filter needs to be fixed
+        N((d) => d !== null),
+        re()
+      ),
+      Mt
+    );
+    W(
+      v(
+        e,
+        N($t),
+        z((d) => d == null ? void 0 : d.length)
+      ),
+      r
+    ), W(
+      v(
+        m,
+        z((d) => d.topListHeight)
+      ),
+      T
+    ), W(T, l), W(
+      v(
+        m,
+        z((d) => [d.top, d.bottom])
+      ),
+      s
+    ), W(
+      v(
+        m,
+        z((d) => d.items)
+      ),
+      f
+    );
+    const C = He(
+      v(
+        m,
+        N(({ items: d }) => d.length > 0),
+        $(r, e),
+        N(([{ items: d }, w]) => d[d.length - 1].originalIndex === w - 1),
+        z(([, d, w]) => [d - 1, w]),
+        re(lt),
+        z(([d]) => d)
+      )
+    ), _ = He(
+      v(
+        m,
+        Pe(200),
+        N(({ items: d, topItems: w }) => d.length > 0 && d[0].originalIndex === w.length),
+        z(({ items: d }) => d[0].index),
+        re()
+      )
+    ), a = He(
+      v(
+        m,
+        N(({ items: d }) => d.length > 0),
+        z(({ items: d }) => {
+          let w = 0, R = d.length - 1;
+          for (; d[w].type === "group" && w < R; )
+            w++;
+          for (; d[R].type === "group" && R > w; )
+            R--;
+          return {
+            endIndex: d[R].index,
+            startIndex: d[w].index
+          };
+        }),
+        re(Vo)
+      )
+    );
+    return { endReached: C, initialItemCount: x, itemsRendered: f, listState: m, rangeChanged: a, startReached: _, topItemsIndexes: y, ...g };
+  },
+  ie(
+    Oe,
+    qo,
+    Jt,
+    mt,
+    dt,
+    ft,
+    $e,
+    Kt
+  ),
+  { singleton: !0 }
+), Xo = J(
+  ([{ fixedFooterHeight: e, fixedHeaderHeight: t, footerHeight: o, headerHeight: n }, { listState: r }]) => {
+    const i = K(), s = pe(
+      v(
+        ae(o, e, n, t, r),
+        z(([l, c, u, h, T]) => l + c + u + h + T.offsetBottom + T.bottom)
+      ),
+      0
+    );
+    return W(A(s), i), { totalListHeight: s, totalListHeightChanged: i };
+  },
+  ie(xe, Xe),
+  { singleton: !0 }
+), nr = J(
+  ([{ viewportHeight: e }, { totalListHeight: t }]) => {
+    const o = b(!1), n = pe(
+      v(
+        ae(o, e, t),
+        N(([r]) => r),
+        z(([, r, i]) => Math.max(0, r - i)),
+        Pe(0),
+        re()
+      ),
+      0
+    );
+    return { alignToBottom: o, paddingTopAddition: n };
+  },
+  ie(xe, Xo),
+  { singleton: !0 }
+), Zo = J(() => ({
+  context: b(null)
+})), rr = ({
+  itemBottom: e,
+  itemTop: t,
+  locationParams: { align: o, behavior: n, ...r },
+  viewportBottom: i,
+  viewportTop: s
+}) => t < s ? { ...r, align: o ?? "start", behavior: n } : e > i ? { ...r, align: o ?? "end", behavior: n } : null, Jo = J(
+  ([
+    { gap: e, sizes: t, totalCount: o },
+    { fixedFooterHeight: n, fixedHeaderHeight: r, headerHeight: i, scrollingInProgress: s, scrollTop: l, viewportHeight: c },
+    { scrollToIndex: u }
+  ]) => {
+    const h = K();
+    return W(
+      v(
+        h,
+        $(t, c, o, i, r, n, l),
+        $(e),
+        z(([[T, g, p, H, y, x, f, m], C]) => {
+          const { align: _, behavior: a, calculateViewLocation: d = rr, done: w, ...R } = T, B = $o(T, g, H - 1), M = ct(B, g.offsetTree, C) + y + x, O = M + Be(g.sizeTree, B)[1], U = m + x, Q = m + p - f, L = d({
+            itemBottom: O,
+            itemTop: M,
+            locationParams: { align: _, behavior: a, ...R },
+            viewportBottom: Q,
+            viewportTop: U
+          });
+          return L ? w && _e(
+            v(
+              s,
+              N((P) => !P),
+              // skips the initial publish of false, and the cleanup call.
+              // but if scrollingInProgress is true, we skip the initial publish.
+              Ke(le(s) ? 1 : 2)
+            ),
+            w
+          ) : w && w(), L;
+        }),
+        N((T) => T !== null)
+      ),
+      u
+    ), {
+      scrollIntoView: h
+    };
+  },
+  ie(Oe, xe, dt, Xe, Fe),
+  { singleton: !0 }
+);
+function Co(e) {
+  return e ? e === "smooth" ? "smooth" : "auto" : !1;
+}
+const ir = (e, t) => typeof e == "function" ? Co(e(t)) : t && Co(e), sr = J(
+  ([
+    { listRefresh: e, totalCount: t, fixedItemSize: o, data: n },
+    { atBottomState: r, isAtBottom: i },
+    { scrollToIndex: s },
+    { scrolledToInitialItem: l },
+    { didMount: c, propsReady: u },
+    { log: h },
+    { scrollingInProgress: T },
+    { context: g },
+    { scrollIntoView: p }
+  ]) => {
+    const H = b(!1), y = K();
+    let x = null;
+    function f(a) {
+      F(s, {
+        align: "end",
+        behavior: a,
+        index: "LAST"
+      });
+    }
+    Z(
+      v(
+        ae(v(A(t), Ke(1)), c),
+        $(A(H), i, l, T),
+        z(([[a, d], w, R, B, M]) => {
+          let O = d && B, U = "auto";
+          return O && (U = ir(w, R || M), O = O && !!U), { followOutputBehavior: U, shouldFollow: O, totalCount: a };
+        }),
+        N(({ shouldFollow: a }) => a)
+      ),
+      ({ followOutputBehavior: a, totalCount: d }) => {
+        x && (x(), x = null), le(o) ? requestAnimationFrame(() => {
+          le(h)("following output to ", { totalCount: d }, Te.DEBUG), f(a);
+        }) : x = _e(e, () => {
+          le(h)("following output to ", { totalCount: d }, Te.DEBUG), f(a), x = null;
+        });
+      }
+    );
+    function m(a) {
+      const d = _e(r, (w) => {
+        a && !w.atBottom && w.notAtBottomBecause === "SIZE_INCREASED" && !x && (le(h)("scrolling to bottom due to increased size", {}, Te.DEBUG), f("auto"));
+      });
+      setTimeout(d, 100);
+    }
+    Z(
+      v(
+        ae(A(H), t, u),
+        N(([a, , d]) => a && d),
+        Ae(
+          ({ value: a }, [, d]) => ({ refreshed: a === d, value: d }),
+          { refreshed: !1, value: 0 }
+        ),
+        N(({ refreshed: a }) => a),
+        $(H, t)
+      ),
+      ([, a]) => {
+        le(l) && m(a !== !1);
+      }
+    ), Z(y, () => {
+      m(le(H) !== !1);
+    }), Z(ae(A(H), r), ([a, d]) => {
+      a && !d.atBottom && d.notAtBottomBecause === "VIEWPORT_HEIGHT_DECREASING" && f("auto");
+    });
+    const C = b(null), _ = K();
+    return W(
+      Nt(
+        v(
+          A(n),
+          z((a) => {
+            var d;
+            return (d = a == null ? void 0 : a.length) != null ? d : 0;
+          })
+        ),
+        v(A(t))
+      ),
+      _
+    ), Z(
+      v(
+        ae(v(_, Ke(1)), c),
+        $(A(C), l, T, g),
+        z(([[a, d], w, R, B, M]) => d && R && (w == null ? void 0 : w({ context: M, totalCount: a, scrollingInProgress: B }))),
+        N((a) => !!a),
+        Pe(0)
+      ),
+      (a) => {
+        x && (x(), x = null), le(o) ? requestAnimationFrame(() => {
+          le(h)("scrolling into view", {}), F(p, a);
+        }) : x = _e(e, () => {
+          le(h)("scrolling into view", {}), F(p, a), x = null;
+        });
+      }
+    ), { autoscrollToBottom: y, followOutput: H, scrollIntoViewOnChange: C };
+  },
+  ie(
+    Oe,
+    ft,
+    dt,
+    mt,
+    $e,
+    Fe,
+    xe,
+    Zo,
+    Jo
+  )
+), lr = J(
+  ([{ data: e, firstItemIndex: t, gap: o, sizes: n }, { initialTopMostItemIndex: r }, { initialItemCount: i, listState: s }, { didMount: l }]) => (W(
+    v(
+      l,
+      $(i),
+      N(([, c]) => c !== 0),
+      $(r, n, t, o, e),
+      z(([[, c], u, h, T, g, p = []]) => Yo(c, u, h, T, g, p))
+    ),
+    s
+  ), {}),
+  ie(Oe, mt, Xe, $e),
+  { singleton: !0 }
+), cr = J(
+  ([{ didMount: e }, { scrollTo: t }, { listState: o }]) => {
+    const n = b(0);
+    return Z(
+      v(
+        e,
+        $(n),
+        N(([, r]) => r !== 0),
+        z(([, r]) => ({ top: r }))
+      ),
+      (r) => {
+        _e(
+          v(
+            o,
+            Ke(1),
+            N((i) => i.items.length > 1)
+          ),
+          () => {
+            requestAnimationFrame(() => {
+              F(t, r);
+            });
+          }
+        );
+      }
+    ), {
+      initialScrollTop: n
+    };
+  },
+  ie($e, xe, Xe),
+  { singleton: !0 }
+), Qo = J(
+  ([{ scrollVelocity: e }]) => {
+    const t = b(!1), o = K(), n = b(!1);
+    return W(
+      v(
+        e,
+        $(n, t, o),
+        N(([r, i]) => !!i),
+        z(([r, i, s, l]) => {
+          const { enter: c, exit: u } = i;
+          if (s) {
+            if (u(r, l))
+              return !1;
+          } else if (c(r, l))
+            return !0;
+          return s;
+        }),
+        re()
+      ),
+      t
+    ), Z(
+      v(ae(t, e, o), $(n)),
+      ([[r, i, s], l]) => {
+        r && l && l.change && l.change(i, s);
+      }
+    ), { isSeeking: t, scrollSeekConfiguration: n, scrollSeekRangeChanged: o, scrollVelocity: e };
+  },
+  ie(ft),
+  { singleton: !0 }
+), Qt = J(([{ scrollContainerState: e, scrollTo: t }]) => {
+  const o = K(), n = K(), r = K(), i = b(!1), s = b(void 0);
+  return W(
+    v(
+      ae(o, n),
+      z(([{ scrollHeight: l, scrollTop: c, viewportHeight: u }, { offsetTop: h }]) => ({
+        scrollHeight: l,
+        scrollTop: Math.max(0, c - h),
+        viewportHeight: u
+      }))
+    ),
+    e
+  ), W(
+    v(
+      t,
+      $(n),
+      z(([l, { offsetTop: c }]) => ({
+        ...l,
+        top: l.top + c
+      }))
+    ),
+    r
+  ), {
+    customScrollParent: s,
+    // config
+    useWindowScroll: i,
+    // input
+    windowScrollContainerState: o,
+    // signals
+    windowScrollTo: r,
+    windowViewportRect: n
+  };
+}, ie(xe)), ar = J(
+  ([
+    { sizeRanges: e, sizes: t },
+    { headerHeight: o, scrollTop: n },
+    { initialTopMostItemIndex: r },
+    { didMount: i },
+    { useWindowScroll: s, windowScrollContainerState: l, windowViewportRect: c }
+  ]) => {
+    const u = K(), h = b(void 0), T = b(null), g = b(null);
+    return W(l, T), W(c, g), Z(
+      v(
+        u,
+        $(t, n, s, T, g, o)
+      ),
+      ([p, H, y, x, f, m, C]) => {
+        const _ = qn(H.sizeTree);
+        x && f !== null && m !== null && (y = f.scrollTop - m.offsetTop), y -= C, p({ ranges: _, scrollTop: y });
+      }
+    ), W(v(h, N($t), z(ur)), r), W(
+      v(
+        i,
+        $(h),
+        N(([, p]) => p !== void 0),
+        re(),
+        z(([, p]) => p.ranges)
+      ),
+      e
+    ), {
+      getState: u,
+      restoreStateFrom: h
+    };
+  },
+  ie(Oe, xe, mt, $e, Qt)
+);
+function ur(e) {
+  return { align: "start", index: 0, offset: e.scrollTop };
+}
+const dr = J(([{ topItemsIndexes: e }]) => {
+  const t = b(0);
+  return W(
+    v(
+      t,
+      N((o) => o >= 0),
+      z((o) => Array.from({ length: o }).map((n, r) => r))
+    ),
+    e
+  ), { topItemCount: t };
+}, ie(Xe));
+function en(e) {
+  let t = !1, o;
+  return () => (t || (t = !0, o = e()), o);
+}
+const mr = en(() => /iP(ad|od|hone)/i.test(navigator.userAgent) && /WebKit/i.test(navigator.userAgent)), fr = J(
+  ([
+    { deviation: e, scrollBy: t, scrollingInProgress: o, scrollTop: n },
+    { isAtBottom: r, isScrolling: i, lastJumpDueToItemResize: s, scrollDirection: l },
+    { listState: c },
+    { beforeUnshiftWith: u, gap: h, shiftWithOffset: T, sizes: g },
+    { log: p },
+    { recalcInProgress: H }
+  ]) => {
+    const y = He(
+      v(
+        c,
+        $(s),
+        Ae(
+          ([, f, m, C], [{ bottom: _, items: a, offsetBottom: d, totalCount: w }, R]) => {
+            const B = _ + d;
+            let M = 0;
+            return m === w && f.length > 0 && a.length > 0 && (a[0].originalIndex === 0 && f[0].originalIndex === 0 || (M = B - C, M !== 0 && (M += R))), [M, a, w, B];
+          },
+          [0, [], 0, 0]
+        ),
+        N(([f]) => f !== 0),
+        $(n, l, o, r, p, H),
+        N(([, f, m, C, , , _]) => !_ && !C && f !== 0 && m === at),
+        z(([[f], , , , , m]) => (m("Upward scrolling compensation", { amount: f }, Te.DEBUG), f))
+      )
+    );
+    function x(f) {
+      f > 0 ? (F(t, { behavior: "auto", top: -f }), F(e, 0)) : (F(e, 0), F(t, { behavior: "auto", top: -f }));
+    }
+    return Z(v(y, $(e, i)), ([f, m, C]) => {
+      C && mr() ? F(e, m - f) : x(-f);
+    }), Z(
+      v(
+        ae(pe(i, !1), e, H),
+        N(([f, m, C]) => !f && !C && m !== 0),
+        z(([f, m]) => m),
+        Pe(1)
+      ),
+      x
+    ), W(
+      v(
+        T,
+        z((f) => ({ top: -f }))
+      ),
+      t
+    ), Z(
+      v(
+        u,
+        $(g, h),
+        z(([f, { groupIndices: m, lastSize: C, sizeTree: _ }, a]) => {
+          function d(w) {
+            return w * (C + a);
+          }
+          if (m.length === 0)
+            return d(f);
+          {
+            let w = 0;
+            const R = st(_, 0);
+            let B = 0, M = 0;
+            for (; B < f; ) {
+              B++, w += R;
+              let O = m.length === M + 1 ? 1 / 0 : m[M + 1] - m[M] - 1;
+              B + O > f && (w -= R, O = f - B + 1), B += O, w += d(O), M++;
+            }
+            return w;
+          }
+        })
+      ),
+      (f) => {
+        F(e, f), requestAnimationFrame(() => {
+          F(t, { top: f }), requestAnimationFrame(() => {
+            F(e, 0), F(H, !1);
+          });
+        });
+      }
+    ), { deviation: e };
+  },
+  ie(xe, ft, Xe, Oe, Fe, Kt)
+), hr = J(
+  ([
+    e,
+    t,
+    o,
+    n,
+    r,
+    i,
+    s,
+    l,
+    c,
+    u,
+    h
+  ]) => ({
+    ...e,
+    ...t,
+    ...o,
+    ...n,
+    ...r,
+    ...i,
+    ...s,
+    ...l,
+    ...c,
+    ...u,
+    ...h
+  }),
+  ie(
+    Jt,
+    lr,
+    $e,
+    Qo,
+    Xo,
+    cr,
+    nr,
+    Qt,
+    Jo,
+    Fe,
+    Zo
+  )
+), gr = J(
+  ([
+    {
+      data: e,
+      defaultItemSize: t,
+      firstItemIndex: o,
+      fixedItemSize: n,
+      gap: r,
+      groupIndices: i,
+      itemSize: s,
+      sizeRanges: l,
+      sizes: c,
+      statefulTotalCount: u,
+      totalCount: h,
+      trackItemSizes: T
+    },
+    { initialItemFinalLocationReached: g, initialTopMostItemIndex: p, scrolledToInitialItem: H },
+    y,
+    x,
+    f,
+    { listState: m, topItemsIndexes: C, ..._ },
+    { scrollToIndex: a },
+    d,
+    { topItemCount: w },
+    { groupCounts: R },
+    B
+  ]) => (W(_.rangeChanged, B.scrollSeekRangeChanged), W(
+    v(
+      B.windowViewportRect,
+      z((M) => M.visibleHeight)
+    ),
+    y.viewportHeight
+  ), {
+    data: e,
+    defaultItemHeight: t,
+    firstItemIndex: o,
+    fixedItemHeight: n,
+    gap: r,
+    groupCounts: R,
+    initialItemFinalLocationReached: g,
+    initialTopMostItemIndex: p,
+    scrolledToInitialItem: H,
+    sizeRanges: l,
+    topItemCount: w,
+    topItemsIndexes: C,
+    // input
+    totalCount: h,
+    ...f,
+    groupIndices: i,
+    itemSize: s,
+    listState: m,
+    scrollToIndex: a,
+    // output
+    statefulTotalCount: u,
+    trackItemSizes: T,
+    // exported from stateFlagsSystem
+    ..._,
+    // the bag of IO from featureGroup1System
+    ...B,
+    ...y,
+    sizes: c,
+    ...x
+  }),
+  ie(
+    Oe,
+    mt,
+    xe,
+    ar,
+    sr,
+    Xe,
+    dt,
+    fr,
+    dr,
+    qo,
+    hr
+  )
+);
+function pr(e, t) {
+  const o = {}, n = {};
+  let r = 0;
+  const i = e.length;
+  for (; r < i; )
+    n[e[r]] = 1, r += 1;
+  for (const s in t)
+    Object.hasOwn(n, s) || (o[s] = t[s]);
+  return o;
+}
+const xt = typeof document < "u" ? j.useLayoutEffect : j.useEffect;
+function tn(e, t, o) {
+  const n = Object.keys(t.required || {}), r = Object.keys(t.optional || {}), i = Object.keys(t.methods || {}), s = Object.keys(t.events || {}), l = j.createContext({});
+  function c(x, f) {
+    x.propsReady && F(x.propsReady, !1);
+    for (const m of n) {
+      const C = x[t.required[m]];
+      F(C, f[m]);
+    }
+    for (const m of r)
+      if (m in f) {
+        const C = x[t.optional[m]];
+        F(C, f[m]);
+      }
+    x.propsReady && F(x.propsReady, !0);
+  }
+  function u(x) {
+    return i.reduce((f, m) => (f[m] = (C) => {
+      const _ = x[t.methods[m]];
+      F(_, C);
+    }, f), {});
+  }
+  function h(x) {
+    return s.reduce((f, m) => (f[m] = _n(x[t.events[m]]), f), {});
+  }
+  const T = j.forwardRef((x, f) => {
+    const { children: m, ...C } = x, [_] = j.useState(() => kt(Ln(e), (w) => {
+      c(w, C);
+    })), [a] = j.useState(fo(h, _));
+    xt(() => {
+      for (const w of s)
+        w in C && Z(a[w], C[w]);
+      return () => {
+        Object.values(a).map(qt);
+      };
+    }, [C, a, _]), xt(() => {
+      c(_, C);
+    }), j.useImperativeHandle(f, mo(u(_)));
+    const d = o;
+    return /* @__PURE__ */ k.jsx(l.Provider, { value: _, children: o ? /* @__PURE__ */ k.jsx(d, { ...pr([...n, ...r, ...s], C), children: m }) : m });
+  }), g = (x) => {
+    const f = j.useContext(l);
+    return j.useCallback(
+      (m) => {
+        F(f[x], m);
+      },
+      [f, x]
+    );
+  }, p = (x) => {
+    const f = j.useContext(l)[x], m = j.useCallback(
+      (C) => Z(f, C),
+      [f]
+    );
+    return j.useSyncExternalStore(
+      m,
+      () => le(f),
+      () => le(f)
+    );
+  }, H = (x) => {
+    const f = j.useContext(l)[x], [m, C] = j.useState(fo(le, f));
+    return xt(
+      () => Z(f, (_) => {
+        _ !== m && C(mo(_));
+      }),
+      [f, m]
+    ), m;
+  }, y = j.version.startsWith("18") ? p : H;
+  return {
+    Component: T,
+    useEmitter: (x, f) => {
+      const m = j.useContext(l)[x];
+      xt(() => Z(m, f), [f, m]);
+    },
+    useEmitterValue: y,
+    usePublisher: g
+  };
+}
+const on = j.createContext(void 0), nn = j.createContext(void 0), rn = typeof document < "u" ? j.useLayoutEffect : j.useEffect;
+function Wt(e) {
+  return "self" in e;
+}
+function xr(e) {
+  return "body" in e;
+}
+function sn(e, t, o, n = ut, r, i) {
+  const s = j.useRef(null), l = j.useRef(null), c = j.useRef(null), u = j.useCallback(
+    (g) => {
+      let p, H, y;
+      const x = g.target;
+      if (xr(x) || Wt(x)) {
+        const m = Wt(x) ? x : x.defaultView;
+        y = i ? m.scrollX : m.scrollY, p = i ? m.document.documentElement.scrollWidth : m.document.documentElement.scrollHeight, H = i ? m.innerWidth : m.innerHeight;
+      } else
+        y = i ? x.scrollLeft : x.scrollTop, p = i ? x.scrollWidth : x.scrollHeight, H = i ? x.offsetWidth : x.offsetHeight;
+      const f = () => {
+        e({
+          scrollHeight: p,
+          scrollTop: Math.max(y, 0),
+          viewportHeight: H
+        });
+      };
+      g.suppressFlushSync ? f() : gn.flushSync(f), l.current !== null && (y === l.current || y <= 0 || y === p - H) && (l.current = null, t(!0), c.current && (clearTimeout(c.current), c.current = null));
+    },
+    [e, t, i]
+  );
+  j.useEffect(() => {
+    const g = r || s.current;
+    return n(r || s.current), u({ suppressFlushSync: !0, target: g }), g.addEventListener("scroll", u, { passive: !0 }), () => {
+      n(null), g.removeEventListener("scroll", u);
+    };
+  }, [s, u, o, n, r]);
+  function h(g) {
+    const p = s.current;
+    if (!p || (i ? "offsetWidth" in p && p.offsetWidth === 0 : "offsetHeight" in p && p.offsetHeight === 0))
+      return;
+    const H = g.behavior === "smooth";
+    let y, x, f;
+    Wt(p) ? (x = Math.max(
+      Ve(p.document.documentElement, i ? "width" : "height"),
+      i ? p.document.documentElement.scrollWidth : p.document.documentElement.scrollHeight
+    ), y = i ? p.innerWidth : p.innerHeight, f = i ? window.scrollX : window.scrollY) : (x = p[i ? "scrollWidth" : "scrollHeight"], y = Ve(p, i ? "width" : "height"), f = p[i ? "scrollLeft" : "scrollTop"]);
+    const m = x - y;
+    if (g.top = Math.ceil(Math.max(Math.min(m, g.top), 0)), Ko(y, x) || g.top === f) {
+      e({ scrollHeight: x, scrollTop: f, viewportHeight: y }), H && t(!0);
+      return;
+    }
+    H ? (l.current = g.top, c.current && clearTimeout(c.current), c.current = setTimeout(() => {
+      c.current = null, l.current = null, t(!0);
+    }, 1e3)) : l.current = null, i && (g = { behavior: g.behavior, left: g.top }), p.scrollTo(g);
+  }
+  function T(g) {
+    i && (g = { behavior: g.behavior, left: g.top }), s.current.scrollBy(g);
+  }
+  return { scrollByCallback: T, scrollerRef: s, scrollToCallback: h };
+}
+const At = "-webkit-sticky", So = "sticky", eo = en(() => {
+  if (typeof document > "u")
+    return So;
+  const e = document.createElement("div");
+  return e.style.position = At, e.style.position === At ? At : So;
+});
+function ln(e) {
+  return e;
+}
+const vr = /* @__PURE__ */ J(() => {
+  const e = b((l) => `Item ${l}`), t = b((l) => `Group ${l}`), o = b({}), n = b(ln), r = b("div"), i = b(ut), s = (l, c = null) => pe(
+    v(
+      o,
+      z((u) => u[l]),
+      re()
+    ),
+    c
+  );
+  return {
+    components: o,
+    computeItemKey: n,
+    EmptyPlaceholder: s("EmptyPlaceholder"),
+    FooterComponent: s("Footer"),
+    GroupComponent: s("Group", "div"),
+    groupContent: t,
+    HeaderComponent: s("Header"),
+    HeaderFooterTag: r,
+    ItemComponent: s("Item", "div"),
+    itemContent: e,
+    ListComponent: s("List", "div"),
+    ScrollerComponent: s("Scroller", "div"),
+    scrollerRef: i,
+    ScrollSeekPlaceholder: s("ScrollSeekPlaceholder"),
+    TopItemListComponent: s("TopItemList")
+  };
+}), Ir = /* @__PURE__ */ J(
+  ([e, t]) => ({ ...e, ...t }),
+  ie(gr, vr)
+), Tr = ({ height: e }) => /* @__PURE__ */ k.jsx("div", { style: { height: e } }), wr = { overflowAnchor: "none", position: eo(), zIndex: 1 }, cn = { overflowAnchor: "none" }, Cr = { ...cn, display: "inline-block", height: "100%" }, yo = /* @__PURE__ */ j.memo(function({ showTopList: e = !1 }) {
+  const t = V("listState"), o = ke("sizeRanges"), n = V("useWindowScroll"), r = V("customScrollParent"), i = ke("windowScrollContainerState"), s = ke("scrollContainerState"), l = r || n ? i : s, c = V("itemContent"), u = V("context"), h = V("groupContent"), T = V("trackItemSizes"), g = V("itemSize"), p = V("log"), H = ke("gap"), y = V("horizontalDirection"), { callbackRef: x } = Wn(
+    o,
+    g,
+    T,
+    e ? ut : l,
+    p,
+    H,
+    r,
+    y,
+    V("skipAnimationFrameInResizeObserver")
+  ), [f, m] = j.useState(0);
+  to("deviation", (L) => {
+    f !== L && m(L);
+  });
+  const C = V("EmptyPlaceholder"), _ = V("ScrollSeekPlaceholder") || Tr, a = V("ListComponent"), d = V("ItemComponent"), w = V("GroupComponent"), R = V("computeItemKey"), B = V("isSeeking"), M = V("groupIndices").length > 0, O = V("alignToBottom"), U = V("initialItemFinalLocationReached"), Q = e ? {} : {
+    boxSizing: "border-box",
+    ...y ? {
+      display: "inline-block",
+      height: "100%",
+      marginLeft: f !== 0 ? f : O ? "auto" : 0,
+      paddingLeft: t.offsetTop,
+      paddingRight: t.offsetBottom,
+      whiteSpace: "nowrap"
+    } : {
+      marginTop: f !== 0 ? f : O ? "auto" : 0,
+      paddingBottom: t.offsetBottom,
+      paddingTop: t.offsetTop
+    },
+    ...U ? {} : { visibility: "hidden" }
+  };
+  return !e && t.totalCount === 0 && C ? /* @__PURE__ */ k.jsx(C, { ...ge(C, u) }) : /* @__PURE__ */ k.jsx(
+    a,
+    {
+      ...ge(a, u),
+      "data-testid": e ? "virtuoso-top-item-list" : "virtuoso-item-list",
+      ref: x,
+      style: Q,
+      children: (e ? t.topItems : t.items).map((L) => {
+        const P = L.originalIndex, ue = R(P + t.firstItemIndex, L.data, u);
+        return B ? /* @__PURE__ */ It(
+          _,
+          {
+            ...ge(_, u),
+            height: L.size,
+            index: L.index,
+            key: ue,
+            type: L.type || "item",
+            ...L.type === "group" ? {} : { groupIndex: L.groupIndex }
+          }
+        ) : L.type === "group" ? /* @__PURE__ */ It(
+          w,
+          {
+            ...ge(w, u),
+            "data-index": P,
+            "data-item-index": L.index,
+            "data-known-size": L.size,
+            key: ue,
+            style: wr
+          },
+          h(L.index, u)
+        ) : /* @__PURE__ */ It(
+          d,
+          {
+            ...ge(d, u),
+            ...Hr(d, L.data),
+            "data-index": P,
+            "data-item-group-index": L.groupIndex,
+            "data-item-index": L.index,
+            "data-known-size": L.size,
+            key: ue,
+            style: y ? Cr : cn
+          },
+          M ? c(L.index, L.groupIndex, L.data, u) : c(L.index, L.data, u)
+        );
+      })
+    }
+  );
+}), Sr = {
+  height: "100%",
+  outline: "none",
+  overflowY: "auto",
+  position: "relative",
+  WebkitOverflowScrolling: "touch"
+}, yr = {
+  outline: "none",
+  overflowX: "auto",
+  position: "relative"
+}, zt = (e) => ({
+  height: "100%",
+  position: "absolute",
+  top: 0,
+  width: "100%",
+  ...e ? { display: "flex", flexDirection: "column" } : {}
+}), br = {
+  position: eo(),
+  top: 0,
+  width: "100%",
+  zIndex: 1
+};
+function ge(e, t) {
+  if (typeof e != "string")
+    return { context: t };
+}
+function Hr(e, t) {
+  return { item: typeof e == "string" ? void 0 : t };
+}
+const kr = /* @__PURE__ */ j.memo(function() {
+  const e = V("HeaderComponent"), t = ke("headerHeight"), o = V("HeaderFooterTag"), n = Ye(
+    j.useMemo(
+      () => (i) => {
+        t(Ve(i, "height"));
+      },
+      [t]
+    ),
+    !0,
+    V("skipAnimationFrameInResizeObserver")
+  ), r = V("context");
+  return e ? /* @__PURE__ */ k.jsx(o, { ref: n, children: /* @__PURE__ */ k.jsx(e, { ...ge(e, r) }) }) : null;
+}), Rr = /* @__PURE__ */ j.memo(function() {
+  const e = V("FooterComponent"), t = ke("footerHeight"), o = V("HeaderFooterTag"), n = Ye(
+    j.useMemo(
+      () => (i) => {
+        t(Ve(i, "height"));
+      },
+      [t]
+    ),
+    !0,
+    V("skipAnimationFrameInResizeObserver")
+  ), r = V("context");
+  return e ? /* @__PURE__ */ k.jsx(o, { ref: n, children: /* @__PURE__ */ k.jsx(e, { ...ge(e, r) }) }) : null;
+});
+function an({ useEmitter: e, useEmitterValue: t, usePublisher: o }) {
+  return j.memo(function({ children: n, style: r, context: i, ...s }) {
+    const l = o("scrollContainerState"), c = t("ScrollerComponent"), u = o("smoothScrollTargetReached"), h = t("scrollerRef"), T = t("horizontalDirection") || !1, { scrollByCallback: g, scrollerRef: p, scrollToCallback: H } = sn(
+      l,
+      u,
+      c,
+      h,
+      void 0,
+      T
+    );
+    return e("scrollTo", H), e("scrollBy", g), /* @__PURE__ */ k.jsx(
+      c,
+      {
+        "data-testid": "virtuoso-scroller",
+        "data-virtuoso-scroller": !0,
+        ref: p,
+        style: { ...T ? yr : Sr, ...r },
+        tabIndex: 0,
+        ...s,
+        ...ge(c, i),
+        children: n
+      }
+    );
+  });
+}
+function un({ useEmitter: e, useEmitterValue: t, usePublisher: o }) {
+  return j.memo(function({ children: n, style: r, context: i, ...s }) {
+    const l = o("windowScrollContainerState"), c = t("ScrollerComponent"), u = o("smoothScrollTargetReached"), h = t("totalListHeight"), T = t("deviation"), g = t("customScrollParent"), p = j.useRef(null), H = t("scrollerRef"), { scrollByCallback: y, scrollerRef: x, scrollToCallback: f } = sn(
+      l,
+      u,
+      c,
+      H,
+      g
+    );
+    return rn(() => {
+      var m;
+      return x.current = g || ((m = p.current) == null ? void 0 : m.ownerDocument.defaultView), () => {
+        x.current = null;
+      };
+    }, [x, g]), e("windowScrollTo", f), e("scrollBy", y), /* @__PURE__ */ k.jsx(
+      c,
+      {
+        ref: p,
+        "data-virtuoso-scroller": !0,
+        style: { position: "relative", ...r, ...h !== 0 ? { height: h + T } : {} },
+        ...s,
+        ...ge(c, i),
+        children: n
+      }
+    );
+  });
+}
+const Er = ({ children: e }) => {
+  const t = j.useContext(on), o = ke("viewportHeight"), n = ke("fixedItemHeight"), r = V("alignToBottom"), i = V("horizontalDirection"), s = j.useMemo(
+    () => jo(o, (c) => Ve(c, i ? "width" : "height")),
+    [o, i]
+  ), l = Ye(s, !0, V("skipAnimationFrameInResizeObserver"));
+  return j.useEffect(() => {
+    t && (o(t.viewportHeight), n(t.itemHeight));
+  }, [t, o, n]), /* @__PURE__ */ k.jsx("div", { "data-viewport-type": "element", ref: l, style: zt(r), children: e });
+}, zr = ({ children: e }) => {
+  const t = j.useContext(on), o = ke("windowViewportRect"), n = ke("fixedItemHeight"), r = V("customScrollParent"), i = Wo(
+    o,
+    r,
+    V("skipAnimationFrameInResizeObserver")
+  ), s = V("alignToBottom");
+  return j.useEffect(() => {
+    t && (n(t.itemHeight), o({ offsetTop: 0, visibleHeight: t.viewportHeight, visibleWidth: 100 }));
+  }, [t, o, n]), /* @__PURE__ */ k.jsx("div", { "data-viewport-type": "window", ref: i, style: zt(s), children: e });
+}, _r = ({ children: e }) => {
+  const t = V("TopItemListComponent") || "div", o = V("headerHeight"), n = { ...br, marginTop: `${o}px` }, r = V("context");
+  return /* @__PURE__ */ k.jsx(t, { style: n, ...ge(t, r), children: e });
+}, Br = /* @__PURE__ */ j.memo(function(e) {
+  const t = V("useWindowScroll"), o = V("topItemsIndexes").length > 0, n = V("customScrollParent"), r = V("context");
+  return /* @__PURE__ */ k.jsxs(n || t ? Mr : jr, { ...e, context: r, children: [
+    o && /* @__PURE__ */ k.jsx(_r, { children: /* @__PURE__ */ k.jsx(yo, { showTopList: !0 }) }),
+    /* @__PURE__ */ k.jsxs(n || t ? zr : Er, { children: [
+      /* @__PURE__ */ k.jsx(kr, {}),
+      /* @__PURE__ */ k.jsx(yo, {}),
+      /* @__PURE__ */ k.jsx(Rr, {})
+    ] })
+  ] });
+}), {
+  Component: Lr,
+  useEmitter: to,
+  useEmitterValue: V,
+  usePublisher: ke
+} = /* @__PURE__ */ tn(
+  Ir,
+  {
+    required: {},
+    optional: {
+      restoreStateFrom: "restoreStateFrom",
+      context: "context",
+      followOutput: "followOutput",
+      scrollIntoViewOnChange: "scrollIntoViewOnChange",
+      itemContent: "itemContent",
+      groupContent: "groupContent",
+      overscan: "overscan",
+      increaseViewportBy: "increaseViewportBy",
+      totalCount: "totalCount",
+      groupCounts: "groupCounts",
+      topItemCount: "topItemCount",
+      firstItemIndex: "firstItemIndex",
+      initialTopMostItemIndex: "initialTopMostItemIndex",
+      components: "components",
+      atBottomThreshold: "atBottomThreshold",
+      atTopThreshold: "atTopThreshold",
+      computeItemKey: "computeItemKey",
+      defaultItemHeight: "defaultItemHeight",
+      fixedItemHeight: "fixedItemHeight",
+      itemSize: "itemSize",
+      scrollSeekConfiguration: "scrollSeekConfiguration",
+      headerFooterTag: "HeaderFooterTag",
+      data: "data",
+      initialItemCount: "initialItemCount",
+      initialScrollTop: "initialScrollTop",
+      alignToBottom: "alignToBottom",
+      useWindowScroll: "useWindowScroll",
+      customScrollParent: "customScrollParent",
+      scrollerRef: "scrollerRef",
+      logLevel: "logLevel",
+      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"
+    }
+  },
+  Br
+), jr = /* @__PURE__ */ an({ useEmitter: to, useEmitterValue: V, usePublisher: ke }), Mr = /* @__PURE__ */ un({ useEmitter: to, useEmitterValue: V, usePublisher: ke }), Wr = Lr;
+eo();
+const bo = {
+  bottom: 0,
+  itemHeight: 0,
+  items: [],
+  itemWidth: 0,
+  offsetBottom: 0,
+  offsetTop: 0,
+  top: 0
+}, Ar = {
+  bottom: 0,
+  itemHeight: 0,
+  items: [{ index: 0 }],
+  itemWidth: 0,
+  offsetBottom: 0,
+  offsetTop: 0,
+  top: 0
+}, { ceil: Ho, floor: bt, max: rt, min: Ot, round: ko } = Math;
+function Ro(e, t, o) {
+  return Array.from({ length: t - e + 1 }).map((n, r) => ({ data: o === null ? null : o[r + e], index: r + e }));
+}
+function Or(e) {
+  return {
+    ...Ar,
+    items: e
+  };
+}
+function vt(e, t) {
+  return e && e.width === t.width && e.height === t.height;
+}
+function Nr(e, t) {
+  return e && e.column === t.column && e.row === t.row;
+}
+const Pr = /* @__PURE__ */ J(
+  ([
+    { increaseViewportBy: e, listBoundary: t, overscan: o, visibleRange: n },
+    { footerHeight: r, headerHeight: i, scrollBy: s, scrollContainerState: l, scrollTo: c, scrollTop: u, smoothScrollTargetReached: h, viewportHeight: T },
+    g,
+    p,
+    { didMount: H, propsReady: y },
+    { customScrollParent: x, useWindowScroll: f, windowScrollContainerState: m, windowScrollTo: C, windowViewportRect: _ },
+    a
+  ]) => {
+    const d = b(0), w = b(0), R = b(bo), B = b({ height: 0, width: 0 }), M = b({ height: 0, width: 0 }), O = K(), U = K(), Q = b(0), L = b(null), P = b({ column: 0, row: 0 }), ue = K(), ve = K(), we = b(!1), Ce = b(0), he = b(!0), de = b(!1), Ne = b(!1);
+    Z(
+      v(
+        H,
+        $(Ce),
+        N(([I, G]) => !!G)
+      ),
+      () => {
+        F(he, !1);
+      }
+    ), Z(
+      v(
+        ae(H, he, M, B, Ce, de),
+        N(([I, G, te, S, , E]) => I && !G && te.height !== 0 && S.height !== 0 && !E)
+      ),
+      ([, , , , I]) => {
+        F(de, !0), Xt(1, () => {
+          F(O, I);
+        }), _e(v(u), () => {
+          F(t, [0, 0]), F(he, !0);
+        });
+      }
+    ), W(
+      v(
+        ve,
+        N((I) => I != null && I.scrollTop > 0),
+        We(0)
+      ),
+      w
+    ), Z(
+      v(
+        H,
+        $(ve),
+        N(([, I]) => I != null)
+      ),
+      ([, I]) => {
+        I && (F(B, I.viewport), F(M, I.item), F(P, I.gap), I.scrollTop > 0 && (F(we, !0), _e(v(u, Ke(1)), (G) => {
+          F(we, !1);
+        }), F(c, { top: I.scrollTop })));
+      }
+    ), W(
+      v(
+        B,
+        z(({ height: I }) => I)
+      ),
+      T
+    ), W(
+      v(
+        ae(
+          A(B, vt),
+          A(M, vt),
+          A(P, (I, G) => I && I.column === G.column && I.row === G.row),
+          A(u)
+        ),
+        z(([I, G, te, S]) => ({
+          gap: te,
+          item: G,
+          scrollTop: S,
+          viewport: I
+        }))
+      ),
+      ue
+    ), W(
+      v(
+        ae(
+          A(d),
+          n,
+          A(P, Nr),
+          A(M, vt),
+          A(B, vt),
+          A(L),
+          A(w),
+          A(we),
+          A(he),
+          A(Ce)
+        ),
+        N(([, , , , , , , I]) => !I),
+        z(
+          ([
+            I,
+            [G, te],
+            S,
+            E,
+            Y,
+            D,
+            q,
+            ,
+            oe,
+            X
+          ]) => {
+            const { column: fe, row: Ee } = S, { height: je, width: ye } = E, { width: Me } = Y;
+            if (q === 0 && (I === 0 || Me === 0))
+              return bo;
+            if (ye === 0) {
+              const so = Zt(X, I), hn = so + Math.max(q - 1, 0);
+              return Or(Ro(so, hn, D));
+            }
+            const ht = dn(Me, ye, fe);
+            let Ze, qe;
+            oe ? G === 0 && te === 0 && q > 0 ? (Ze = 0, qe = q - 1) : (Ze = ht * bt((G + Ee) / (je + Ee)), qe = ht * Ho((te + Ee) / (je + Ee)) - 1, qe = Ot(I - 1, rt(qe, ht - 1)), Ze = Ot(qe, rt(0, Ze))) : (Ze = 0, qe = -1);
+            const oo = Ro(Ze, qe, D), { bottom: no, top: ro } = Eo(Y, S, E, oo), io = Ho(I / ht), fn = io * je + (io - 1) * Ee - no;
+            return { bottom: no, itemHeight: je, items: oo, itemWidth: ye, offsetBottom: fn, offsetTop: ro, top: ro };
+          }
+        )
+      ),
+      R
+    ), W(
+      v(
+        L,
+        N((I) => I !== null),
+        z((I) => I.length)
+      ),
+      d
+    ), W(
+      v(
+        ae(B, M, R, P),
+        N(([I, G, { items: te }]) => te.length > 0 && G.height !== 0 && I.height !== 0),
+        z(([I, G, { items: te }, S]) => {
+          const { bottom: E, top: Y } = Eo(I, S, G, te);
+          return [Y, E];
+        }),
+        re(lt)
+      ),
+      t
+    );
+    const Ie = b(!1);
+    W(
+      v(
+        u,
+        $(Ie),
+        z(([I, G]) => G || I !== 0)
+      ),
+      Ie
+    );
+    const Le = He(
+      v(
+        ae(R, d),
+        N(([{ items: I }]) => I.length > 0),
+        $(Ie),
+        N(([[I, G], te]) => {
+          const S = I.items[I.items.length - 1].index === G - 1;
+          return (te || I.bottom > 0 && I.itemHeight > 0 && I.offsetBottom === 0 && I.items.length === G) && S;
+        }),
+        z(([[, I]]) => I - 1),
+        re()
+      )
+    ), De = He(
+      v(
+        A(R),
+        N(({ items: I }) => I.length > 0 && I[0].index === 0),
+        We(0),
+        re()
+      )
+    ), Se = He(
+      v(
+        A(R),
+        $(we),
+        N(([{ items: I }, G]) => I.length > 0 && !G),
+        z(([{ items: I }]) => ({
+          endIndex: I[I.length - 1].index,
+          startIndex: I[0].index
+        })),
+        re(Vo),
+        Pe(0)
+      )
+    );
+    W(Se, p.scrollSeekRangeChanged), W(
+      v(
+        O,
+        $(B, M, d, P),
+        z(([I, G, te, S, E]) => {
+          const Y = Uo(I), { align: D, behavior: q, offset: oe } = Y;
+          let X = Y.index;
+          X === "LAST" && (X = S - 1), X = rt(0, X, Ot(S - 1, X));
+          let fe = Ft(G, E, te, X);
+          return D === "end" ? fe = ko(fe - G.height + te.height) : D === "center" && (fe = ko(fe - G.height / 2 + te.height / 2)), oe && (fe += oe), { behavior: q, top: fe };
+        })
+      ),
+      c
+    );
+    const ce = pe(
+      v(
+        R,
+        z((I) => I.offsetBottom + I.bottom)
+      ),
+      0
+    );
+    return W(
+      v(
+        _,
+        z((I) => ({ height: I.visibleHeight, width: I.visibleWidth }))
+      ),
+      B
+    ), {
+      customScrollParent: x,
+      // input
+      data: L,
+      deviation: Q,
+      footerHeight: r,
+      gap: P,
+      headerHeight: i,
+      increaseViewportBy: e,
+      initialItemCount: w,
+      itemDimensions: M,
+      overscan: o,
+      restoreStateFrom: ve,
+      scrollBy: s,
+      scrollContainerState: l,
+      scrollHeight: U,
+      scrollTo: c,
+      scrollToIndex: O,
+      scrollTop: u,
+      smoothScrollTargetReached: h,
+      totalCount: d,
+      useWindowScroll: f,
+      viewportDimensions: B,
+      windowScrollContainerState: m,
+      windowScrollTo: C,
+      windowViewportRect: _,
+      ...p,
+      // output
+      gridState: R,
+      horizontalDirection: Ne,
+      initialTopMostItemIndex: Ce,
+      totalListHeight: ce,
+      ...g,
+      endReached: Le,
+      propsReady: y,
+      rangeChanged: Se,
+      startReached: De,
+      stateChanged: ue,
+      stateRestoreInProgress: we,
+      ...a
+    };
+  },
+  ie(Jt, xe, ft, Qo, $e, Qt, Fe)
+);
+function dn(e, t, o) {
+  return rt(1, bt((e + o) / (bt(t) + o)));
+}
+function Eo(e, t, o, n) {
+  const { height: r } = o;
+  if (r === void 0 || n.length === 0)
+    return { bottom: 0, top: 0 };
+  const i = Ft(e, t, o, n[0].index);
+  return { bottom: Ft(e, t, o, n[n.length - 1].index) + r, top: i };
+}
+function Ft(e, t, o, n) {
+  const r = dn(e.width, o.width, t.column), i = bt(n / r), s = i * o.height + rt(0, i - 1) * t.row;
+  return s > 0 ? s + t.row : s;
+}
+const Dr = /* @__PURE__ */ J(() => {
+  const e = b((T) => `Item ${T}`), t = b({}), o = b(null), n = b("virtuoso-grid-item"), r = b("virtuoso-grid-list"), i = b(ln), s = b("div"), l = b(ut), c = (T, g = null) => pe(
+    v(
+      t,
+      z((p) => p[T]),
+      re()
+    ),
+    g
+  ), u = b(!1), h = b(!1);
+  return W(A(h), u), {
+    components: t,
+    computeItemKey: i,
+    context: o,
+    FooterComponent: c("Footer"),
+    HeaderComponent: c("Header"),
+    headerFooterTag: s,
+    itemClassName: n,
+    ItemComponent: c("Item", "div"),
+    itemContent: e,
+    listClassName: r,
+    ListComponent: c("List", "div"),
+    readyStateChanged: u,
+    reportReadyState: h,
+    ScrollerComponent: c("Scroller", "div"),
+    scrollerRef: l,
+    ScrollSeekPlaceholder: c("ScrollSeekPlaceholder", "div")
+  };
+}), Vr = /* @__PURE__ */ J(
+  ([e, t]) => ({ ...e, ...t }),
+  ie(Pr, Dr)
+), Gr = /* @__PURE__ */ j.memo(function() {
+  const e = ne("gridState"), t = ne("listClassName"), o = ne("itemClassName"), n = ne("itemContent"), r = ne("computeItemKey"), i = ne("isSeeking"), s = Re("scrollHeight"), l = ne("ItemComponent"), c = ne("ListComponent"), u = ne("ScrollSeekPlaceholder"), h = ne("context"), T = Re("itemDimensions"), g = Re("gap"), p = ne("log"), H = ne("stateRestoreInProgress"), y = Re("reportReadyState"), x = Ye(
+    j.useMemo(
+      () => (f) => {
+        const m = f.parentElement.parentElement.scrollHeight;
+        s(m);
+        const C = f.firstChild;
+        if (C) {
+          const { height: _, width: a } = C.getBoundingClientRect();
+          T({ height: _, width: a });
+        }
+        g({
+          column: zo("column-gap", getComputedStyle(f).columnGap, p),
+          row: zo("row-gap", getComputedStyle(f).rowGap, p)
+        });
+      },
+      [s, T, g, p]
+    ),
+    !0,
+    !1
+  );
+  return rn(() => {
+    e.itemHeight > 0 && e.itemWidth > 0 && y(!0);
+  }, [e]), H ? null : /* @__PURE__ */ k.jsx(
+    c,
+    {
+      className: t,
+      ref: x,
+      ...ge(c, h),
+      "data-testid": "virtuoso-item-list",
+      style: { paddingBottom: e.offsetBottom, paddingTop: e.offsetTop },
+      children: e.items.map((f) => {
+        const m = r(f.index, f.data, h);
+        return i ? /* @__PURE__ */ k.jsx(
+          u,
+          {
+            ...ge(u, h),
+            height: e.itemHeight,
+            index: f.index,
+            width: e.itemWidth
+          },
+          m
+        ) : /* @__PURE__ */ It(
+          l,
+          {
+            ...ge(l, h),
+            className: o,
+            "data-index": f.index,
+            key: m
+          },
+          n(f.index, f.data, h)
+        );
+      })
+    }
+  );
+}), Fr = j.memo(function() {
+  const e = ne("HeaderComponent"), t = Re("headerHeight"), o = ne("headerFooterTag"), n = Ye(
+    j.useMemo(
+      () => (i) => {
+        t(Ve(i, "height"));
+      },
+      [t]
+    ),
+    !0,
+    !1
+  ), r = ne("context");
+  return e ? /* @__PURE__ */ k.jsx(o, { ref: n, children: /* @__PURE__ */ k.jsx(e, { ...ge(e, r) }) }) : null;
+}), $r = j.memo(function() {
+  const e = ne("FooterComponent"), t = Re("footerHeight"), o = ne("headerFooterTag"), n = Ye(
+    j.useMemo(
+      () => (i) => {
+        t(Ve(i, "height"));
+      },
+      [t]
+    ),
+    !0,
+    !1
+  ), r = ne("context");
+  return e ? /* @__PURE__ */ k.jsx(o, { ref: n, children: /* @__PURE__ */ k.jsx(e, { ...ge(e, r) }) }) : null;
+}), qr = ({ children: e }) => {
+  const t = j.useContext(nn), o = Re("itemDimensions"), n = Re("viewportDimensions"), r = Ye(
+    j.useMemo(
+      () => (i) => {
+        n(i.getBoundingClientRect());
+      },
+      [n]
+    ),
+    !0,
+    !1
+  );
+  return j.useEffect(() => {
+    t && (n({ height: t.viewportHeight, width: t.viewportWidth }), o({ height: t.itemHeight, width: t.itemWidth }));
+  }, [t, n, o]), /* @__PURE__ */ k.jsx("div", { ref: r, style: zt(!1), children: e });
+}, Ur = ({ children: e }) => {
+  const t = j.useContext(nn), o = Re("windowViewportRect"), n = Re("itemDimensions"), r = ne("customScrollParent"), i = Wo(o, r, !1);
+  return j.useEffect(() => {
+    t && (n({ height: t.itemHeight, width: t.itemWidth }), o({ offsetTop: 0, visibleHeight: t.viewportHeight, visibleWidth: t.viewportWidth }));
+  }, [t, o, n]), /* @__PURE__ */ k.jsx("div", { ref: i, style: zt(!1), children: e });
+}, Kr = /* @__PURE__ */ j.memo(function({ ...e }) {
+  const t = ne("useWindowScroll"), o = ne("customScrollParent"), n = o || t ? Xr : Yr, r = o || t ? Ur : qr, i = ne("context");
+  return /* @__PURE__ */ k.jsx(n, { ...e, ...ge(n, i), children: /* @__PURE__ */ k.jsxs(r, { children: [
+    /* @__PURE__ */ k.jsx(Fr, {}),
+    /* @__PURE__ */ k.jsx(Gr, {}),
+    /* @__PURE__ */ k.jsx($r, {})
+  ] }) });
+}), {
+  Component: is,
+  useEmitter: mn,
+  useEmitterValue: ne,
+  usePublisher: Re
+} = /* @__PURE__ */ tn(
+  Vr,
+  {
+    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"
+    }
+  },
+  Kr
+), Yr = /* @__PURE__ */ an({ useEmitter: mn, useEmitterValue: ne, usePublisher: Re }), Xr = /* @__PURE__ */ un({ useEmitter: mn, useEmitterValue: ne, usePublisher: Re });
+function zo(e, t, o) {
+  return t !== "normal" && !(t != null && t.endsWith("px")) && o(`${e} was not resolved to pixel value correctly`, t, Te.WARN), t === "normal" ? 0 : parseInt(t ?? "0", 10);
+}
+const Zr = "_realTimeLogModalStyle_1f0fd_2", Jr = "_customHeader_1f0fd_10", Qr = "_modalHeader_1f0fd_18", ei = "_modalLeft_1f0fd_38", ti = "_buttonGroup_1f0fd_45", oi = "_iosIcon_1f0fd_56", ni = "_modalLoader_1f0fd_86", ri = "_dash_1f0fd_90", ii = "_searchWrapper_1f0fd_95", si = "_chevronIcons_1f0fd_101", li = "_logInput_1f0fd_123", ci = "_searchResult_1f0fd_130", ai = "_loadingWrap_1f0fd_140", ui = "_modalRight_1f0fd_151", di = "_inputsWrapper_1f0fd_155", mi = "_search_1f0fd_95", fi = "_cliCommand_1f0fd_172", hi = "_buttonsWrapper_1f0fd_198", gi = "_downloadIconBtn_1f0fd_204", pi = "_downloadIconBtn__disabled_1f0fd_228", xi = "_copyIconBtn_1f0fd_238", vi = "_copyIconBtn__disabled_1f0fd_262", Ii = "_iconGroup_1f0fd_272", Ti = "_activeIcon_1f0fd_284", se = {
+  realTimeLogModalStyle: Zr,
+  customHeader: Jr,
+  modalHeader: Qr,
+  modalLeft: ei,
+  buttonGroup: ti,
+  iosIcon: oi,
+  modalLoader: ni,
+  dash: ri,
+  searchWrapper: ii,
+  chevronIcons: si,
+  logInput: li,
+  searchResult: ci,
+  loadingWrap: ai,
+  modalRight: ui,
+  inputsWrapper: di,
+  search: mi,
+  cliCommand: fi,
+  buttonsWrapper: hi,
+  downloadIconBtn: gi,
+  downloadIconBtn__disabled: pi,
+  copyIconBtn: xi,
+  copyIconBtn__disabled: vi,
+  iconGroup: Ii,
+  activeIcon: Ti
+}, ss = {
+  status: (e) => ({
+    title: Je.t("label.status"),
+    dataIndex: "status",
+    className: "capitalize",
+    render: (t) => /* @__PURE__ */ k.jsx(bn, { status: e[t], text: t })
+  }),
+  dateCreated: {
+    title: Je.t("label.date_created"),
+    dataIndex: "created_date",
+    render: (e) => /* @__PURE__ */ k.jsx(In, { date: e })
+  }
+}, ls = {
+  edit: (e, t) => ({
+    title: Je.t("label.edit"),
+    dataIndex: e,
+    render: (o, n) => /* @__PURE__ */ k.jsx(pt, { icon: Qe.Edit, onClick: () => t(o, n) })
+  }),
+  delete: (e, t) => ({
+    title: Je.t("label.delete"),
+    dataIndex: e,
+    render: (o, n) => /* @__PURE__ */ k.jsx(pt, { icon: Qe.Trash, onClick: () => t(o, n) })
+  }),
+  download: (e, t) => ({
+    title: Je.t("label.export"),
+    dataIndex: e,
+    render: (o, n) => /* @__PURE__ */ k.jsx(pt, { icon: Qe.Download, onClick: () => t(o, n) })
+  }),
+  detail: (e, t) => ({
+    title: Je.t("label.detail"),
+    dataIndex: e,
+    render: (o, n) => /* @__PURE__ */ k.jsx(pt, { icon: Qe.Link, onClick: () => t(o, n) })
+  })
+};
+var wi = { BASE_URL: "/", MODE: "production", DEV: !1, PROD: !0, SSR: !1 };
+const _o = Number(
+  wi.VITE_APP_LOKI_REALTIME_LOG_RESPONSE_MIN_LINE_LIMIT
+), Bo = 200, Ci = 100, Si = (e) => {
+  const {
+    onClose: t,
+    projectPk: o,
+    interval: n,
+    appPk: r,
+    logTypes: i,
+    logs: s,
+    responseCount: l,
+    lastLogIndex: c = 0,
+    download: u,
+    onFetchLogs: h,
+    onClearLogs: T,
+    withoutPermission: g
+  } = e, p = _t(null), [, H] = Tn(e.id), [y, x] = ot(!1), [f, m] = ot(), [C, _] = ot(""), [a, d] = ot(), [w, R] = ot(0), B = s || [], M = l === void 0, O = (S, E, Y, D) => {
+    const q = {
+      applications: [E || i[0].value],
+      scroll_mode: S || void 0
+    };
+    h({ projectPk: o, appPk: r, applications: q.applications, scroll_mode: q.scroll_mode, withoutPermission: g }).then(
+      (oe) => {
+        if (Object.prototype.hasOwnProperty.call(oe, "error")) {
+          D && D();
+          return;
+        }
+        Y && Y();
+      }
+    );
+  };
+  function U(S) {
+    let E = 0;
+    const Y = {};
+    return S.forEach((D, q) => {
+      const oe = D.message.match(/<mark\b[^>]*>/g);
+      E += oe ? oe.length : 0, oe && (Y[q] = oe);
+    }), { total: E, filteredLogs: Y };
+  }
+  const Q = pn(O, n * 1e3), L = _t(), P = _t(Q), ue = (S, E, Y, D) => {
+    if (!E || E.length < 1)
+      return S;
+    let q = S;
+    if (D.group)
+      if (D.regex) {
+        let X;
+        try {
+          X = new RegExp(
+            E,
+            D.caseSensitive ? "g" : "gi"
+          );
+        } catch {
+          return S;
+        }
+        q = S.filter((fe) => X.test(fe.message));
+      } else
+        D.caseSensitive ? q = S.filter(
+          (X) => X.message.includes(E)
+        ) : q = S.filter(
+          (X) => X.message.toLocaleLowerCase().includes(E.toLocaleLowerCase())
+        );
+    return q.map((X, fe) => ({
+      ...X,
+      message: ve(X.message, E, D, fe) + `
+`
+    }));
+  }, ve = (S, E, Y, D) => {
+    if (!E)
+      return S;
+    try {
+      if (Y.regex) {
+        let q;
+        const oe = E.match(/^\/(.+)\/([gimsuy]*)$/);
+        return oe ? q = new RegExp(oe[1], oe[2]) : q = new RegExp(
+          E,
+          Y.caseSensitive ? "g" : "gi"
+        ), S.replace(
+          q,
+          (X) => `<mark data-mark-index="${D}">${X}</mark>`
+        );
+      } else {
+        if (Y.caseSensitive)
+          return S.split(E).join(`<mark data-mark-index="${D}">${E}</mark>`);
+        {
+          const q = new RegExp(E, "gi");
+          return S.replace(
+            q,
+            (oe) => `<mark data-mark-index="${D}">${oe}</mark>`
+          );
+        }
+      }
+    } catch {
+      return S;
+    }
+  }, we = () => {
+    _("");
+  }, Ce = () => {
+    x(!y);
+  }, he = () => {
+    let S = "";
+    B.forEach((E) => {
+      S += E.message;
+    }), yn({
+      type: Sn.SUCCESS,
+      message: gt("text.copied"),
+      closeTime: 3e3
+    }), navigator.clipboard.writeText(S);
+  }, de = (S, E) => {
+    S.currentTarget.classList.toggle(se.activeIcon), d({
+      ...a,
+      [E]: !(a != null && a[E])
+    });
+  }, Ne = (S) => {
+    var E, Y;
+    m(S), clearTimeout(L.current), (E = P.current) == null || E.stopInterval(), (Y = P.current) == null || Y.fetch(void 0, S), Bt(() => {
+      var D;
+      (D = p.current) == null || D.scrollToIndex({ index: "LAST" });
+    }, 300)();
+  }, Ie = (S) => {
+    S.classList.add(se.selectedMark);
+  }, Le = (S) => {
+    Array.from(S).forEach(
+      (E) => E.classList.remove(se.selectedMark)
+    );
+  }, De = (S, E, Y) => {
+    var oe;
+    let D = S - 1;
+    D < 1 && (D = E), R(D);
+    let q = 0;
+    for (const X in Y) {
+      const fe = Y[X];
+      if (q + fe.length >= D) {
+        const Ee = D - q - 1;
+        (oe = p.current) == null || oe.scrollToIndex({ index: Number(X) });
+        const je = document.querySelector(
+          `[data-index="${Number(X) + 1}"]`
+        );
+        if (je) {
+          const ye = je.getElementsByTagName("mark");
+          Le(ye);
+        }
+        Bt(() => {
+          const ye = document.querySelector(
+            `[data-index="${X}"]`
+          );
+          if (ye) {
+            const Me = ye.getElementsByTagName("mark");
+            Me[Ee] && (Le(Me), Ie(Me[Ee]));
+          }
+        }, 300)();
+        break;
+      } else
+        q += fe.length;
+    }
+  }, Se = (S, E, Y) => {
+    var oe;
+    let D = S + 1;
+    D > E && (D = 1), R(D);
+    let q = 0;
+    for (const X in Y) {
+      const fe = Y[X];
+      if (q + fe.length >= D) {
+        const Ee = D - q - 1;
+        (oe = p.current) == null || oe.scrollToIndex({ index: Number(X) });
+        const je = document.querySelector(
+          `[data-index="${Number(X) - 1}"]`
+        );
+        if (je) {
+          const ye = je.getElementsByTagName("mark");
+          Le(ye);
+        }
+        Bt(() => {
+          const ye = document.querySelector(
+            `[data-index="${X}"]`
+          );
+          if (ye) {
+            const Me = ye.getElementsByTagName("mark");
+            Me[Ee] && (Le(Me), Ie(Me[Ee]));
+          }
+        }, 300)();
+        break;
+      } else
+        q += fe.length;
+    }
+  }, ce = ue(B, C, P, {
+    regex: a == null ? void 0 : a.regex,
+    caseSensitive: a == null ? void 0 : a.caseSensitive,
+    group: a == null ? void 0 : a.group
+  }), I = U(ce), G = (S) => {
+    S.key === "Enter" && Se(
+      w,
+      I.total,
+      I.filteredLogs
+    );
+  }, te = (S, E) => /* @__PURE__ */ k.jsx(
+    "div",
+    {
+      "data-index": S,
+      dangerouslySetInnerHTML: { __html: E.message }
+    }
+  );
+  return lo(() => {
+    var S, E;
+    return (S = P.current) == null || S.fetch(void 0, f), (E = P.current) == null || E.startInterval("newer", f), () => {
+      clearTimeout(L.current), P.current.stopInterval(), T();
+    };
+  }, []), lo(() => (window.removeEventListener("keydown", G), window.addEventListener("keydown", G), () => {
+    window.removeEventListener("keydown", G);
+  }), [w, I.total, I.filteredLogs]), /* @__PURE__ */ k.jsx(
+    wn,
+    {
+      visible: !0,
+      showClose: !1,
+      onClose: () => {
+      },
+      className: Lt(se.realTimeLogModalStyle, {
+        "w-[90%]!": !y,
+        "w-full! h-full!": y
+      }),
+      headerClass: se.customHeader,
+      header: /* @__PURE__ */ k.jsxs("div", { className: se.modalHeader, children: [
+        /* @__PURE__ */ k.jsxs("div", { className: se.modalLeft, children: [
+          /* @__PURE__ */ k.jsxs("div", { className: se.buttonGroup, children: [
+            /* @__PURE__ */ k.jsx(
+              "div",
+              {
+                className: se.iosIcon,
+                onClick: () => {
+                  t && t(), H();
+                },
+                children: /* @__PURE__ */ k.jsx(ze, { name: "close-window" })
+              }
+            ),
+            /* @__PURE__ */ k.jsx("div", { className: se.iosIcon, onClick: Ce, children: /* @__PURE__ */ k.jsx(ze, { name: "expand-window" }) })
+          ] }),
+          /* @__PURE__ */ k.jsx("div", { children: /* @__PURE__ */ k.jsx(
+            Cn,
+            {
+              name: "logTypeSelect",
+              style: { height: 39 },
+              wrapperClassName: se.logSelect,
+              value: f,
+              items: i,
+              searchable: !1,
+              placeholder: `${gt("placeholder.selected_log_type")}: ${i[0].label}`,
+              itemPrefix: `${gt("placeholder.selected_log_type")}: `,
+              onChange: (S) => {
+                Ne(S);
+              }
+            }
+          ) }),
+          /* @__PURE__ */ k.jsxs("div", { className: se.searchWrapper, children: [
+            /* @__PURE__ */ k.jsx(
+              vn,
+              {
+                name: "logSearch",
+                type: "text",
+                placeholder: gt("placeholder.search"),
+                isFormGroup: !1,
+                value: C,
+                className: se.logInput,
+                prefixClickable: !0,
+                suffixClickable: !0,
+                onChange: (S) => {
+                  var E;
+                  _(S.target.value), S.target.value.length > 1 && ((E = P.current) == null || E.stopInterval()), R(0);
+                },
+                prefix: /* @__PURE__ */ k.jsxs("div", { className: se.iconGroup, children: [
+                  /* @__PURE__ */ k.jsx(
+                    ze,
+                    {
+                      name: "group",
+                      onClick: (S) => {
+                        de(S, "group");
+                      }
+                    }
+                  ),
+                  /* @__PURE__ */ k.jsx(
+                    ze,
+                    {
+                      name: "case-sensitive",
+                      onClick: (S) => {
+                        de(S, "caseSensitive");
+                      }
+                    }
+                  ),
+                  /* @__PURE__ */ k.jsx(
+                    ze,
+                    {
+                      name: "regex",
+                      onClick: (S) => {
+                        de(S, "regex");
+                      }
+                    }
+                  )
+                ] }),
+                suffix: C.length > 0 ? /* @__PURE__ */ k.jsx("div", { children: /* @__PURE__ */ k.jsx(ze, { onClick: we, name: "close" }) }) : /* @__PURE__ */ k.jsx("div", { children: /* @__PURE__ */ k.jsx(ze, { name: "search" }) })
+              }
+            ),
+            /* @__PURE__ */ k.jsxs("div", { className: se.searchResult, children: [
+              C.length > 0 ? w : 0,
+              /* @__PURE__ */ k.jsxs("span", { children: [
+                "/",
+                C.length > 0 ? I.total : 0
+              ] })
+            ] }),
+            /* @__PURE__ */ k.jsxs("div", { className: se.chevronIcons, children: [
+              /* @__PURE__ */ k.jsx(
+                ze,
+                {
+                  name: "chevron-left",
+                  onClick: () => {
+                    Se(
+                      w,
+                      I.total,
+                      I.filteredLogs
+                    );
+                  }
+                }
+              ),
+              /* @__PURE__ */ k.jsx(
+                ze,
+                {
+                  name: "chevron-left",
+                  onClick: () => {
+                    De(
+                      w,
+                      I.total,
+                      I.filteredLogs
+                    );
+                  }
+                }
+              )
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ k.jsx("div", { className: se.modalRight, children: /* @__PURE__ */ k.jsxs("div", { className: se.buttonsWrapper, children: [
+          /* @__PURE__ */ k.jsx(
+            uo,
+            {
+              appearance: ao.PRIMARY,
+              className: Lt(se.downloadIconBtn, {
+                [se.downloadIconBtn__disabled]: B.length === 0
+              }),
+              onClick: () => {
+                var S;
+                return u(
+                  {
+                    applications: [
+                      f || i[0].value
+                    ],
+                    start_datetime: co(
+                      (S = B == null ? void 0 : B[0]) == null ? void 0 : S.log_timestamp
+                    ).format(),
+                    end_datetime: co().format()
+                  },
+                  !0
+                );
+              },
+              children: /* @__PURE__ */ k.jsx(ze, { name: Qe.Download })
+            }
+          ),
+          /* @__PURE__ */ k.jsx(
+            uo,
+            {
+              appearance: ao.PRIMARY,
+              className: Lt(se.copyIconBtn, {
+                [se.copyIconBtn__disabled]: B.length === 0
+              }),
+              onClick: he,
+              children: /* @__PURE__ */ k.jsx(ze, { name: Qe.Copy })
+            }
+          )
+        ] }) })
+      ] }),
+      children: /* @__PURE__ */ k.jsx(
+        Wr,
+        {
+          ref: p,
+          style: {
+            overflow: "auto",
+            height: y ? "100%" : "500px"
+          },
+          data: ce,
+          initialTopMostItemIndex: ce.length - 1 || 0,
+          totalCount: ce.length,
+          itemContent: te,
+          onScroll: (S) => {
+            S.currentTarget.scrollHeight - S.currentTarget.scrollTop <= S.currentTarget.clientHeight + Bo || P.current.stopInterval();
+          },
+          atTopThreshold: Ci,
+          atTopStateChange: (S) => {
+            var D;
+            if (C.length > 0 || M)
+              return;
+            const E = () => ce.length - c < 30 || c === 0 ? 10 : c, Y = () => {
+              var q;
+              (q = p.current) == null || q.scrollToIndex({
+                index: E()
+              });
+            };
+            S && !M && ((D = P.current) == null || D.fetch(
+              "older",
+              f,
+              Y
+            ));
+          },
+          atBottomThreshold: Bo,
+          atBottomStateChange: (S) => {
+            if (ce.length <= 0 || C.length > 0 || M)
+              return;
+            const E = () => {
+              var D, q;
+              if (console.log("onNewerSuccess ,first", ce.length), (D = p.current) == null || D.scrollToIndex({
+                index: ce.length - 50
+              }), l < _o) {
+                P.current.stopInterval(), console.log(
+                  "onNewerSuccess minLineLimit",
+                  l,
+                  _o
+                ), (q = p.current) == null || q.scrollToIndex({
+                  index: ce.length - 1
+                }), P.current.startInterval("newer", f);
+                return;
+              }
+            }, Y = () => {
+              var D;
+              console.log("Error fetching newer logs"), P.current.stopInterval(), (D = p.current) == null || D.scrollToIndex({
+                index: ce.length - 10
+              }), P.current.startInterval("newer", f);
+            };
+            S && P.current.fetch(
+              "newer",
+              f,
+              E,
+              Y
+            );
+          }
+        }
+      )
+    }
+  );
+}, cs = xn.create(Si);
+export {
+  cs as R,
+  ls as T,
+  ss as a
+};