@autoai-ui/autoui 0.0.28

package/dist/index.mjs

@@ -0,0 +1,4074 @@
+import P, { forwardRef as yn, useMemo as Po, createContext as Bo, useContext as Ao, useState as Ct, createElement as wt, useRef as $t, useEffect as Tt, useCallback as Ne, memo as _o, lazy as Cn } from "react";
+import Rn, { createPortal as En } from "react-dom";
+var gt = { exports: {} }, et = {};
+var co;
+function kn() {
+  if (co) return et;
+  co = 1;
+  var e = Symbol.for("react.transitional.element"), t = Symbol.for("react.fragment");
+  function o(n, r, s) {
+    var i = null;
+    if (s !== void 0 && (i = "" + s), r.key !== void 0 && (i = "" + r.key), "key" in r) {
+      s = {};
+      for (var l in r)
+        l !== "key" && (s[l] = r[l]);
+    } else s = r;
+    return r = s.ref, {
+      $$typeof: e,
+      type: n,
+      key: i,
+      ref: r !== void 0 ? r : null,
+      props: s
+    };
+  }
+  return et.Fragment = t, et.jsx = o, et.jsxs = o, et;
+}
+var tt = {};
+var uo;
+function zn() {
+  return uo || (uo = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(h) {
+      if (h == null) return null;
+      if (typeof h == "function")
+        return h.$$typeof === A ? null : h.displayName || h.name || null;
+      if (typeof h == "string") return h;
+      switch (h) {
+        case g:
+          return "Fragment";
+        case f:
+          return "Profiler";
+        case d:
+          return "StrictMode";
+        case H:
+          return "Suspense";
+        case u:
+          return "SuspenseList";
+        case z:
+          return "Activity";
+      }
+      if (typeof h == "object")
+        switch (typeof h.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), h.$$typeof) {
+          case E:
+            return "Portal";
+          case O:
+            return h.displayName || "Context";
+          case I:
+            return (h._context.displayName || "Context") + ".Consumer";
+          case k:
+            var M = h.render;
+            return h = h.displayName, h || (h = M.displayName || M.name || "", h = h !== "" ? "ForwardRef(" + h + ")" : "ForwardRef"), h;
+          case v:
+            return M = h.displayName || null, M !== null ? M : e(h.type) || "Memo";
+          case y:
+            M = h._payload, h = h._init;
+            try {
+              return e(h(M));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function t(h) {
+      return "" + h;
+    }
+    function o(h) {
+      try {
+        t(h);
+        var M = !1;
+      } catch {
+        M = !0;
+      }
+      if (M) {
+        M = console;
+        var q = M.error, Q = typeof Symbol == "function" && Symbol.toStringTag && h[Symbol.toStringTag] || h.constructor.name || "Object";
+        return q.call(
+          M,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          Q
+        ), t(h);
+      }
+    }
+    function n(h) {
+      if (h === g) return "<>";
+      if (typeof h == "object" && h !== null && h.$$typeof === y)
+        return "<...>";
+      try {
+        var M = e(h);
+        return M ? "<" + M + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function r() {
+      var h = F.A;
+      return h === null ? null : h.getOwner();
+    }
+    function s() {
+      return Error("react-stack-top-frame");
+    }
+    function i(h) {
+      if (D.call(h, "key")) {
+        var M = Object.getOwnPropertyDescriptor(h, "key").get;
+        if (M && M.isReactWarning) return !1;
+      }
+      return h.key !== void 0;
+    }
+    function l(h, M) {
+      function q() {
+        X || (X = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          M
+        ));
+      }
+      q.isReactWarning = !0, Object.defineProperty(h, "key", {
+        get: q,
+        configurable: !0
+      });
+    }
+    function a() {
+      var h = e(this.type);
+      return K[h] || (K[h] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), h = this.props.ref, h !== void 0 ? h : null;
+    }
+    function c(h, M, q, Q, Pe, Be) {
+      var ee = q.ref;
+      return h = {
+        $$typeof: b,
+        type: h,
+        key: M,
+        props: q,
+        _owner: Q
+      }, (ee !== void 0 ? ee : null) !== null ? Object.defineProperty(h, "ref", {
+        enumerable: !1,
+        get: a
+      }) : Object.defineProperty(h, "ref", { enumerable: !1, value: null }), h._store = {}, Object.defineProperty(h._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(h, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(h, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: Pe
+      }), Object.defineProperty(h, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: Be
+      }), Object.freeze && (Object.freeze(h.props), Object.freeze(h)), h;
+    }
+    function m(h, M, q, Q, Pe, Be) {
+      var ee = M.children;
+      if (ee !== void 0)
+        if (Q)
+          if (_(ee)) {
+            for (Q = 0; Q < ee.length; Q++)
+              T(ee[Q]);
+            Object.freeze && Object.freeze(ee);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else T(ee);
+      if (D.call(M, "key")) {
+        ee = e(h);
+        var R = Object.keys(M).filter(function(ne) {
+          return ne !== "key";
+        });
+        Q = 0 < R.length ? "{key: someKey, " + R.join(": ..., ") + ": ...}" : "{key: someKey}", Te[ee + Q] || (R = 0 < R.length ? "{" + R.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          Q,
+          ee,
+          R,
+          ee
+        ), Te[ee + Q] = !0);
+      }
+      if (ee = null, q !== void 0 && (o(q), ee = "" + q), i(M) && (o(M.key), ee = "" + M.key), "key" in M) {
+        q = {};
+        for (var G in M)
+          G !== "key" && (q[G] = M[G]);
+      } else q = M;
+      return ee && l(
+        q,
+        typeof h == "function" ? h.displayName || h.name || "Unknown" : h
+      ), c(
+        h,
+        ee,
+        q,
+        r(),
+        Pe,
+        Be
+      );
+    }
+    function T(h) {
+      p(h) ? h._store && (h._store.validated = 1) : typeof h == "object" && h !== null && h.$$typeof === y && (h._payload.status === "fulfilled" ? p(h._payload.value) && h._payload.value._store && (h._payload.value._store.validated = 1) : h._store && (h._store.validated = 1));
+    }
+    function p(h) {
+      return typeof h == "object" && h !== null && h.$$typeof === b;
+    }
+    var x = P, b = Symbol.for("react.transitional.element"), E = Symbol.for("react.portal"), g = Symbol.for("react.fragment"), d = Symbol.for("react.strict_mode"), f = Symbol.for("react.profiler"), I = Symbol.for("react.consumer"), O = Symbol.for("react.context"), k = Symbol.for("react.forward_ref"), H = Symbol.for("react.suspense"), u = Symbol.for("react.suspense_list"), v = Symbol.for("react.memo"), y = Symbol.for("react.lazy"), z = Symbol.for("react.activity"), A = Symbol.for("react.client.reference"), F = x.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, D = Object.prototype.hasOwnProperty, _ = Array.isArray, V = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    x = {
+      react_stack_bottom_frame: function(h) {
+        return h();
+      }
+    };
+    var X, K = {}, ve = x.react_stack_bottom_frame.bind(
+      x,
+      s
+    )(), we = V(n(s)), Te = {};
+    tt.Fragment = g, tt.jsx = function(h, M, q) {
+      var Q = 1e4 > F.recentlyCreatedOwnerStacks++;
+      return m(
+        h,
+        M,
+        q,
+        !1,
+        Q ? Error("react-stack-top-frame") : ve,
+        Q ? V(n(h)) : we
+      );
+    }, tt.jsxs = function(h, M, q) {
+      var Q = 1e4 > F.recentlyCreatedOwnerStacks++;
+      return m(
+        h,
+        M,
+        q,
+        !0,
+        Q ? Error("react-stack-top-frame") : ve,
+        Q ? V(n(h)) : we
+      );
+    };
+  })()), tt;
+}
+var fo;
+function jn() {
+  return fo || (fo = 1, process.env.NODE_ENV === "production" ? gt.exports = kn() : gt.exports = zn()), gt.exports;
+}
+var C = jn();
+function Mo(e) {
+  var t, o, n = "";
+  if (typeof e == "string" || typeof e == "number") n += e;
+  else if (typeof e == "object") if (Array.isArray(e)) {
+    var r = e.length;
+    for (t = 0; t < r; t++) e[t] && (o = Mo(e[t])) && (n && (n += " "), n += o);
+  } else for (o in e) e[o] && (n && (n += " "), n += o);
+  return n;
+}
+function xe() {
+  for (var e, t, o = 0, n = "", r = arguments.length; o < r; o++) (e = arguments[o]) && (t = Mo(e)) && (n && (n += " "), n += t);
+  return n;
+}
+const On = yn(
+  ({ variant: e = "default", label: t, className: o, classNames: n = {}, ...r }, s) => {
+    const i = xe("inline-flex flex-col items-center justify-center", o), l = Po(() => {
+      switch (e) {
+        case "wave":
+        case "dots":
+          return /* @__PURE__ */ C.jsx("div", { className: xe("flex gap-1", n.wrapper), children: [...Array(3)].map((a, c) => /* @__PURE__ */ C.jsx(
+            "i",
+            {
+              className: xe("block w-2 h-2 bg-current rounded-full animate-bounce", n.dots),
+              style: {
+                animationDelay: `${c * 0.2}s`
+              }
+            },
+            c
+          )) });
+        case "simple":
+          return /* @__PURE__ */ C.jsxs(
+            "svg",
+            {
+              className: xe("animate-spin text-current", n.wrapper),
+              width: "24",
+              height: "24",
+              fill: "none",
+              viewBox: "0 0 24 24",
+              children: [
+                /* @__PURE__ */ C.jsx(
+                  "circle",
+                  {
+                    className: xe("opacity-25", n.circle1),
+                    cx: "12",
+                    cy: "12",
+                    r: "10",
+                    stroke: "currentColor",
+                    strokeWidth: "4"
+                  }
+                ),
+                /* @__PURE__ */ C.jsx(
+                  "path",
+                  {
+                    className: xe("opacity-75", n.circle2),
+                    fill: "currentColor",
+                    d: "M4 12a8 8 0 018-8V0C5.37 0 0 5.37 0 12h4z"
+                  }
+                )
+              ]
+            }
+          );
+        case "spinner":
+          return /* @__PURE__ */ C.jsx("div", { className: xe("relative w-6 h-6", n.wrapper), children: [...Array(12)].map((a, c) => /* @__PURE__ */ C.jsx(
+            "i",
+            {
+              className: xe(
+                "absolute left-1/2 top-1/2 w-0.5 h-1.5 bg-current origin-center opacity-20 animate-pulse",
+                n.spinnerBars
+              ),
+              style: {
+                transform: `rotate(${c * 30}deg) translateY(-8px)`,
+                animationDelay: `${c * 0.1}s`
+              }
+            },
+            c
+          )) });
+        default:
+          return /* @__PURE__ */ C.jsxs("div", { className: xe("relative w-8 h-8", n.wrapper), children: [
+            /* @__PURE__ */ C.jsx(
+              "i",
+              {
+                className: xe(
+                  "absolute inset-0 rounded-full border-4 border-current border-opacity-25",
+                  n.circle1
+                )
+              }
+            ),
+            /* @__PURE__ */ C.jsx(
+              "i",
+              {
+                className: xe(
+                  "absolute inset-0 rounded-full border-4 border-t-transparent animate-spin",
+                  n.circle2
+                )
+              }
+            )
+          ] });
+      }
+    }, [e, n]);
+    return /* @__PURE__ */ C.jsxs("div", { ref: s, className: i, "aria-label": t || "Loading", ...r, children: [
+      l,
+      t && /* @__PURE__ */ C.jsx("span", { className: xe("mt-2 text-sm text-gray-600", n.label), children: t })
+    ] });
+  }
+), No = Bo(void 0), Hn = ({ children: e, value: t, config: o }) => /* @__PURE__ */ C.jsx(No.Provider, { value: { ...t, config: o }, children: e }), Rt = () => {
+  const e = Ao(No);
+  if (!e)
+    throw new Error("useChatContext must be used within a ChatProvider");
+  return e;
+};
+function ot(...e) {
+  return e.filter(Boolean).join(" ");
+}
+const Pn = "data:image/svg+xml,%3c?xml%20version='1.0'%20encoding='utf-8'?%3e%3c!--%20Uploaded%20to:%20SVG%20Repo,%20www.svgrepo.com,%20Generator:%20SVG%20Repo%20Mixer%20Tools%20--%3e%3csvg%20width='800px'%20height='800px'%20viewBox='0%200%2024%2024'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M4%2012H20M12%204V20'%20stroke='%23000000'%20stroke-width='2'%20stroke-linecap='round'%20stroke-linejoin='round'/%3e%3c/svg%3e", Wo = "data:image/svg+xml,%3c?xml%20version='1.0'%20encoding='utf-8'?%3e%3c!--%20Uploaded%20to:%20SVG%20Repo,%20www.svgrepo.com,%20Generator:%20SVG%20Repo%20Mixer%20Tools%20--%3e%3csvg%20width='800px'%20height='800px'%20viewBox='0%200%2024%2024'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M6%206L18%2018M18%206L6%2018'%20stroke='%23000000'%20stroke-width='2'%20stroke-linecap='round'%20stroke-linejoin='round'/%3e%3c/svg%3e", Bn = "data:image/svg+xml,%3c?xml%20version='1.0'%20encoding='utf-8'?%3e%3c!--%20Uploaded%20to:%20SVG%20Repo,%20www.svgrepo.com,%20Generator:%20SVG%20Repo%20Mixer%20Tools%20--%3e%3csvg%20width='800px'%20height='800px'%20viewBox='0%200%2024%2024'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M12%206V18M12%206L7%2011M12%206L17%2011'%20stroke='%23000000'%20stroke-width='2'%20stroke-linecap='round'%20stroke-linejoin='round'/%3e%3c/svg%3e", An = () => {
+  const { classNames: e, handleSend: t } = Rt(), [o, n] = Ct(""), r = (s) => {
+    s.preventDefault(), t(o), n("");
+  };
+  return /* @__PURE__ */ C.jsxs(
+    "form",
+    {
+      role: "inputWrapper",
+      className: ot("autoui-chat-input", e?.inputWrapper),
+      onSubmit: r,
+      "aria-label": "Chat input area",
+      children: [
+        /* @__PURE__ */ C.jsx(
+          "input",
+          {
+            role: "input",
+            className: ot("autoui-chat-textbox", e?.input),
+            type: "text",
+            value: o,
+            onChange: (s) => n(s.target.value),
+            placeholder: "Type a message...",
+            "aria-label": "Message input"
+          }
+        ),
+        /* @__PURE__ */ C.jsx(
+          "button",
+          {
+            role: "inputButton",
+            type: "submit",
+            className: ot("autoui-chat-send", e?.inputButton),
+            "aria-label": "Send message",
+            children: /* @__PURE__ */ C.jsx("img", { src: Bn, alt: "arrow up" })
+          }
+        )
+      ]
+    }
+  );
+}, _n = ({ message: e }) => {
+  const t = e.role === "user", { classNames: o } = Rt();
+  return /* @__PURE__ */ C.jsx(
+    "div",
+    {
+      role: "message",
+      className: xe("autoui-chat-message", t ? "user" : "assistant", o?.message),
+      "aria-label": t ? "User message" : "Assistant message",
+      children: /* @__PURE__ */ C.jsx("div", { className: "autoui-chat-bubble", children: e.content })
+    }
+  );
+}, Et = 0, De = 1, Ke = 2, Fo = 4;
+function mo(e) {
+  return () => e;
+}
+function Mn(e) {
+  e();
+}
+function Do(e, t) {
+  return (o) => e(t(o));
+}
+function ho(e, t) {
+  return () => e(t);
+}
+function Nn(e, t) {
+  return (o) => e(t, o);
+}
+function Ut(e) {
+  return e !== void 0;
+}
+function Wn(...e) {
+  return () => {
+    e.map(Mn);
+  };
+}
+function Qe() {
+}
+function kt(e, t) {
+  return t(e), e;
+}
+function Fn(e, t) {
+  return t(e);
+}
+function ie(...e) {
+  return e;
+}
+function Z(e, t) {
+  return e(De, t);
+}
+function $(e, t) {
+  e(Et, t);
+}
+function Gt(e) {
+  e(Ke);
+}
+function ae(e) {
+  return e(Fo);
+}
+function B(e, t) {
+  return Z(e, Nn(t, Et));
+}
+function Oe(e, t) {
+  const o = e(De, (n) => {
+    o(), t(n);
+  });
+  return o;
+}
+function po(e) {
+  let t, o;
+  return (n) => (r) => {
+    t = r, o && clearTimeout(o), o = setTimeout(() => {
+      n(t);
+    }, e);
+  };
+}
+function Lo(e, t) {
+  return e === t;
+}
+function se(e = Lo) {
+  let t;
+  return (o) => (n) => {
+    e(t, n) || (t = n, o(n));
+  };
+}
+function W(e) {
+  return (t) => (o) => {
+    e(o) && t(o);
+  };
+}
+function j(e) {
+  return (t) => Do(t, e);
+}
+function Ae(e) {
+  return (t) => () => {
+    t(e);
+  };
+}
+function w(e, ...t) {
+  const o = Dn(...t);
+  return (n, r) => {
+    switch (n) {
+      case Ke:
+        Gt(e);
+        return;
+      case De:
+        return Z(e, o(r));
+    }
+  };
+}
+function _e(e, t) {
+  return (o) => (n) => {
+    o(t = e(t, n));
+  };
+}
+function Ge(e) {
+  return (t) => (o) => {
+    e > 0 ? e-- : t(o);
+  };
+}
+function We(e) {
+  let t = null, o;
+  return (n) => (r) => {
+    t = r, !o && (o = setTimeout(() => {
+      o = void 0, n(t);
+    }, e));
+  };
+}
+function U(...e) {
+  const t = new Array(e.length);
+  let o = 0, n = null;
+  const r = Math.pow(2, e.length) - 1;
+  return e.forEach((s, i) => {
+    const l = Math.pow(2, i);
+    Z(s, (a) => {
+      const c = o;
+      o = o | l, t[i] = a, c !== r && o === r && n && (n(), n = null);
+    });
+  }), (s) => (i) => {
+    const l = () => {
+      s([i].concat(t));
+    };
+    o === r ? l() : n = l;
+  };
+}
+function Dn(...e) {
+  return (t) => e.reduceRight(Fn, t);
+}
+function Ln(e) {
+  let t, o;
+  const n = () => t?.();
+  return function(r, s) {
+    switch (r) {
+      case De:
+        return s ? o === s ? void 0 : (n(), o = s, t = Z(e, s), t) : (n(), Qe);
+      case Ke:
+        n(), o = null;
+        return;
+    }
+  };
+}
+function S(e) {
+  let t = e;
+  const o = Y();
+  return (n, r) => {
+    switch (n) {
+      case Et:
+        t = r;
+        break;
+      case De: {
+        r(t);
+        break;
+      }
+      case Fo:
+        return t;
+    }
+    return o(n, r);
+  };
+}
+function Se(e, t) {
+  return kt(S(t), (o) => B(e, o));
+}
+function Y() {
+  const e = [];
+  return (t, o) => {
+    switch (t) {
+      case Et:
+        e.slice().forEach((n) => {
+          n(o);
+        });
+        return;
+      case Ke:
+        e.splice(0, e.length);
+        return;
+      case De:
+        return e.push(o), () => {
+          const n = e.indexOf(o);
+          n > -1 && e.splice(n, 1);
+        };
+    }
+  };
+}
+function Re(e) {
+  return kt(Y(), (t) => B(e, t));
+}
+function J(e, t = [], { singleton: o } = { singleton: !0 }) {
+  return {
+    constructor: e,
+    dependencies: t,
+    id: Vn(),
+    singleton: o
+  };
+}
+const Vn = () => Symbol();
+function $n(e) {
+  const t = /* @__PURE__ */ new Map(), o = ({ constructor: n, dependencies: r, id: s, singleton: i }) => {
+    if (i && t.has(s))
+      return t.get(s);
+    const l = n(r.map((a) => o(a)));
+    return i && t.set(s, l), l;
+  };
+  return o(e);
+}
+function de(...e) {
+  const t = Y(), o = new Array(e.length);
+  let n = 0;
+  const r = Math.pow(2, e.length) - 1;
+  return e.forEach((s, i) => {
+    const l = Math.pow(2, i);
+    Z(s, (a) => {
+      o[i] = a, n = n | l, n === r && $(t, o);
+    });
+  }), function(s, i) {
+    switch (s) {
+      case Ke: {
+        Gt(t);
+        return;
+      }
+      case De:
+        return n === r && i(o), Z(t, i);
+    }
+  };
+}
+function N(e, t = Lo) {
+  return w(e, se(t));
+}
+function Mt(...e) {
+  return function(t, o) {
+    switch (t) {
+      case Ke:
+        return;
+      case De:
+        return Wn(...e.map((n) => Z(n, o)));
+    }
+  };
+}
+var ye = /* @__PURE__ */ ((e) => (e[e.DEBUG = 0] = "DEBUG", e[e.INFO = 1] = "INFO", e[e.WARN = 2] = "WARN", e[e.ERROR = 3] = "ERROR", e))(ye || {});
+const Un = {
+  0: "debug",
+  3: "error",
+  1: "log",
+  2: "warn"
+}, Gn = () => typeof globalThis > "u" ? window : globalThis, Le = J(
+  () => {
+    const e = S(
+      3
+      /* ERROR */
+    );
+    return {
+      log: S((t, o, n = 1) => {
+        var r;
+        const s = (r = Gn().VIRTUOSO_LOG_LEVEL) != null ? r : ae(e);
+        n >= s && console[Un[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 Yt(e, t, o).callbackRef;
+}
+function Yt(e, t, o) {
+  const n = P.useRef(null);
+  let r = (i) => {
+  };
+  const s = P.useMemo(() => typeof ResizeObserver < "u" ? new ResizeObserver((i) => {
+    const l = () => {
+      const a = i[0].target;
+      a.offsetParent !== null && e(a);
+    };
+    o ? l() : requestAnimationFrame(l);
+  }) : null, [e, o]);
+  return r = (i) => {
+    i && t ? (s?.observe(i), n.current = i) : (n.current && s?.unobserve(n.current), n.current = null);
+  }, { callbackRef: r, ref: n };
+}
+function Yn(e, t, o, n, r, s, i, l, a) {
+  const c = P.useCallback(
+    (m) => {
+      const T = qn(m.children, t, l ? "offsetWidth" : "offsetHeight", r);
+      let p = m.parentElement;
+      for (; !p.dataset.virtuosoScroller; )
+        p = p.parentElement;
+      const x = p.lastElementChild.dataset.viewportType === "window";
+      let b;
+      x && (b = p.ownerDocument.defaultView);
+      const E = i ? l ? i.scrollLeft : i.scrollTop : x ? l ? b.scrollX || b.document.documentElement.scrollLeft : b.scrollY || b.document.documentElement.scrollTop : l ? p.scrollLeft : p.scrollTop, g = i ? l ? i.scrollWidth : i.scrollHeight : x ? l ? b.document.documentElement.scrollWidth : b.document.documentElement.scrollHeight : l ? p.scrollWidth : p.scrollHeight, d = i ? l ? i.offsetWidth : i.offsetHeight : x ? l ? b.innerWidth : b.innerHeight : l ? p.offsetWidth : p.offsetHeight;
+      n({
+        scrollHeight: g,
+        scrollTop: Math.max(E, 0),
+        viewportHeight: d
+      }), s?.(
+        l ? go("column-gap", getComputedStyle(m).columnGap, r) : go("row-gap", getComputedStyle(m).rowGap, r)
+      ), T !== null && e(T);
+    },
+    [e, t, r, s, i, n, l]
+  );
+  return Yt(c, o, a);
+}
+function qn(e, t, o, n) {
+  const r = e.length;
+  if (r === 0)
+    return null;
+  const s = [];
+  for (let i = 0; i < r; i++) {
+    const l = e.item(i);
+    if (l.dataset.index === void 0)
+      continue;
+    const a = parseInt(l.dataset.index), c = parseFloat(l.dataset.knownSize), m = t(l, o);
+    if (m === 0 && n("Zero-sized element, this should not happen", { child: l }, ye.ERROR), m === c)
+      continue;
+    const T = s[s.length - 1];
+    s.length === 0 || T.size !== m || T.endIndex !== a - 1 ? s.push({ endIndex: a, size: m, startIndex: a }) : s[s.length - 1].endIndex++;
+  }
+  return s;
+}
+function go(e, t, o) {
+  return t !== "normal" && !(t != null && t.endsWith("px")) && o(`${e} was not resolved to pixel value correctly`, t, ye.WARN), t === "normal" ? 0 : parseInt(t ?? "0", 10);
+}
+function Vo(e, t, o) {
+  const n = P.useRef(null), r = P.useCallback(
+    (a) => {
+      if (!(a != null && a.offsetParent))
+        return;
+      const c = a.getBoundingClientRect(), m = c.width;
+      let T, p;
+      if (t) {
+        const x = t.getBoundingClientRect(), b = c.top - x.top;
+        p = x.height - Math.max(0, b), T = b + t.scrollTop;
+      } else {
+        const x = i.current.ownerDocument.defaultView;
+        p = x.innerHeight - Math.max(0, c.top), T = c.top + x.scrollY;
+      }
+      n.current = {
+        offsetTop: T,
+        visibleHeight: p,
+        visibleWidth: m
+      }, e(n.current);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e, t]
+  ), { callbackRef: s, ref: i } = Yt(r, !0, o), l = P.useCallback(() => {
+    r(i.current);
+  }, [r, i]);
+  return P.useEffect(() => {
+    var a;
+    if (t) {
+      t.addEventListener("scroll", l);
+      const c = new ResizeObserver(() => {
+        requestAnimationFrame(l);
+      });
+      return c.observe(t), () => {
+        t.removeEventListener("scroll", l), c.unobserve(t);
+      };
+    } else {
+      const c = (a = i.current) == null ? void 0 : a.ownerDocument.defaultView;
+      return c?.addEventListener("scroll", l), c?.addEventListener("resize", l), () => {
+        c?.removeEventListener("scroll", l), c?.removeEventListener("resize", l);
+      };
+    }
+  }, [l, t, i]), s;
+}
+const be = J(
+  () => {
+    const e = Y(), t = Y(), o = S(0), n = Y(), r = S(0), s = Y(), i = Y(), l = S(0), a = S(0), c = S(0), m = S(0), T = Y(), p = Y(), x = S(!1), b = S(!1), E = S(!1);
+    return B(
+      w(
+        e,
+        j(({ scrollTop: g }) => g)
+      ),
+      t
+    ), B(
+      w(
+        e,
+        j(({ scrollHeight: g }) => g)
+      ),
+      i
+    ), B(t, r), {
+      deviation: o,
+      fixedFooterHeight: c,
+      fixedHeaderHeight: a,
+      footerHeight: m,
+      headerHeight: l,
+      horizontalDirection: b,
+      scrollBy: p,
+      // input
+      scrollContainerState: e,
+      scrollHeight: i,
+      scrollingInProgress: x,
+      // signals
+      scrollTo: T,
+      scrollTop: t,
+      skipAnimationFrameInResizeObserver: E,
+      smoothScrollTargetReached: n,
+      // state
+      statefulScrollTop: r,
+      viewportHeight: s
+    };
+  },
+  [],
+  { singleton: !0 }
+), st = { lvl: 0 };
+function $o(e, t) {
+  const o = e.length;
+  if (o === 0)
+    return [];
+  let { index: n, value: r } = t(e[0]);
+  const s = [];
+  for (let i = 1; i < o; i++) {
+    const { index: l, value: a } = t(e[i]);
+    s.push({ end: l - 1, start: n, value: r }), n = l, r = a;
+  }
+  return s.push({ end: 1 / 0, start: n, value: r }), s;
+}
+function oe(e) {
+  return e === st;
+}
+function it(e, t) {
+  if (!oe(e))
+    return t === e.k ? e.v : t < e.k ? it(e.l, t) : it(e.r, t);
+}
+function He(e, t, o = "k") {
+  if (oe(e))
+    return [-1 / 0, void 0];
+  if (Number(e[o]) === t)
+    return [e.k, e.v];
+  if (Number(e[o]) < t) {
+    const n = He(e.r, t, o);
+    return n[0] === -1 / 0 ? [e.k, e.v] : n;
+  }
+  return He(e.l, t, o);
+}
+function Ce(e, t, o) {
+  return oe(e) ? Yo(t, o, 1) : t === e.k ? me(e, { k: t, v: o }) : t < e.k ? xo(me(e, { l: Ce(e.l, t, o) })) : xo(me(e, { r: Ce(e.r, t, o) }));
+}
+function Xe() {
+  return st;
+}
+function Ze(e, t, o) {
+  if (oe(e))
+    return [];
+  const n = He(e, t)[0];
+  return Jn(Wt(e, n, o));
+}
+function Nt(e, t) {
+  if (oe(e)) return st;
+  const { k: o, l: n, r } = e;
+  if (t === o) {
+    if (oe(n))
+      return r;
+    if (oe(r))
+      return n;
+    {
+      const [s, i] = Go(n);
+      return It(me(e, { k: s, l: Uo(n), v: i }));
+    }
+  } else return t < o ? It(me(e, { l: Nt(n, t) })) : It(me(e, { r: Nt(r, t) }));
+}
+function Ue(e) {
+  return oe(e) ? [] : [...Ue(e.l), { k: e.k, v: e.v }, ...Ue(e.r)];
+}
+function Wt(e, t, o) {
+  if (oe(e))
+    return [];
+  const { k: n, l: r, r: s, v: i } = e;
+  let l = [];
+  return n > t && (l = l.concat(Wt(r, t, o))), n >= t && n <= o && l.push({ k: n, v: i }), n <= o && (l = l.concat(Wt(s, t, o))), l;
+}
+function It(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 (Ht(t))
+      return qo(me(e, { lvl: o - 1 }));
+    if (!oe(t) && !oe(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 (Ht(e))
+      return Ft(me(e, { lvl: o - 1 }));
+    if (!oe(n) && !oe(n.l)) {
+      const r = n.l, s = Ht(r) ? n.lvl - 1 : n.lvl;
+      return me(r, {
+        l: me(e, {
+          lvl: o - 1,
+          r: r.l
+        }),
+        lvl: r.lvl + 1,
+        r: Ft(me(n, { l: r.r, lvl: s }))
+      });
+    } else
+      throw new Error("Unexpected empty nodes");
+  }
+}
+function me(e, t) {
+  return Yo(
+    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 Uo(e) {
+  return oe(e.r) ? e.l : It(me(e, { r: Uo(e.r) }));
+}
+function Ht(e) {
+  return oe(e) || e.lvl > e.r.lvl;
+}
+function Go(e) {
+  return oe(e.r) ? [e.k, e.v] : Go(e.r);
+}
+function Yo(e, t, o, n = st, r = st) {
+  return { k: e, l: n, lvl: o, r, v: t };
+}
+function xo(e) {
+  return Ft(qo(e));
+}
+function qo(e) {
+  const { l: t } = e;
+  return !oe(t) && t.lvl === e.lvl ? me(t, { r: me(e, { l: t.r }) }) : e;
+}
+function Ft(e) {
+  const { lvl: t, r: o } = e;
+  return !oe(o) && !oe(o.r) && o.lvl === t && o.r.lvl === t ? me(o, { l: me(e, { r: o.l }), lvl: t + 1 }) : e;
+}
+function Jn(e) {
+  return $o(e, ({ k: t, v: o }) => ({ index: t, value: o }));
+}
+function Jo(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 qt = J(
+  () => ({ recalcInProgress: S(!1) }),
+  [],
+  { singleton: !0 }
+);
+function Xo(e, t, o) {
+  return e[bt(e, t, o)];
+}
+function bt(e, t, o, n = 0) {
+  let r = e.length - 1;
+  for (; n <= r; ) {
+    const s = Math.floor((n + r) / 2), i = e[s], l = o(i, t);
+    if (l === 0)
+      return s;
+    if (l === -1) {
+      if (r - n < 2)
+        return s - 1;
+      r = s - 1;
+    } else {
+      if (r === n)
+        return s;
+      n = s + 1;
+    }
+  }
+  throw new Error(`Failed binary finding record in array - ${e.join(",")}, searched for ${t}`);
+}
+function Xn(e, t, o, n) {
+  const r = bt(e, t, n), s = bt(e, o, n, r);
+  return e.slice(r, s + 1);
+}
+function Fe(e, t) {
+  return Math.round(e.getBoundingClientRect()[t]);
+}
+function zt(e) {
+  return !oe(e.groupOffsetTree);
+}
+function Jt({ index: e }, t) {
+  return t === e ? 0 : t < e ? -1 : 1;
+}
+function Zn() {
+  return {
+    groupIndices: [],
+    groupOffsetTree: Xe(),
+    lastIndex: 0,
+    lastOffset: 0,
+    lastSize: 0,
+    offsetTree: [],
+    sizeTree: Xe()
+  };
+}
+function Kn(e, t) {
+  let o = oe(e) ? 0 : 1 / 0;
+  for (const n of t) {
+    const { endIndex: r, size: s, startIndex: i } = n;
+    if (o = Math.min(o, i), oe(e)) {
+      e = Ce(e, 0, s);
+      continue;
+    }
+    const l = Ze(e, i - 1, r + 1);
+    if (l.some(sr(n)))
+      continue;
+    let a = !1, c = !1;
+    for (const { end: m, start: T, value: p } of l)
+      a ? (r >= T || s === p) && (e = Nt(e, T)) : (c = p !== s, a = !0), m > r && r >= T && p !== s && (e = Ce(e, r + 1, p));
+    c && (e = Ce(e, i, s));
+  }
+  return [e, o];
+}
+function Qn(e) {
+  return typeof e.groupIndex < "u";
+}
+function er({ offset: e }, t) {
+  return t === e ? 0 : t < e ? -1 : 1;
+}
+function at(e, t, o) {
+  if (t.length === 0)
+    return 0;
+  const { index: n, offset: r, size: s } = Xo(t, e, Jt), i = e - n, l = s * i + (i - 1) * o + r;
+  return l > 0 ? l + o : l;
+}
+function Zo(e, t) {
+  if (!zt(t))
+    return e;
+  let o = 0;
+  for (; t.groupIndices[o] <= e + o; )
+    o++;
+  return e + o;
+}
+function Ko(e, t, o) {
+  if (Qn(e))
+    return t.groupIndices[e.groupIndex] + 1;
+  {
+    const n = e.index === "LAST" ? o : e.index;
+    let r = Zo(n, t);
+    return r = Math.max(0, r, Math.min(o, r)), r;
+  }
+}
+function tr(e, t, o, n = 0) {
+  return n > 0 && (t = Math.max(t, Xo(e, n, Jt).offset)), $o(Xn(e, t, o, er), rr);
+}
+function or(e, [t, o, n, r]) {
+  t.length > 0 && n("received item sizes", t, ye.DEBUG);
+  const s = e.sizeTree;
+  let i = s, l = 0;
+  if (o.length > 0 && oe(s) && t.length === 2) {
+    const p = t[0].size, x = t[1].size;
+    i = o.reduce((b, E) => Ce(Ce(b, E, p), E + 1, x), i);
+  } else
+    [i, l] = Kn(i, t);
+  if (i === s)
+    return e;
+  const { lastIndex: a, lastOffset: c, lastSize: m, offsetTree: T } = Dt(e.offsetTree, l, i, r);
+  return {
+    groupIndices: o,
+    groupOffsetTree: o.reduce((p, x) => Ce(p, x, at(x, T, r)), Xe()),
+    lastIndex: a,
+    lastOffset: c,
+    lastSize: m,
+    offsetTree: T,
+    sizeTree: i
+  };
+}
+function nr(e) {
+  return Ue(e).map(({ k: t, v: o }, n, r) => {
+    const s = r[n + 1];
+    return { endIndex: s ? s.k - 1 : 1 / 0, size: o, startIndex: t };
+  });
+}
+function vo(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 Dt(e, t, o, n) {
+  let r = e, s = 0, i = 0, l = 0, a = 0;
+  if (t !== 0) {
+    a = bt(r, t - 1, Jt), l = r[a].offset;
+    const c = He(o, t - 1);
+    s = c[0], i = c[1], r.length && r[a].size === He(o, t)[1] && (a -= 1), r = r.slice(0, a + 1);
+  } else
+    r = [];
+  for (const { start: c, value: m } of Ze(o, t, 1 / 0)) {
+    const T = c - s, p = T * i + l + T * n;
+    r.push({
+      index: c,
+      offset: p,
+      size: m
+    }), s = c, l = p, i = m;
+  }
+  return {
+    lastIndex: s,
+    lastOffset: l,
+    lastSize: i,
+    offsetTree: r
+  };
+}
+function rr(e) {
+  return { index: e.index, value: e };
+}
+function sr(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 ir = {
+  offsetHeight: "height",
+  offsetWidth: "width"
+}, Me = J(
+  ([{ log: e }, { recalcInProgress: t }]) => {
+    const o = Y(), n = Y(), r = Se(n, 0), s = Y(), i = Y(), l = S(0), a = S([]), c = S(void 0), m = S(void 0), T = S(void 0), p = S(void 0), x = S((u, v) => Fe(u, ir[v])), b = S(void 0), E = S(0), g = Zn(), d = Se(
+      w(o, U(a, e, E), _e(or, g), se()),
+      g
+    ), f = Se(
+      w(
+        a,
+        se(),
+        _e((u, v) => ({ current: v, prev: u.current }), {
+          current: [],
+          prev: []
+        }),
+        j(({ prev: u }) => u)
+      ),
+      []
+    );
+    B(
+      w(
+        a,
+        W((u) => u.length > 0),
+        U(d, E),
+        j(([u, v, y]) => {
+          const z = u.reduce((A, F, D) => Ce(A, F, at(F, v.offsetTree, y) || D), Xe());
+          return {
+            ...v,
+            groupIndices: u,
+            groupOffsetTree: z
+          };
+        })
+      ),
+      d
+    ), B(
+      w(
+        n,
+        U(d),
+        W(([u, { lastIndex: v }]) => u < v),
+        j(([u, { lastIndex: v, lastSize: y }]) => [
+          {
+            endIndex: v,
+            size: y,
+            startIndex: u
+          }
+        ])
+      ),
+      o
+    ), B(c, m);
+    const I = Se(
+      w(
+        c,
+        j((u) => u === void 0)
+      ),
+      !0
+    );
+    B(
+      w(
+        m,
+        W((u) => u !== void 0 && oe(ae(d).sizeTree)),
+        j((u) => {
+          const v = ae(T), y = ae(a).length > 0;
+          return v ? y ? [
+            { endIndex: 0, size: v, startIndex: 0 },
+            { endIndex: 1, size: u, startIndex: 1 }
+          ] : [] : [{ endIndex: 0, size: u, startIndex: 0 }];
+        })
+      ),
+      o
+    ), B(
+      w(
+        p,
+        W((u) => u !== void 0 && u.length > 0 && oe(ae(d).sizeTree)),
+        j((u) => {
+          const v = [];
+          let y = u[0], z = 0;
+          for (let A = 1; A < u.length; A++) {
+            const F = u[A];
+            F !== y && (v.push({
+              endIndex: A - 1,
+              size: y,
+              startIndex: z
+            }), y = F, z = A);
+          }
+          return v.push({
+            endIndex: u.length - 1,
+            size: y,
+            startIndex: z
+          }), v;
+        })
+      ),
+      o
+    ), B(
+      w(
+        a,
+        U(T, m),
+        W(([, u, v]) => u !== void 0 && v !== void 0),
+        j(([u, v, y]) => {
+          const z = [];
+          for (let A = 0; A < u.length; A++) {
+            const F = u[A], D = u[A + 1];
+            z.push({
+              startIndex: F,
+              endIndex: F,
+              size: v
+            }), D !== void 0 && z.push({
+              startIndex: F + 1,
+              endIndex: D - 1,
+              size: y
+            });
+          }
+          return z;
+        })
+      ),
+      o
+    );
+    const O = Re(
+      w(
+        o,
+        U(d),
+        _e(
+          ({ sizes: u }, [v, y]) => ({
+            changed: y !== u,
+            sizes: y
+          }),
+          { changed: !1, sizes: g }
+        ),
+        j((u) => u.changed)
+      )
+    );
+    Z(
+      w(
+        l,
+        _e(
+          (u, v) => ({ diff: u.prev - v, prev: v }),
+          { diff: 0, prev: 0 }
+        ),
+        j((u) => u.diff)
+      ),
+      (u) => {
+        const { groupIndices: v } = ae(d);
+        if (u > 0)
+          $(t, !0), $(s, u + vo(u, v));
+        else if (u < 0) {
+          const y = ae(f);
+          y.length > 0 && (u -= vo(-u, y)), $(i, u);
+        }
+      }
+    ), Z(w(l, U(e)), ([u, v]) => {
+      u < 0 && v(
+        "`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 },
+        ye.ERROR
+      );
+    });
+    const k = Re(s);
+    B(
+      w(
+        s,
+        U(d),
+        j(([u, v]) => {
+          const y = v.groupIndices.length > 0, z = [], A = v.lastSize;
+          if (y) {
+            const F = it(v.sizeTree, 0);
+            let D = 0, _ = 0;
+            for (; D < u; ) {
+              const X = v.groupIndices[_], K = v.groupIndices.length === _ + 1 ? 1 / 0 : v.groupIndices[_ + 1] - X - 1;
+              z.push({
+                endIndex: X,
+                size: F,
+                startIndex: X
+              }), z.push({
+                endIndex: X + 1 + K - 1,
+                size: A,
+                startIndex: X + 1
+              }), _++, D += K + 1;
+            }
+            const V = Ue(v.sizeTree);
+            return D !== u && V.shift(), V.reduce(
+              (X, { k: K, v: ve }) => {
+                let we = X.ranges;
+                return X.prevSize !== 0 && (we = [
+                  ...X.ranges,
+                  {
+                    endIndex: K + u - 1,
+                    size: X.prevSize,
+                    startIndex: X.prevIndex
+                  }
+                ]), {
+                  prevIndex: K + u,
+                  prevSize: ve,
+                  ranges: we
+                };
+              },
+              {
+                prevIndex: u,
+                prevSize: 0,
+                ranges: z
+              }
+            ).ranges;
+          }
+          return Ue(v.sizeTree).reduce(
+            (F, { k: D, v: _ }) => ({
+              prevIndex: D + u,
+              prevSize: _,
+              ranges: [...F.ranges, { endIndex: D + u - 1, size: F.prevSize, startIndex: F.prevIndex }]
+            }),
+            {
+              prevIndex: 0,
+              prevSize: A,
+              ranges: []
+            }
+          ).ranges;
+        })
+      ),
+      o
+    );
+    const H = Re(
+      w(
+        i,
+        U(d, E),
+        j(([u, { offsetTree: v }, y]) => {
+          const z = -u;
+          return at(z, v, y);
+        })
+      )
+    );
+    return B(
+      w(
+        i,
+        U(d, E),
+        j(([u, v, y]) => {
+          if (v.groupIndices.length > 0) {
+            if (oe(v.sizeTree))
+              return v;
+            let z = Xe();
+            const A = ae(f);
+            let F = 0, D = 0, _ = 0;
+            for (; F < -u; ) {
+              _ = A[D];
+              const V = A[D + 1] - _ - 1;
+              D++, F += V + 1;
+            }
+            if (z = Ue(v.sizeTree).reduce((V, { k: X, v: K }) => Ce(V, Math.max(0, X + u), K), z), F !== -u) {
+              const V = it(v.sizeTree, _);
+              z = Ce(z, 0, V);
+              const X = He(v.sizeTree, -u + 1)[1];
+              z = Ce(z, 1, X);
+            }
+            return {
+              ...v,
+              sizeTree: z,
+              ...Dt(v.offsetTree, 0, z, y)
+            };
+          } else {
+            const z = Ue(v.sizeTree).reduce((A, { k: F, v: D }) => Ce(A, Math.max(0, F + u), D), Xe());
+            return {
+              ...v,
+              sizeTree: z,
+              ...Dt(v.offsetTree, 0, z, y)
+            };
+          }
+        })
+      ),
+      d
+    ), {
+      beforeUnshiftWith: k,
+      // input
+      data: b,
+      defaultItemSize: m,
+      firstItemIndex: l,
+      fixedItemSize: c,
+      fixedGroupSize: T,
+      gap: E,
+      groupIndices: a,
+      heightEstimates: p,
+      itemSize: x,
+      listRefresh: O,
+      shiftWith: i,
+      shiftWithOffset: H,
+      sizeRanges: o,
+      // output
+      sizes: d,
+      statefulTotalCount: r,
+      totalCount: n,
+      trackItemSizes: I,
+      unshiftWith: s
+    };
+  },
+  ie(Le, qt),
+  { singleton: !0 }
+);
+function lr(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 s = Y(), i = Y(), l = Re(w(s, j(lr)));
+    return B(
+      w(
+        l,
+        j((a) => a.totalCount)
+      ),
+      o
+    ), B(
+      w(
+        l,
+        j((a) => a.groupIndices)
+      ),
+      e
+    ), B(
+      w(
+        de(r, t, n),
+        W(([a, c]) => zt(c)),
+        j(([a, c, m]) => He(c.groupOffsetTree, Math.max(a - m, 0), "v")[0]),
+        se(),
+        j((a) => [a])
+      ),
+      i
+    ), { groupCounts: s, topItemsIndexes: i };
+  },
+  ie(Me, be)
+), Ve = J(
+  ([{ log: e }]) => {
+    const t = S(!1), o = Re(
+      w(
+        t,
+        W((n) => n),
+        se()
+      )
+    );
+    return Z(t, (n) => {
+      n && ae(e)("props updated", {}, ye.DEBUG);
+    }), { didMount: o, propsReady: t };
+  },
+  ie(Le),
+  { singleton: !0 }
+), ar = typeof document < "u" && "scrollBehavior" in document.documentElement.style;
+function en(e) {
+  const t = typeof e == "number" ? { index: e } : e;
+  return t.align || (t.align = "start"), (!t.behavior || !ar) && (t.behavior = "auto"), t.offset || (t.offset = 0), t;
+}
+const ft = J(
+  ([
+    { gap: e, listRefresh: t, sizes: o, totalCount: n },
+    {
+      fixedFooterHeight: r,
+      fixedHeaderHeight: s,
+      footerHeight: i,
+      headerHeight: l,
+      scrollingInProgress: a,
+      scrollTo: c,
+      smoothScrollTargetReached: m,
+      viewportHeight: T
+    },
+    { log: p }
+  ]) => {
+    const x = Y(), b = Y(), E = S(0);
+    let g = null, d = null, f = null;
+    function I() {
+      g && (g(), g = null), f && (f(), f = null), d && (clearTimeout(d), d = null), $(a, !1);
+    }
+    return B(
+      w(
+        x,
+        U(o, T, n, E, l, i, p),
+        U(e, s, r),
+        j(
+          ([
+            [O, k, H, u, v, y, z, A],
+            F,
+            D,
+            _
+          ]) => {
+            const V = en(O), { align: X, behavior: K, offset: ve } = V, we = u - 1, Te = Ko(V, k, we);
+            let h = at(Te, k.offsetTree, F) + y;
+            X === "end" ? (h += D + He(k.sizeTree, Te)[1] - H + _, Te === we && (h += z)) : X === "center" ? h += (D + He(k.sizeTree, Te)[1] - H + _) / 2 : h -= v, ve && (h += ve);
+            const M = (q) => {
+              I(), q ? (A("retrying to scroll to", { location: O }, ye.DEBUG), $(x, O)) : ($(b, !0), A("list did not change, scroll successful", {}, ye.DEBUG));
+            };
+            if (I(), K === "smooth") {
+              let q = !1;
+              f = Z(t, (Q) => {
+                q = q || Q;
+              }), g = Oe(m, () => {
+                M(q);
+              });
+            } else
+              g = Oe(w(t, cr(150)), M);
+            return d = setTimeout(() => {
+              I();
+            }, 1200), $(a, !0), A("scrolling from index to", { behavior: K, index: Te, top: h }, ye.DEBUG), { behavior: K, top: h };
+          }
+        )
+      ),
+      c
+    ), {
+      scrollTargetReached: b,
+      scrollToIndex: x,
+      topListHeight: E
+    };
+  },
+  ie(Me, be, Le),
+  { singleton: !0 }
+);
+function cr(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: s }, { didMount: i }]) => {
+    const l = S(!0), a = S(0), c = S(!0);
+    return B(
+      w(
+        i,
+        U(a),
+        W(([m, T]) => !!T),
+        Ae(!1)
+      ),
+      l
+    ), B(
+      w(
+        i,
+        U(a),
+        W(([m, T]) => !!T),
+        Ae(!1)
+      ),
+      c
+    ), Z(
+      w(
+        de(t, i),
+        U(l, o, e, c),
+        W(([[, m], T, { sizeTree: p }, x, b]) => m && (!oe(p) || Ut(x)) && !T && !b),
+        U(a)
+      ),
+      ([, m]) => {
+        Oe(r, () => {
+          $(c, !0);
+        }), Xt(4, () => {
+          Oe(n, () => {
+            $(l, !0);
+          }), $(s, m);
+        });
+      }
+    ), {
+      initialItemFinalLocationReached: c,
+      initialTopMostItemIndex: a,
+      scrolledToInitialItem: l
+    };
+  },
+  ie(Me, be, ft, Ve),
+  { singleton: !0 }
+);
+function tn(e, t) {
+  return Math.abs(e - t) < 1.01;
+}
+const ct = "up", nt = "down", ur = "none", dr = {
+  atBottom: !1,
+  notAtBottomBecause: "NOT_SHOWING_LAST_ITEM",
+  state: {
+    offsetBottom: 0,
+    scrollHeight: 0,
+    scrollTop: 0,
+    viewportHeight: 0
+  }
+}, fr = 0, ht = J(([{ footerHeight: e, headerHeight: t, scrollBy: o, scrollContainerState: n, scrollTop: r, viewportHeight: s }]) => {
+  const i = S(!1), l = S(!0), a = Y(), c = Y(), m = S(4), T = S(fr), p = Se(
+    w(
+      Mt(w(N(r), Ge(1), Ae(!0)), w(N(r), Ge(1), Ae(!1), po(100))),
+      se()
+    ),
+    !1
+  ), x = Se(
+    w(Mt(w(o, Ae(!0)), w(o, Ae(!1), po(200))), se()),
+    !1
+  );
+  B(
+    w(
+      de(N(r), N(T)),
+      j(([f, I]) => f <= I),
+      se()
+    ),
+    l
+  ), B(w(l, We(50)), c);
+  const b = Re(
+    w(
+      de(n, N(s), N(t), N(e), N(m)),
+      _e((f, [{ scrollHeight: I, scrollTop: O }, k, H, u, v]) => {
+        const y = O + k - I > -v, z = {
+          scrollHeight: I,
+          scrollTop: O,
+          viewportHeight: k
+        };
+        if (y) {
+          let F, D;
+          return O > f.state.scrollTop ? (F = "SCROLLED_DOWN", D = f.state.scrollTop - O) : (F = "SIZE_DECREASED", D = f.state.scrollTop - O || f.scrollTopDelta), {
+            atBottom: !0,
+            atBottomBecause: F,
+            scrollTopDelta: D,
+            state: z
+          };
+        }
+        let A;
+        return z.scrollHeight > f.state.scrollHeight ? A = "SIZE_INCREASED" : k < f.state.viewportHeight ? A = "VIEWPORT_HEIGHT_DECREASING" : O < f.state.scrollTop ? A = "SCROLLING_UPWARDS" : A = "NOT_FULLY_SCROLLED_TO_LAST_ITEM_BOTTOM", {
+          atBottom: !1,
+          notAtBottomBecause: A,
+          state: z
+        };
+      }, dr),
+      se((f, I) => f && f.atBottom === I.atBottom)
+    )
+  ), E = Se(
+    w(
+      n,
+      _e(
+        (f, { scrollHeight: I, scrollTop: O, viewportHeight: k }) => {
+          if (tn(f.scrollHeight, I))
+            return {
+              changed: !1,
+              jump: 0,
+              scrollHeight: I,
+              scrollTop: O
+            };
+          {
+            const H = I - (O + k) < 1;
+            return f.scrollTop !== O && H ? {
+              changed: !0,
+              jump: f.scrollTop - O,
+              scrollHeight: I,
+              scrollTop: O
+            } : {
+              changed: !0,
+              jump: 0,
+              scrollHeight: I,
+              scrollTop: O
+            };
+          }
+        },
+        { changed: !1, jump: 0, scrollHeight: 0, scrollTop: 0 }
+      ),
+      W((f) => f.changed),
+      j((f) => f.jump)
+    ),
+    0
+  );
+  B(
+    w(
+      b,
+      j((f) => f.atBottom)
+    ),
+    i
+  ), B(w(i, We(50)), a);
+  const g = S(nt);
+  B(
+    w(
+      n,
+      j(({ scrollTop: f }) => f),
+      se(),
+      _e(
+        (f, I) => ae(x) ? { direction: f.direction, prevScrollTop: I } : { direction: I < f.prevScrollTop ? ct : nt, prevScrollTop: I },
+        { direction: nt, prevScrollTop: 0 }
+      ),
+      j((f) => f.direction)
+    ),
+    g
+  ), B(w(n, We(50), Ae(ur)), g);
+  const d = S(0);
+  return B(
+    w(
+      p,
+      W((f) => !f),
+      Ae(0)
+    ),
+    d
+  ), B(
+    w(
+      r,
+      We(100),
+      U(p),
+      W(([f, I]) => !!I),
+      _e(([f, I], [O]) => [I, O], [0, 0]),
+      j(([f, I]) => I - f)
+    ),
+    d
+  ), {
+    atBottomState: b,
+    atBottomStateChange: a,
+    atBottomThreshold: m,
+    atTopStateChange: c,
+    atTopThreshold: T,
+    isAtBottom: i,
+    isAtTop: l,
+    isScrolling: p,
+    lastJumpDueToItemResize: E,
+    scrollDirection: g,
+    scrollVelocity: d
+  };
+}, ie(be)), ut = "top", dt = "bottom", wo = "none";
+function To(e, t, o) {
+  return typeof e == "number" ? o === ct && t === ut || o === nt && t === dt ? e : 0 : o === ct ? t === ut ? e.main : e.reverse : t === dt ? e.main : e.reverse;
+}
+function Io(e, t) {
+  var o;
+  return typeof e == "number" ? e : (o = e[t]) != null ? o : 0;
+}
+const Kt = J(
+  ([{ deviation: e, fixedHeaderHeight: t, headerHeight: o, scrollTop: n, viewportHeight: r }]) => {
+    const s = Y(), i = S(0), l = S(0), a = S(0), c = Se(
+      w(
+        de(
+          N(n),
+          N(r),
+          N(o),
+          N(s, lt),
+          N(a),
+          N(i),
+          N(t),
+          N(e),
+          N(l)
+        ),
+        j(
+          ([
+            m,
+            T,
+            p,
+            [x, b],
+            E,
+            g,
+            d,
+            f,
+            I
+          ]) => {
+            const O = m - f, k = g + d, H = Math.max(p - O, 0);
+            let u = wo;
+            const v = Io(I, ut), y = Io(I, dt);
+            return x -= f, x += p + d, b += p + d, b -= f, x > m + k - v && (u = ct), b < m - H + T + y && (u = nt), u !== wo ? [
+              Math.max(O - p - To(E, ut, u) - v, 0),
+              O - H - d + T + To(E, dt, u) + y
+            ] : null;
+          }
+        ),
+        W((m) => m != null),
+        se(lt)
+      ),
+      [0, 0]
+    );
+    return {
+      increaseViewportBy: l,
+      // input
+      listBoundary: s,
+      overscan: a,
+      topListHeight: i,
+      // output
+      visibleRange: c
+    };
+  },
+  ie(be),
+  { singleton: !0 }
+);
+function mr(e, t, o) {
+  if (zt(t)) {
+    const n = Zo(e, t);
+    return [
+      { index: He(t.groupOffsetTree, n)[0], offset: 0, size: 0 },
+      { data: o?.[0], index: n, offset: 0, size: 0 }
+    ];
+  }
+  return [{ data: o?.[0], index: e, offset: 0, size: 0 }];
+}
+const Pt = {
+  bottom: 0,
+  firstItemIndex: 0,
+  items: [],
+  offsetBottom: 0,
+  offsetTop: 0,
+  top: 0,
+  topItems: [],
+  topListHeight: 0,
+  totalCount: 0
+};
+function St(e, t, o, n, r, s) {
+  const { lastIndex: i, lastOffset: l, lastSize: a } = r;
+  let c = 0, m = 0;
+  if (e.length > 0) {
+    c = e[0].offset;
+    const E = e[e.length - 1];
+    m = E.offset + E.size;
+  }
+  const T = o - i, p = l + T * a + (T - 1) * n, x = c, b = p - m;
+  return {
+    bottom: m,
+    firstItemIndex: s,
+    items: So(e, r, s),
+    offsetBottom: b,
+    offsetTop: c,
+    top: x,
+    topItems: So(t, r, s),
+    topListHeight: t.reduce((E, g) => g.size + E, 0),
+    totalCount: o
+  };
+}
+function on(e, t, o, n, r, s) {
+  let i = 0;
+  if (o.groupIndices.length > 0)
+    for (const m of o.groupIndices) {
+      if (m - i >= e)
+        break;
+      i++;
+    }
+  const l = e + i, a = Zt(t, l), c = Array.from({ length: l }).map((m, T) => ({
+    data: s[T + a],
+    index: T + a,
+    offset: 0,
+    size: 0
+  }));
+  return St(c, [], l, r, o, n);
+}
+function So(e, t, o) {
+  if (e.length === 0)
+    return [];
+  if (!zt(t))
+    return e.map((c) => ({ ...c, index: c.index + o, originalIndex: c.index }));
+  const n = e[0].index, r = e[e.length - 1].index, s = [], i = Ze(t.groupOffsetTree, n, r);
+  let l, a = 0;
+  for (const c of e) {
+    (!l || l.end < c.index) && (l = i.shift(), a = t.groupIndices.indexOf(l.start));
+    let m;
+    c.index === l.start ? m = {
+      index: a,
+      type: "group"
+    } : m = {
+      groupIndex: a,
+      index: c.index - (a + 1) + o
+    }, s.push({
+      ...m,
+      data: c.data,
+      offset: c.offset,
+      originalIndex: c.index,
+      size: c.size
+    });
+  }
+  return s;
+}
+function bo(e, t) {
+  var o;
+  return e === void 0 ? 0 : typeof e == "number" ? e : (o = e[t]) != null ? o : 0;
+}
+const qe = J(
+  ([
+    { data: e, firstItemIndex: t, gap: o, sizes: n, totalCount: r },
+    s,
+    { listBoundary: i, topListHeight: l, visibleRange: a },
+    { initialTopMostItemIndex: c, scrolledToInitialItem: m },
+    { topListHeight: T },
+    p,
+    { didMount: x },
+    { recalcInProgress: b }
+  ]) => {
+    const E = S([]), g = S(0), d = Y(), f = S(0);
+    B(s.topItemsIndexes, E);
+    const I = Se(
+      w(
+        de(
+          x,
+          b,
+          N(a, lt),
+          N(r),
+          N(n),
+          N(c),
+          m,
+          N(E),
+          N(t),
+          N(o),
+          N(f),
+          e
+        ),
+        W(([u, v, , y, , , , , , , , z]) => {
+          const A = z && z.length !== y;
+          return u && !v && !A;
+        }),
+        j(
+          ([
+            ,
+            ,
+            [u, v],
+            y,
+            z,
+            A,
+            F,
+            D,
+            _,
+            V,
+            X,
+            K
+          ]) => {
+            var ve, we, Te, h;
+            const M = z, { offsetTree: q, sizeTree: Q } = M, Pe = ae(g);
+            if (y === 0)
+              return { ...Pt, totalCount: y };
+            if (u === 0 && v === 0)
+              return Pe === 0 ? { ...Pt, totalCount: y } : on(Pe, A, z, _, V, K || []);
+            if (oe(Q))
+              return Pe > 0 ? null : St(
+                mr(Zt(A, y), M, K),
+                [],
+                y,
+                V,
+                M,
+                _
+              );
+            const Be = [];
+            if (D.length > 0) {
+              const fe = D[0], ce = D[D.length - 1];
+              let he = 0;
+              for (const ue of Ze(Q, fe, ce)) {
+                const te = ue.value, re = Math.max(ue.start, fe), ke = Math.min(ue.end, ce);
+                for (let ge = re; ge <= ke; ge++)
+                  Be.push({ data: K?.[ge], index: ge, offset: he, size: te }), he += te;
+              }
+            }
+            if (!F)
+              return St([], Be, y, V, M, _);
+            const ee = D.length > 0 ? D[D.length - 1] + 1 : 0, R = tr(q, u, v, ee);
+            if (R.length === 0)
+              return null;
+            const G = y - 1, ne = kt([], (fe) => {
+              for (const ce of R) {
+                const he = ce.value;
+                let ue = he.offset, te = ce.start;
+                const re = he.size;
+                if (he.offset < u) {
+                  te += Math.floor((u - he.offset + V) / (re + V));
+                  const ge = te - ce.start;
+                  ue += ge * re + ge * V;
+                }
+                te < ee && (ue += (ee - te) * re, te = ee);
+                const ke = Math.min(ce.end, G);
+                for (let ge = te; ge <= ke && !(ue >= v); ge++)
+                  fe.push({ data: K?.[ge], index: ge, offset: ue, size: re }), ue += re + V;
+              }
+            }), pe = bo(X, ut), Ee = bo(X, dt);
+            if (ne.length > 0 && (pe > 0 || Ee > 0)) {
+              const fe = ne[0], ce = ne[ne.length - 1];
+              if (pe > 0 && fe.index > ee) {
+                const he = Math.min(pe, fe.index - ee), ue = [];
+                let te = fe.offset;
+                for (let re = fe.index - 1; re >= fe.index - he; re--) {
+                  const ke = (we = (ve = Ze(Q, re, re)[0]) == null ? void 0 : ve.value) != null ? we : fe.size;
+                  te -= ke + V, ue.unshift({ data: K?.[re], index: re, offset: te, size: ke });
+                }
+                ne.unshift(...ue);
+              }
+              if (Ee > 0 && ce.index < G) {
+                const he = Math.min(Ee, G - ce.index);
+                let ue = ce.offset + ce.size + V;
+                for (let te = ce.index + 1; te <= ce.index + he; te++) {
+                  const re = (h = (Te = Ze(Q, te, te)[0]) == null ? void 0 : Te.value) != null ? h : ce.size;
+                  ne.push({ data: K?.[te], index: te, offset: ue, size: re }), ue += re + V;
+                }
+              }
+            }
+            return St(ne, Be, y, V, M, _);
+          }
+        ),
+        //@ts-expect-error filter needs to be fixed
+        W((u) => u !== null),
+        se()
+      ),
+      Pt
+    );
+    B(
+      w(
+        e,
+        W(Ut),
+        j((u) => u?.length)
+      ),
+      r
+    ), B(
+      w(
+        I,
+        j((u) => u.topListHeight)
+      ),
+      T
+    ), B(T, l), B(
+      w(
+        I,
+        j((u) => [u.top, u.bottom])
+      ),
+      i
+    ), B(
+      w(
+        I,
+        j((u) => u.items)
+      ),
+      d
+    );
+    const O = Re(
+      w(
+        I,
+        W(({ items: u }) => u.length > 0),
+        U(r, e),
+        W(([{ items: u }, v]) => u[u.length - 1].originalIndex === v - 1),
+        j(([, u, v]) => [u - 1, v]),
+        se(lt),
+        j(([u]) => u)
+      )
+    ), k = Re(
+      w(
+        I,
+        We(200),
+        W(({ items: u, topItems: v }) => u.length > 0 && u[0].originalIndex === v.length),
+        j(({ items: u }) => u[0].index),
+        se()
+      )
+    ), H = Re(
+      w(
+        I,
+        W(({ items: u }) => u.length > 0),
+        j(({ items: u }) => {
+          let v = 0, y = u.length - 1;
+          for (; u[v].type === "group" && v < y; )
+            v++;
+          for (; u[y].type === "group" && y > v; )
+            y--;
+          return {
+            endIndex: u[y].index,
+            startIndex: u[v].index
+          };
+        }),
+        se(Jo)
+      )
+    );
+    return {
+      endReached: O,
+      initialItemCount: g,
+      itemsRendered: d,
+      listState: I,
+      minOverscanItemCount: f,
+      rangeChanged: H,
+      startReached: k,
+      topItemsIndexes: E,
+      ...p
+    };
+  },
+  ie(
+    Me,
+    Qo,
+    Kt,
+    mt,
+    ft,
+    ht,
+    Ve,
+    qt
+  ),
+  { singleton: !0 }
+), nn = J(
+  ([{ fixedFooterHeight: e, fixedHeaderHeight: t, footerHeight: o, headerHeight: n }, { listState: r }]) => {
+    const s = Y(), i = Se(
+      w(
+        de(o, e, n, t, r),
+        j(([l, a, c, m, T]) => l + a + c + m + T.offsetBottom + T.bottom)
+      ),
+      0
+    );
+    return B(N(i), s), { totalListHeight: i, totalListHeightChanged: s };
+  },
+  ie(be, qe),
+  { singleton: !0 }
+), hr = J(
+  ([{ viewportHeight: e }, { totalListHeight: t }]) => {
+    const o = S(!1), n = Se(
+      w(
+        de(o, e, t),
+        W(([r]) => r),
+        j(([, r, s]) => Math.max(0, r - s)),
+        We(0),
+        se()
+      ),
+      0
+    );
+    return { alignToBottom: o, paddingTopAddition: n };
+  },
+  ie(be, nn),
+  { singleton: !0 }
+), rn = J(() => ({
+  context: S(null)
+})), pr = ({
+  itemBottom: e,
+  itemTop: t,
+  locationParams: { align: o, behavior: n, ...r },
+  viewportBottom: s,
+  viewportTop: i
+}) => t < i ? { ...r, align: o ?? "start", behavior: n } : e > s ? { ...r, align: o ?? "end", behavior: n } : null, sn = J(
+  ([
+    { gap: e, sizes: t, totalCount: o },
+    { fixedFooterHeight: n, fixedHeaderHeight: r, headerHeight: s, scrollingInProgress: i, scrollTop: l, viewportHeight: a },
+    { scrollToIndex: c }
+  ]) => {
+    const m = Y();
+    return B(
+      w(
+        m,
+        U(t, a, o, s, r, n, l),
+        U(e),
+        j(([[T, p, x, b, E, g, d, f], I]) => {
+          const { align: O, behavior: k, calculateViewLocation: H = pr, done: u, ...v } = T, y = Ko(T, p, b - 1), z = at(y, p.offsetTree, I) + E + g, A = z + He(p.sizeTree, y)[1], F = f + g, D = f + x - d, _ = H({
+            itemBottom: A,
+            itemTop: z,
+            locationParams: { align: O, behavior: k, ...v },
+            viewportBottom: D,
+            viewportTop: F
+          });
+          return _ ? u && Oe(
+            w(
+              i,
+              W((V) => !V),
+              // skips the initial publish of false, and the cleanup call.
+              // but if scrollingInProgress is true, we skip the initial publish.
+              Ge(ae(i) ? 1 : 2)
+            ),
+            u
+          ) : u && u(), _;
+        }),
+        W((T) => T !== null)
+      ),
+      c
+    ), {
+      scrollIntoView: m
+    };
+  },
+  ie(Me, be, ft, qe, Le),
+  { singleton: !0 }
+);
+function yo(e) {
+  return e ? e === "smooth" ? "smooth" : "auto" : !1;
+}
+const gr = (e, t) => typeof e == "function" ? yo(e(t)) : t && yo(e), xr = J(
+  ([
+    { listRefresh: e, totalCount: t, fixedItemSize: o, data: n },
+    { atBottomState: r, isAtBottom: s },
+    { scrollToIndex: i },
+    { scrolledToInitialItem: l },
+    { didMount: a, propsReady: c },
+    { log: m },
+    { scrollingInProgress: T },
+    { context: p },
+    { scrollIntoView: x }
+  ]) => {
+    const b = S(!1), E = Y();
+    let g = null;
+    function d(k) {
+      $(i, {
+        align: "end",
+        behavior: k,
+        index: "LAST"
+      });
+    }
+    Z(
+      w(
+        de(w(N(t), Ge(1)), a),
+        U(N(b), s, l, T),
+        j(([[k, H], u, v, y, z]) => {
+          let A = H && y, F = "auto";
+          return A && (F = gr(u, v || z), A = A && !!F), { followOutputBehavior: F, shouldFollow: A, totalCount: k };
+        }),
+        W(({ shouldFollow: k }) => k)
+      ),
+      ({ followOutputBehavior: k, totalCount: H }) => {
+        g && (g(), g = null), ae(o) ? requestAnimationFrame(() => {
+          ae(m)("following output to ", { totalCount: H }, ye.DEBUG), d(k);
+        }) : g = Oe(e, () => {
+          ae(m)("following output to ", { totalCount: H }, ye.DEBUG), d(k), g = null;
+        });
+      }
+    );
+    function f(k) {
+      const H = Oe(r, (u) => {
+        k && !u.atBottom && u.notAtBottomBecause === "SIZE_INCREASED" && !g && (ae(m)("scrolling to bottom due to increased size", {}, ye.DEBUG), d("auto"));
+      });
+      setTimeout(H, 100);
+    }
+    Z(
+      w(
+        de(N(b), t, c),
+        W(([k, , H]) => k && H),
+        _e(
+          ({ value: k }, [, H]) => ({ refreshed: k === H, value: H }),
+          { refreshed: !1, value: 0 }
+        ),
+        W(({ refreshed: k }) => k),
+        U(b, t)
+      ),
+      ([, k]) => {
+        ae(l) && f(k !== !1);
+      }
+    ), Z(E, () => {
+      f(ae(b) !== !1);
+    }), Z(de(N(b), r), ([k, H]) => {
+      k && !H.atBottom && H.notAtBottomBecause === "VIEWPORT_HEIGHT_DECREASING" && d("auto");
+    });
+    const I = S(null), O = Y();
+    return B(
+      Mt(
+        w(
+          N(n),
+          j((k) => {
+            var H;
+            return (H = k?.length) != null ? H : 0;
+          })
+        ),
+        w(N(t))
+      ),
+      O
+    ), Z(
+      w(
+        de(w(O, Ge(1)), a),
+        U(N(I), l, T, p),
+        j(([[k, H], u, v, y, z]) => H && v && u?.({ context: z, totalCount: k, scrollingInProgress: y })),
+        W((k) => !!k),
+        We(0)
+      ),
+      (k) => {
+        g && (g(), g = null), ae(o) ? requestAnimationFrame(() => {
+          ae(m)("scrolling into view", {}), $(x, k);
+        }) : g = Oe(e, () => {
+          ae(m)("scrolling into view", {}), $(x, k), g = null;
+        });
+      }
+    ), { autoscrollToBottom: E, followOutput: b, scrollIntoViewOnChange: I };
+  },
+  ie(
+    Me,
+    ht,
+    ft,
+    mt,
+    Ve,
+    Le,
+    be,
+    rn,
+    sn
+  )
+), vr = J(
+  ([{ data: e, firstItemIndex: t, gap: o, sizes: n }, { initialTopMostItemIndex: r }, { initialItemCount: s, listState: i }, { didMount: l }]) => (B(
+    w(
+      l,
+      U(s),
+      W(([, a]) => a !== 0),
+      U(r, n, t, o, e),
+      j(([[, a], c, m, T, p, x = []]) => on(a, c, m, T, p, x))
+    ),
+    i
+  ), {}),
+  ie(Me, mt, qe, Ve),
+  { singleton: !0 }
+), wr = J(
+  ([{ didMount: e }, { scrollTo: t }, { listState: o }]) => {
+    const n = S(0);
+    return Z(
+      w(
+        e,
+        U(n),
+        W(([, r]) => r !== 0),
+        j(([, r]) => ({ top: r }))
+      ),
+      (r) => {
+        Oe(
+          w(
+            o,
+            Ge(1),
+            W((s) => s.items.length > 1)
+          ),
+          () => {
+            requestAnimationFrame(() => {
+              $(t, r);
+            });
+          }
+        );
+      }
+    ), {
+      initialScrollTop: n
+    };
+  },
+  ie(Ve, be, qe),
+  { singleton: !0 }
+), ln = J(
+  ([{ scrollVelocity: e }]) => {
+    const t = S(!1), o = Y(), n = S(!1);
+    return B(
+      w(
+        e,
+        U(n, t, o),
+        W(([r, s]) => !!s),
+        j(([r, s, i, l]) => {
+          const { enter: a, exit: c } = s;
+          if (i) {
+            if (c(r, l))
+              return !1;
+          } else if (a(r, l))
+            return !0;
+          return i;
+        }),
+        se()
+      ),
+      t
+    ), Z(
+      w(de(t, e, o), U(n)),
+      ([[r, s, i], l]) => {
+        r && l && l.change && l.change(s, i);
+      }
+    ), { isSeeking: t, scrollSeekConfiguration: n, scrollSeekRangeChanged: o, scrollVelocity: e };
+  },
+  ie(ht),
+  { singleton: !0 }
+), Qt = J(([{ scrollContainerState: e, scrollTo: t }]) => {
+  const o = Y(), n = Y(), r = Y(), s = S(!1), i = S(void 0);
+  return B(
+    w(
+      de(o, n),
+      j(([{ scrollHeight: l, scrollTop: a, viewportHeight: c }, { offsetTop: m }]) => ({
+        scrollHeight: l,
+        scrollTop: Math.max(0, a - m),
+        viewportHeight: c
+      }))
+    ),
+    e
+  ), B(
+    w(
+      t,
+      U(n),
+      j(([l, { offsetTop: a }]) => ({
+        ...l,
+        top: l.top + a
+      }))
+    ),
+    r
+  ), {
+    customScrollParent: i,
+    // config
+    useWindowScroll: s,
+    // input
+    windowScrollContainerState: o,
+    // signals
+    windowScrollTo: r,
+    windowViewportRect: n
+  };
+}, ie(be)), Tr = J(
+  ([
+    { sizeRanges: e, sizes: t },
+    { headerHeight: o, scrollTop: n },
+    { initialTopMostItemIndex: r },
+    { didMount: s },
+    { useWindowScroll: i, windowScrollContainerState: l, windowViewportRect: a }
+  ]) => {
+    const c = Y(), m = S(void 0), T = S(null), p = S(null);
+    return B(l, T), B(a, p), Z(
+      w(
+        c,
+        U(t, n, i, T, p, o)
+      ),
+      ([x, b, E, g, d, f, I]) => {
+        const O = nr(b.sizeTree);
+        g && d !== null && f !== null && (E = d.scrollTop - f.offsetTop), E -= I, x({ ranges: O, scrollTop: E });
+      }
+    ), B(w(m, W(Ut), j(Ir)), r), B(
+      w(
+        s,
+        U(m),
+        W(([, x]) => x !== void 0),
+        se(),
+        j(([, x]) => x.ranges)
+      ),
+      e
+    ), {
+      getState: c,
+      restoreStateFrom: m
+    };
+  },
+  ie(Me, be, mt, Ve, Qt)
+);
+function Ir(e) {
+  return { align: "start", index: 0, offset: e.scrollTop };
+}
+const Sr = J(([{ topItemsIndexes: e }]) => {
+  const t = S(0);
+  return B(
+    w(
+      t,
+      W((o) => o >= 0),
+      j((o) => Array.from({ length: o }).map((n, r) => r))
+    ),
+    e
+  ), { topItemCount: t };
+}, ie(qe));
+function an(e) {
+  let t = !1, o;
+  return () => (t || (t = !0, o = e()), o);
+}
+const br = an(() => /iP(ad|od|hone)/i.test(navigator.userAgent) && /WebKit/i.test(navigator.userAgent)), yr = J(
+  ([
+    { deviation: e, scrollBy: t, scrollingInProgress: o, scrollTop: n },
+    { isAtBottom: r, isScrolling: s, lastJumpDueToItemResize: i, scrollDirection: l },
+    { listState: a },
+    { beforeUnshiftWith: c, gap: m, shiftWithOffset: T, sizes: p },
+    { log: x },
+    { recalcInProgress: b }
+  ]) => {
+    const E = Re(
+      w(
+        a,
+        U(i),
+        _e(
+          ([, d, f, I], [{ bottom: O, items: k, offsetBottom: H, totalCount: u }, v]) => {
+            const y = O + H;
+            let z = 0;
+            return f === u && d.length > 0 && k.length > 0 && (k[0].originalIndex === 0 && d[0].originalIndex === 0 || (z = y - I, z !== 0 && (z += v))), [z, k, u, y];
+          },
+          [0, [], 0, 0]
+        ),
+        W(([d]) => d !== 0),
+        U(n, l, o, r, x, b),
+        W(([, d, f, I, , , O]) => !O && !I && d !== 0 && f === ct),
+        j(([[d], , , , , f]) => (f("Upward scrolling compensation", { amount: d }, ye.DEBUG), d))
+      )
+    );
+    function g(d) {
+      d > 0 ? ($(t, { behavior: "auto", top: -d }), $(e, 0)) : ($(e, 0), $(t, { behavior: "auto", top: -d }));
+    }
+    return Z(w(E, U(e, s)), ([d, f, I]) => {
+      I && br() ? $(e, f - d) : g(-d);
+    }), Z(
+      w(
+        de(Se(s, !1), e, b),
+        W(([d, f, I]) => !d && !I && f !== 0),
+        j(([d, f]) => f),
+        We(1)
+      ),
+      g
+    ), B(
+      w(
+        T,
+        j((d) => ({ top: -d }))
+      ),
+      t
+    ), Z(
+      w(
+        c,
+        U(p, m),
+        j(([d, { groupIndices: f, lastSize: I, sizeTree: O }, k]) => {
+          function H(u) {
+            return u * (I + k);
+          }
+          if (f.length === 0)
+            return H(d);
+          {
+            let u = 0;
+            const v = it(O, 0);
+            let y = 0, z = 0;
+            for (; y < d; ) {
+              y++, u += v;
+              let A = f.length === z + 1 ? 1 / 0 : f[z + 1] - f[z] - 1;
+              y + A > d && (u -= v, A = d - y + 1), y += A, u += H(A), z++;
+            }
+            return u;
+          }
+        })
+      ),
+      (d) => {
+        $(e, d), requestAnimationFrame(() => {
+          $(t, { top: d }), requestAnimationFrame(() => {
+            $(e, 0), $(b, !1);
+          });
+        });
+      }
+    ), { deviation: e };
+  },
+  ie(be, ht, qe, Me, Le, qt)
+), Cr = J(
+  ([
+    e,
+    t,
+    o,
+    n,
+    r,
+    s,
+    i,
+    l,
+    a,
+    c,
+    m
+  ]) => ({
+    ...e,
+    ...t,
+    ...o,
+    ...n,
+    ...r,
+    ...s,
+    ...i,
+    ...l,
+    ...a,
+    ...c,
+    ...m
+  }),
+  ie(
+    Kt,
+    vr,
+    Ve,
+    ln,
+    nn,
+    wr,
+    hr,
+    Qt,
+    sn,
+    Le,
+    rn
+  )
+), cn = J(
+  ([
+    {
+      data: e,
+      defaultItemSize: t,
+      firstItemIndex: o,
+      fixedItemSize: n,
+      fixedGroupSize: r,
+      gap: s,
+      groupIndices: i,
+      heightEstimates: l,
+      itemSize: a,
+      sizeRanges: c,
+      sizes: m,
+      statefulTotalCount: T,
+      totalCount: p,
+      trackItemSizes: x
+    },
+    { initialItemFinalLocationReached: b, initialTopMostItemIndex: E, scrolledToInitialItem: g },
+    d,
+    f,
+    I,
+    O,
+    { scrollToIndex: k },
+    H,
+    { topItemCount: u },
+    { groupCounts: v },
+    y
+  ]) => {
+    const { listState: z, minOverscanItemCount: A, topItemsIndexes: F, rangeChanged: D, ..._ } = O;
+    return B(D, y.scrollSeekRangeChanged), B(
+      w(
+        y.windowViewportRect,
+        j((V) => V.visibleHeight)
+      ),
+      d.viewportHeight
+    ), {
+      data: e,
+      defaultItemHeight: t,
+      firstItemIndex: o,
+      fixedItemHeight: n,
+      fixedGroupHeight: r,
+      gap: s,
+      groupCounts: v,
+      heightEstimates: l,
+      initialItemFinalLocationReached: b,
+      initialTopMostItemIndex: E,
+      scrolledToInitialItem: g,
+      sizeRanges: c,
+      topItemCount: u,
+      topItemsIndexes: F,
+      // input
+      totalCount: p,
+      ...I,
+      groupIndices: i,
+      itemSize: a,
+      listState: z,
+      minOverscanItemCount: A,
+      scrollToIndex: k,
+      // output
+      statefulTotalCount: T,
+      trackItemSizes: x,
+      // exported from stateFlagsSystem
+      rangeChanged: D,
+      ..._,
+      // the bag of IO from featureGroup1System
+      ...y,
+      ...d,
+      sizes: m,
+      ...f
+    };
+  },
+  ie(
+    Me,
+    mt,
+    be,
+    Tr,
+    xr,
+    qe,
+    ft,
+    yr,
+    Sr,
+    Qo,
+    Cr
+  )
+);
+function Rr(e, t) {
+  const o = {}, n = {};
+  let r = 0;
+  const s = e.length;
+  for (; r < s; )
+    n[e[r]] = 1, r += 1;
+  for (const i in t)
+    Object.hasOwn(n, i) || (o[i] = t[i]);
+  return o;
+}
+const xt = typeof document < "u" ? P.useLayoutEffect : P.useEffect;
+function un(e, t, o) {
+  const n = Object.keys(t.required || {}), r = Object.keys(t.optional || {}), s = Object.keys(t.methods || {}), i = Object.keys(t.events || {}), l = P.createContext({});
+  function a(g, d) {
+    g.propsReady && $(g.propsReady, !1);
+    for (const f of n) {
+      const I = g[t.required[f]];
+      $(I, d[f]);
+    }
+    for (const f of r)
+      if (f in d) {
+        const I = g[t.optional[f]];
+        $(I, d[f]);
+      }
+    g.propsReady && $(g.propsReady, !0);
+  }
+  function c(g) {
+    return s.reduce((d, f) => (d[f] = (I) => {
+      const O = g[t.methods[f]];
+      $(O, I);
+    }, d), {});
+  }
+  function m(g) {
+    return i.reduce((d, f) => (d[f] = Ln(g[t.events[f]]), d), {});
+  }
+  const T = P.forwardRef((g, d) => {
+    const { children: f, ...I } = g, [O] = P.useState(() => kt($n(e), (u) => {
+      a(u, I);
+    })), [k] = P.useState(ho(m, O));
+    xt(() => {
+      for (const u of i)
+        u in I && Z(k[u], I[u]);
+      return () => {
+        Object.values(k).map(Gt);
+      };
+    }, [I, k, O]), xt(() => {
+      a(O, I);
+    }), P.useImperativeHandle(d, mo(c(O)));
+    const H = o;
+    return /* @__PURE__ */ C.jsx(l.Provider, { value: O, children: o ? /* @__PURE__ */ C.jsx(H, { ...Rr([...n, ...r, ...i], I), children: f }) : f });
+  }), p = (g) => {
+    const d = P.useContext(l);
+    return P.useCallback(
+      (f) => {
+        $(d[g], f);
+      },
+      [d, g]
+    );
+  }, x = (g) => {
+    const d = P.useContext(l)[g], f = P.useCallback(
+      (I) => Z(d, I),
+      [d]
+    );
+    return P.useSyncExternalStore(
+      f,
+      () => ae(d),
+      () => ae(d)
+    );
+  }, b = (g) => {
+    const d = P.useContext(l)[g], [f, I] = P.useState(ho(ae, d));
+    return xt(
+      () => Z(d, (O) => {
+        O !== f && I(mo(O));
+      }),
+      [d, f]
+    ), f;
+  }, E = P.version.startsWith("18") ? x : b;
+  return {
+    Component: T,
+    useEmitter: (g, d) => {
+      const f = P.useContext(l)[g];
+      xt(() => Z(f, d), [d, f]);
+    },
+    useEmitterValue: E,
+    usePublisher: p
+  };
+}
+const dn = P.createContext(void 0), fn = P.createContext(void 0), mn = typeof document < "u" ? P.useLayoutEffect : P.useEffect;
+function Bt(e) {
+  return "self" in e;
+}
+function Er(e) {
+  return "body" in e;
+}
+function hn(e, t, o, n = Qe, r, s) {
+  const i = P.useRef(null), l = P.useRef(null), a = P.useRef(null), c = P.useCallback(
+    (p) => {
+      let x, b, E;
+      const g = p.target;
+      if (Er(g) || Bt(g)) {
+        const f = Bt(g) ? g : g.defaultView;
+        E = s ? f.scrollX : f.scrollY, x = s ? f.document.documentElement.scrollWidth : f.document.documentElement.scrollHeight, b = s ? f.innerWidth : f.innerHeight;
+      } else
+        E = s ? g.scrollLeft : g.scrollTop, x = s ? g.scrollWidth : g.scrollHeight, b = s ? g.offsetWidth : g.offsetHeight;
+      const d = () => {
+        e({
+          scrollHeight: x,
+          scrollTop: Math.max(E, 0),
+          viewportHeight: b
+        });
+      };
+      p.suppressFlushSync ? d() : Rn.flushSync(d), l.current !== null && (E === l.current || E <= 0 || E === x - b) && (l.current = null, t(!0), a.current && (clearTimeout(a.current), a.current = null));
+    },
+    [e, t, s]
+  );
+  P.useEffect(() => {
+    const p = r || i.current;
+    return n(r || i.current), c({ suppressFlushSync: !0, target: p }), p.addEventListener("scroll", c, { passive: !0 }), () => {
+      n(null), p.removeEventListener("scroll", c);
+    };
+  }, [i, c, o, n, r]);
+  function m(p) {
+    const x = i.current;
+    if (!x || (s ? "offsetWidth" in x && x.offsetWidth === 0 : "offsetHeight" in x && x.offsetHeight === 0))
+      return;
+    const b = p.behavior === "smooth";
+    let E, g, d;
+    Bt(x) ? (g = Math.max(
+      Fe(x.document.documentElement, s ? "width" : "height"),
+      s ? x.document.documentElement.scrollWidth : x.document.documentElement.scrollHeight
+    ), E = s ? x.innerWidth : x.innerHeight, d = s ? window.scrollX : window.scrollY) : (g = x[s ? "scrollWidth" : "scrollHeight"], E = Fe(x, s ? "width" : "height"), d = x[s ? "scrollLeft" : "scrollTop"]);
+    const f = g - E;
+    if (p.top = Math.ceil(Math.max(Math.min(f, p.top), 0)), tn(E, g) || p.top === d) {
+      e({ scrollHeight: g, scrollTop: d, viewportHeight: E }), b && t(!0);
+      return;
+    }
+    b ? (l.current = p.top, a.current && clearTimeout(a.current), a.current = setTimeout(() => {
+      a.current = null, l.current = null, t(!0);
+    }, 1e3)) : l.current = null, s && (p = { behavior: p.behavior, left: p.top }), x.scrollTo(p);
+  }
+  function T(p) {
+    s && (p = { behavior: p.behavior, left: p.top }), i.current.scrollBy(p);
+  }
+  return { scrollByCallback: T, scrollerRef: i, scrollToCallback: m };
+}
+const At = "-webkit-sticky", Co = "sticky", eo = an(() => {
+  if (typeof document > "u")
+    return Co;
+  const e = document.createElement("div");
+  return e.style.position = At, e.style.position === At ? At : Co;
+});
+function to(e) {
+  return e;
+}
+const kr = /* @__PURE__ */ J(() => {
+  const e = S((l) => `Item ${l}`), t = S((l) => `Group ${l}`), o = S({}), n = S(to), r = S("div"), s = S(Qe), i = (l, a = null) => Se(
+    w(
+      o,
+      j((c) => c[l]),
+      se()
+    ),
+    a
+  );
+  return {
+    components: o,
+    computeItemKey: n,
+    EmptyPlaceholder: i("EmptyPlaceholder"),
+    FooterComponent: i("Footer"),
+    GroupComponent: i("Group", "div"),
+    groupContent: t,
+    HeaderComponent: i("Header"),
+    HeaderFooterTag: r,
+    ItemComponent: i("Item", "div"),
+    itemContent: e,
+    ListComponent: i("List", "div"),
+    ScrollerComponent: i("Scroller", "div"),
+    scrollerRef: s,
+    ScrollSeekPlaceholder: i("ScrollSeekPlaceholder"),
+    TopItemListComponent: i("TopItemList")
+  };
+}), zr = /* @__PURE__ */ J(
+  ([e, t]) => ({ ...e, ...t }),
+  ie(cn, kr)
+), jr = ({ height: e }) => /* @__PURE__ */ C.jsx("div", { style: { height: e } }), Or = { overflowAnchor: "none", position: eo(), zIndex: 1 }, pn = { overflowAnchor: "none" }, Hr = { ...pn, display: "inline-block", height: "100%" }, Ro = /* @__PURE__ */ P.memo(function({ showTopList: e = !1 }) {
+  const t = L("listState"), o = ze("sizeRanges"), n = L("useWindowScroll"), r = L("customScrollParent"), s = ze("windowScrollContainerState"), i = ze("scrollContainerState"), l = r || n ? s : i, a = L("itemContent"), c = L("context"), m = L("groupContent"), T = L("trackItemSizes"), p = L("itemSize"), x = L("log"), b = ze("gap"), E = L("horizontalDirection"), { callbackRef: g } = Yn(
+    o,
+    p,
+    T,
+    e ? Qe : l,
+    x,
+    b,
+    r,
+    E,
+    L("skipAnimationFrameInResizeObserver")
+  ), [d, f] = P.useState(0);
+  oo("deviation", (_) => {
+    d !== _ && f(_);
+  });
+  const I = L("EmptyPlaceholder"), O = L("ScrollSeekPlaceholder") || jr, k = L("ListComponent"), H = L("ItemComponent"), u = L("GroupComponent"), v = L("computeItemKey"), y = L("isSeeking"), z = L("groupIndices").length > 0, A = L("alignToBottom"), F = L("initialItemFinalLocationReached"), D = e ? {} : {
+    boxSizing: "border-box",
+    ...E ? {
+      display: "inline-block",
+      height: "100%",
+      marginLeft: d !== 0 ? d : A ? "auto" : 0,
+      paddingLeft: t.offsetTop,
+      paddingRight: t.offsetBottom,
+      whiteSpace: "nowrap"
+    } : {
+      marginTop: d !== 0 ? d : A ? "auto" : 0,
+      paddingBottom: t.offsetBottom,
+      paddingTop: t.offsetTop
+    },
+    ...F ? {} : { visibility: "hidden" }
+  };
+  return !e && t.totalCount === 0 && I ? /* @__PURE__ */ C.jsx(I, { ...Ie(I, c) }) : /* @__PURE__ */ C.jsx(
+    k,
+    {
+      ...Ie(k, c),
+      "data-testid": e ? "virtuoso-top-item-list" : "virtuoso-item-list",
+      ref: g,
+      style: D,
+      children: (e ? t.topItems : t.items).map((_) => {
+        const V = _.originalIndex, X = v(V + t.firstItemIndex, _.data, c);
+        return y ? /* @__PURE__ */ wt(
+          O,
+          {
+            ...Ie(O, c),
+            height: _.size,
+            index: _.index,
+            key: X,
+            type: _.type || "item",
+            ..._.type === "group" ? {} : { groupIndex: _.groupIndex }
+          }
+        ) : _.type === "group" ? /* @__PURE__ */ wt(
+          u,
+          {
+            ...Ie(u, c),
+            "data-index": V,
+            "data-item-index": _.index,
+            "data-known-size": _.size,
+            key: X,
+            style: Or
+          },
+          m(_.index, c)
+        ) : /* @__PURE__ */ wt(
+          H,
+          {
+            ...Ie(H, c),
+            ..._r(H, _.data),
+            "data-index": V,
+            "data-item-group-index": _.groupIndex,
+            "data-item-index": _.index,
+            "data-known-size": _.size,
+            key: X,
+            style: E ? Hr : pn
+          },
+          z ? a(_.index, _.groupIndex, _.data, c) : a(_.index, _.data, c)
+        );
+      })
+    }
+  );
+}), Pr = {
+  height: "100%",
+  outline: "none",
+  overflowY: "auto",
+  position: "relative",
+  WebkitOverflowScrolling: "touch"
+}, Br = {
+  outline: "none",
+  overflowX: "auto",
+  position: "relative"
+}, jt = (e) => ({
+  height: "100%",
+  position: "absolute",
+  top: 0,
+  width: "100%",
+  ...e ? { display: "flex", flexDirection: "column" } : {}
+}), Ar = {
+  position: eo(),
+  top: 0,
+  width: "100%",
+  zIndex: 1
+};
+function Ie(e, t) {
+  if (typeof e != "string")
+    return { context: t };
+}
+function _r(e, t) {
+  return { item: typeof e == "string" ? void 0 : t };
+}
+const Mr = /* @__PURE__ */ P.memo(function() {
+  const e = L("HeaderComponent"), t = ze("headerHeight"), o = L("HeaderFooterTag"), n = Ye(
+    P.useMemo(
+      () => (s) => {
+        t(Fe(s, "height"));
+      },
+      [t]
+    ),
+    !0,
+    L("skipAnimationFrameInResizeObserver")
+  ), r = L("context");
+  return e ? /* @__PURE__ */ C.jsx(o, { ref: n, children: /* @__PURE__ */ C.jsx(e, { ...Ie(e, r) }) }) : null;
+}), Nr = /* @__PURE__ */ P.memo(function() {
+  const e = L("FooterComponent"), t = ze("footerHeight"), o = L("HeaderFooterTag"), n = Ye(
+    P.useMemo(
+      () => (s) => {
+        t(Fe(s, "height"));
+      },
+      [t]
+    ),
+    !0,
+    L("skipAnimationFrameInResizeObserver")
+  ), r = L("context");
+  return e ? /* @__PURE__ */ C.jsx(o, { ref: n, children: /* @__PURE__ */ C.jsx(e, { ...Ie(e, r) }) }) : null;
+});
+function gn({ useEmitter: e, useEmitterValue: t, usePublisher: o }) {
+  return P.memo(function({ children: n, style: r, context: s, ...i }) {
+    const l = o("scrollContainerState"), a = t("ScrollerComponent"), c = o("smoothScrollTargetReached"), m = t("scrollerRef"), T = t("horizontalDirection") || !1, { scrollByCallback: p, scrollerRef: x, scrollToCallback: b } = hn(
+      l,
+      c,
+      a,
+      m,
+      void 0,
+      T
+    );
+    return e("scrollTo", b), e("scrollBy", p), /* @__PURE__ */ C.jsx(
+      a,
+      {
+        "data-testid": "virtuoso-scroller",
+        "data-virtuoso-scroller": !0,
+        ref: x,
+        style: { ...T ? Br : Pr, ...r },
+        tabIndex: 0,
+        ...i,
+        ...Ie(a, s),
+        children: n
+      }
+    );
+  });
+}
+function xn({ useEmitter: e, useEmitterValue: t, usePublisher: o }) {
+  return P.memo(function({ children: n, style: r, context: s, ...i }) {
+    const l = o("windowScrollContainerState"), a = t("ScrollerComponent"), c = o("smoothScrollTargetReached"), m = t("totalListHeight"), T = t("deviation"), p = t("customScrollParent"), x = P.useRef(null), b = t("scrollerRef"), { scrollByCallback: E, scrollerRef: g, scrollToCallback: d } = hn(
+      l,
+      c,
+      a,
+      b,
+      p
+    );
+    return mn(() => {
+      var f;
+      return g.current = p || ((f = x.current) == null ? void 0 : f.ownerDocument.defaultView), () => {
+        g.current = null;
+      };
+    }, [g, p]), e("windowScrollTo", d), e("scrollBy", E), /* @__PURE__ */ C.jsx(
+      a,
+      {
+        ref: x,
+        "data-virtuoso-scroller": !0,
+        style: { position: "relative", ...r, ...m !== 0 ? { height: m + T } : {} },
+        ...i,
+        ...Ie(a, s),
+        children: n
+      }
+    );
+  });
+}
+const Wr = ({ children: e }) => {
+  const t = P.useContext(dn), o = ze("viewportHeight"), n = ze("fixedItemHeight"), r = L("alignToBottom"), s = L("horizontalDirection"), i = P.useMemo(
+    () => Do(o, (a) => Fe(a, s ? "width" : "height")),
+    [o, s]
+  ), l = Ye(i, !0, L("skipAnimationFrameInResizeObserver"));
+  return P.useEffect(() => {
+    t && (o(t.viewportHeight), n(t.itemHeight));
+  }, [t, o, n]), /* @__PURE__ */ C.jsx("div", { "data-viewport-type": "element", ref: l, style: jt(r), children: e });
+}, Fr = ({ children: e }) => {
+  const t = P.useContext(dn), o = ze("windowViewportRect"), n = ze("fixedItemHeight"), r = L("customScrollParent"), s = Vo(
+    o,
+    r,
+    L("skipAnimationFrameInResizeObserver")
+  ), i = L("alignToBottom");
+  return P.useEffect(() => {
+    t && (n(t.itemHeight), o({ offsetTop: 0, visibleHeight: t.viewportHeight, visibleWidth: 100 }));
+  }, [t, o, n]), /* @__PURE__ */ C.jsx("div", { "data-viewport-type": "window", ref: s, style: jt(i), children: e });
+}, Dr = ({ children: e }) => {
+  const t = L("TopItemListComponent") || "div", o = L("headerHeight"), n = { ...Ar, marginTop: `${o}px` }, r = L("context");
+  return /* @__PURE__ */ C.jsx(t, { style: n, ...Ie(t, r), children: e });
+}, Lr = /* @__PURE__ */ P.memo(function(e) {
+  const t = L("useWindowScroll"), o = L("topItemsIndexes").length > 0, n = L("customScrollParent"), r = L("context");
+  return /* @__PURE__ */ C.jsxs(n || t ? Ur : $r, { ...e, context: r, children: [
+    o && /* @__PURE__ */ C.jsx(Dr, { children: /* @__PURE__ */ C.jsx(Ro, { showTopList: !0 }) }),
+    /* @__PURE__ */ C.jsxs(n || t ? Fr : Wr, { children: [
+      /* @__PURE__ */ C.jsx(Mr, {}),
+      /* @__PURE__ */ C.jsx(Ro, {}),
+      /* @__PURE__ */ C.jsx(Nr, {})
+    ] })
+  ] });
+}), {
+  Component: Vr,
+  useEmitter: oo,
+  useEmitterValue: L,
+  usePublisher: ze
+} = /* @__PURE__ */ un(
+  zr,
+  {
+    required: {},
+    optional: {
+      restoreStateFrom: "restoreStateFrom",
+      context: "context",
+      followOutput: "followOutput",
+      scrollIntoViewOnChange: "scrollIntoViewOnChange",
+      itemContent: "itemContent",
+      groupContent: "groupContent",
+      overscan: "overscan",
+      increaseViewportBy: "increaseViewportBy",
+      minOverscanItemCount: "minOverscanItemCount",
+      totalCount: "totalCount",
+      groupCounts: "groupCounts",
+      topItemCount: "topItemCount",
+      firstItemIndex: "firstItemIndex",
+      initialTopMostItemIndex: "initialTopMostItemIndex",
+      components: "components",
+      atBottomThreshold: "atBottomThreshold",
+      atTopThreshold: "atTopThreshold",
+      computeItemKey: "computeItemKey",
+      defaultItemHeight: "defaultItemHeight",
+      fixedGroupHeight: "fixedGroupHeight",
+      // Must be set above 'fixedItemHeight'
+      fixedItemHeight: "fixedItemHeight",
+      heightEstimates: "heightEstimates",
+      itemSize: "itemSize",
+      scrollSeekConfiguration: "scrollSeekConfiguration",
+      headerFooterTag: "HeaderFooterTag",
+      data: "data",
+      initialItemCount: "initialItemCount",
+      initialScrollTop: "initialScrollTop",
+      alignToBottom: "alignToBottom",
+      useWindowScroll: "useWindowScroll",
+      customScrollParent: "customScrollParent",
+      scrollerRef: "scrollerRef",
+      logLevel: "logLevel",
+      horizontalDirection: "horizontalDirection",
+      skipAnimationFrameInResizeObserver: "skipAnimationFrameInResizeObserver"
+    },
+    methods: {
+      scrollToIndex: "scrollToIndex",
+      scrollIntoView: "scrollIntoView",
+      scrollTo: "scrollTo",
+      scrollBy: "scrollBy",
+      autoscrollToBottom: "autoscrollToBottom",
+      getState: "getState"
+    },
+    events: {
+      isScrolling: "isScrolling",
+      endReached: "endReached",
+      startReached: "startReached",
+      rangeChanged: "rangeChanged",
+      atBottomStateChange: "atBottomStateChange",
+      atTopStateChange: "atTopStateChange",
+      totalListHeightChanged: "totalListHeightChanged",
+      itemsRendered: "itemsRendered",
+      groupIndices: "groupIndices"
+    }
+  },
+  Lr
+), $r = /* @__PURE__ */ gn({ useEmitter: oo, useEmitterValue: L, usePublisher: ze }), Ur = /* @__PURE__ */ xn({ useEmitter: oo, useEmitterValue: L, usePublisher: ze }), Gr = Vr, Yr = /* @__PURE__ */ J(() => {
+  const e = S((c) => /* @__PURE__ */ C.jsxs("td", { children: [
+    "Item $",
+    c
+  ] })), t = S(null), o = S((c) => /* @__PURE__ */ C.jsxs("td", { colSpan: 1e3, children: [
+    "Group ",
+    c
+  ] })), n = S(null), r = S(null), s = S({}), i = S(to), l = S(Qe), a = (c, m = null) => Se(
+    w(
+      s,
+      j((T) => T[c]),
+      se()
+    ),
+    m
+  );
+  return {
+    components: s,
+    computeItemKey: i,
+    context: t,
+    EmptyPlaceholder: a("EmptyPlaceholder"),
+    FillerRow: a("FillerRow"),
+    fixedFooterContent: r,
+    fixedHeaderContent: n,
+    itemContent: e,
+    groupContent: o,
+    ScrollerComponent: a("Scroller", "div"),
+    scrollerRef: l,
+    ScrollSeekPlaceholder: a("ScrollSeekPlaceholder"),
+    TableBodyComponent: a("TableBody", "tbody"),
+    TableComponent: a("Table", "table"),
+    TableFooterComponent: a("TableFoot", "tfoot"),
+    TableHeadComponent: a("TableHead", "thead"),
+    TableRowComponent: a("TableRow", "tr"),
+    GroupComponent: a("Group", "tr")
+  };
+});
+ie(cn, Yr);
+eo();
+const Eo = {
+  bottom: 0,
+  itemHeight: 0,
+  items: [],
+  itemWidth: 0,
+  offsetBottom: 0,
+  offsetTop: 0,
+  top: 0
+}, qr = {
+  bottom: 0,
+  itemHeight: 0,
+  items: [{ index: 0 }],
+  itemWidth: 0,
+  offsetBottom: 0,
+  offsetTop: 0,
+  top: 0
+}, { ceil: ko, floor: yt, max: rt, min: _t, round: zo } = Math;
+function jo(e, t, o) {
+  return Array.from({ length: t - e + 1 }).map((n, r) => ({ data: o === null ? null : o[r + e], index: r + e }));
+}
+function Jr(e) {
+  return {
+    ...qr,
+    items: e
+  };
+}
+function vt(e, t) {
+  return e && e.width === t.width && e.height === t.height;
+}
+function Xr(e, t) {
+  return e && e.column === t.column && e.row === t.row;
+}
+const Zr = /* @__PURE__ */ J(
+  ([
+    { increaseViewportBy: e, listBoundary: t, overscan: o, visibleRange: n },
+    { footerHeight: r, headerHeight: s, scrollBy: i, scrollContainerState: l, scrollTo: a, scrollTop: c, smoothScrollTargetReached: m, viewportHeight: T },
+    p,
+    x,
+    { didMount: b, propsReady: E },
+    { customScrollParent: g, useWindowScroll: d, windowScrollContainerState: f, windowScrollTo: I, windowViewportRect: O },
+    k
+  ]) => {
+    const H = S(0), u = S(0), v = S(Eo), y = S({ height: 0, width: 0 }), z = S({ height: 0, width: 0 }), A = Y(), F = Y(), D = S(0), _ = S(null), V = S({ column: 0, row: 0 }), X = Y(), K = Y(), ve = S(!1), we = S(0), Te = S(!0), h = S(!1), M = S(!1);
+    Z(
+      w(
+        b,
+        U(we),
+        W(([R, G]) => !!G)
+      ),
+      () => {
+        $(Te, !1);
+      }
+    ), Z(
+      w(
+        de(b, Te, z, y, we, h),
+        W(([R, G, ne, pe, , Ee]) => R && !G && ne.height !== 0 && pe.height !== 0 && !Ee)
+      ),
+      ([, , , , R]) => {
+        $(h, !0), Xt(1, () => {
+          $(A, R);
+        }), Oe(w(c), () => {
+          $(t, [0, 0]), $(Te, !0);
+        });
+      }
+    ), B(
+      w(
+        K,
+        W((R) => R != null && R.scrollTop > 0),
+        Ae(0)
+      ),
+      u
+    ), Z(
+      w(
+        b,
+        U(K),
+        W(([, R]) => R != null)
+      ),
+      ([, R]) => {
+        R && ($(y, R.viewport), $(z, R.item), $(V, R.gap), R.scrollTop > 0 && ($(ve, !0), Oe(w(c, Ge(1)), (G) => {
+          $(ve, !1);
+        }), $(a, { top: R.scrollTop })));
+      }
+    ), B(
+      w(
+        y,
+        j(({ height: R }) => R)
+      ),
+      T
+    ), B(
+      w(
+        de(
+          N(y, vt),
+          N(z, vt),
+          N(V, (R, G) => R && R.column === G.column && R.row === G.row),
+          N(c)
+        ),
+        j(([R, G, ne, pe]) => ({
+          gap: ne,
+          item: G,
+          scrollTop: pe,
+          viewport: R
+        }))
+      ),
+      X
+    ), B(
+      w(
+        de(
+          N(H),
+          n,
+          N(V, Xr),
+          N(z, vt),
+          N(y, vt),
+          N(_),
+          N(u),
+          N(ve),
+          N(Te),
+          N(we)
+        ),
+        W(([, , , , , , , R]) => !R),
+        j(
+          ([
+            R,
+            [G, ne],
+            pe,
+            Ee,
+            fe,
+            ce,
+            he,
+            ,
+            ue,
+            te
+          ]) => {
+            const { column: re, row: ke } = pe, { height: ge, width: Ot } = Ee, { width: no } = fe;
+            if (he === 0 && (R === 0 || no === 0))
+              return Eo;
+            if (Ot === 0) {
+              const ao = Zt(te, R), bn = ao + Math.max(he - 1, 0);
+              return Jr(jo(ao, bn, ce));
+            }
+            const pt = vn(no, Ot, re);
+            let Je, $e;
+            ue ? G === 0 && ne === 0 && he > 0 ? (Je = 0, $e = he - 1) : (Je = pt * yt((G + ke) / (ge + ke)), $e = pt * ko((ne + ke) / (ge + ke)) - 1, $e = _t(R - 1, rt($e, pt - 1)), Je = _t($e, rt(0, Je))) : (Je = 0, $e = -1);
+            const ro = jo(Je, $e, ce), { bottom: so, top: io } = Oo(fe, pe, Ee, ro), lo = ko(R / pt), Sn = lo * ge + (lo - 1) * ke - so;
+            return { bottom: so, itemHeight: ge, items: ro, itemWidth: Ot, offsetBottom: Sn, offsetTop: io, top: io };
+          }
+        )
+      ),
+      v
+    ), B(
+      w(
+        _,
+        W((R) => R !== null),
+        j((R) => R.length)
+      ),
+      H
+    ), B(
+      w(
+        de(y, z, v, V),
+        W(([R, G, { items: ne }]) => ne.length > 0 && G.height !== 0 && R.height !== 0),
+        j(([R, G, { items: ne }, pe]) => {
+          const { bottom: Ee, top: fe } = Oo(R, pe, G, ne);
+          return [fe, Ee];
+        }),
+        se(lt)
+      ),
+      t
+    );
+    const q = S(!1);
+    B(
+      w(
+        c,
+        U(q),
+        j(([R, G]) => G || R !== 0)
+      ),
+      q
+    );
+    const Q = Re(
+      w(
+        de(v, H),
+        W(([{ items: R }]) => R.length > 0),
+        U(q),
+        W(([[R, G], ne]) => {
+          const pe = R.items[R.items.length - 1].index === G - 1;
+          return (ne || R.bottom > 0 && R.itemHeight > 0 && R.offsetBottom === 0 && R.items.length === G) && pe;
+        }),
+        j(([[, R]]) => R - 1),
+        se()
+      )
+    ), Pe = Re(
+      w(
+        N(v),
+        W(({ items: R }) => R.length > 0 && R[0].index === 0),
+        Ae(0),
+        se()
+      )
+    ), Be = Re(
+      w(
+        N(v),
+        U(ve),
+        W(([{ items: R }, G]) => R.length > 0 && !G),
+        j(([{ items: R }]) => ({
+          endIndex: R[R.length - 1].index,
+          startIndex: R[0].index
+        })),
+        se(Jo),
+        We(0)
+      )
+    );
+    B(Be, x.scrollSeekRangeChanged), B(
+      w(
+        A,
+        U(y, z, H, V),
+        j(([R, G, ne, pe, Ee]) => {
+          const fe = en(R), { align: ce, behavior: he, offset: ue } = fe;
+          let te = fe.index;
+          te === "LAST" && (te = pe - 1), te = rt(0, te, _t(pe - 1, te));
+          let re = Lt(G, Ee, ne, te);
+          return ce === "end" ? re = zo(re - G.height + ne.height) : ce === "center" && (re = zo(re - G.height / 2 + ne.height / 2)), ue && (re += ue), { behavior: he, top: re };
+        })
+      ),
+      a
+    );
+    const ee = Se(
+      w(
+        v,
+        j((R) => R.offsetBottom + R.bottom)
+      ),
+      0
+    );
+    return B(
+      w(
+        O,
+        j((R) => ({ height: R.visibleHeight, width: R.visibleWidth }))
+      ),
+      y
+    ), {
+      customScrollParent: g,
+      // input
+      data: _,
+      deviation: D,
+      footerHeight: r,
+      gap: V,
+      headerHeight: s,
+      increaseViewportBy: e,
+      initialItemCount: u,
+      itemDimensions: z,
+      overscan: o,
+      restoreStateFrom: K,
+      scrollBy: i,
+      scrollContainerState: l,
+      scrollHeight: F,
+      scrollTo: a,
+      scrollToIndex: A,
+      scrollTop: c,
+      smoothScrollTargetReached: m,
+      totalCount: H,
+      useWindowScroll: d,
+      viewportDimensions: y,
+      windowScrollContainerState: f,
+      windowScrollTo: I,
+      windowViewportRect: O,
+      ...x,
+      // output
+      gridState: v,
+      horizontalDirection: M,
+      initialTopMostItemIndex: we,
+      totalListHeight: ee,
+      ...p,
+      endReached: Q,
+      propsReady: E,
+      rangeChanged: Be,
+      startReached: Pe,
+      stateChanged: X,
+      stateRestoreInProgress: ve,
+      ...k
+    };
+  },
+  ie(Kt, be, ht, ln, Ve, Qt, Le)
+);
+function vn(e, t, o) {
+  return rt(1, yt((e + o) / (yt(t) + o)));
+}
+function Oo(e, t, o, n) {
+  const { height: r } = o;
+  if (r === void 0 || n.length === 0)
+    return { bottom: 0, top: 0 };
+  const s = Lt(e, t, o, n[0].index);
+  return { bottom: Lt(e, t, o, n[n.length - 1].index) + r, top: s };
+}
+function Lt(e, t, o, n) {
+  const r = vn(e.width, o.width, t.column), s = yt(n / r), i = s * o.height + rt(0, s - 1) * t.row;
+  return i > 0 ? i + t.row : i;
+}
+const Kr = /* @__PURE__ */ J(() => {
+  const e = S((T) => `Item ${T}`), t = S({}), o = S(null), n = S("virtuoso-grid-item"), r = S("virtuoso-grid-list"), s = S(to), i = S("div"), l = S(Qe), a = (T, p = null) => Se(
+    w(
+      t,
+      j((x) => x[T]),
+      se()
+    ),
+    p
+  ), c = S(!1), m = S(!1);
+  return B(N(m), c), {
+    components: t,
+    computeItemKey: s,
+    context: o,
+    FooterComponent: a("Footer"),
+    HeaderComponent: a("Header"),
+    headerFooterTag: i,
+    itemClassName: n,
+    ItemComponent: a("Item", "div"),
+    itemContent: e,
+    listClassName: r,
+    ListComponent: a("List", "div"),
+    readyStateChanged: c,
+    reportReadyState: m,
+    ScrollerComponent: a("Scroller", "div"),
+    scrollerRef: l,
+    ScrollSeekPlaceholder: a("ScrollSeekPlaceholder", "div")
+  };
+}), Qr = /* @__PURE__ */ J(
+  ([e, t]) => ({ ...e, ...t }),
+  ie(Zr, Kr)
+), es = /* @__PURE__ */ P.memo(function() {
+  const e = le("gridState"), t = le("listClassName"), o = le("itemClassName"), n = le("itemContent"), r = le("computeItemKey"), s = le("isSeeking"), i = je("scrollHeight"), l = le("ItemComponent"), a = le("ListComponent"), c = le("ScrollSeekPlaceholder"), m = le("context"), T = je("itemDimensions"), p = je("gap"), x = le("log"), b = le("stateRestoreInProgress"), E = je("reportReadyState"), g = Ye(
+    P.useMemo(
+      () => (d) => {
+        const f = d.parentElement.parentElement.scrollHeight;
+        i(f);
+        const I = d.firstChild;
+        if (I) {
+          const { height: O, width: k } = I.getBoundingClientRect();
+          T({ height: O, width: k });
+        }
+        p({
+          column: Ho("column-gap", getComputedStyle(d).columnGap, x),
+          row: Ho("row-gap", getComputedStyle(d).rowGap, x)
+        });
+      },
+      [i, T, p, x]
+    ),
+    !0,
+    !1
+  );
+  return mn(() => {
+    e.itemHeight > 0 && e.itemWidth > 0 && E(!0);
+  }, [e]), b ? null : /* @__PURE__ */ C.jsx(
+    a,
+    {
+      className: t,
+      ref: g,
+      ...Ie(a, m),
+      "data-testid": "virtuoso-item-list",
+      style: { paddingBottom: e.offsetBottom, paddingTop: e.offsetTop },
+      children: e.items.map((d) => {
+        const f = r(d.index, d.data, m);
+        return s ? /* @__PURE__ */ C.jsx(
+          c,
+          {
+            ...Ie(c, m),
+            height: e.itemHeight,
+            index: d.index,
+            width: e.itemWidth
+          },
+          f
+        ) : /* @__PURE__ */ wt(
+          l,
+          {
+            ...Ie(l, m),
+            className: o,
+            "data-index": d.index,
+            key: f
+          },
+          n(d.index, d.data, m)
+        );
+      })
+    }
+  );
+}), ts = P.memo(function() {
+  const e = le("HeaderComponent"), t = je("headerHeight"), o = le("headerFooterTag"), n = Ye(
+    P.useMemo(
+      () => (s) => {
+        t(Fe(s, "height"));
+      },
+      [t]
+    ),
+    !0,
+    !1
+  ), r = le("context");
+  return e ? /* @__PURE__ */ C.jsx(o, { ref: n, children: /* @__PURE__ */ C.jsx(e, { ...Ie(e, r) }) }) : null;
+}), os = P.memo(function() {
+  const e = le("FooterComponent"), t = je("footerHeight"), o = le("headerFooterTag"), n = Ye(
+    P.useMemo(
+      () => (s) => {
+        t(Fe(s, "height"));
+      },
+      [t]
+    ),
+    !0,
+    !1
+  ), r = le("context");
+  return e ? /* @__PURE__ */ C.jsx(o, { ref: n, children: /* @__PURE__ */ C.jsx(e, { ...Ie(e, r) }) }) : null;
+}), ns = ({ children: e }) => {
+  const t = P.useContext(fn), o = je("itemDimensions"), n = je("viewportDimensions"), r = Ye(
+    P.useMemo(
+      () => (s) => {
+        n(s.getBoundingClientRect());
+      },
+      [n]
+    ),
+    !0,
+    !1
+  );
+  return P.useEffect(() => {
+    t && (n({ height: t.viewportHeight, width: t.viewportWidth }), o({ height: t.itemHeight, width: t.itemWidth }));
+  }, [t, n, o]), /* @__PURE__ */ C.jsx("div", { ref: r, style: jt(!1), children: e });
+}, rs = ({ children: e }) => {
+  const t = P.useContext(fn), o = je("windowViewportRect"), n = je("itemDimensions"), r = le("customScrollParent"), s = Vo(o, r, !1);
+  return P.useEffect(() => {
+    t && (n({ height: t.itemHeight, width: t.itemWidth }), o({ offsetTop: 0, visibleHeight: t.viewportHeight, visibleWidth: t.viewportWidth }));
+  }, [t, o, n]), /* @__PURE__ */ C.jsx("div", { ref: s, style: jt(!1), children: e });
+}, ss = /* @__PURE__ */ P.memo(function({ ...e }) {
+  const t = le("useWindowScroll"), o = le("customScrollParent"), n = o || t ? ls : is, r = o || t ? rs : ns, s = le("context");
+  return /* @__PURE__ */ C.jsx(n, { ...e, ...Ie(n, s), children: /* @__PURE__ */ C.jsxs(r, { children: [
+    /* @__PURE__ */ C.jsx(ts, {}),
+    /* @__PURE__ */ C.jsx(es, {}),
+    /* @__PURE__ */ C.jsx(os, {})
+  ] }) });
+}), {
+  useEmitter: wn,
+  useEmitterValue: le,
+  usePublisher: je
+} = /* @__PURE__ */ un(
+  Qr,
+  {
+    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"
+    }
+  },
+  ss
+), is = /* @__PURE__ */ gn({ useEmitter: wn, useEmitterValue: le, usePublisher: je }), ls = /* @__PURE__ */ xn({ useEmitter: wn, useEmitterValue: le, usePublisher: je });
+function Ho(e, t, o) {
+  return t !== "normal" && !(t != null && t.endsWith("px")) && o(`${e} was not resolved to pixel value correctly`, t, ye.WARN), t === "normal" ? 0 : parseInt(t ?? "0", 10);
+}
+const as = () => {
+  const { messages: e, classNames: t, isOpen: o, isLoading: n } = Rt(), r = $t(null), s = () => {
+    const l = r.current;
+    l && l.scrollTo({ top: l.scrollHeight, behavior: "smooth" });
+  }, i = e?.length ?? 1;
+  return Tt(() => {
+    o && setTimeout(s, 0);
+  }, [o]), /* @__PURE__ */ C.jsxs("div", { className: ot("autoui-chat-messages", t?.messageList), children: [
+    /* @__PURE__ */ C.jsx(
+      Gr,
+      {
+        data: e,
+        overscan: 100,
+        followOutput: "smooth",
+        initialTopMostItemIndex: i - 1,
+        itemContent: (l, a) => /* @__PURE__ */ C.jsx(_n, { message: a }, a.id)
+      }
+    ),
+    n && /* @__PURE__ */ C.jsx(On, { variant: "dots" })
+  ] });
+};
+function cs(e, t) {
+  const o = Object.entries(t.functions).map(([i, l]) => {
+    const a = l.params ? Object.entries(l.params).map(([c, m]) => `- ${c}: ${m}`).join(`
+`) : "(no documented params)";
+    return `FUNCTION ${i}:
+Description: ${l.prompt}
+Params:
+${a}`;
+  }), n = Object.entries(t.components).map(([i, l]) => {
+    const a = l.props ? Object.entries(l.props).map(([c, m]) => `- ${c}: ${m}`).join(`
+`) : "(no documented props)";
+    return `COMPONENT ${i}:
+Description: ${l.prompt}
+Props:
+${a}`;
+  });
+  return [
+    `You are AutoUI Intent Planner.
+Return ONLY a valid JSON InstructionPlan and nothing else.
+Do not wrap in markdown fences. Do not include any fields outside the schema.
+
+SCHEMA (must match exactly):
+{
+  "type": "sequence",
+  "steps": [
+    { "type": "function", "name": "<function name>", "params": { /* optional */ }, "assign": "<ctxKey>" },
+    { "type": "component", "name": "<component name>", "props": { /* optional, may reference {{ctxKey}} */ } }
+     { "type": "text", "text": "<actual generated text>"} }
+  ]
+}
+
+RULES:
+- "type" must be exactly "sequence".
+- "steps" must be a non-empty array.
+- Use ONLY declared function/component names from the lists below.
+- If a component needs data, call a function first and save it under an "assign" key, then reference it in props via "{{assignKey}}".
+- Do not add "intent", "explanations", or any keys not in the schema.
+- Output a single JSON object (no arrays or strings at top-level).
+
+${t.llm.appDescriptionPrompt && `Here is the description of the current app using AUTOUI library made by developer so that you would know the context of what your answers must be about. If userMessages are not related to that description below then inform user that you can only answer questions related to this current website: ${t.llm.appDescriptionPrompt} ${t.metadata?.appName}`}
+`,
+    "",
+    "Available functions:",
+    o.join(`
+
+`),
+    "",
+    "Available components:",
+    n.join(`
+
+`),
+    "",
+    `VALID EXAMPLE:
+{
+  "type": "sequence",
+  "steps": [
+    { "type": "function", "name": "fetchProducts", "params": { "color": "red" }, "assign": "items" },
+    { "type": "component", "name": "ProductList", "props": { "products": "{{items}}", "onAddToCart": "addToCart" } }
+    { "type": "text", "text": "Here is the product list we found for you" }
+  ]
+}`,
+    "",
+    `USER MESSAGE: "${e}"`,
+    "",
+    "Respond with ONLY the plan JSON (no code fences, no commentary)."
+  ].join(`
+`);
+}
+const us = {}, ds = async (e, t) => (await (await fetch(
+  t.llm.baseUrl ? t.llm.baseUrl : "https://openrouter.ai/api/v1/chat/completions",
+  {
+    method: "POST",
+    headers: {
+      Authorization: t.llm.apiKey ? `Bearer ${t.llm.apiKey}` : "",
+      "HTTP-Referer": t.metadata?.appName || "autoui library user",
+      "X-Title": us?.VITE_OPENROUTER_SITE_TITLE ?? "AutoUI Demo",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: t.llm.model ? t.llm.model : "openai/gpt-5-chat",
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: cs(e, t)
+            }
+          ]
+        }
+      ]
+    })
+  }
+)).json()).choices?.[0]?.message?.content;
+function fs(e) {
+  return { processMessage: Ne(
+    async (o) => {
+      let n = await ds(o, e);
+      if (typeof n == "string")
+        try {
+          n = JSON.parse(n);
+        } catch {
+          throw console.error("❌ Failed to parse plan JSON:", n), new Error("Invalid plan format: could not parse JSON");
+        }
+      if (!n || typeof n != "object" || !n.type || !n.steps)
+        throw console.error("❌ Invalid plan structure:", n), new Error("Plan must be an object with 'type' and 'steps'.");
+      return n;
+    },
+    [e]
+  ) };
+}
+function Vt(e, t, o) {
+  if (e == null) return e;
+  if (typeof e == "string") {
+    if (e.startsWith("{{") && e.endsWith("}}")) {
+      const n = e.slice(2, -2).trim();
+      return t[n];
+    }
+    return e;
+  }
+  if (Array.isArray(e))
+    return e.map((n) => Vt(n, t, o));
+  if (typeof e == "object") {
+    const n = {};
+    for (const [r, s] of Object.entries(e))
+      if (typeof s == "string" && /^on[A-Z]/.test(r) && o.functions[s]) {
+        const i = s;
+        n[r] = async (...l) => await o.functions[i].callFunc({ args: l });
+      } else
+        n[r] = Vt(s, t, o);
+    return n;
+  }
+  return e;
+}
+async function ms(e, t, o, n, r) {
+  const s = {};
+  for (const i of e.steps)
+    await hs(i, s, t, o, n, r);
+  return s;
+}
+async function hs(e, t, o, n, r, s) {
+  const i = (a) => !!a && typeof a == "object" && !Array.isArray(a);
+  if (e.type === "function") {
+    const a = o.functions[e.name];
+    if (!a) throw new Error(`Unknown function: ${e.name}`);
+    const c = a.callFunc, m = e, T = Array.isArray(m.args), p = !!m.params && typeof m.params == "object";
+    let x;
+    if (T) {
+      let b = m.args;
+      if (b.length === 1 && i(b[0]) && Array.isArray(a.params) && a.params.length > 0) {
+        const E = b[0];
+        b = a.params.map((g) => E[g]);
+      }
+      try {
+        x = await c(...b);
+      } catch {
+        x = await c(b);
+      }
+    } else p ? x = await c(m.params) : x = await c();
+    e.assign && (t[e.assign] = x);
+    return;
+  }
+  if (e.type === "component") {
+    console.log(
+      "component step already includes the context of the instructionPlan, so here it is:",
+      JSON.stringify(t)
+    );
+    const a = Vt(e.props ?? {}, t, o), c = n(e.name, a);
+    r(c), s((m) => a?.children ? [
+      ...m,
+      { id: `${Date.now()}-a`, role: "assistant", kind: "ui", ui: { t: "fragment", children: a.children } }
+    ] : [
+      ...m,
+      {
+        id: `${Date.now()}-a`,
+        role: "assistant",
+        kind: "ui",
+        ui: { t: "component", name: e.name, props: a }
+      }
+    ]);
+    return;
+  }
+  if (e.type === "text") {
+    const a = e;
+    s((c) => [...c, { id: `${Date.now()}-a`, role: "assistant", kind: "text", text: a.text }]), r(a.text ?? "");
+    return;
+  }
+  return e;
+}
+function ps(e) {
+  if (typeof e != "object" || e === null)
+    throw new Error("Plan must be an object.");
+  if (e.type !== "sequence")
+    throw new Error('Plan.type must be "sequence".');
+  if (!Array.isArray(e.steps))
+    throw new Error("Plan.steps must be an array.");
+  const t = /* @__PURE__ */ new Set(["function", "component", "text"]);
+  e.steps.forEach((o, n) => {
+    if (typeof o != "object" || o === null)
+      throw new Error(`Step[${n}] must be an object.`);
+    if (!t.has(o.type))
+      throw new Error(`Step[${n}].type must be one of "function" | "component" | "text".`);
+    if (o.type === "function") {
+      if (typeof o.name != "string" || !o.name)
+        throw new Error(`Step[${n}].name (function) must be a non-empty string.`);
+      if (o.params !== void 0 && typeof o.params != "object")
+        throw new Error(`Step[${n}].params (function) must be an object if provided.`);
+      if (o.assign !== void 0 && typeof o.assign != "string")
+        throw new Error(`Step[${n}].assign (function) must be a string if provided.`);
+    }
+    if (o.type === "component") {
+      if (typeof o.name != "string" || !o.name)
+        throw new Error(`Step[${n}].name (component) must be a non-empty string.`);
+      if (o.props !== void 0 && typeof o.props != "object")
+        throw new Error(`Step[${n}].props (component) must be an object if provided.`);
+    }
+    if (o.type === "text" && typeof o.text != "string")
+      throw new Error(`Step[${n}].text (text) must be a string.`);
+  });
+}
+async function gs(e, t, o, n, r, s) {
+  return ps(e), await ms(e, t, o, n, r);
+}
+const xs = (e, t, o) => {
+  let n = [];
+  for (let r of e) {
+    if (r.kind == "ui") {
+      const { t: s } = r.ui;
+      let i = s == "component" ? t(r.ui.name, r.ui.props) : "unsuccessful rerender";
+      i && o(i), n.push({ id: r.id, role: r.role, content: i });
+    }
+    r.kind == "text" && (o(r.text), n.push({ id: r.id, role: r.role, content: r.text }));
+  }
+  return n;
+};
+function Tn(e) {
+  const t = $t(null), o = Ne((s) => {
+    t.current = s;
+  }, []), n = Ne(
+    (s, i) => {
+      const l = e?.components?.[s];
+      if (!l?.callComponent) throw new Error(`Unknown component: ${s}`);
+      const a = l.callComponent;
+      return /* @__PURE__ */ C.jsx(a, { ...i });
+    },
+    [e?.components]
+  ), r = Ne((s) => {
+    console.log("setUI called with:", s), t.current?.(s);
+  }, []);
+  return { setUIRenderer: o, resolveComponent: n, setUI: r };
+}
+function vs(e, t) {
+  const { resolveComponent: o, setUI: n } = Tn(t), [r, s] = Ct(() => {
+    try {
+      const a = localStorage.getItem(e);
+      return a ? JSON.parse(a) : [];
+    } catch {
+      return [];
+    }
+  }), i = $t(!1);
+  Tt(() => {
+    i.current = !0;
+  }, []), Tt(() => {
+    try {
+      const a = localStorage.getItem(e);
+      s(a ? JSON.parse(a) : []);
+    } catch {
+      s([]);
+    }
+  }, [e]);
+  const l = Po(
+    () => xs(r, o, n),
+    [r, o, n]
+  );
+  return Tt(() => {
+    if (!i.current) return;
+    const a = setTimeout(() => {
+      localStorage.setItem(e, JSON.stringify(r));
+    }, 50);
+    return () => clearTimeout(a);
+  }, [r, e]), { messages: l, serializedMessages: r, setSerializedMessages: s };
+}
+function ws({
+  config: e,
+  onError: t,
+  onClose: o,
+  storageKey: n = "autoui_chat_history",
+  title: r,
+  classNames: s,
+  isOpen: i
+}) {
+  const { messages: l, setSerializedMessages: a } = vs(n, e), { processMessage: c } = fs(e), { resolveComponent: m, setUI: T } = Tn(e), [p, x] = Ct(!1), b = Ne(
+    async (I) => {
+      if (!I.trim()) return;
+      const k = {
+        id: Date.now().toString(),
+        role: "user",
+        kind: "text",
+        text: I,
+        ts: Date.now()
+      };
+      a((H) => [...H, k]);
+      try {
+        x(!0);
+        const H = await c(I);
+        await gs(H, e, m, T, a, { validate: !0 });
+      } catch (H) {
+        a((u) => [
+          ...u,
+          {
+            id: `${Date.now()}-e`,
+            role: "assistant",
+            kind: "text",
+            text: "⚠️ Something went wrong.",
+            ts: Date.now()
+          }
+        ]), t?.(H);
+      } finally {
+        x(!1);
+      }
+    },
+    [c, e, m, T, a, t]
+  ), E = Ne(() => {
+    a([]), localStorage.removeItem(n);
+  }, [a, n]), g = Ne(
+    () => ({
+      onSend: b,
+      disabled: p
+    }),
+    [b, p]
+  ), d = Ne(
+    () => ({
+      title: "AutoUI Chat",
+      onClose: o
+    }),
+    [o]
+  ), f = Ne(
+    () => ({
+      messages: l
+    }),
+    [l]
+  );
+  return {
+    config: e,
+    isOpen: i,
+    title: r,
+    classNames: s,
+    messages: l,
+    isLoading: p,
+    handleSend: b,
+    onClose: o,
+    handleClear: E,
+    getChatInputProps: g,
+    getChatHeaderProps: d,
+    getMessageListProps: f
+  };
+}
+const Ts = () => {
+  const { title: e, classNames: t, onClose: o, closeIcon: n } = Rt();
+  return /* @__PURE__ */ C.jsxs("header", { role: "header", className: xe("autoui-chat-header", t?.header), children: [
+    /* @__PURE__ */ C.jsx("h2", { role: "title", className: xe("autoui-chat-title", t?.title), children: e }),
+    o && /* @__PURE__ */ C.jsx("button", { role: "closeButton", className: xe("autoui-chat-closebtn", t?.closeButton), onClick: o, children: n ?? /* @__PURE__ */ C.jsx("img", { src: Wo, alt: "Open char", width: 24, height: 24 }) })
+  ] });
+}, Is = _o(
+  ({ config: e, title: t = "AutoUI Chat", isOpen: o = !0, classNames: n, onClose: r, onError: s, closeIcon: i }) => {
+    const l = ws({ config: e, title: t, isOpen: o, classNames: n, onClose: r, onError: s });
+    return o ? /* @__PURE__ */ C.jsx(Hn, { config: e, value: l, children: /* @__PURE__ */ C.jsxs("section", { role: "base", className: xe("autoui-chat", n?.base), "aria-label": "Chat", children: [
+      /* @__PURE__ */ C.jsx(Ts, {}),
+      /* @__PURE__ */ C.jsx(as, {}),
+      /* @__PURE__ */ C.jsx(An, {})
+    ] }) }) : null;
+  }
+), Ss = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Chat: Is
+}, Symbol.toStringTag, { value: "Module" })), In = Bo(void 0), bs = ({ config: e, children: t }) => {
+  const [o, n] = Ct({ isOpen: !1 });
+  return /* @__PURE__ */ C.jsx(In.Provider, { value: { value: o, setValue: n, config: e }, children: t });
+}, ys = () => {
+  const e = Ao(In);
+  if (!e)
+    throw new Error("useModalChatContext must be used within a ModalChatProvider");
+  return e;
+}, Cs = ({ onOpenChange: e, isOpen: t, className: o }) => {
+  const n = t ?? !0, r = n ? Wo : Pn;
+  return /* @__PURE__ */ C.jsx("button", { onClick: e, className: ot("autoui-chat-open-btn", o), children: /* @__PURE__ */ C.jsx("img", { src: r, alt: n ? "Close chat" : "Open chat", width: 24, height: 24 }) });
+}, Rs = Cn(
+  () => Promise.resolve().then(() => Ss).then((e) => ({
+    default: e.Chat
+  }))
+), js = _o(({ config: e, portalContainer: t }) => /* @__PURE__ */ C.jsx(bs, { config: e, children: /* @__PURE__ */ C.jsx(Es, { config: e, portalContainer: t }) })), Es = ({ config: e, portalContainer: t }) => {
+  const { value: o, setValue: n } = ys(), { isOpen: r } = o, s = () => n((a) => ({ ...a, isOpen: !1 })), i = () => n((a) => ({ ...a, isOpen: !a.isOpen })), l = t ?? document.body;
+  return /* @__PURE__ */ C.jsxs(C.Fragment, { children: [
+    /* @__PURE__ */ C.jsx(Cs, { onOpenChange: i, isOpen: r }),
+    r && En(
+      /* @__PURE__ */ C.jsx("div", { className: "autoui-chat-portal", children: /* @__PURE__ */ C.jsx("div", { className: "autoui-chat-wrapper", children: /* @__PURE__ */ C.jsx(Rs, { config: e, ...o, onClose: s }) }) }),
+      l
+    )
+  ] });
+};
+export {
+  Is as Chat,
+  js as ModalChat
+};