@yester/virtual-table 1.0.0

package/dist/virtual-table.es.js

@@ -0,0 +1,2837 @@
+import * as ee from "react";
+import Ye, { version as xr, isValidElement as Tr, forwardRef as Pr, useMemo as ye, memo as Gt, useState as Me, useImperativeHandle as jr, useEffect as Je, createElement as At, useLayoutEffect as yt, useRef as Ae, useCallback as he } from "react";
+import Mt from "react-dom";
+function Ar(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var ut = { exports: {} }, We = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var zt;
+function Mr() {
+  if (zt)
+    return We;
+  zt = 1;
+  var e = Ye, t = Symbol.for("react.element"), r = Symbol.for("react.fragment"), n = Object.prototype.hasOwnProperty, i = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, s = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function a(c, l, v) {
+    var u, m = {}, E = null, I = null;
+    v !== void 0 && (E = "" + v), l.key !== void 0 && (E = "" + l.key), l.ref !== void 0 && (I = l.ref);
+    for (u in l)
+      n.call(l, u) && !s.hasOwnProperty(u) && (m[u] = l[u]);
+    if (c && c.defaultProps)
+      for (u in l = c.defaultProps, l)
+        m[u] === void 0 && (m[u] = l[u]);
+    return { $$typeof: t, type: c, key: E, ref: I, props: m, _owner: i.current };
+  }
+  return We.Fragment = r, We.jsx = a, We.jsxs = a, We;
+}
+var Ve = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var It;
+function zr() {
+  return It || (It = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = Ye, t = Symbol.for("react.element"), r = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), i = Symbol.for("react.strict_mode"), s = Symbol.for("react.profiler"), a = Symbol.for("react.provider"), c = Symbol.for("react.context"), l = Symbol.for("react.forward_ref"), v = Symbol.for("react.suspense"), u = Symbol.for("react.suspense_list"), m = Symbol.for("react.memo"), E = Symbol.for("react.lazy"), I = Symbol.for("react.offscreen"), $ = Symbol.iterator, C = "@@iterator";
+    function d(o) {
+      if (o === null || typeof o != "object")
+        return null;
+      var f = $ && o[$] || o[C];
+      return typeof f == "function" ? f : null;
+    }
+    var k = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function D(o) {
+      {
+        for (var f = arguments.length, p = new Array(f > 1 ? f - 1 : 0), M = 1; M < f; M++)
+          p[M - 1] = arguments[M];
+        ie("error", o, p);
+      }
+    }
+    function ie(o, f, p) {
+      {
+        var M = k.ReactDebugCurrentFrame, B = M.getStackAddendum();
+        B !== "" && (f += "%s", p = p.concat([B]));
+        var q = p.map(function(W) {
+          return String(W);
+        });
+        q.unshift("Warning: " + f), Function.prototype.apply.call(console[o], console, q);
+      }
+    }
+    var P = !1, S = !1, z = !1, T = !1, j = !1, V;
+    V = Symbol.for("react.module.reference");
+    function x(o) {
+      return !!(typeof o == "string" || typeof o == "function" || o === n || o === s || j || o === i || o === v || o === u || T || o === I || P || S || z || typeof o == "object" && o !== null && (o.$$typeof === E || o.$$typeof === m || o.$$typeof === a || o.$$typeof === c || o.$$typeof === l || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      o.$$typeof === V || o.getModuleId !== void 0));
+    }
+    function F(o, f, p) {
+      var M = o.displayName;
+      if (M)
+        return M;
+      var B = f.displayName || f.name || "";
+      return B !== "" ? p + "(" + B + ")" : p;
+    }
+    function U(o) {
+      return o.displayName || "Context";
+    }
+    function G(o) {
+      if (o == null)
+        return null;
+      if (typeof o.tag == "number" && D("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof o == "function")
+        return o.displayName || o.name || null;
+      if (typeof o == "string")
+        return o;
+      switch (o) {
+        case n:
+          return "Fragment";
+        case r:
+          return "Portal";
+        case s:
+          return "Profiler";
+        case i:
+          return "StrictMode";
+        case v:
+          return "Suspense";
+        case u:
+          return "SuspenseList";
+      }
+      if (typeof o == "object")
+        switch (o.$$typeof) {
+          case c:
+            var f = o;
+            return U(f) + ".Consumer";
+          case a:
+            var p = o;
+            return U(p._context) + ".Provider";
+          case l:
+            return F(o, o.render, "ForwardRef");
+          case m:
+            var M = o.displayName || null;
+            return M !== null ? M : G(o.type) || "Memo";
+          case E: {
+            var B = o, q = B._payload, W = B._init;
+            try {
+              return G(W(q));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var Q = Object.assign, le = 0, be, Re, Ee, fe, y, w, O;
+    function g() {
+    }
+    g.__reactDisabledLog = !0;
+    function h() {
+      {
+        if (le === 0) {
+          be = console.log, Re = console.info, Ee = console.warn, fe = console.error, y = console.group, w = console.groupCollapsed, O = console.groupEnd;
+          var o = {
+            configurable: !0,
+            enumerable: !0,
+            value: g,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: o,
+            log: o,
+            warn: o,
+            error: o,
+            group: o,
+            groupCollapsed: o,
+            groupEnd: o
+          });
+        }
+        le++;
+      }
+    }
+    function R() {
+      {
+        if (le--, le === 0) {
+          var o = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: Q({}, o, {
+              value: be
+            }),
+            info: Q({}, o, {
+              value: Re
+            }),
+            warn: Q({}, o, {
+              value: Ee
+            }),
+            error: Q({}, o, {
+              value: fe
+            }),
+            group: Q({}, o, {
+              value: y
+            }),
+            groupCollapsed: Q({}, o, {
+              value: w
+            }),
+            groupEnd: Q({}, o, {
+              value: O
+            })
+          });
+        }
+        le < 0 && D("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var L = k.ReactCurrentDispatcher, _;
+    function A(o, f, p) {
+      {
+        if (_ === void 0)
+          try {
+            throw Error();
+          } catch (B) {
+            var M = B.stack.trim().match(/\n( *(at )?)/);
+            _ = M && M[1] || "";
+          }
+        return `
+` + _ + o;
+      }
+    }
+    var H = !1, X;
+    {
+      var we = typeof WeakMap == "function" ? WeakMap : Map;
+      X = new we();
+    }
+    function se(o, f) {
+      if (!o || H)
+        return "";
+      {
+        var p = X.get(o);
+        if (p !== void 0)
+          return p;
+      }
+      var M;
+      H = !0;
+      var B = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var q;
+      q = L.current, L.current = null, h();
+      try {
+        if (f) {
+          var W = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(W.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(W, []);
+            } catch (ue) {
+              M = ue;
+            }
+            Reflect.construct(o, [], W);
+          } else {
+            try {
+              W.call();
+            } catch (ue) {
+              M = ue;
+            }
+            o.call(W.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (ue) {
+            M = ue;
+          }
+          o();
+        }
+      } catch (ue) {
+        if (ue && M && typeof ue.stack == "string") {
+          for (var N = ue.stack.split(`
+`), ce = M.stack.split(`
+`), re = N.length - 1, oe = ce.length - 1; re >= 1 && oe >= 0 && N[re] !== ce[oe]; )
+            oe--;
+          for (; re >= 1 && oe >= 0; re--, oe--)
+            if (N[re] !== ce[oe]) {
+              if (re !== 1 || oe !== 1)
+                do
+                  if (re--, oe--, oe < 0 || N[re] !== ce[oe]) {
+                    var me = `
+` + N[re].replace(" at new ", " at ");
+                    return o.displayName && me.includes("<anonymous>") && (me = me.replace("<anonymous>", o.displayName)), typeof o == "function" && X.set(o, me), me;
+                  }
+                while (re >= 1 && oe >= 0);
+              break;
+            }
+        }
+      } finally {
+        H = !1, L.current = q, R(), Error.prepareStackTrace = B;
+      }
+      var Le = o ? o.displayName || o.name : "", je = Le ? A(Le) : "";
+      return typeof o == "function" && X.set(o, je), je;
+    }
+    function ae(o, f, p) {
+      return se(o, !1);
+    }
+    function b(o) {
+      var f = o.prototype;
+      return !!(f && f.isReactComponent);
+    }
+    function ne(o, f, p) {
+      if (o == null)
+        return "";
+      if (typeof o == "function")
+        return se(o, b(o));
+      if (typeof o == "string")
+        return A(o);
+      switch (o) {
+        case v:
+          return A("Suspense");
+        case u:
+          return A("SuspenseList");
+      }
+      if (typeof o == "object")
+        switch (o.$$typeof) {
+          case l:
+            return ae(o.render);
+          case m:
+            return ne(o.type, f, p);
+          case E: {
+            var M = o, B = M._payload, q = M._init;
+            try {
+              return ne(q(B), f, p);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var te = Object.prototype.hasOwnProperty, Se = {}, pe = k.ReactDebugCurrentFrame;
+    function Z(o) {
+      if (o) {
+        var f = o._owner, p = ne(o.type, o._source, f ? f.type : null);
+        pe.setExtraStackFrame(p);
+      } else
+        pe.setExtraStackFrame(null);
+    }
+    function xe(o, f, p, M, B) {
+      {
+        var q = Function.call.bind(te);
+        for (var W in o)
+          if (q(o, W)) {
+            var N = void 0;
+            try {
+              if (typeof o[W] != "function") {
+                var ce = Error((M || "React class") + ": " + p + " type `" + W + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof o[W] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw ce.name = "Invariant Violation", ce;
+              }
+              N = o[W](f, W, M, p, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (re) {
+              N = re;
+            }
+            N && !(N instanceof Error) && (Z(B), D("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", M || "React class", p, W, typeof N), Z(null)), N instanceof Error && !(N.message in Se) && (Se[N.message] = !0, Z(B), D("Failed %s type: %s", p, N.message), Z(null));
+          }
+      }
+    }
+    var ze = Array.isArray;
+    function Pe(o) {
+      return ze(o);
+    }
+    function Ne(o) {
+      {
+        var f = typeof Symbol == "function" && Symbol.toStringTag, p = f && o[Symbol.toStringTag] || o.constructor.name || "Object";
+        return p;
+      }
+    }
+    function ve(o) {
+      try {
+        return Ie(o), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function Ie(o) {
+      return "" + o;
+    }
+    function wt(o) {
+      if (ve(o))
+        return D("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Ne(o)), Ie(o);
+    }
+    var Fe = k.ReactCurrentOwner, lr = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, _t, Rt, Ze;
+    Ze = {};
+    function ur(o) {
+      if (te.call(o, "ref")) {
+        var f = Object.getOwnPropertyDescriptor(o, "ref").get;
+        if (f && f.isReactWarning)
+          return !1;
+      }
+      return o.ref !== void 0;
+    }
+    function fr(o) {
+      if (te.call(o, "key")) {
+        var f = Object.getOwnPropertyDescriptor(o, "key").get;
+        if (f && f.isReactWarning)
+          return !1;
+      }
+      return o.key !== void 0;
+    }
+    function dr(o, f) {
+      if (typeof o.ref == "string" && Fe.current && f && Fe.current.stateNode !== f) {
+        var p = G(Fe.current.type);
+        Ze[p] || (D('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', G(Fe.current.type), o.ref), Ze[p] = !0);
+      }
+    }
+    function hr(o, f) {
+      {
+        var p = function() {
+          _t || (_t = !0, D("%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://reactjs.org/link/special-props)", f));
+        };
+        p.isReactWarning = !0, Object.defineProperty(o, "key", {
+          get: p,
+          configurable: !0
+        });
+      }
+    }
+    function pr(o, f) {
+      {
+        var p = function() {
+          Rt || (Rt = !0, D("%s: `ref` 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://reactjs.org/link/special-props)", f));
+        };
+        p.isReactWarning = !0, Object.defineProperty(o, "ref", {
+          get: p,
+          configurable: !0
+        });
+      }
+    }
+    var vr = function(o, f, p, M, B, q, W) {
+      var N = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: t,
+        // Built-in properties that belong on the element
+        type: o,
+        key: f,
+        ref: p,
+        props: W,
+        // Record the component responsible for creating this element.
+        _owner: q
+      };
+      return N._store = {}, Object.defineProperty(N._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(N, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: M
+      }), Object.defineProperty(N, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: B
+      }), Object.freeze && (Object.freeze(N.props), Object.freeze(N)), N;
+    };
+    function mr(o, f, p, M, B) {
+      {
+        var q, W = {}, N = null, ce = null;
+        p !== void 0 && (wt(p), N = "" + p), fr(f) && (wt(f.key), N = "" + f.key), ur(f) && (ce = f.ref, dr(f, B));
+        for (q in f)
+          te.call(f, q) && !lr.hasOwnProperty(q) && (W[q] = f[q]);
+        if (o && o.defaultProps) {
+          var re = o.defaultProps;
+          for (q in re)
+            W[q] === void 0 && (W[q] = re[q]);
+        }
+        if (N || ce) {
+          var oe = typeof o == "function" ? o.displayName || o.name || "Unknown" : o;
+          N && hr(W, oe), ce && pr(W, oe);
+        }
+        return vr(o, N, ce, B, M, Fe.current, W);
+      }
+    }
+    var Qe = k.ReactCurrentOwner, St = k.ReactDebugCurrentFrame;
+    function ke(o) {
+      if (o) {
+        var f = o._owner, p = ne(o.type, o._source, f ? f.type : null);
+        St.setExtraStackFrame(p);
+      } else
+        St.setExtraStackFrame(null);
+    }
+    var et;
+    et = !1;
+    function tt(o) {
+      return typeof o == "object" && o !== null && o.$$typeof === t;
+    }
+    function Ct() {
+      {
+        if (Qe.current) {
+          var o = G(Qe.current.type);
+          if (o)
+            return `
+
+Check the render method of \`` + o + "`.";
+        }
+        return "";
+      }
+    }
+    function gr(o) {
+      {
+        if (o !== void 0) {
+          var f = o.fileName.replace(/^.*[\\\/]/, ""), p = o.lineNumber;
+          return `
+
+Check your code at ` + f + ":" + p + ".";
+        }
+        return "";
+      }
+    }
+    var Ot = {};
+    function yr(o) {
+      {
+        var f = Ct();
+        if (!f) {
+          var p = typeof o == "string" ? o : o.displayName || o.name;
+          p && (f = `
+
+Check the top-level render call using <` + p + ">.");
+        }
+        return f;
+      }
+    }
+    function xt(o, f) {
+      {
+        if (!o._store || o._store.validated || o.key != null)
+          return;
+        o._store.validated = !0;
+        var p = yr(f);
+        if (Ot[p])
+          return;
+        Ot[p] = !0;
+        var M = "";
+        o && o._owner && o._owner !== Qe.current && (M = " It was passed a child from " + G(o._owner.type) + "."), ke(o), D('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', p, M), ke(null);
+      }
+    }
+    function Tt(o, f) {
+      {
+        if (typeof o != "object")
+          return;
+        if (Pe(o))
+          for (var p = 0; p < o.length; p++) {
+            var M = o[p];
+            tt(M) && xt(M, f);
+          }
+        else if (tt(o))
+          o._store && (o._store.validated = !0);
+        else if (o) {
+          var B = d(o);
+          if (typeof B == "function" && B !== o.entries)
+            for (var q = B.call(o), W; !(W = q.next()).done; )
+              tt(W.value) && xt(W.value, f);
+        }
+      }
+    }
+    function br(o) {
+      {
+        var f = o.type;
+        if (f == null || typeof f == "string")
+          return;
+        var p;
+        if (typeof f == "function")
+          p = f.propTypes;
+        else if (typeof f == "object" && (f.$$typeof === l || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        f.$$typeof === m))
+          p = f.propTypes;
+        else
+          return;
+        if (p) {
+          var M = G(f);
+          xe(p, o.props, "prop", M, o);
+        } else if (f.PropTypes !== void 0 && !et) {
+          et = !0;
+          var B = G(f);
+          D("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", B || "Unknown");
+        }
+        typeof f.getDefaultProps == "function" && !f.getDefaultProps.isReactClassApproved && D("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function Er(o) {
+      {
+        for (var f = Object.keys(o.props), p = 0; p < f.length; p++) {
+          var M = f[p];
+          if (M !== "children" && M !== "key") {
+            ke(o), D("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", M), ke(null);
+            break;
+          }
+        }
+        o.ref !== null && (ke(o), D("Invalid attribute `ref` supplied to `React.Fragment`."), ke(null));
+      }
+    }
+    var Pt = {};
+    function jt(o, f, p, M, B, q) {
+      {
+        var W = x(o);
+        if (!W) {
+          var N = "";
+          (o === void 0 || typeof o == "object" && o !== null && Object.keys(o).length === 0) && (N += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var ce = gr(B);
+          ce ? N += ce : N += Ct();
+          var re;
+          o === null ? re = "null" : Pe(o) ? re = "array" : o !== void 0 && o.$$typeof === t ? (re = "<" + (G(o.type) || "Unknown") + " />", N = " Did you accidentally export a JSX literal instead of a component?") : re = typeof o, D("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", re, N);
+        }
+        var oe = mr(o, f, p, B, q);
+        if (oe == null)
+          return oe;
+        if (W) {
+          var me = f.children;
+          if (me !== void 0)
+            if (M)
+              if (Pe(me)) {
+                for (var Le = 0; Le < me.length; Le++)
+                  Tt(me[Le], o);
+                Object.freeze && Object.freeze(me);
+              } else
+                D("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
+              Tt(me, o);
+        }
+        if (te.call(f, "key")) {
+          var je = G(o), ue = Object.keys(f).filter(function(Or) {
+            return Or !== "key";
+          }), rt = ue.length > 0 ? "{key: someKey, " + ue.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!Pt[je + rt]) {
+            var Cr = ue.length > 0 ? "{" + ue.join(": ..., ") + ": ...}" : "{}";
+            D(`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} />`, rt, je, Cr, je), Pt[je + rt] = !0;
+          }
+        }
+        return o === n ? Er(oe) : br(oe), oe;
+      }
+    }
+    function wr(o, f, p) {
+      return jt(o, f, p, !0);
+    }
+    function _r(o, f, p) {
+      return jt(o, f, p, !1);
+    }
+    var Rr = _r, Sr = wr;
+    Ve.Fragment = n, Ve.jsx = Rr, Ve.jsxs = Sr;
+  }()), Ve;
+}
+process.env.NODE_ENV === "production" ? ut.exports = Mr() : ut.exports = zr();
+var J = ut.exports;
+function ft() {
+  return ft = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var r = arguments[t];
+      for (var n in r)
+        ({}).hasOwnProperty.call(r, n) && (e[n] = r[n]);
+    }
+    return e;
+  }, ft.apply(null, arguments);
+}
+function _e(e) {
+  "@babel/helpers - typeof";
+  return _e = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, _e(e);
+}
+var Ir = Symbol.for("react.element"), kr = Symbol.for("react.transitional.element"), Lr = Symbol.for("react.fragment");
+function Ut(e) {
+  return (
+    // Base object type
+    e && _e(e) === "object" && // React Element type
+    (e.$$typeof === Ir || e.$$typeof === kr) && // React Fragment type
+    e.type === Lr
+  );
+}
+function dt(e) {
+  var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, r = [];
+  return Ye.Children.forEach(e, function(n) {
+    n == null && !t.keepEmpty || (Array.isArray(n) ? r = r.concat(dt(n)) : Ut(n) && n.props ? r = r.concat(dt(n.props.children, t)) : r.push(n));
+  }), r;
+}
+var $r = [];
+function kt(e, t) {
+  if (process.env.NODE_ENV !== "production" && !e && console !== void 0) {
+    var r = $r.reduce(function(n, i) {
+      return i(n ?? "", "warning");
+    }, t);
+    r && console.error("Warning: ".concat(r));
+  }
+}
+function Dr(e, t) {
+  if (_e(e) != "object" || !e)
+    return e;
+  var r = e[Symbol.toPrimitive];
+  if (r !== void 0) {
+    var n = r.call(e, t || "default");
+    if (_e(n) != "object")
+      return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(e);
+}
+function qt(e) {
+  var t = Dr(e, "string");
+  return _e(t) == "symbol" ? t : t + "";
+}
+function Nr(e, t, r) {
+  return (t = qt(t)) in e ? Object.defineProperty(e, t, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[t] = r, e;
+}
+function Lt(e, t) {
+  var r = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    t && (n = n.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(e, i).enumerable;
+    })), r.push.apply(r, n);
+  }
+  return r;
+}
+function $t(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var r = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? Lt(Object(r), !0).forEach(function(n) {
+      Nr(e, n, r[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : Lt(Object(r)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
+    });
+  }
+  return e;
+}
+function Dt(e) {
+  return e instanceof HTMLElement || e instanceof SVGElement;
+}
+function Fr(e) {
+  return e && _e(e) === "object" && Dt(e.nativeElement) ? e.nativeElement : Dt(e) ? e : null;
+}
+function nt(e) {
+  var t = Fr(e);
+  if (t)
+    return t;
+  if (e instanceof Ye.Component) {
+    var r;
+    return (r = Mt.findDOMNode) === null || r === void 0 ? void 0 : r.call(Mt, e);
+  }
+  return null;
+}
+var ht = { exports: {} }, Y = {};
+/**
+ * @license React
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Nt;
+function Wr() {
+  if (Nt)
+    return Y;
+  Nt = 1;
+  var e = Symbol.for("react.element"), t = Symbol.for("react.portal"), r = Symbol.for("react.fragment"), n = Symbol.for("react.strict_mode"), i = Symbol.for("react.profiler"), s = Symbol.for("react.provider"), a = Symbol.for("react.context"), c = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), v = Symbol.for("react.suspense"), u = Symbol.for("react.suspense_list"), m = Symbol.for("react.memo"), E = Symbol.for("react.lazy"), I = Symbol.for("react.offscreen"), $;
+  $ = Symbol.for("react.module.reference");
+  function C(d) {
+    if (typeof d == "object" && d !== null) {
+      var k = d.$$typeof;
+      switch (k) {
+        case e:
+          switch (d = d.type, d) {
+            case r:
+            case i:
+            case n:
+            case v:
+            case u:
+              return d;
+            default:
+              switch (d = d && d.$$typeof, d) {
+                case c:
+                case a:
+                case l:
+                case E:
+                case m:
+                case s:
+                  return d;
+                default:
+                  return k;
+              }
+          }
+        case t:
+          return k;
+      }
+    }
+  }
+  return Y.ContextConsumer = a, Y.ContextProvider = s, Y.Element = e, Y.ForwardRef = l, Y.Fragment = r, Y.Lazy = E, Y.Memo = m, Y.Portal = t, Y.Profiler = i, Y.StrictMode = n, Y.Suspense = v, Y.SuspenseList = u, Y.isAsyncMode = function() {
+    return !1;
+  }, Y.isConcurrentMode = function() {
+    return !1;
+  }, Y.isContextConsumer = function(d) {
+    return C(d) === a;
+  }, Y.isContextProvider = function(d) {
+    return C(d) === s;
+  }, Y.isElement = function(d) {
+    return typeof d == "object" && d !== null && d.$$typeof === e;
+  }, Y.isForwardRef = function(d) {
+    return C(d) === l;
+  }, Y.isFragment = function(d) {
+    return C(d) === r;
+  }, Y.isLazy = function(d) {
+    return C(d) === E;
+  }, Y.isMemo = function(d) {
+    return C(d) === m;
+  }, Y.isPortal = function(d) {
+    return C(d) === t;
+  }, Y.isProfiler = function(d) {
+    return C(d) === i;
+  }, Y.isStrictMode = function(d) {
+    return C(d) === n;
+  }, Y.isSuspense = function(d) {
+    return C(d) === v;
+  }, Y.isSuspenseList = function(d) {
+    return C(d) === u;
+  }, Y.isValidElementType = function(d) {
+    return typeof d == "string" || typeof d == "function" || d === r || d === i || d === n || d === v || d === u || d === I || typeof d == "object" && d !== null && (d.$$typeof === E || d.$$typeof === m || d.$$typeof === s || d.$$typeof === a || d.$$typeof === l || d.$$typeof === $ || d.getModuleId !== void 0);
+  }, Y.typeOf = C, Y;
+}
+var K = {};
+/**
+ * @license React
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ft;
+function Vr() {
+  return Ft || (Ft = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = Symbol.for("react.element"), t = Symbol.for("react.portal"), r = Symbol.for("react.fragment"), n = Symbol.for("react.strict_mode"), i = Symbol.for("react.profiler"), s = Symbol.for("react.provider"), a = Symbol.for("react.context"), c = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), v = Symbol.for("react.suspense"), u = Symbol.for("react.suspense_list"), m = Symbol.for("react.memo"), E = Symbol.for("react.lazy"), I = Symbol.for("react.offscreen"), $ = !1, C = !1, d = !1, k = !1, D = !1, ie;
+    ie = Symbol.for("react.module.reference");
+    function P(b) {
+      return !!(typeof b == "string" || typeof b == "function" || b === r || b === i || D || b === n || b === v || b === u || k || b === I || $ || C || d || typeof b == "object" && b !== null && (b.$$typeof === E || b.$$typeof === m || b.$$typeof === s || b.$$typeof === a || b.$$typeof === l || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      b.$$typeof === ie || b.getModuleId !== void 0));
+    }
+    function S(b) {
+      if (typeof b == "object" && b !== null) {
+        var ne = b.$$typeof;
+        switch (ne) {
+          case e:
+            var te = b.type;
+            switch (te) {
+              case r:
+              case i:
+              case n:
+              case v:
+              case u:
+                return te;
+              default:
+                var Se = te && te.$$typeof;
+                switch (Se) {
+                  case c:
+                  case a:
+                  case l:
+                  case E:
+                  case m:
+                  case s:
+                    return Se;
+                  default:
+                    return ne;
+                }
+            }
+          case t:
+            return ne;
+        }
+      }
+    }
+    var z = a, T = s, j = e, V = l, x = r, F = E, U = m, G = t, Q = i, le = n, be = v, Re = u, Ee = !1, fe = !1;
+    function y(b) {
+      return Ee || (Ee = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.")), !1;
+    }
+    function w(b) {
+      return fe || (fe = !0, console.warn("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.")), !1;
+    }
+    function O(b) {
+      return S(b) === a;
+    }
+    function g(b) {
+      return S(b) === s;
+    }
+    function h(b) {
+      return typeof b == "object" && b !== null && b.$$typeof === e;
+    }
+    function R(b) {
+      return S(b) === l;
+    }
+    function L(b) {
+      return S(b) === r;
+    }
+    function _(b) {
+      return S(b) === E;
+    }
+    function A(b) {
+      return S(b) === m;
+    }
+    function H(b) {
+      return S(b) === t;
+    }
+    function X(b) {
+      return S(b) === i;
+    }
+    function we(b) {
+      return S(b) === n;
+    }
+    function se(b) {
+      return S(b) === v;
+    }
+    function ae(b) {
+      return S(b) === u;
+    }
+    K.ContextConsumer = z, K.ContextProvider = T, K.Element = j, K.ForwardRef = V, K.Fragment = x, K.Lazy = F, K.Memo = U, K.Portal = G, K.Profiler = Q, K.StrictMode = le, K.Suspense = be, K.SuspenseList = Re, K.isAsyncMode = y, K.isConcurrentMode = w, K.isContextConsumer = O, K.isContextProvider = g, K.isElement = h, K.isForwardRef = R, K.isFragment = L, K.isLazy = _, K.isMemo = A, K.isPortal = H, K.isProfiler = X, K.isStrictMode = we, K.isSuspense = se, K.isSuspenseList = ae, K.isValidElementType = P, K.typeOf = S;
+  }()), K;
+}
+process.env.NODE_ENV === "production" ? ht.exports = Wr() : ht.exports = Vr();
+var ot = ht.exports;
+function Hr(e, t, r) {
+  var n = ee.useRef({});
+  return (!("value" in n.current) || r(n.current.condition, t)) && (n.current.value = e(), n.current.condition = t), n.current.value;
+}
+var Br = Number(xr.split(".")[0]), Yr = function(t, r) {
+  typeof t == "function" ? t(r) : _e(t) === "object" && t && "current" in t && (t.current = r);
+}, Kr = function() {
+  for (var t = arguments.length, r = new Array(t), n = 0; n < t; n++)
+    r[n] = arguments[n];
+  var i = r.filter(Boolean);
+  return i.length <= 1 ? i[0] : function(s) {
+    r.forEach(function(a) {
+      Yr(a, s);
+    });
+  };
+}, Gr = function() {
+  for (var t = arguments.length, r = new Array(t), n = 0; n < t; n++)
+    r[n] = arguments[n];
+  return Hr(function() {
+    return Kr.apply(void 0, r);
+  }, r, function(i, s) {
+    return i.length !== s.length || i.every(function(a, c) {
+      return a !== s[c];
+    });
+  });
+}, Ur = function(t) {
+  var r, n;
+  if (!t)
+    return !1;
+  if (Jt(t) && Br >= 19)
+    return !0;
+  var i = ot.isMemo(t) ? t.type.type : t.type;
+  return !(typeof i == "function" && !((r = i.prototype) !== null && r !== void 0 && r.render) && i.$$typeof !== ot.ForwardRef || typeof t == "function" && !((n = t.prototype) !== null && n !== void 0 && n.render) && t.$$typeof !== ot.ForwardRef);
+};
+function Jt(e) {
+  return /* @__PURE__ */ Tr(e) && !Ut(e);
+}
+var qr = function(t) {
+  if (t && Jt(t)) {
+    var r = t;
+    return r.props.propertyIsEnumerable("ref") ? r.props.ref : r.ref;
+  }
+  return null;
+}, pt = /* @__PURE__ */ ee.createContext(null);
+function Jr(e) {
+  var t = e.children, r = e.onBatchResize, n = ee.useRef(0), i = ee.useRef([]), s = ee.useContext(pt), a = ee.useCallback(function(c, l, v) {
+    n.current += 1;
+    var u = n.current;
+    i.current.push({
+      size: c,
+      element: l,
+      data: v
+    }), Promise.resolve().then(function() {
+      u === n.current && (r == null || r(i.current), i.current = []);
+    }), s == null || s(c, l, v);
+  }, [r, s]);
+  return /* @__PURE__ */ ee.createElement(pt.Provider, {
+    value: a
+  }, t);
+}
+var Xt = function() {
+  if (typeof Map < "u")
+    return Map;
+  function e(t, r) {
+    var n = -1;
+    return t.some(function(i, s) {
+      return i[0] === r ? (n = s, !0) : !1;
+    }), n;
+  }
+  return (
+    /** @class */
+    function() {
+      function t() {
+        this.__entries__ = [];
+      }
+      return Object.defineProperty(t.prototype, "size", {
+        /**
+         * @returns {boolean}
+         */
+        get: function() {
+          return this.__entries__.length;
+        },
+        enumerable: !0,
+        configurable: !0
+      }), t.prototype.get = function(r) {
+        var n = e(this.__entries__, r), i = this.__entries__[n];
+        return i && i[1];
+      }, t.prototype.set = function(r, n) {
+        var i = e(this.__entries__, r);
+        ~i ? this.__entries__[i][1] = n : this.__entries__.push([r, n]);
+      }, t.prototype.delete = function(r) {
+        var n = this.__entries__, i = e(n, r);
+        ~i && n.splice(i, 1);
+      }, t.prototype.has = function(r) {
+        return !!~e(this.__entries__, r);
+      }, t.prototype.clear = function() {
+        this.__entries__.splice(0);
+      }, t.prototype.forEach = function(r, n) {
+        n === void 0 && (n = null);
+        for (var i = 0, s = this.__entries__; i < s.length; i++) {
+          var a = s[i];
+          r.call(n, a[1], a[0]);
+        }
+      }, t;
+    }()
+  );
+}(), vt = typeof window < "u" && typeof document < "u" && window.document === document, Ke = function() {
+  return typeof global < "u" && global.Math === Math ? global : typeof self < "u" && self.Math === Math ? self : typeof window < "u" && window.Math === Math ? window : Function("return this")();
+}(), Xr = function() {
+  return typeof requestAnimationFrame == "function" ? requestAnimationFrame.bind(Ke) : function(e) {
+    return setTimeout(function() {
+      return e(Date.now());
+    }, 1e3 / 60);
+  };
+}(), Zr = 2;
+function Qr(e, t) {
+  var r = !1, n = !1, i = 0;
+  function s() {
+    r && (r = !1, e()), n && c();
+  }
+  function a() {
+    Xr(s);
+  }
+  function c() {
+    var l = Date.now();
+    if (r) {
+      if (l - i < Zr)
+        return;
+      n = !0;
+    } else
+      r = !0, n = !1, setTimeout(a, t);
+    i = l;
+  }
+  return c;
+}
+var en = 20, tn = ["top", "right", "bottom", "left", "width", "height", "size", "weight"], rn = typeof MutationObserver < "u", nn = (
+  /** @class */
+  function() {
+    function e() {
+      this.connected_ = !1, this.mutationEventsAdded_ = !1, this.mutationsObserver_ = null, this.observers_ = [], this.onTransitionEnd_ = this.onTransitionEnd_.bind(this), this.refresh = Qr(this.refresh.bind(this), en);
+    }
+    return e.prototype.addObserver = function(t) {
+      ~this.observers_.indexOf(t) || this.observers_.push(t), this.connected_ || this.connect_();
+    }, e.prototype.removeObserver = function(t) {
+      var r = this.observers_, n = r.indexOf(t);
+      ~n && r.splice(n, 1), !r.length && this.connected_ && this.disconnect_();
+    }, e.prototype.refresh = function() {
+      var t = this.updateObservers_();
+      t && this.refresh();
+    }, e.prototype.updateObservers_ = function() {
+      var t = this.observers_.filter(function(r) {
+        return r.gatherActive(), r.hasActive();
+      });
+      return t.forEach(function(r) {
+        return r.broadcastActive();
+      }), t.length > 0;
+    }, e.prototype.connect_ = function() {
+      !vt || this.connected_ || (document.addEventListener("transitionend", this.onTransitionEnd_), window.addEventListener("resize", this.refresh), rn ? (this.mutationsObserver_ = new MutationObserver(this.refresh), this.mutationsObserver_.observe(document, {
+        attributes: !0,
+        childList: !0,
+        characterData: !0,
+        subtree: !0
+      })) : (document.addEventListener("DOMSubtreeModified", this.refresh), this.mutationEventsAdded_ = !0), this.connected_ = !0);
+    }, e.prototype.disconnect_ = function() {
+      !vt || !this.connected_ || (document.removeEventListener("transitionend", this.onTransitionEnd_), window.removeEventListener("resize", this.refresh), this.mutationsObserver_ && this.mutationsObserver_.disconnect(), this.mutationEventsAdded_ && document.removeEventListener("DOMSubtreeModified", this.refresh), this.mutationsObserver_ = null, this.mutationEventsAdded_ = !1, this.connected_ = !1);
+    }, e.prototype.onTransitionEnd_ = function(t) {
+      var r = t.propertyName, n = r === void 0 ? "" : r, i = tn.some(function(s) {
+        return !!~n.indexOf(s);
+      });
+      i && this.refresh();
+    }, e.getInstance = function() {
+      return this.instance_ || (this.instance_ = new e()), this.instance_;
+    }, e.instance_ = null, e;
+  }()
+), Zt = function(e, t) {
+  for (var r = 0, n = Object.keys(t); r < n.length; r++) {
+    var i = n[r];
+    Object.defineProperty(e, i, {
+      value: t[i],
+      enumerable: !1,
+      writable: !1,
+      configurable: !0
+    });
+  }
+  return e;
+}, De = function(e) {
+  var t = e && e.ownerDocument && e.ownerDocument.defaultView;
+  return t || Ke;
+}, Qt = Xe(0, 0, 0, 0);
+function Ge(e) {
+  return parseFloat(e) || 0;
+}
+function Wt(e) {
+  for (var t = [], r = 1; r < arguments.length; r++)
+    t[r - 1] = arguments[r];
+  return t.reduce(function(n, i) {
+    var s = e["border-" + i + "-width"];
+    return n + Ge(s);
+  }, 0);
+}
+function on(e) {
+  for (var t = ["top", "right", "bottom", "left"], r = {}, n = 0, i = t; n < i.length; n++) {
+    var s = i[n], a = e["padding-" + s];
+    r[s] = Ge(a);
+  }
+  return r;
+}
+function sn(e) {
+  var t = e.getBBox();
+  return Xe(0, 0, t.width, t.height);
+}
+function an(e) {
+  var t = e.clientWidth, r = e.clientHeight;
+  if (!t && !r)
+    return Qt;
+  var n = De(e).getComputedStyle(e), i = on(n), s = i.left + i.right, a = i.top + i.bottom, c = Ge(n.width), l = Ge(n.height);
+  if (n.boxSizing === "border-box" && (Math.round(c + s) !== t && (c -= Wt(n, "left", "right") + s), Math.round(l + a) !== r && (l -= Wt(n, "top", "bottom") + a)), !ln(e)) {
+    var v = Math.round(c + s) - t, u = Math.round(l + a) - r;
+    Math.abs(v) !== 1 && (c -= v), Math.abs(u) !== 1 && (l -= u);
+  }
+  return Xe(i.left, i.top, c, l);
+}
+var cn = function() {
+  return typeof SVGGraphicsElement < "u" ? function(e) {
+    return e instanceof De(e).SVGGraphicsElement;
+  } : function(e) {
+    return e instanceof De(e).SVGElement && typeof e.getBBox == "function";
+  };
+}();
+function ln(e) {
+  return e === De(e).document.documentElement;
+}
+function un(e) {
+  return vt ? cn(e) ? sn(e) : an(e) : Qt;
+}
+function fn(e) {
+  var t = e.x, r = e.y, n = e.width, i = e.height, s = typeof DOMRectReadOnly < "u" ? DOMRectReadOnly : Object, a = Object.create(s.prototype);
+  return Zt(a, {
+    x: t,
+    y: r,
+    width: n,
+    height: i,
+    top: r,
+    right: t + n,
+    bottom: i + r,
+    left: t
+  }), a;
+}
+function Xe(e, t, r, n) {
+  return { x: e, y: t, width: r, height: n };
+}
+var dn = (
+  /** @class */
+  function() {
+    function e(t) {
+      this.broadcastWidth = 0, this.broadcastHeight = 0, this.contentRect_ = Xe(0, 0, 0, 0), this.target = t;
+    }
+    return e.prototype.isActive = function() {
+      var t = un(this.target);
+      return this.contentRect_ = t, t.width !== this.broadcastWidth || t.height !== this.broadcastHeight;
+    }, e.prototype.broadcastRect = function() {
+      var t = this.contentRect_;
+      return this.broadcastWidth = t.width, this.broadcastHeight = t.height, t;
+    }, e;
+  }()
+), hn = (
+  /** @class */
+  function() {
+    function e(t, r) {
+      var n = fn(r);
+      Zt(this, { target: t, contentRect: n });
+    }
+    return e;
+  }()
+), pn = (
+  /** @class */
+  function() {
+    function e(t, r, n) {
+      if (this.activeObservations_ = [], this.observations_ = new Xt(), typeof t != "function")
+        throw new TypeError("The callback provided as parameter 1 is not a function.");
+      this.callback_ = t, this.controller_ = r, this.callbackCtx_ = n;
+    }
+    return e.prototype.observe = function(t) {
+      if (!arguments.length)
+        throw new TypeError("1 argument required, but only 0 present.");
+      if (!(typeof Element > "u" || !(Element instanceof Object))) {
+        if (!(t instanceof De(t).Element))
+          throw new TypeError('parameter 1 is not of type "Element".');
+        var r = this.observations_;
+        r.has(t) || (r.set(t, new dn(t)), this.controller_.addObserver(this), this.controller_.refresh());
+      }
+    }, e.prototype.unobserve = function(t) {
+      if (!arguments.length)
+        throw new TypeError("1 argument required, but only 0 present.");
+      if (!(typeof Element > "u" || !(Element instanceof Object))) {
+        if (!(t instanceof De(t).Element))
+          throw new TypeError('parameter 1 is not of type "Element".');
+        var r = this.observations_;
+        r.has(t) && (r.delete(t), r.size || this.controller_.removeObserver(this));
+      }
+    }, e.prototype.disconnect = function() {
+      this.clearActive(), this.observations_.clear(), this.controller_.removeObserver(this);
+    }, e.prototype.gatherActive = function() {
+      var t = this;
+      this.clearActive(), this.observations_.forEach(function(r) {
+        r.isActive() && t.activeObservations_.push(r);
+      });
+    }, e.prototype.broadcastActive = function() {
+      if (this.hasActive()) {
+        var t = this.callbackCtx_, r = this.activeObservations_.map(function(n) {
+          return new hn(n.target, n.broadcastRect());
+        });
+        this.callback_.call(t, r, t), this.clearActive();
+      }
+    }, e.prototype.clearActive = function() {
+      this.activeObservations_.splice(0);
+    }, e.prototype.hasActive = function() {
+      return this.activeObservations_.length > 0;
+    }, e;
+  }()
+), er = typeof WeakMap < "u" ? /* @__PURE__ */ new WeakMap() : new Xt(), tr = (
+  /** @class */
+  function() {
+    function e(t) {
+      if (!(this instanceof e))
+        throw new TypeError("Cannot call a class as a function.");
+      if (!arguments.length)
+        throw new TypeError("1 argument required, but only 0 present.");
+      var r = nn.getInstance(), n = new pn(t, r, this);
+      er.set(this, n);
+    }
+    return e;
+  }()
+);
+[
+  "observe",
+  "unobserve",
+  "disconnect"
+].forEach(function(e) {
+  tr.prototype[e] = function() {
+    var t;
+    return (t = er.get(this))[e].apply(t, arguments);
+  };
+});
+var vn = function() {
+  return typeof Ke.ResizeObserver < "u" ? Ke.ResizeObserver : tr;
+}(), Oe = /* @__PURE__ */ new Map();
+function rr(e) {
+  e.forEach(function(t) {
+    var r, n = t.target;
+    (r = Oe.get(n)) === null || r === void 0 || r.forEach(function(i) {
+      return i(n);
+    });
+  });
+}
+var nr = new vn(rr);
+process.env.NODE_ENV;
+process.env.NODE_ENV;
+function mn(e, t) {
+  Oe.has(e) || (Oe.set(e, /* @__PURE__ */ new Set()), nr.observe(e)), Oe.get(e).add(t);
+}
+function gn(e, t) {
+  Oe.has(e) && (Oe.get(e).delete(t), Oe.get(e).size || (nr.unobserve(e), Oe.delete(e)));
+}
+function yn(e, t) {
+  if (!(e instanceof t))
+    throw new TypeError("Cannot call a class as a function");
+}
+function Vt(e, t) {
+  for (var r = 0; r < t.length; r++) {
+    var n = t[r];
+    n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, qt(n.key), n);
+  }
+}
+function bn(e, t, r) {
+  return t && Vt(e.prototype, t), r && Vt(e, r), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+function mt(e, t) {
+  return mt = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(r, n) {
+    return r.__proto__ = n, r;
+  }, mt(e, t);
+}
+function En(e, t) {
+  if (typeof t != "function" && t !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  e.prototype = Object.create(t && t.prototype, {
+    constructor: {
+      value: e,
+      writable: !0,
+      configurable: !0
+    }
+  }), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), t && mt(e, t);
+}
+function Ue(e) {
+  return Ue = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, Ue(e);
+}
+function or() {
+  try {
+    var e = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (or = function() {
+    return !!e;
+  })();
+}
+function wn(e) {
+  if (e === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+function _n(e, t) {
+  if (t && (_e(t) == "object" || typeof t == "function"))
+    return t;
+  if (t !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return wn(e);
+}
+function Rn(e) {
+  var t = or();
+  return function() {
+    var r, n = Ue(e);
+    if (t) {
+      var i = Ue(this).constructor;
+      r = Reflect.construct(n, arguments, i);
+    } else
+      r = n.apply(this, arguments);
+    return _n(this, r);
+  };
+}
+var Sn = /* @__PURE__ */ function(e) {
+  En(r, e);
+  var t = Rn(r);
+  function r() {
+    return yn(this, r), t.apply(this, arguments);
+  }
+  return bn(r, [{
+    key: "render",
+    value: function() {
+      return this.props.children;
+    }
+  }]), r;
+}(ee.Component);
+function Cn(e, t) {
+  var r = e.children, n = e.disabled, i = ee.useRef(null), s = ee.useRef(null), a = ee.useContext(pt), c = typeof r == "function", l = c ? r(i) : r, v = ee.useRef({
+    width: -1,
+    height: -1,
+    offsetWidth: -1,
+    offsetHeight: -1
+  }), u = !c && /* @__PURE__ */ ee.isValidElement(l) && Ur(l), m = u ? qr(l) : null, E = Gr(m, i), I = function() {
+    var k;
+    return nt(i.current) || // Support `nativeElement` format
+    (i.current && _e(i.current) === "object" ? nt((k = i.current) === null || k === void 0 ? void 0 : k.nativeElement) : null) || nt(s.current);
+  };
+  ee.useImperativeHandle(t, function() {
+    return I();
+  });
+  var $ = ee.useRef(e);
+  $.current = e;
+  var C = ee.useCallback(function(d) {
+    var k = $.current, D = k.onResize, ie = k.data, P = d.getBoundingClientRect(), S = P.width, z = P.height, T = d.offsetWidth, j = d.offsetHeight, V = Math.floor(S), x = Math.floor(z);
+    if (v.current.width !== V || v.current.height !== x || v.current.offsetWidth !== T || v.current.offsetHeight !== j) {
+      var F = {
+        width: V,
+        height: x,
+        offsetWidth: T,
+        offsetHeight: j
+      };
+      v.current = F;
+      var U = T === Math.round(S) ? S : T, G = j === Math.round(z) ? z : j, Q = $t($t({}, F), {}, {
+        offsetWidth: U,
+        offsetHeight: G
+      });
+      a == null || a(Q, d, ie), D && Promise.resolve().then(function() {
+        D(Q, d);
+      });
+    }
+  }, []);
+  return ee.useEffect(function() {
+    var d = I();
+    return d && !n && mn(d, C), function() {
+      return gn(d, C);
+    };
+  }, [i.current, n]), /* @__PURE__ */ ee.createElement(Sn, {
+    ref: s
+  }, u ? /* @__PURE__ */ ee.cloneElement(l, {
+    ref: E
+  }) : l);
+}
+var ir = /* @__PURE__ */ ee.forwardRef(Cn);
+process.env.NODE_ENV !== "production" && (ir.displayName = "SingleObserver");
+var On = "rc-observer-key";
+function xn(e, t) {
+  var r = e.children, n = typeof r == "function" ? [r] : dt(r);
+  return process.env.NODE_ENV !== "production" && (n.length > 1 ? kt(!1, "Find more than one child node with `children` in ResizeObserver. Please use ResizeObserver.Collection instead.") : n.length === 0 && kt(!1, "`children` of ResizeObserver is empty. Nothing is in observe.")), n.map(function(i, s) {
+    var a = (i == null ? void 0 : i.key) || "".concat(On, "-").concat(s);
+    return /* @__PURE__ */ ee.createElement(ir, ft({}, e, {
+      key: a,
+      ref: s === 0 ? t : void 0
+    }), i);
+  });
+}
+var bt = /* @__PURE__ */ ee.forwardRef(xn);
+process.env.NODE_ENV !== "production" && (bt.displayName = "ResizeObserver");
+bt.Collection = Jr;
+var sr = { exports: {} };
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+(function(e) {
+  (function() {
+    var t = {}.hasOwnProperty;
+    function r() {
+      for (var s = "", a = 0; a < arguments.length; a++) {
+        var c = arguments[a];
+        c && (s = i(s, n(c)));
+      }
+      return s;
+    }
+    function n(s) {
+      if (typeof s == "string" || typeof s == "number")
+        return s;
+      if (typeof s != "object")
+        return "";
+      if (Array.isArray(s))
+        return r.apply(null, s);
+      if (s.toString !== Object.prototype.toString && !s.toString.toString().includes("[native code]"))
+        return s.toString();
+      var a = "";
+      for (var c in s)
+        t.call(s, c) && s[c] && (a = i(a, c));
+      return a;
+    }
+    function i(s, a) {
+      return a ? s ? s + " " + a : s + a : s;
+    }
+    e.exports ? (r.default = r, e.exports = r) : window.classNames = r;
+  })();
+})(sr);
+var Tn = sr.exports;
+const Et = /* @__PURE__ */ Ar(Tn);
+const Pn = Pr(({ columns: e, width: t, onScroll: r }, n) => {
+  const i = ye(() => {
+    const s = [], a = (v) => {
+      let u = 0;
+      return v.forEach((m) => {
+        if (m.children && m.children.length > 0) {
+          const E = a(m.children);
+          E > u && (u = E);
+        }
+      }), u + 1;
+    }, c = a(e), l = (v, u) => {
+      s[u] || (s[u] = []), v.forEach((m) => {
+        var I;
+        const E = {
+          key: m.field || m.dataIndex || m.title || String(Math.random()),
+          title: m.title,
+          width: m.width,
+          align: ((I = m.style) == null ? void 0 : I.textAlign) || "center",
+          className: void 0,
+          // col.className not in type, ignore
+          colSpan: 1,
+          rowSpan: 1
+        };
+        if (m.children && m.children.length > 0) {
+          const $ = (C) => C.children && C.children.length > 0 ? C.children.reduce((d, k) => d + $(k), 0) : 1;
+          E.colSpan = $(m), s[u].push(E), l(m.children, u + 1);
+        } else
+          E.rowSpan = c - u, s[u].push(E);
+      });
+    };
+    return l(e, 0), s;
+  }, [e]);
+  return /* @__PURE__ */ J.jsx(
+    "div",
+    {
+      ref: n,
+      className: "virtual-table-header hide-scrollbar",
+      style: { overflow: "auto", width: t },
+      onScroll: r,
+      children: /* @__PURE__ */ J.jsxs("table", { style: { tableLayout: "fixed", width: "100%" }, children: [
+        /* @__PURE__ */ J.jsx("colgroup", { children: e.map((s, a) => {
+          const c = (l) => l.children && l.children.length > 0 ? l.children.flatMap(c) : [l.width];
+          return c(s).map((l, v) => /* @__PURE__ */ J.jsx("col", { style: { width: l, minWidth: l } }, `${a}-${v}`));
+        }).flat() }),
+        /* @__PURE__ */ J.jsx("thead", { className: "virtual-table-thead", children: i.map((s, a) => /* @__PURE__ */ J.jsx("tr", { className: "virtual-table-row", children: s.map((c, l) => /* @__PURE__ */ J.jsx(
+          "th",
+          {
+            className: Et("virtual-table-cell", c.className),
+            colSpan: c.colSpan,
+            rowSpan: c.rowSpan,
+            title: c.title,
+            style: {
+              textAlign: c.align
+            },
+            children: c.title
+          },
+          l
+        )) }, a)) })
+      ] })
+    }
+  );
+}), gt = (e) => {
+  if (e === null || typeof e != "object")
+    return e;
+  if (Array.isArray(e))
+    return e.map((r) => gt(r));
+  const t = {};
+  for (const r in e)
+    Object.prototype.hasOwnProperty.call(e, r) && (t[r] = gt(e[r]));
+  return t;
+}, ar = 43, jn = 100, Ce = "-", Ht = "合计";
+function An(e) {
+  let t = e;
+  for (; t; ) {
+    if (t.dir)
+      return t.dir === "rtl";
+    t = t.parentElement;
+  }
+  return !1;
+}
+function Mn(e, t) {
+  const [r, n] = Me(t === "rtl");
+  return yt(() => {
+    e && (t || n(An(e)));
+  }, [t, e]), r;
+}
+const qe = typeof window < "u" ? yt : Je;
+function Bt(e) {
+  if (e !== void 0)
+    switch (typeof e) {
+      case "number":
+        return e;
+      case "string": {
+        if (e.endsWith("px"))
+          return parseFloat(e);
+        break;
+      }
+    }
+}
+function zn({
+  box: e,
+  defaultHeight: t,
+  defaultWidth: r,
+  disabled: n,
+  element: i,
+  mode: s,
+  style: a
+}) {
+  const { styleHeight: c, styleWidth: l } = ye(
+    () => ({
+      styleHeight: Bt(a == null ? void 0 : a.height),
+      styleWidth: Bt(a == null ? void 0 : a.width)
+    }),
+    [a == null ? void 0 : a.height, a == null ? void 0 : a.width]
+  ), [v, u] = Me({
+    height: t,
+    width: r
+  }), m = n || s === "only-height" && c !== void 0 || s === "only-width" && l !== void 0 || c !== void 0 && l !== void 0;
+  return qe(() => {
+    if (i === null || m)
+      return;
+    const E = new ResizeObserver((I) => {
+      for (const $ of I) {
+        const { contentRect: C, target: d } = $;
+        i === d && u((k) => k.height === C.height && k.width === C.width ? k : {
+          height: C.height,
+          width: C.width
+        });
+      }
+    });
+    return E.observe(i, { box: e }), () => {
+      E == null || E.unobserve(i);
+    };
+  }, [e, m, i, c, l]), ye(
+    () => ({
+      height: c ?? v.height,
+      width: l ?? v.width
+    }),
+    [v, c, l]
+  );
+}
+function In(e) {
+  const t = Ae(() => {
+    throw new Error("Cannot call during render.");
+  });
+  return qe(() => {
+    t.current = e;
+  }, [e]), he((r) => {
+    var n;
+    return (n = t.current) == null ? void 0 : n.call(t, r);
+  }, [t]);
+}
+let $e = null;
+function kn(e = !1) {
+  if ($e === null || e) {
+    const t = document.createElement("div"), r = t.style;
+    r.width = "50px", r.height = "50px", r.overflow = "scroll", r.direction = "rtl";
+    const n = document.createElement("div"), i = n.style;
+    return i.width = "100px", i.height = "100px", t.appendChild(n), document.body.appendChild(t), t.scrollLeft > 0 ? $e = "positive-descending" : (t.scrollLeft = 1, t.scrollLeft === 0 ? $e = "negative" : $e = "positive-ascending"), document.body.removeChild(t), $e;
+  }
+  return $e;
+}
+function it({
+  containerElement: e,
+  direction: t,
+  isRtl: r,
+  scrollOffset: n
+}) {
+  if (t === "horizontal" && r)
+    switch (kn()) {
+      case "negative":
+        return -n;
+      case "positive-descending": {
+        if (e) {
+          const { clientWidth: i, scrollLeft: s, scrollWidth: a } = e;
+          return a - i - s;
+        }
+        break;
+      }
+    }
+  return n;
+}
+function Te(e, t = "Assertion error") {
+  if (!e)
+    throw console.error(t), Error(t);
+}
+function Be(e, t) {
+  if (e === t)
+    return !0;
+  if (!!e != !!t || (Te(e !== void 0), Te(t !== void 0), Object.keys(e).length !== Object.keys(t).length))
+    return !1;
+  for (const r in e)
+    if (!Object.is(t[r], e[r]))
+      return !1;
+  return !0;
+}
+function cr({
+  cachedBounds: e,
+  itemCount: t,
+  itemSize: r
+}) {
+  if (t === 0)
+    return 0;
+  if (typeof r == "number")
+    return t * r;
+  {
+    const n = e.get(
+      e.size === 0 ? 0 : e.size - 1
+    );
+    Te(n !== void 0, "Unexpected bounds cache miss");
+    const i = (n.scrollOffset + n.size) / e.size;
+    return t * i;
+  }
+}
+function Ln({
+  align: e,
+  cachedBounds: t,
+  index: r,
+  itemCount: n,
+  itemSize: i,
+  containerScrollOffset: s,
+  containerSize: a
+}) {
+  if (r < 0 || r >= n)
+    throw RangeError(`Invalid index specified: ${r}`, {
+      cause: `Index ${r} is not within the range of 0 - ${n - 1}`
+    });
+  const c = cr({
+    cachedBounds: t,
+    itemCount: n,
+    itemSize: i
+  }), l = t.get(r), v = Math.max(
+    0,
+    Math.min(c - a, l.scrollOffset)
+  ), u = Math.max(
+    0,
+    l.scrollOffset - a + l.size
+  );
+  switch (e === "smart" && (s >= u && s <= v ? e = "auto" : e = "center"), e) {
+    case "start":
+      return v;
+    case "end":
+      return u;
+    case "center":
+      return l.scrollOffset <= a / 2 ? 0 : l.scrollOffset + l.size / 2 >= c - a / 2 ? c - a : l.scrollOffset + l.size / 2 - a / 2;
+    case "auto":
+    default:
+      return s >= u && s <= v ? s : s < u ? u : v;
+  }
+}
+function st({
+  cachedBounds: e,
+  containerScrollOffset: t,
+  containerSize: r,
+  itemCount: n,
+  overscanCount: i
+}) {
+  const s = n - 1;
+  let a = 0, c = -1, l = 0, v = -1, u = 0;
+  for (; u < s; ) {
+    const m = e.get(u);
+    if (m.scrollOffset + m.size > t)
+      break;
+    u++;
+  }
+  for (a = u, l = Math.max(0, a - i); u < s; ) {
+    const m = e.get(u);
+    if (m.scrollOffset + m.size >= t + r)
+      break;
+    u++;
+  }
+  return c = Math.min(s, u), v = Math.min(n - 1, c + i), a < 0 && (a = 0, c = -1, l = 0, v = -1), {
+    startIndexVisible: a,
+    stopIndexVisible: c,
+    startIndexOverscan: l,
+    stopIndexOverscan: v
+  };
+}
+function $n({
+  itemCount: e,
+  itemProps: t,
+  itemSize: r
+}) {
+  const n = /* @__PURE__ */ new Map();
+  return {
+    get(i) {
+      for (Te(i < e, `Invalid index ${i}`); n.size - 1 < i; ) {
+        const a = n.size;
+        let c;
+        switch (typeof r) {
+          case "function": {
+            c = r(a, t);
+            break;
+          }
+          case "number": {
+            c = r;
+            break;
+          }
+        }
+        if (a === 0)
+          n.set(a, {
+            size: c,
+            scrollOffset: 0
+          });
+        else {
+          const l = n.get(a - 1);
+          Te(
+            l !== void 0,
+            `Unexpected bounds cache miss for index ${i}`
+          ), n.set(a, {
+            scrollOffset: l.scrollOffset + l.size,
+            size: c
+          });
+        }
+      }
+      const s = n.get(i);
+      return Te(
+        s !== void 0,
+        `Unexpected bounds cache miss for index ${i}`
+      ), s;
+    },
+    set(i, s) {
+      n.set(i, s);
+    },
+    get size() {
+      return n.size;
+    }
+  };
+}
+function Dn({
+  itemCount: e,
+  itemProps: t,
+  itemSize: r
+}) {
+  return ye(
+    () => $n({
+      itemCount: e,
+      itemProps: t,
+      itemSize: r
+    }),
+    [e, t, r]
+  );
+}
+function Nn({
+  containerSize: e,
+  itemSize: t
+}) {
+  let r;
+  switch (typeof t) {
+    case "string": {
+      Te(
+        t.endsWith("%"),
+        `Invalid item size: "${t}"; string values must be percentages (e.g. "100%")`
+      ), Te(
+        e !== void 0,
+        "Container size must be defined if a percentage item size is specified"
+      ), r = e * parseInt(t) / 100;
+      break;
+    }
+    default: {
+      r = t;
+      break;
+    }
+  }
+  return r;
+}
+function Yt({
+  containerElement: e,
+  containerStyle: t,
+  defaultContainerSize: r = 0,
+  direction: n,
+  isRtl: i = !1,
+  itemCount: s,
+  itemProps: a,
+  itemSize: c,
+  onResize: l,
+  overscanCount: v
+}) {
+  const { height: u = r, width: m = r } = zn({
+    defaultHeight: n === "vertical" ? r : void 0,
+    defaultWidth: n === "horizontal" ? r : void 0,
+    element: e,
+    mode: n === "vertical" ? "only-height" : "only-width",
+    style: t
+  }), E = Ae({
+    height: 0,
+    width: 0
+  }), I = n === "vertical" ? u : m, $ = Nn({ containerSize: I, itemSize: c });
+  yt(() => {
+    if (typeof l == "function") {
+      const x = E.current;
+      (x.height !== u || x.width !== m) && (l({ height: u, width: m }, { ...x }), x.height = u, x.width = m);
+    }
+  }, [u, l, m]);
+  const C = Dn({
+    itemCount: s,
+    itemProps: a,
+    itemSize: $
+  }), d = he(
+    (x) => C.get(x),
+    [C]
+  ), [k, D] = Me(
+    () => st({
+      cachedBounds: C,
+      // TODO Potentially support a defaultScrollOffset prop?
+      containerScrollOffset: 0,
+      containerSize: I,
+      itemCount: s,
+      overscanCount: v
+    })
+  ), {
+    startIndexVisible: ie,
+    startIndexOverscan: P,
+    stopIndexVisible: S,
+    stopIndexOverscan: z
+  } = {
+    startIndexVisible: Math.min(s - 1, k.startIndexVisible),
+    startIndexOverscan: Math.min(s - 1, k.startIndexOverscan),
+    stopIndexVisible: Math.min(s - 1, k.stopIndexVisible),
+    stopIndexOverscan: Math.min(s - 1, k.stopIndexOverscan)
+  }, T = he(
+    () => cr({
+      cachedBounds: C,
+      itemCount: s,
+      itemSize: $
+    }),
+    [C, s, $]
+  ), j = he(
+    (x) => {
+      const F = it({
+        containerElement: e,
+        direction: n,
+        isRtl: i,
+        scrollOffset: x
+      });
+      return st({
+        cachedBounds: C,
+        containerScrollOffset: F,
+        containerSize: I,
+        itemCount: s,
+        overscanCount: v
+      });
+    },
+    [
+      C,
+      e,
+      I,
+      n,
+      i,
+      s,
+      v
+    ]
+  );
+  qe(() => {
+    const x = (n === "vertical" ? e == null ? void 0 : e.scrollTop : e == null ? void 0 : e.scrollLeft) ?? 0;
+    D(j(x));
+  }, [e, n, j]), qe(() => {
+    if (!e)
+      return;
+    const x = () => {
+      D((F) => {
+        const { scrollLeft: U, scrollTop: G } = e, Q = it({
+          containerElement: e,
+          direction: n,
+          isRtl: i,
+          scrollOffset: n === "vertical" ? G : U
+        }), le = st({
+          cachedBounds: C,
+          containerScrollOffset: Q,
+          containerSize: I,
+          itemCount: s,
+          overscanCount: v
+        });
+        return Be(le, F) ? F : le;
+      });
+    };
+    return e.addEventListener("scroll", x), () => {
+      e.removeEventListener("scroll", x);
+    };
+  }, [
+    C,
+    e,
+    I,
+    n,
+    s,
+    v
+  ]);
+  const V = In(
+    ({
+      align: x = "auto",
+      containerScrollOffset: F,
+      index: U
+    }) => {
+      let G = Ln({
+        align: x,
+        cachedBounds: C,
+        containerScrollOffset: F,
+        containerSize: I,
+        index: U,
+        itemCount: s,
+        itemSize: $
+      });
+      if (e) {
+        if (G = it({
+          containerElement: e,
+          direction: n,
+          isRtl: i,
+          scrollOffset: G
+        }), typeof e.scrollTo != "function") {
+          const Q = j(G);
+          Be(k, Q) || D(Q);
+        }
+        return G;
+      }
+    }
+  );
+  return {
+    getCellBounds: d,
+    getEstimatedSize: T,
+    scrollToIndex: V,
+    startIndexOverscan: P,
+    startIndexVisible: ie,
+    stopIndexOverscan: z,
+    stopIndexVisible: S
+  };
+}
+function Fn(e) {
+  return ye(() => e, Object.values(e));
+}
+function Wn(e, t) {
+  const {
+    ariaAttributes: r,
+    style: n,
+    ...i
+  } = e, {
+    ariaAttributes: s,
+    style: a,
+    ...c
+  } = t;
+  return Be(r, s) && Be(n, a) && Be(i, c);
+}
+function Vn({
+  cellComponent: e,
+  cellProps: t,
+  children: r,
+  className: n,
+  columnCount: i,
+  columnWidth: s,
+  defaultHeight: a = 0,
+  defaultWidth: c = 0,
+  dir: l,
+  gridRef: v,
+  onCellsRendered: u,
+  onResize: m,
+  overscanCount: E = 3,
+  rowCount: I,
+  rowHeight: $,
+  style: C,
+  tagName: d = "div",
+  ...k
+}) {
+  const D = Fn(t), ie = ye(
+    () => Gt(e, Wn),
+    [e]
+  ), [P, S] = Me(null), z = Mn(P, l), {
+    getCellBounds: T,
+    getEstimatedSize: j,
+    startIndexOverscan: V,
+    startIndexVisible: x,
+    scrollToIndex: F,
+    stopIndexOverscan: U,
+    stopIndexVisible: G
+  } = Yt({
+    containerElement: P,
+    containerStyle: C,
+    defaultContainerSize: c,
+    direction: "horizontal",
+    isRtl: z,
+    itemCount: i,
+    itemProps: D,
+    itemSize: s,
+    onResize: m,
+    overscanCount: E
+  }), {
+    getCellBounds: Q,
+    getEstimatedSize: le,
+    startIndexOverscan: be,
+    startIndexVisible: Re,
+    scrollToIndex: Ee,
+    stopIndexOverscan: fe,
+    stopIndexVisible: y
+  } = Yt({
+    containerElement: P,
+    containerStyle: C,
+    defaultContainerSize: a,
+    direction: "vertical",
+    itemCount: I,
+    itemProps: D,
+    itemSize: $,
+    onResize: m,
+    overscanCount: E
+  });
+  jr(
+    v,
+    () => ({
+      get element() {
+        return P;
+      },
+      scrollToCell({
+        behavior: g = "auto",
+        columnAlign: h = "auto",
+        columnIndex: R,
+        rowAlign: L = "auto",
+        rowIndex: _
+      }) {
+        const A = F({
+          align: h,
+          containerScrollOffset: (P == null ? void 0 : P.scrollLeft) ?? 0,
+          index: R
+        }), H = Ee({
+          align: L,
+          containerScrollOffset: (P == null ? void 0 : P.scrollTop) ?? 0,
+          index: _
+        });
+        typeof (P == null ? void 0 : P.scrollTo) == "function" && P.scrollTo({
+          behavior: g,
+          left: A,
+          top: H
+        });
+      },
+      scrollToColumn({
+        align: g = "auto",
+        behavior: h = "auto",
+        index: R
+      }) {
+        const L = F({
+          align: g,
+          containerScrollOffset: (P == null ? void 0 : P.scrollLeft) ?? 0,
+          index: R
+        });
+        typeof (P == null ? void 0 : P.scrollTo) == "function" && P.scrollTo({
+          behavior: h,
+          left: L
+        });
+      },
+      scrollToRow({
+        align: g = "auto",
+        behavior: h = "auto",
+        index: R
+      }) {
+        const L = Ee({
+          align: g,
+          containerScrollOffset: (P == null ? void 0 : P.scrollTop) ?? 0,
+          index: R
+        });
+        typeof (P == null ? void 0 : P.scrollTo) == "function" && P.scrollTo({
+          behavior: h,
+          top: L
+        });
+      }
+    }),
+    [P, F, Ee]
+  ), Je(() => {
+    V >= 0 && U >= 0 && be >= 0 && fe >= 0 && u && u(
+      {
+        columnStartIndex: x,
+        columnStopIndex: G,
+        rowStartIndex: Re,
+        rowStopIndex: y
+      },
+      {
+        columnStartIndex: V,
+        columnStopIndex: U,
+        rowStartIndex: be,
+        rowStopIndex: fe
+      }
+    );
+  }, [
+    u,
+    V,
+    x,
+    U,
+    G,
+    be,
+    Re,
+    fe,
+    y
+  ]);
+  const w = ye(() => {
+    const g = [];
+    if (i > 0 && I > 0)
+      for (let h = be; h <= fe; h++) {
+        const R = Q(h), L = [];
+        for (let _ = V; _ <= U; _++) {
+          const A = T(_);
+          L.push(
+            /* @__PURE__ */ At(
+              ie,
+              {
+                ...D,
+                ariaAttributes: {
+                  "aria-colindex": _ + 1,
+                  role: "gridcell"
+                },
+                columnIndex: _,
+                key: _,
+                rowIndex: h,
+                style: {
+                  position: "absolute",
+                  left: z ? void 0 : 0,
+                  right: z ? 0 : void 0,
+                  transform: `translate(${z ? -A.scrollOffset : A.scrollOffset}px, ${R.scrollOffset}px)`,
+                  height: R.size,
+                  width: A.size
+                }
+              }
+            )
+          );
+        }
+        g.push(
+          /* @__PURE__ */ J.jsx("div", { role: "row", "aria-rowindex": h + 1, children: L }, h)
+        );
+      }
+    return g;
+  }, [
+    ie,
+    D,
+    i,
+    V,
+    U,
+    T,
+    Q,
+    z,
+    I,
+    be,
+    fe
+  ]), O = /* @__PURE__ */ J.jsx(
+    "div",
+    {
+      "aria-hidden": !0,
+      style: {
+        height: le(),
+        width: j(),
+        zIndex: -1
+      }
+    }
+  );
+  return At(
+    d,
+    {
+      "aria-colcount": i,
+      "aria-rowcount": I,
+      role: "grid",
+      ...k,
+      className: n,
+      dir: l,
+      ref: S,
+      style: {
+        position: "relative",
+        maxHeight: "100%",
+        maxWidth: "100%",
+        flexGrow: 1,
+        overflow: "auto",
+        ...C
+      }
+    },
+    w,
+    r,
+    O
+  );
+}
+const Hn = (e) => /* @__PURE__ */ J.jsxs("svg", { viewBox: "64 64 896 896", focusable: "false", width: "1em", height: "1em", fill: "currentColor", "aria-hidden": "true", ...e, children: [
+  /* @__PURE__ */ J.jsx("path", { d: "M518.5 360.3a7.95 7.95 0 00-12.9 0l-178 246c-3.8 5.3 0 12.7 6.5 12.7H381c10.2 0 19.9-4.9 25.9-13.2L512 460.4l105.2 145.4c6 8.3 15.6 13.2 25.9 13.2H690c6.5 0 10.3-7.4 6.5-12.7l-178-246z" }),
+  /* @__PURE__ */ J.jsx("path", { d: "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z" })
+] }), Bn = (e) => /* @__PURE__ */ J.jsxs("svg", { viewBox: "64 64 896 896", focusable: "false", width: "1em", height: "1em", fill: "currentColor", "aria-hidden": "true", ...e, children: [
+  /* @__PURE__ */ J.jsx("path", { d: "M690 405h-46.9c-10.2 0-19.9 4.9-25.9 13.2L512 563.6 406.8 418.2c-6-8.3-15.6-13.2-25.9-13.2H334c-6.5 0-10.3 7.4-6.5 12.7l178 246c3.2 4.4 9.7 4.4 12.9 0l178-246c3.9-5.3.1-12.7-6.4-12.7z" }),
+  /* @__PURE__ */ J.jsx("path", { d: "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z" })
+] }), Yn = (e, t, r) => {
+  var i;
+  const n = (i = r[e]) == null ? void 0 : i[t];
+  return !n || n.rowspan === 0 || n.colspan === 0;
+}, Kn = (e, t, r, n, i) => {
+  var l, v, u;
+  const s = (l = n[e]) == null ? void 0 : l[t];
+  if (!s || s.rowspan === 0 || s.colspan === 0)
+    return;
+  const a = { ...r }, c = i[t];
+  if (s.colspan > 1) {
+    let m = 0;
+    for (let E = t; E < t + s.colspan; E++)
+      m += Number((v = i[E]) == null ? void 0 : v.width) || 100;
+    a.width = m;
+  }
+  return s.rowspan > 1 && (a.height = s.rowspan * ar), (u = c == null ? void 0 : c.style) != null && u.textAlign && (a.textAlign = c.style.textAlign, c.style.textAlign === "right" && (a.justifyContent = "flex-end"), c.style.textAlign === "center" && (a.justifyContent = "center")), a.border = "1px solid #f0f0f0", a.padding = "8px 16px", a.display = "flex", a.alignItems = "center", a.backgroundColor = "#fff", a;
+}, Gn = ({ columnIndex: e, rowIndex: t, style: r, mergedData: n, columns: i, handleExpand: s, meta: a }) => {
+  if (Yn(t, e, n))
+    return null;
+  const c = n[t][e], l = Kn(t, e, r, n, i), v = i[e], u = a == null ? void 0 : a.find((I) => I.field === v.field), m = Ye.isValidElement(c.content);
+  let E;
+  if (E = c.content, u != null && u.clickHandler && !m && E !== null && E !== void 0) {
+    const I = c.data;
+    E = /* @__PURE__ */ J.jsx(
+      "a",
+      {
+        href: "javascript:void(0)",
+        onClick: ($) => {
+          $.preventDefault(), $.stopPropagation(), u.clickHandler(I);
+        },
+        style: { cursor: "pointer", textDecoration: "underline", color: "#1890ff" },
+        children: E
+      }
+    );
+  }
+  return /* @__PURE__ */ J.jsxs(
+    "div",
+    {
+      style: l,
+      className: Et("table-cell", "virtual-table-cell", {
+        "virtual-table-cell-last": e === i.length - 1
+      }),
+      title: typeof E == "string" ? E : void 0,
+      children: [
+        /* @__PURE__ */ J.jsx("span", { className: "expand-icon", children: c.expandable ? c.expanded ? /* @__PURE__ */ J.jsx(Bn, { onClick: () => {
+          console.log("DownCircleOutlined onClick", c), c.onClick && c.onClick(c), s(c);
+        } }) : /* @__PURE__ */ J.jsx(Hn, { onClick: () => {
+          console.log("UpCircleOutlined onClick", c), c.onClick && c.onClick(c), s(c);
+        } }) : null }),
+        E
+      ]
+    }
+  );
+}, Un = (e) => {
+  const { data: t, info: r, scroll: n, columns: i, tableWidth: s } = e, { ref: a, onScroll: c } = r, l = Ae(), v = ye(() => {
+    const S = {};
+    return Object.defineProperty(S, "scrollLeft", {
+      get: () => {
+        var z, T;
+        return ((T = (z = l.current) == null ? void 0 : z.element) == null ? void 0 : T.scrollLeft) || 0;
+      },
+      set: (z) => {
+        var T;
+        (T = l.current) != null && T.element && (l.current.element.scrollLeft = z);
+      }
+    }), Object.defineProperty(S, "scrollTop", {
+      get: () => {
+        var z, T;
+        return ((T = (z = l.current) == null ? void 0 : z.element) == null ? void 0 : T.scrollTop) || 0;
+      },
+      set: (z) => {
+        var T;
+        (T = l.current) != null && T.element && (l.current.element.scrollTop = z);
+      }
+    }), S;
+  }, []);
+  Je(() => {
+    a && (a.current = v);
+  }, [a, v]);
+  const u = t, m = u.length, E = he((S) => {
+    let z = 0;
+    return S.forEach((T) => {
+      T != null && T.children && T.children.length > 0 ? z += E(T.children) : z += 1;
+    }), z;
+  }, []), I = E(i), $ = he((S) => {
+    let z = [];
+    return S.forEach((T) => {
+      T != null && T.children && T.children.length > 0 ? z = [...z, ...$(T.children)] : z.push(T);
+    }), z;
+  }, []), C = $(i), d = he((S) => {
+    const z = C[S];
+    let T = (z == null ? void 0 : z.width) || 100;
+    return typeof T == "string" && (T = parseInt(T.replace("px", "")) || 100), T;
+  }, [C]), k = he((S) => ar, []), D = ye(() => u.map((S) => S.cells), [u]), ie = he((S) => {
+    if (S && typeof S.scrollLeft == "number") {
+      c && c(S);
+      return;
+    }
+    if (S && S.target) {
+      const { scrollLeft: z, scrollTop: T } = S.target;
+      c && c({ scrollLeft: z, scrollTop: T });
+    }
+  }, [c]), P = (typeof (n == null ? void 0 : n.y) == "number" ? n.y : parseInt((n == null ? void 0 : n.y) || "400")) || 400;
+  return /* @__PURE__ */ J.jsx(
+    Vn,
+    {
+      gridRef: l,
+      columnCount: I,
+      columnWidth: d,
+      rowCount: m,
+      rowHeight: k,
+      style: { height: P - 40, width: s },
+      onScroll: ie,
+      className: "virtual-grid",
+      overscanCount: 20,
+      cellComponent: Gn,
+      cellProps: {
+        mergedData: D,
+        columns: C,
+        data: u,
+        handleExpand: e.handleExpand,
+        meta: e.meta
+      }
+    }
+  );
+}, He = (e) => {
+  const t = [], r = (n) => {
+    n.children && n.children.length > 0 ? n.children.forEach((i) => r(i)) : t.push(n);
+  };
+  return e.forEach((n) => r(n)), t;
+}, de = (e, t) => {
+  const r = t.split(".");
+  let n = e;
+  for (const i of r) {
+    if (n == null)
+      return n;
+    n = n[i];
+  }
+  return n == null && (n = Ce), n;
+}, at = (e, t) => "|" + t.map((n) => de(e, n)).join("|"), Kt = {
+  sum: (e) => e.reduce((t, r) => t + (Number(r) || 0), 0),
+  avg: (e) => {
+    const t = e.filter((r) => !isNaN(Number(r)));
+    return t.length > 0 ? t.reduce((r, n) => r + Number(n), 0) / t.length : 0;
+  },
+  count: (e) => e.length,
+  min: (e) => Math.min(...e.map((t) => Number(t) || 1 / 0)),
+  max: (e) => Math.max(...e.map((t) => Number(t) || -1 / 0)),
+  d_count: (e) => new Set(e).size,
+  variance: (e) => {
+    const t = e.map((i) => Number(i)).filter((i) => !isNaN(i));
+    if (t.length === 0)
+      return 0;
+    const r = t.reduce((i, s) => i + s, 0) / t.length;
+    return t.map((i) => Math.pow(i - r, 2)).reduce((i, s) => i + s, 0) / t.length;
+  },
+  stddev: (e) => {
+    const t = e.map((s) => Number(s)).filter((s) => !isNaN(s));
+    if (t.length === 0)
+      return 0;
+    const r = t.reduce((s, a) => s + a, 0) / t.length, i = t.map((s) => Math.pow(s - r, 2)).reduce((s, a) => s + a, 0) / t.length;
+    return Math.sqrt(i);
+  }
+}, ge = /* @__PURE__ */ new Map(), ct = /* @__PURE__ */ new Map(), lt = /* @__PURE__ */ new Map(), qn = (e) => {
+  const { data: t, sortParams: r, fields: n } = e, { rows: i, columns: s, values: a } = n;
+  if (!t || t.length === 0 || !i.length && !s.length && !a.length)
+    return {
+      list: [],
+      dataExpandFilter: (y) => y
+    };
+  console.group("透视表数据处理");
+  const c = He(i), l = He(s), v = He(a), u = c.map((y) => y.field), m = l.map((y) => y.field), E = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Map(), $ = /* @__PURE__ */ new Map();
+  t.forEach((y) => {
+    const w = at(y, u);
+    E.has(w) || E.set(w, []), E.get(w).push(y);
+    const O = at(y, m);
+    I.has(O) || I.set(O, []), I.get(O).push(y);
+    const g = `${w}||${O}`;
+    $.has(g) || $.set(g, []), $.get(g).push(y);
+  });
+  const C = () => Array.from(E.entries()).sort(([y, w], [O, g]) => {
+    if (r && r.length > 0)
+      for (const h of r) {
+        const { field: R, sortType: L } = h, _ = L === "asc", A = de(w[0], R), H = de(g[0], R);
+        if (A < H)
+          return _ ? -1 : 1;
+        if (A > H)
+          return _ ? 1 : -1;
+      }
+    for (let h = 0; h < u.length; h++) {
+      const R = u[h], L = c[h], _ = de(w[0], R), A = de(g[0], R);
+      if (_ !== A)
+        if (L.sort && L.sort.enabled) {
+          const H = L.sort.type === "asc";
+          if (_ < A)
+            return H ? -1 : 1;
+          if (_ > A)
+            return H ? 1 : -1;
+        } else {
+          if (_ < A)
+            return -1;
+          if (_ > A)
+            return 1;
+        }
+    }
+    return 0;
+  }), d = () => Array.from(I.entries()).sort(([y, w], [O, g]) => {
+    for (let h = 0; h < m.length; h++) {
+      const R = m[h], L = l[h], _ = de(w[0], R), A = de(g[0], R);
+      if (_ !== A)
+        if (L.sort && L.sort.enabled) {
+          const H = L.sort.type === "asc";
+          if (_ < A)
+            return H ? -1 : 1;
+          if (_ > A)
+            return H ? 1 : -1;
+        } else {
+          if (_ < A)
+            return -1;
+          if (_ > A)
+            return 1;
+        }
+    }
+    return 0;
+  }), k = () => {
+    const y = [], w = He(i);
+    for (let O = 1; O <= w.length; O++)
+      y.push(w.slice(0, O));
+    return y;
+  }, D = () => {
+    const y = k(), w = /* @__PURE__ */ new Set();
+    return y.forEach((O, g) => {
+      const h = O[O.length - 1];
+      h.total && h.total.enabled && w.add(g);
+    }), w;
+  }, ie = () => {
+    const y = k(), w = [], O = D();
+    return O.size === 0 || O.forEach((g) => {
+      let h = [];
+      g > 0 && (h = y[g - 1]);
+      const R = {};
+      t.forEach((L) => {
+        let _ = "";
+        if (g > 0 ? _ = h.map((A) => de(L, A.field)).join("|") : _ = "__GLOBAL__", !R[_]) {
+          const H = y[g][g].total;
+          R[_] = {
+            records: [],
+            config: H
+          };
+        }
+        R[_].records.push(L);
+      }), w.push({ level: g, data: R });
+    }), w;
+  }, P = d(), S = /* @__PURE__ */ new Map(), z = (y, w) => {
+    if (console.log("toggleExpand", y, w), ge.has(y)) {
+      const O = ge.get(y), g = O.get(w);
+      O.set(w, !g), ct.set("rowKey", w), ct.set("level", y), ct.set("expanded", !g);
+    }
+  }, T = (y) => {
+    const w = ie(), O = [...y];
+    if (w.length === 0)
+      return O;
+    for (let g = 0; g < w.length; g++) {
+      const { level: h, data: R } = w[g];
+      Object.keys(R).forEach((L) => {
+        const { records: _, config: A } = R[L], { label: H = Ht, position: X = "bottom" } = A || {}, we = L.split("|");
+        let se = -1, ae = -1;
+        if (h === 0)
+          se = 0, ae = O.length - 1;
+        else
+          for (let b = 0; b < O.length; b++) {
+            const ne = O[b];
+            u.slice(0, h).every((Se, pe) => {
+              var Z;
+              return ((Z = ne[pe]) == null ? void 0 : Z.content) === we[pe];
+            }) && (se === -1 && (se = b), ae = b);
+          }
+        if (se !== -1) {
+          const b = [];
+          let ne = "";
+          u.forEach((Se, pe) => {
+            let Z = Ce;
+            const xe = pe + 1, ze = xe < u.length, Pe = c[pe];
+            pe <= h && (pe === h ? Z = H : Z = we[pe], ne += `|${Z}`);
+            const Ne = ge.has(xe) && ge.get(xe).get(ne) || !0;
+            (Z === Ce || Z === null || Z === void 0) && Pe.emptyReplace && (Z = Pe.emptyReplace), b.push({
+              content: Z,
+              rowspan: 1,
+              colspan: 1,
+              data: null,
+              rowKey: ne,
+              expandable: X === "top" && ze && Z !== Ce && Z !== Ht,
+              expanded: X === "top" ? Ne : !1,
+              level: xe,
+              onClick: X === "top" && ze ? (ve) => z(ve.level, ve.rowKey) : void 0
+            });
+          }), P.forEach(([Se, pe]) => {
+            v.forEach((Z) => {
+              const xe = Z.field, ze = Z.calculateType || "sum", Ne = _.filter((Ie) => at(Ie, m) === Se).map((Ie) => de(Ie, xe));
+              let ve = Kt[ze](Ne);
+              (ve === Ce || ve === null || ve === void 0 || typeof ve == "number" && isNaN(ve)) && Z.emptyReplace && (ve = Z.emptyReplace), b.push({
+                content: ve,
+                rowspan: 1,
+                colspan: 1,
+                data: null
+              });
+            });
+          });
+          const te = X === "top" ? se : ae + 1;
+          lt.has(ne) || (O.splice(te, 0, b), lt.set(ne, 1), X === "top" && h > 0 && S.set(L, ne));
+        }
+      });
+    }
+    return O;
+  }, j = He(i);
+  ge.clear(), t.forEach((y) => {
+    let w = "";
+    u.forEach((O, g) => {
+      const h = g + 1, R = de(y, O);
+      w += `|${R}`, ge.has(h) || ge.set(h, /* @__PURE__ */ new Map()), ge.get(h).set(w, !0);
+    });
+  });
+  const V = C();
+  let x = [];
+  const F = /* @__PURE__ */ new Map();
+  V.forEach(([y, w]) => {
+    const O = w[0];
+    let g = "";
+    u.forEach((h, R) => {
+      const L = de(O, h), _ = R + 1;
+      g += `|${L}`, F.has(_) || F.set(_, /* @__PURE__ */ new Map());
+      const A = F.get(_);
+      A.set(g, (A.get(g) || 0) + 1);
+    });
+  }), V.forEach(([y, w]) => {
+    const O = w[0], g = [];
+    let h = "";
+    u.forEach((R, L) => {
+      var ne;
+      let _ = de(O, R);
+      const A = L + 1, H = A < u.length, X = c[L];
+      h += `|${_}`;
+      let we = y;
+      const se = j.find((te) => te.field === R);
+      if ((ne = se == null ? void 0 : se.total) != null && ne.enabled && se.total.label && (we = `${h}|${se.total.label}`), H) {
+        const te = h;
+        S.has(te) || S.set(te, we);
+      }
+      const ae = ge.has(A) && ge.get(A).get(h) || !0, b = A < u.length ? (F.get(A).get(h) || 0) > 1 : !1;
+      (_ === Ce || _ === null || _ === void 0) && X.emptyReplace && (_ = X.emptyReplace), g.push({
+        content: _,
+        rowspan: 1,
+        colspan: 1,
+        data: O,
+        expandable: H && b,
+        expanded: ae,
+        level: A,
+        rowKey: h,
+        onClick: H && b ? (te) => z(te.level, te.rowKey) : void 0
+      });
+    }), P.forEach(([R, L]) => {
+      v.forEach((_) => {
+        const A = _.field, H = _.calculateType || "sum", X = `${y}||${R}`, se = ($.get(X) || []).map((b) => de(b, A));
+        let ae = Kt[H](se);
+        (ae === Ce || ae === null || ae === void 0 || typeof ae == "number" && isNaN(ae)) && _.emptyReplace && (ae = _.emptyReplace), g.push({
+          content: ae,
+          rowspan: 1,
+          colspan: 1,
+          data: O
+        });
+      });
+    }), x.push({ cells: g, rowKey: h });
+  });
+  const U = (y) => {
+    const O = y.split("|").filter(Boolean).length;
+    for (let g = 1; g < O; g++)
+      if (ge.has(g)) {
+        const h = ge.get(g), R = y.split("|").slice(0, g + 1).join("|");
+        if (h.has(R) && !h.get(R)) {
+          const L = R, _ = S.get(L);
+          if (y !== _)
+            return !1;
+        }
+      }
+    return !0;
+  }, G = (y) => {
+    var w, O;
+    if (!y || y.length === 0)
+      return y;
+    for (let g = 0; g < c.length; g++) {
+      let h = y[0][g].content, R = 0, L = c[g], _ = (w = L.total) == null ? void 0 : w.enabled, A = ((O = L.total) == null ? void 0 : O.label) || "";
+      for (let H = 1; H < y.length; H++) {
+        const X = y[H][g];
+        X.content !== Ce && (!_ || X.content !== A) && X.content === h ? (X.rowspan = 0, y[R][g].rowspan++) : (h = X.content, R = H);
+      }
+    }
+    return y;
+  }, Q = (y) => {
+    console.group("透视表数据处理 - 过滤可见行");
+    const w = y.filter((h) => U(h.rowKey)), O = w.map((h) => h.cells.map((R) => ({ ...R })));
+    G(O);
+    const g = w.map((h, R) => ({
+      rowKey: h.rowKey,
+      cells: O[R]
+    }));
+    return console.groupEnd(), g;
+  };
+  lt.clear();
+  const le = x.map((y) => y.cells), Re = T(le).map((y, w) => {
+    let O = "";
+    return y.forEach((g, h) => {
+      h < u.length && g.rowKey && (O = g.rowKey);
+    }), { cells: y, rowKey: O };
+  }), fe = (() => {
+    const y = [];
+    return c.forEach((w) => {
+      y.push({
+        ...w,
+        width: w.width || 100,
+        fixed: "left",
+        key: w.field
+      });
+    }), l.length === 0 ? v.forEach((w) => {
+      y.push({
+        ...w,
+        width: w.width || 100,
+        key: w.field
+      });
+    }) : P.forEach(([w, O]) => {
+      const g = w.split("|").filter((h) => h !== "");
+      v.forEach((h) => {
+        let R = g.join(" - ");
+        R ? R += ` - ${h.title || h.field}` : R = h.title || h.field, y.push({
+          ...h,
+          field: `${w}||${h.field}`,
+          // Unique identifier for the column in data handling
+          title: R,
+          width: h.width || 100,
+          key: `${w}||${h.field}`
+        });
+      });
+    }), y;
+  })();
+  return console.groupEnd(), {
+    list: Re,
+    dataExpandFilter: Q,
+    tableColumns: fe
+  };
+}, Jn = (e) => {
+  const { data: t, fields: r } = e, { rows: n, columns: i, values: s } = r;
+  if (!s || s.length === 0)
+    return { list: [], dataExpandFilter: (a) => a };
+  if (!t || t.length === 0)
+    return { list: [], dataExpandFilter: (a) => a };
+  if (n.length === 0 && i.length === 0) {
+    const a = s.map((l) => ({
+      ...l,
+      width: l.width || 100,
+      key: l.field
+    }));
+    return {
+      list: t.map((l, v) => ({ cells: s.map((m) => ({
+        content: l[m.field] ?? Ce,
+        rowspan: 1,
+        colspan: 1,
+        style: m.style
+      })), rowKey: v.toString() })),
+      dataExpandFilter: (l) => l,
+      tableColumns: a
+    };
+  }
+  return qn(e);
+}, Qn = Gt((e) => {
+  const { scroll: t, data: r, meta: n, sortParams: i, fields: s } = e, [a, c] = Me(0), [l, v] = Me([]), [u, m] = Me([]);
+  console.log("list", l);
+  const E = Ae(null), I = he(() => {
+    if (E.current) {
+      let j = E.current;
+      if (console.log("rs=", j), !j || !j.list || !j.dataExpandFilter)
+        return;
+      v(j.dataExpandFilter(j.list));
+    }
+  }, []);
+  Je(() => {
+    let V = Jn({
+      data: r,
+      meta: n,
+      sortParams: i,
+      fields: s
+    });
+    E.current = V, V.tableColumns && m(V.tableColumns), I();
+  }, [r, n, i, s, I]);
+  const $ = he((j) => j ? typeof j == "string" ? parseInt(j.replace("px", "")) || 0 : typeof j == "number" ? j : 0 : 0, []), { baseWidth: C, colCount: d } = ye(() => {
+    let j = 0, V = 0;
+    const x = (F) => {
+      F.forEach((U) => {
+        U.type !== "group" && (j += $(U.width), V += 1), U != null && U.children && U.children.length > 0 && x(U.children);
+      });
+    };
+    return x(u), { baseWidth: j, colCount: V };
+  }, [u, $]), k = ye(() => {
+    const j = (V) => V.map((x) => {
+      let F = 0;
+      C < a && d > 0 && (F = Math.floor((a - C) / d));
+      const G = (x.width ? $(x.width) : jn) + F;
+      return x.colSpan && x.colSpan > 1 ? x.width = G * x.colSpan : x.width = G, x.fixed && (x.fixed = !1), x != null && x.children && x.children.length > 0 && (x.children = j(x.children)), x;
+    });
+    return j(gt(u));
+  }, [u, C, a, d, $]), D = ye(() => {
+    let j = 0;
+    const V = (x) => {
+      x.forEach((F) => {
+        F.type !== "group" && (j += $(F.width)), F != null && F.children && F.children.length > 0 && V(F.children);
+      });
+    };
+    return V(k), j;
+  }, [k, $]), ie = Ae(null), P = Ae(null), S = Ae(!1), z = he(({ scrollLeft: j }) => {
+    S.current || (S.current = !0, ie.current && (ie.current.scrollLeft = j), requestAnimationFrame(() => {
+      S.current = !1;
+    }));
+  }, []), T = he((j) => {
+    if (S.current)
+      return;
+    S.current = !0;
+    const V = j.currentTarget.scrollLeft;
+    P.current && (P.current.scrollLeft = V), requestAnimationFrame(() => {
+      S.current = !1;
+    });
+  }, []);
+  return /* @__PURE__ */ J.jsx(
+    bt,
+    {
+      onResize: ({ width: j }) => {
+        j && j !== a && c(j);
+      },
+      children: /* @__PURE__ */ J.jsxs(
+        "div",
+        {
+          className: Et("virtual-table", e.className),
+          style: { width: "100%", ...e.style },
+          children: [
+            /* @__PURE__ */ J.jsx(
+              Pn,
+              {
+                ref: ie,
+                columns: k,
+                width: a,
+                onScroll: T
+              }
+            ),
+            /* @__PURE__ */ J.jsx("div", { className: "virtual-table-body", style: { width: "100%" }, children: /* @__PURE__ */ J.jsx(
+              Un,
+              {
+                data: l,
+                info: {
+                  ref: P,
+                  onScroll: z
+                },
+                scroll: t,
+                columns: k,
+                tableWidth: a,
+                gridWidth: D,
+                handleExpand: I,
+                meta: n
+              }
+            ) })
+          ]
+        }
+      )
+    }
+  );
+});
+export {
+  Qn as VirtualTable,
+  Jn as dataHandler,
+  qn as pivotDataHandler
+};
+//# sourceMappingURL=virtual-table.es.js.map