st-comp 0.0.69 → 0.0.71

package/lib/VirtualTable.es.js

@@ -0,0 +1,2679 @@
+import { aa as Do, a6 as Me, d as N, b as le, u as De, k as Y, C as Lo, i as Ot, z as Po, t as et, H as $e, E as Wo, e as St, A as ke, v as Xe, B as Fo, w as Xt } from "./base-a240bf62.js";
+import { E as Jt } from "./el-empty-282e5e93.js";
+import { B as Go, d as Ko, u as Vo } from "./el-scrollbar-7dc53299.js";
+import { getCurrentInstance as Rt, computed as R, defineComponent as ge, ref as G, reactive as $o, unref as r, watch as Le, onBeforeUnmount as Qt, h as me, withModifiers as ko, onMounted as xt, nextTick as Ve, resolveDynamicComponent as Nt, shallowRef as Te, isVNode as Ie, toRef as At, createVNode as _, mergeProps as B, inject as eo, provide as Bo, mergeModels as zt, useModel as jo, onUnmounted as qo, openBlock as Uo, createBlock as Yo, withCtx as Dt } from "vue";
+import { m as to } from "./typescript-7ae59c4c.js";
+import { c as oo, r as no } from "./raf-fc8a56cf.js";
+import { g as Zo } from "./scroll-cfdae01b.js";
+import { c as Xo } from "./castArray-a723a736.js";
+import { E as lo, t as Jo, u as Qo, b as en } from "./index-1508a06b.js";
+import { _ as tn } from "./_plugin-vue_export-helper-dad06003.js";
+var Lt = Number.isNaN || function(t) {
+  return typeof t == "number" && t !== t;
+};
+function on(e, t) {
+  return !!(e === t || Lt(e) && Lt(t));
+}
+function nn(e, t) {
+  if (e.length !== t.length)
+    return !1;
+  for (var o = 0; o < e.length; o++)
+    if (!on(e[o], t[o]))
+      return !1;
+  return !0;
+}
+function ln(e, t) {
+  t === void 0 && (t = nn);
+  var o = null;
+  function n() {
+    for (var s = [], a = 0; a < arguments.length; a++)
+      s[a] = arguments[a];
+    if (o && o.lastThis === this && t(s, o.lastArgs))
+      return o.lastResult;
+    var i = e.apply(this, s);
+    return o = {
+      lastResult: i,
+      lastArgs: s,
+      lastThis: this
+    }, i;
+  }
+  return n.clear = function() {
+    o = null;
+  }, n;
+}
+const rn = () => {
+  const t = Rt().proxy.$props;
+  return R(() => {
+    const o = (n, s, a) => ({});
+    return t.perfMode ? Do(o) : ln(o);
+  });
+}, Pt = 50, Wt = "itemRendered", Ft = "scroll", Ke = "forward", st = "backward", Ce = "auto", ro = "smart", it = "start", ze = "center", ct = "end", dt = "horizontal", ao = "vertical", so = "rtl", ut = "negative", io = "positive-ascending", co = "positive-descending", an = {
+  [dt]: "left",
+  [ao]: "top"
+}, sn = 20, ht = Me({
+  type: N([Number, Function]),
+  required: !0
+}), ft = Me({
+  type: Number
+}), mt = Me({
+  type: Number,
+  default: 2
+}), cn = Me({
+  type: String,
+  values: ["ltr", "rtl"],
+  default: "ltr"
+}), vt = Me({
+  type: Number,
+  default: 0
+}), tt = Me({
+  type: Number,
+  required: !0
+}), uo = Me({
+  type: String,
+  values: ["horizontal", "vertical"],
+  default: ao
+}), ho = le({
+  className: {
+    type: String,
+    default: ""
+  },
+  containerElement: {
+    type: N([String, Object]),
+    default: "div"
+  },
+  data: {
+    type: N(Array),
+    default: () => to([])
+  },
+  direction: cn,
+  height: {
+    type: [String, Number],
+    required: !0
+  },
+  innerElement: {
+    type: [String, Object],
+    default: "div"
+  },
+  style: {
+    type: N([Object, String, Array])
+  },
+  useIsScrolling: {
+    type: Boolean,
+    default: !1
+  },
+  width: {
+    type: [Number, String],
+    required: !1
+  },
+  perfMode: {
+    type: Boolean,
+    default: !0
+  },
+  scrollbarAlwaysOn: {
+    type: Boolean,
+    default: !1
+  }
+}), dn = le({
+  cache: mt,
+  estimatedItemSize: ft,
+  layout: uo,
+  initScrollOffset: vt,
+  total: tt,
+  itemSize: ht,
+  ...ho
+}), gt = {
+  type: Number,
+  default: 6
+}, fo = { type: Number, default: 0 }, mo = { type: Number, default: 2 }, He = le({
+  columnCache: mt,
+  columnWidth: ht,
+  estimatedColumnWidth: ft,
+  estimatedRowHeight: ft,
+  initScrollLeft: vt,
+  initScrollTop: vt,
+  itemKey: {
+    type: N(Function),
+    default: ({
+      columnIndex: e,
+      rowIndex: t
+    }) => `${t}:${e}`
+  },
+  rowCache: mt,
+  rowHeight: ht,
+  totalColumn: tt,
+  totalRow: tt,
+  hScrollbarSize: gt,
+  vScrollbarSize: gt,
+  scrollbarStartGap: fo,
+  scrollbarEndGap: mo,
+  role: String,
+  ...ho
+}), vo = le({
+  alwaysOn: Boolean,
+  class: String,
+  layout: uo,
+  total: tt,
+  ratio: {
+    type: Number,
+    required: !0
+  },
+  clientSize: {
+    type: Number,
+    required: !0
+  },
+  scrollFrom: {
+    type: Number,
+    required: !0
+  },
+  scrollbarSize: gt,
+  startGap: fo,
+  endGap: mo,
+  visible: Boolean
+}), Ze = (e, t) => e < t ? Ke : st, Gt = (e) => e === so;
+let Ae = null;
+function Kt(e = !1) {
+  if (Ae === null || e) {
+    const t = document.createElement("div"), o = t.style;
+    o.width = "50px", o.height = "50px", o.overflow = "scroll", o.direction = "rtl";
+    const n = document.createElement("div"), s = n.style;
+    return s.width = "100px", s.height = "100px", t.appendChild(n), document.body.appendChild(t), t.scrollLeft > 0 ? Ae = co : (t.scrollLeft = 1, t.scrollLeft === 0 ? Ae = ut : Ae = io), document.body.removeChild(t), Ae;
+  }
+  return Ae;
+}
+function un({ move: e, size: t, bar: o }, n) {
+  const s = {}, a = `translate${o.axis}(${e}px)`;
+  return s[o.size] = t, s.transform = a, s.msTransform = a, s.webkitTransform = a, n === "horizontal" ? s.height = "100%" : s.width = "100%", s;
+}
+const Vt = ge({
+  name: "ElVirtualScrollBar",
+  props: vo,
+  emits: ["scroll", "start-move", "stop-move"],
+  setup(e, { emit: t }) {
+    const o = R(() => e.startGap + e.endGap), n = De("virtual-scrollbar"), s = De("scrollbar"), a = G(), i = G();
+    let c = null, m = null;
+    const h = $o({
+      isDragging: !1,
+      traveled: 0
+    }), d = R(() => Go[e.layout]), v = R(() => e.clientSize - r(o)), w = R(() => ({
+      position: "absolute",
+      width: `${dt === e.layout ? v.value : e.scrollbarSize}px`,
+      height: `${dt === e.layout ? e.scrollbarSize : v.value}px`,
+      [an[e.layout]]: "2px",
+      right: "2px",
+      bottom: "2px",
+      borderRadius: "4px"
+    })), g = R(() => {
+      const T = e.ratio, O = e.clientSize;
+      if (T >= 100)
+        return Number.POSITIVE_INFINITY;
+      if (T >= 50)
+        return T * O / 100;
+      const M = O / 3;
+      return Math.floor(Math.min(Math.max(T * O, sn), M));
+    }), f = R(() => {
+      if (!Number.isFinite(g.value))
+        return {
+          display: "none"
+        };
+      const T = `${g.value}px`;
+      return un({
+        bar: d.value,
+        size: T,
+        move: h.traveled
+      }, e.layout);
+    }), l = R(() => Math.floor(e.clientSize - g.value - r(o))), u = () => {
+      window.addEventListener("mousemove", x), window.addEventListener("mouseup", S);
+      const T = r(i);
+      T && (m = document.onselectstart, document.onselectstart = () => !1, T.addEventListener("touchmove", x), T.addEventListener("touchend", S));
+    }, y = () => {
+      window.removeEventListener("mousemove", x), window.removeEventListener("mouseup", S), document.onselectstart = m, m = null;
+      const T = r(i);
+      T && (T.removeEventListener("touchmove", x), T.removeEventListener("touchend", S));
+    }, b = (T) => {
+      T.stopImmediatePropagation(), !(T.ctrlKey || [1, 2].includes(T.button)) && (h.isDragging = !0, h[d.value.axis] = T.currentTarget[d.value.offset] - (T[d.value.client] - T.currentTarget.getBoundingClientRect()[d.value.direction]), t("start-move"), u());
+    }, S = () => {
+      h.isDragging = !1, h[d.value.axis] = 0, t("stop-move"), y();
+    }, x = (T) => {
+      const { isDragging: O } = h;
+      if (!O || !i.value || !a.value)
+        return;
+      const M = h[d.value.axis];
+      if (!M)
+        return;
+      oo(c);
+      const A = (a.value.getBoundingClientRect()[d.value.direction] - T[d.value.client]) * -1, C = i.value[d.value.offset] - M, P = A - C;
+      c = no(() => {
+        h.traveled = Math.max(e.startGap, Math.min(P, l.value)), t("scroll", P, l.value);
+      });
+    }, I = (T) => {
+      const O = Math.abs(T.target.getBoundingClientRect()[d.value.direction] - T[d.value.client]), M = i.value[d.value.offset] / 2, A = O - M;
+      h.traveled = Math.max(0, Math.min(A, l.value)), t("scroll", A, l.value);
+    };
+    return Le(() => e.scrollFrom, (T) => {
+      h.isDragging || (h.traveled = Math.ceil(T * l.value));
+    }), Qt(() => {
+      y();
+    }), () => me("div", {
+      role: "presentation",
+      ref: a,
+      class: [
+        n.b(),
+        e.class,
+        (e.alwaysOn || h.isDragging) && "always-on"
+      ],
+      style: w.value,
+      onMousedown: ko(I, ["stop", "prevent"]),
+      onTouchstartPrevent: b
+    }, me("div", {
+      ref: i,
+      class: s.e("thumb"),
+      style: f.value,
+      onMousedown: b
+    }, []));
+  }
+}), hn = ({ atXEndEdge: e, atXStartEdge: t, atYEndEdge: o, atYStartEdge: n }, s) => {
+  let a = null, i = 0, c = 0;
+  const m = (d, v) => {
+    const w = d <= 0 && t.value || d >= 0 && e.value, g = v <= 0 && n.value || v >= 0 && o.value;
+    return w && g;
+  };
+  return {
+    hasReachedEdge: m,
+    onWheel: (d) => {
+      oo(a);
+      let v = d.deltaX, w = d.deltaY;
+      Math.abs(v) > Math.abs(w) ? w = 0 : v = 0, d.shiftKey && w !== 0 && (v = w, w = 0), !(m(i, c) && m(i + v, c + w)) && (i += v, c += w, d.preventDefault(), a = no(() => {
+        s(i, c), i = 0, c = 0;
+      }));
+    }
+  };
+}, go = ({
+  name: e,
+  clearCache: t,
+  getColumnPosition: o,
+  getColumnStartIndexForOffset: n,
+  getColumnStopIndexForStartIndex: s,
+  getEstimatedTotalHeight: a,
+  getEstimatedTotalWidth: i,
+  getColumnOffset: c,
+  getRowOffset: m,
+  getRowPosition: h,
+  getRowStartIndexForOffset: d,
+  getRowStopIndexForStartIndex: v,
+  initCache: w,
+  injectToInstance: g,
+  validateProps: f
+}) => ge({
+  name: e ?? "ElVirtualList",
+  props: He,
+  emits: [Wt, Ft],
+  setup(l, { emit: u, expose: y, slots: b }) {
+    const S = De("vl");
+    f(l);
+    const x = Rt(), I = G(w(l, x));
+    g == null || g(x, I);
+    const T = G(), O = G(), M = G(), A = G(null), C = G({
+      isScrolling: !1,
+      scrollLeft: Y(l.initScrollLeft) ? l.initScrollLeft : 0,
+      scrollTop: Y(l.initScrollTop) ? l.initScrollTop : 0,
+      updateRequested: !1,
+      xAxisScrollDir: Ke,
+      yAxisScrollDir: Ke
+    }), P = rn(), $ = R(() => Number.parseInt(`${l.height}`, 10)), k = R(() => Number.parseInt(`${l.width}`, 10)), V = R(() => {
+      const { totalColumn: E, totalRow: H, columnCache: p } = l, { isScrolling: L, xAxisScrollDir: z, scrollLeft: D } = r(C);
+      if (E === 0 || H === 0)
+        return [0, 0, 0, 0];
+      const W = n(l, D, r(I)), F = s(l, W, D, r(I)), K = !L || z === st ? Math.max(1, p) : 1, X = !L || z === Ke ? Math.max(1, p) : 1;
+      return [
+        Math.max(0, W - K),
+        Math.max(0, Math.min(E - 1, F + X)),
+        W,
+        F
+      ];
+    }), j = R(() => {
+      const { totalColumn: E, totalRow: H, rowCache: p } = l, { isScrolling: L, yAxisScrollDir: z, scrollTop: D } = r(C);
+      if (E === 0 || H === 0)
+        return [0, 0, 0, 0];
+      const W = d(l, D, r(I)), F = v(l, W, D, r(I)), K = !L || z === st ? Math.max(1, p) : 1, X = !L || z === Ke ? Math.max(1, p) : 1;
+      return [
+        Math.max(0, W - K),
+        Math.max(0, Math.min(H - 1, F + X)),
+        W,
+        F
+      ];
+    }), Z = R(() => a(l, r(I))), q = R(() => i(l, r(I))), ce = R(() => {
+      var E;
+      return [
+        {
+          position: "relative",
+          overflow: "hidden",
+          WebkitOverflowScrolling: "touch",
+          willChange: "transform"
+        },
+        {
+          direction: l.direction,
+          height: Y(l.height) ? `${l.height}px` : l.height,
+          width: Y(l.width) ? `${l.width}px` : l.width
+        },
+        (E = l.style) != null ? E : {}
+      ];
+    }), ye = R(() => {
+      const E = `${r(q)}px`;
+      return {
+        height: `${r(Z)}px`,
+        pointerEvents: r(C).isScrolling ? "none" : void 0,
+        width: E
+      };
+    }), oe = () => {
+      const { totalColumn: E, totalRow: H } = l;
+      if (E > 0 && H > 0) {
+        const [
+          F,
+          K,
+          X,
+          te
+        ] = r(V), [ee, U, Ye, nt] = r(j);
+        u(Wt, {
+          columnCacheStart: F,
+          columnCacheEnd: K,
+          rowCacheStart: ee,
+          rowCacheEnd: U,
+          columnVisibleStart: X,
+          columnVisibleEnd: te,
+          rowVisibleStart: Ye,
+          rowVisibleEnd: nt
+        });
+      }
+      const {
+        scrollLeft: p,
+        scrollTop: L,
+        updateRequested: z,
+        xAxisScrollDir: D,
+        yAxisScrollDir: W
+      } = r(C);
+      u(Ft, {
+        xAxisScrollDir: D,
+        scrollLeft: p,
+        yAxisScrollDir: W,
+        scrollTop: L,
+        updateRequested: z
+      });
+    }, we = (E) => {
+      const {
+        clientHeight: H,
+        clientWidth: p,
+        scrollHeight: L,
+        scrollLeft: z,
+        scrollTop: D,
+        scrollWidth: W
+      } = E.currentTarget, F = r(C);
+      if (F.scrollTop === D && F.scrollLeft === z)
+        return;
+      let K = z;
+      if (Gt(l.direction))
+        switch (Kt()) {
+          case ut:
+            K = -z;
+            break;
+          case co:
+            K = W - p - z;
+            break;
+        }
+      C.value = {
+        ...F,
+        isScrolling: !0,
+        scrollLeft: K,
+        scrollTop: Math.max(0, Math.min(D, L - H)),
+        updateRequested: !0,
+        xAxisScrollDir: Ze(F.scrollLeft, K),
+        yAxisScrollDir: Ze(F.scrollTop, D)
+      }, Ve(() => Se()), Oe(), oe();
+    }, be = (E, H) => {
+      const p = r($), L = (Z.value - p) / H * E;
+      J({
+        scrollTop: Math.min(Z.value - p, L)
+      });
+    }, de = (E, H) => {
+      const p = r(k), L = (q.value - p) / H * E;
+      J({
+        scrollLeft: Math.min(q.value - p, L)
+      });
+    }, { onWheel: re } = hn({
+      atXStartEdge: R(() => C.value.scrollLeft <= 0),
+      atXEndEdge: R(() => C.value.scrollLeft >= q.value - r(k)),
+      atYStartEdge: R(() => C.value.scrollTop <= 0),
+      atYEndEdge: R(() => C.value.scrollTop >= Z.value - r($))
+    }, (E, H) => {
+      var p, L, z, D;
+      (L = (p = O.value) == null ? void 0 : p.onMouseUp) == null || L.call(p), (D = (z = M.value) == null ? void 0 : z.onMouseUp) == null || D.call(z);
+      const W = r(k), F = r($);
+      J({
+        scrollLeft: Math.min(C.value.scrollLeft + E, q.value - W),
+        scrollTop: Math.min(C.value.scrollTop + H, Z.value - F)
+      });
+    }), J = ({
+      scrollLeft: E = C.value.scrollLeft,
+      scrollTop: H = C.value.scrollTop
+    }) => {
+      E = Math.max(E, 0), H = Math.max(H, 0);
+      const p = r(C);
+      H === p.scrollTop && E === p.scrollLeft || (C.value = {
+        ...p,
+        xAxisScrollDir: Ze(p.scrollLeft, E),
+        yAxisScrollDir: Ze(p.scrollTop, H),
+        scrollLeft: E,
+        scrollTop: H,
+        updateRequested: !0
+      }, Ve(() => Se()), Oe(), oe());
+    }, Pe = (E = 0, H = 0, p = Ce) => {
+      const L = r(C);
+      H = Math.max(0, Math.min(H, l.totalColumn - 1)), E = Math.max(0, Math.min(E, l.totalRow - 1));
+      const z = Zo(S.namespace.value), D = r(I), W = a(l, D), F = i(l, D);
+      J({
+        scrollLeft: c(l, H, p, L.scrollLeft, D, F > l.width ? z : 0),
+        scrollTop: m(l, E, p, L.scrollTop, D, W > l.height ? z : 0)
+      });
+    }, ue = (E, H) => {
+      const { columnWidth: p, direction: L, rowHeight: z } = l, D = P.value(t && p, t && z, t && L), W = `${E},${H}`;
+      if (Po(D, W))
+        return D[W];
+      {
+        const [, F] = o(l, H, r(I)), K = r(I), X = Gt(L), [te, ee] = h(l, E, K), [U] = o(l, H, K);
+        return D[W] = {
+          position: "absolute",
+          left: X ? void 0 : `${F}px`,
+          right: X ? `${F}px` : void 0,
+          top: `${ee}px`,
+          height: `${te}px`,
+          width: `${U}px`
+        }, D[W];
+      }
+    }, Se = () => {
+      C.value.isScrolling = !1, Ve(() => {
+        P.value(-1, null, null);
+      });
+    };
+    xt(() => {
+      if (!Lo)
+        return;
+      const { initScrollLeft: E, initScrollTop: H } = l, p = r(T);
+      p && (Y(E) && (p.scrollLeft = E), Y(H) && (p.scrollTop = H)), oe();
+    });
+    const Oe = () => {
+      const { direction: E } = l, { scrollLeft: H, scrollTop: p, updateRequested: L } = r(C), z = r(T);
+      if (L && z) {
+        if (E === so)
+          switch (Kt()) {
+            case ut: {
+              z.scrollLeft = -H;
+              break;
+            }
+            case io: {
+              z.scrollLeft = H;
+              break;
+            }
+            default: {
+              const { clientWidth: D, scrollWidth: W } = z;
+              z.scrollLeft = W - D - H;
+              break;
+            }
+          }
+        else
+          z.scrollLeft = Math.max(0, H);
+        z.scrollTop = Math.max(0, p);
+      }
+    }, { resetAfterColumnIndex: Re, resetAfterRowIndex: We, resetAfter: Fe } = x.proxy;
+    y({
+      windowRef: T,
+      innerRef: A,
+      getItemStyleCache: P,
+      scrollTo: J,
+      scrollToItem: Pe,
+      states: C,
+      resetAfterColumnIndex: Re,
+      resetAfterRowIndex: We,
+      resetAfter: Fe
+    });
+    const Q = () => {
+      const {
+        scrollbarAlwaysOn: E,
+        scrollbarStartGap: H,
+        scrollbarEndGap: p,
+        totalColumn: L,
+        totalRow: z
+      } = l, D = r(k), W = r($), F = r(q), K = r(Z), { scrollLeft: X, scrollTop: te } = r(C), ee = me(Vt, {
+        ref: O,
+        alwaysOn: E,
+        startGap: H,
+        endGap: p,
+        class: S.e("horizontal"),
+        clientSize: D,
+        layout: "horizontal",
+        onScroll: de,
+        ratio: D * 100 / F,
+        scrollFrom: X / (F - D),
+        total: z,
+        visible: !0
+      }), U = me(Vt, {
+        ref: M,
+        alwaysOn: E,
+        startGap: H,
+        endGap: p,
+        class: S.e("vertical"),
+        clientSize: W,
+        layout: "vertical",
+        onScroll: be,
+        ratio: W * 100 / K,
+        scrollFrom: te / (K - W),
+        total: L,
+        visible: !0
+      });
+      return {
+        horizontalScrollbar: ee,
+        verticalScrollbar: U
+      };
+    }, ae = () => {
+      var E;
+      const [H, p] = r(V), [L, z] = r(j), { data: D, totalColumn: W, totalRow: F, useIsScrolling: K, itemKey: X } = l, te = [];
+      if (F > 0 && W > 0)
+        for (let ee = L; ee <= z; ee++)
+          for (let U = H; U <= p; U++)
+            te.push((E = b.default) == null ? void 0 : E.call(b, {
+              columnIndex: U,
+              data: D,
+              key: X({ columnIndex: U, data: D, rowIndex: ee }),
+              isScrolling: K ? r(C).isScrolling : void 0,
+              style: ue(ee, U),
+              rowIndex: ee
+            }));
+      return te;
+    }, he = () => {
+      const E = Nt(l.innerElement), H = ae();
+      return [
+        me(E, {
+          style: r(ye),
+          ref: A
+        }, Ot(E) ? H : {
+          default: () => H
+        })
+      ];
+    };
+    return () => {
+      const E = Nt(l.containerElement), { horizontalScrollbar: H, verticalScrollbar: p } = Q(), L = he();
+      return me("div", {
+        key: 0,
+        class: S.e("wrapper"),
+        role: l.role
+      }, [
+        me(E, {
+          class: l.className,
+          style: r(ce),
+          onScroll: we,
+          onWheel: re,
+          ref: T
+        }, Ot(E) ? L : { default: () => L }),
+        H,
+        p
+      ]);
+    };
+  }
+}), $t = "ElFixedSizeGrid", fn = go({
+  name: "ElFixedSizeGrid",
+  getColumnPosition: ({ columnWidth: e }, t) => [
+    e,
+    t * e
+  ],
+  getRowPosition: ({ rowHeight: e }, t) => [
+    e,
+    t * e
+  ],
+  getEstimatedTotalHeight: ({ totalRow: e, rowHeight: t }) => t * e,
+  getEstimatedTotalWidth: ({ totalColumn: e, columnWidth: t }) => t * e,
+  getColumnOffset: ({ totalColumn: e, columnWidth: t, width: o }, n, s, a, i, c) => {
+    o = Number(o);
+    const m = Math.max(0, e * t - o), h = Math.min(m, n * t), d = Math.max(0, n * t - o + c + t);
+    switch (s === "smart" && (a >= d - o && a <= h + o ? s = Ce : s = ze), s) {
+      case it:
+        return h;
+      case ct:
+        return d;
+      case ze: {
+        const v = Math.round(d + (h - d) / 2);
+        return v < Math.ceil(o / 2) ? 0 : v > m + Math.floor(o / 2) ? m : v;
+      }
+      case Ce:
+      default:
+        return a >= d && a <= h ? a : d > h || a < d ? d : h;
+    }
+  },
+  getRowOffset: ({ rowHeight: e, height: t, totalRow: o }, n, s, a, i, c) => {
+    t = Number(t);
+    const m = Math.max(0, o * e - t), h = Math.min(m, n * e), d = Math.max(0, n * e - t + c + e);
+    switch (s === ro && (a >= d - t && a <= h + t ? s = Ce : s = ze), s) {
+      case it:
+        return h;
+      case ct:
+        return d;
+      case ze: {
+        const v = Math.round(d + (h - d) / 2);
+        return v < Math.ceil(t / 2) ? 0 : v > m + Math.floor(t / 2) ? m : v;
+      }
+      case Ce:
+      default:
+        return a >= d && a <= h ? a : d > h || a < d ? d : h;
+    }
+  },
+  getColumnStartIndexForOffset: ({ columnWidth: e, totalColumn: t }, o) => Math.max(0, Math.min(t - 1, Math.floor(o / e))),
+  getColumnStopIndexForStartIndex: ({ columnWidth: e, totalColumn: t, width: o }, n, s) => {
+    const a = n * e, i = Math.ceil((o + s - a) / e);
+    return Math.max(0, Math.min(t - 1, n + i - 1));
+  },
+  getRowStartIndexForOffset: ({ rowHeight: e, totalRow: t }, o) => Math.max(0, Math.min(t - 1, Math.floor(o / e))),
+  getRowStopIndexForStartIndex: ({ rowHeight: e, totalRow: t, height: o }, n, s) => {
+    const a = n * e, i = Math.ceil((o + s - a) / e);
+    return Math.max(0, Math.min(t - 1, n + i - 1));
+  },
+  initCache: () => {
+  },
+  clearCache: !0,
+  validateProps: ({ columnWidth: e, rowHeight: t }) => {
+    process.env.NODE_ENV !== "production" && (Y(e) || et($t, `
+          "columnWidth" must be passed as number,
+            instead ${typeof e} was given.
+        `), Y(t) || et($t, `
+          "columnWidth" must be passed as number,
+            instead ${typeof t} was given.
+        `));
+  }
+}), { max: ot, min: yo, floor: wo } = Math, kt = "ElDynamicSizeGrid", mn = {
+  column: "columnWidth",
+  row: "rowHeight"
+}, yt = {
+  column: "lastVisitedColumnIndex",
+  row: "lastVisitedRowIndex"
+}, ie = (e, t, o, n) => {
+  const [s, a, i] = [
+    o[n],
+    e[mn[n]],
+    o[yt[n]]
+  ];
+  if (t > i) {
+    let c = 0;
+    if (i >= 0) {
+      const m = s[i];
+      c = m.offset + m.size;
+    }
+    for (let m = i + 1; m <= t; m++) {
+      const h = a(m);
+      s[m] = {
+        offset: c,
+        size: h
+      }, c += h;
+    }
+    o[yt[n]] = t;
+  }
+  return s[t];
+}, bo = (e, t, o, n, s, a) => {
+  for (; o <= n; ) {
+    const i = o + wo((n - o) / 2), c = ie(e, i, t, a).offset;
+    if (c === s)
+      return i;
+    c < s ? o = i + 1 : n = i - 1;
+  }
+  return ot(0, o - 1);
+}, vn = (e, t, o, n, s) => {
+  const a = s === "column" ? e.totalColumn : e.totalRow;
+  let i = 1;
+  for (; o < a && ie(e, o, t, s).offset < n; )
+    o += i, i *= 2;
+  return bo(e, t, wo(o / 2), yo(o, a - 1), n, s);
+}, Bt = (e, t, o, n) => {
+  const [s, a] = [
+    t[n],
+    t[yt[n]]
+  ];
+  return (a > 0 ? s[a].offset : 0) >= o ? bo(e, t, 0, a, o, n) : vn(e, t, ot(0, a), o, n);
+}, So = ({ totalRow: e }, { estimatedRowHeight: t, lastVisitedRowIndex: o, row: n }) => {
+  let s = 0;
+  if (o >= e && (o = e - 1), o >= 0) {
+    const c = n[o];
+    s = c.offset + c.size;
+  }
+  const i = (e - o - 1) * t;
+  return s + i;
+}, Ro = ({ totalColumn: e }, { column: t, estimatedColumnWidth: o, lastVisitedColumnIndex: n }) => {
+  let s = 0;
+  if (n > e && (n = e - 1), n >= 0) {
+    const c = t[n];
+    s = c.offset + c.size;
+  }
+  const i = (e - n - 1) * o;
+  return s + i;
+}, gn = {
+  column: Ro,
+  row: So
+}, jt = (e, t, o, n, s, a, i) => {
+  const [c, m] = [
+    a === "row" ? e.height : e.width,
+    gn[a]
+  ], h = ie(e, t, s, a), d = m(e, s), v = ot(0, yo(d - c, h.offset)), w = ot(0, h.offset - c + i + h.size);
+  switch (o === ro && (n >= w - c && n <= v + c ? o = Ce : o = ze), o) {
+    case it:
+      return v;
+    case ct:
+      return w;
+    case ze:
+      return Math.round(w + (v - w) / 2);
+    case Ce:
+    default:
+      return n >= w && n <= v ? n : w > v || n < w ? w : v;
+  }
+}, yn = go({
+  name: "ElDynamicSizeGrid",
+  getColumnPosition: (e, t, o) => {
+    const n = ie(e, t, o, "column");
+    return [n.size, n.offset];
+  },
+  getRowPosition: (e, t, o) => {
+    const n = ie(e, t, o, "row");
+    return [n.size, n.offset];
+  },
+  getColumnOffset: (e, t, o, n, s, a) => jt(e, t, o, n, s, "column", a),
+  getRowOffset: (e, t, o, n, s, a) => jt(e, t, o, n, s, "row", a),
+  getColumnStartIndexForOffset: (e, t, o) => Bt(e, o, t, "column"),
+  getColumnStopIndexForStartIndex: (e, t, o, n) => {
+    const s = ie(e, t, n, "column"), a = o + e.width;
+    let i = s.offset + s.size, c = t;
+    for (; c < e.totalColumn - 1 && i < a; )
+      c++, i += ie(e, t, n, "column").size;
+    return c;
+  },
+  getEstimatedTotalHeight: So,
+  getEstimatedTotalWidth: Ro,
+  getRowStartIndexForOffset: (e, t, o) => Bt(e, o, t, "row"),
+  getRowStopIndexForStartIndex: (e, t, o, n) => {
+    const { totalRow: s, height: a } = e, i = ie(e, t, n, "row"), c = o + a;
+    let m = i.size + i.offset, h = t;
+    for (; h < s - 1 && m < c; )
+      h++, m += ie(e, h, n, "row").size;
+    return h;
+  },
+  injectToInstance: (e, t) => {
+    const o = ({ columnIndex: a, rowIndex: i }, c) => {
+      var m, h;
+      c = Wo(c) ? !0 : c, Y(a) && (t.value.lastVisitedColumnIndex = Math.min(t.value.lastVisitedColumnIndex, a - 1)), Y(i) && (t.value.lastVisitedRowIndex = Math.min(t.value.lastVisitedRowIndex, i - 1)), (m = e.exposed) == null || m.getItemStyleCache.value(-1, null, null), c && ((h = e.proxy) == null || h.$forceUpdate());
+    }, n = (a, i) => {
+      o({
+        columnIndex: a
+      }, i);
+    }, s = (a, i) => {
+      o({
+        rowIndex: a
+      }, i);
+    };
+    Object.assign(e.proxy, {
+      resetAfterColumnIndex: n,
+      resetAfterRowIndex: s,
+      resetAfter: o
+    });
+  },
+  initCache: ({
+    estimatedColumnWidth: e = Pt,
+    estimatedRowHeight: t = Pt
+  }) => ({
+    column: {},
+    estimatedColumnWidth: e,
+    estimatedRowHeight: t,
+    lastVisitedColumnIndex: -1,
+    lastVisitedRowIndex: -1,
+    row: {}
+  }),
+  clearCache: !1,
+  validateProps: ({ columnWidth: e, rowHeight: t }) => {
+    process.env.NODE_ENV !== "production" && ($e(e) || et(kt, `
+          "columnWidth" must be passed as function,
+            instead ${typeof e} was given.
+        `), $e(t) || et(kt, `
+          "rowHeight" must be passed as function,
+            instead ${typeof t} was given.
+        `));
+  }
+});
+var Be = /* @__PURE__ */ ((e) => (e.ASC = "asc", e.DESC = "desc", e))(Be || {}), je = /* @__PURE__ */ ((e) => (e.CENTER = "center", e.RIGHT = "right", e))(je || {}), xo = /* @__PURE__ */ ((e) => (e.LEFT = "left", e.RIGHT = "right", e))(xo || {});
+const wt = {
+  asc: "desc",
+  desc: "asc"
+  /* ASC */
+}, qe = Symbol("placeholder"), wn = (e, t, o) => {
+  var n;
+  const s = {
+    flexGrow: 0,
+    flexShrink: 0,
+    ...o ? {} : {
+      flexGrow: e.flexGrow || 0,
+      flexShrink: e.flexShrink || 1
+    }
+  };
+  o || (s.flexShrink = 1);
+  const a = {
+    ...(n = e.style) != null ? n : {},
+    ...s,
+    flexBasis: "auto",
+    width: e.width
+  };
+  return t || (e.maxWidth && (a.maxWidth = e.maxWidth), e.minWidth && (a.minWidth = e.minWidth)), a;
+};
+function bn(e, t, o) {
+  const n = R(() => r(t).filter((l) => !l.hidden)), s = R(() => r(n).filter((l) => l.fixed === "left" || l.fixed === !0)), a = R(() => r(n).filter((l) => l.fixed === "right")), i = R(() => r(n).filter((l) => !l.fixed)), c = R(() => {
+    const l = [];
+    return r(s).forEach((u) => {
+      l.push({
+        ...u,
+        placeholderSign: qe
+      });
+    }), r(i).forEach((u) => {
+      l.push(u);
+    }), r(a).forEach((u) => {
+      l.push({
+        ...u,
+        placeholderSign: qe
+      });
+    }), l;
+  }), m = R(() => r(s).length || r(a).length), h = R(() => r(t).reduce((u, y) => (u[y.key] = wn(y, r(o), e.fixed), u), {})), d = R(() => r(n).reduce((l, u) => l + u.width, 0)), v = (l) => r(t).find((u) => u.key === l), w = (l) => r(h)[l], g = (l, u) => {
+    l.width = u;
+  };
+  function f(l) {
+    var u;
+    const { key: y } = l.currentTarget.dataset;
+    if (!y)
+      return;
+    const { sortState: b, sortBy: S } = e;
+    let x = Be.ASC;
+    St(b) ? x = wt[b[y]] : x = wt[S.order], (u = e.onColumnSort) == null || u.call(e, { column: v(y), key: y, order: x });
+  }
+  return {
+    columns: t,
+    columnsStyles: h,
+    columnsTotalWidth: d,
+    fixedColumnsOnLeft: s,
+    fixedColumnsOnRight: a,
+    hasFixedColumns: m,
+    mainColumns: c,
+    normalColumns: i,
+    visibleColumns: n,
+    getColumn: v,
+    getColumnStyle: w,
+    updateColumnWidth: g,
+    onColumnSorted: f
+  };
+}
+const Sn = (e, {
+  mainTableRef: t,
+  leftTableRef: o,
+  rightTableRef: n,
+  onMaybeEndReached: s
+}) => {
+  const a = G({ scrollLeft: 0, scrollTop: 0 });
+  function i(g) {
+    var f, l, u;
+    const { scrollTop: y } = g;
+    (f = t.value) == null || f.scrollTo(g), (l = o.value) == null || l.scrollToTop(y), (u = n.value) == null || u.scrollToTop(y);
+  }
+  function c(g) {
+    a.value = g, i(g);
+  }
+  function m(g) {
+    a.value.scrollTop = g, i(r(a));
+  }
+  function h(g) {
+    var f, l;
+    a.value.scrollLeft = g, (l = (f = t.value) == null ? void 0 : f.scrollTo) == null || l.call(f, r(a));
+  }
+  function d(g) {
+    var f;
+    c(g), (f = e.onScroll) == null || f.call(e, g);
+  }
+  function v({ scrollTop: g }) {
+    const { scrollTop: f } = r(a);
+    g !== f && m(g);
+  }
+  function w(g, f = "auto") {
+    var l;
+    (l = t.value) == null || l.scrollToRow(g, f);
+  }
+  return Le(() => r(a).scrollTop, (g, f) => {
+    g > f && s();
+  }), {
+    scrollPos: a,
+    scrollTo: c,
+    scrollToLeft: h,
+    scrollToTop: m,
+    scrollToRow: w,
+    onScroll: d,
+    onVerticalScroll: v
+  };
+}, Rn = (e, { mainTableRef: t, leftTableRef: o, rightTableRef: n }) => {
+  const s = Rt(), { emit: a } = s, i = Te(!1), c = Te(null), m = G(e.defaultExpandedRowKeys || []), h = G(-1), d = Te(null), v = G({}), w = G({}), g = Te({}), f = Te({}), l = Te({}), u = R(() => Y(e.estimatedRowHeight));
+  function y(M) {
+    var A;
+    (A = e.onRowsRendered) == null || A.call(e, M), M.rowCacheEnd > r(h) && (h.value = M.rowCacheEnd);
+  }
+  function b({ hovered: M, rowKey: A }) {
+    c.value = M ? A : null;
+  }
+  function S({
+    expanded: M,
+    rowData: A,
+    rowIndex: C,
+    rowKey: P
+  }) {
+    var $, k;
+    const V = [...r(m)], j = V.indexOf(P);
+    M ? j === -1 && V.push(P) : j > -1 && V.splice(j, 1), m.value = V, a("update:expandedRowKeys", V), ($ = e.onRowExpand) == null || $.call(e, {
+      expanded: M,
+      rowData: A,
+      rowIndex: C,
+      rowKey: P
+    }), (k = e.onExpandedRowsChange) == null || k.call(e, V);
+  }
+  const x = Ko(() => {
+    var M, A, C, P;
+    i.value = !0, v.value = { ...r(v), ...r(w) }, I(r(d), !1), w.value = {}, d.value = null, (M = t.value) == null || M.forceUpdate(), (A = o.value) == null || A.forceUpdate(), (C = n.value) == null || C.forceUpdate(), (P = s.proxy) == null || P.$forceUpdate(), i.value = !1;
+  }, 0);
+  function I(M, A = !1) {
+    r(u) && [t, o, n].forEach((C) => {
+      const P = r(C);
+      P && P.resetAfterRowIndex(M, A);
+    });
+  }
+  function T(M, A, C) {
+    const P = r(d);
+    (P === null || P > C) && (d.value = C), w.value[M] = A;
+  }
+  function O({ rowKey: M, height: A, rowIndex: C }, P) {
+    P ? P === xo.RIGHT ? l.value[M] = A : g.value[M] = A : f.value[M] = A;
+    const $ = Math.max(...[g, l, f].map((k) => k.value[M] || 0));
+    r(v)[M] !== $ && (T(M, $, C), x());
+  }
+  return {
+    hoveringRowKey: c,
+    expandedRowKeys: m,
+    lastRenderedRowIndex: h,
+    isDynamic: u,
+    isResetting: i,
+    rowHeights: v,
+    resetAfterIndex: I,
+    onRowExpanded: S,
+    onRowHovered: b,
+    onRowsRendered: y,
+    onRowHeightChange: O
+  };
+}, xn = (e, { expandedRowKeys: t, lastRenderedRowIndex: o, resetAfterIndex: n }) => {
+  const s = G({}), a = R(() => {
+    const c = {}, { data: m, rowKey: h } = e, d = r(t);
+    if (!d || !d.length)
+      return m;
+    const v = [], w = /* @__PURE__ */ new Set();
+    d.forEach((f) => w.add(f));
+    let g = m.slice();
+    for (g.forEach((f) => c[f[h]] = 0); g.length > 0; ) {
+      const f = g.shift();
+      v.push(f), w.has(f[h]) && Array.isArray(f.children) && f.children.length > 0 && (g = [...f.children, ...g], f.children.forEach((l) => c[l[h]] = c[f[h]] + 1));
+    }
+    return s.value = c, v;
+  }), i = R(() => {
+    const { data: c, expandColumnKey: m } = e;
+    return m ? r(a) : c;
+  });
+  return Le(i, (c, m) => {
+    c !== m && (o.value = -1, n(0, !0));
+  }), {
+    data: i,
+    depthMap: s
+  };
+}, Tn = (e, t) => e + t, Je = (e) => ke(e) ? e.reduce(Tn, 0) : e, pe = (e, t, o = {}) => $e(e) ? e(t) : e ?? o, ve = (e) => (["width", "maxWidth", "minWidth", "height"].forEach((t) => {
+  e[t] = Xe(e[t]);
+}), e), To = (e) => Ie(e) ? (t) => me(e, t) : e, En = (e, {
+  columnsTotalWidth: t,
+  data: o,
+  fixedColumnsOnLeft: n,
+  fixedColumnsOnRight: s
+}) => {
+  const a = R(() => {
+    const { fixed: S, width: x, vScrollbarSize: I } = e, T = x - I;
+    return S ? Math.max(Math.round(r(t)), T) : T;
+  }), i = R(() => r(a) + (e.fixed ? e.vScrollbarSize : 0)), c = R(() => {
+    const { height: S = 0, maxHeight: x = 0, footerHeight: I, hScrollbarSize: T } = e;
+    if (x > 0) {
+      const O = r(f), M = r(m), C = r(g) + O + M + T;
+      return Math.min(C, x - I);
+    }
+    return S - I;
+  }), m = R(() => {
+    const { rowHeight: S, estimatedRowHeight: x } = e, I = r(o);
+    return Y(x) ? I.length * x : I.length * S;
+  }), h = R(() => {
+    const { maxHeight: S } = e, x = r(c);
+    if (Y(S) && S > 0)
+      return x;
+    const I = r(m) + r(g) + r(f);
+    return Math.min(x, I);
+  }), d = (S) => S.width, v = R(() => Je(r(n).map(d))), w = R(() => Je(r(s).map(d))), g = R(() => Je(e.headerHeight)), f = R(() => {
+    var S;
+    return (((S = e.fixedData) == null ? void 0 : S.length) || 0) * e.rowHeight;
+  }), l = R(() => r(c) - r(g) - r(f)), u = R(() => {
+    const { style: S = {}, height: x, width: I } = e;
+    return ve({
+      ...S,
+      height: x,
+      width: I
+    });
+  }), y = R(() => ve({ height: e.footerHeight })), b = R(() => ({
+    top: Xe(r(g)),
+    bottom: Xe(e.footerHeight),
+    width: Xe(e.width)
+  }));
+  return {
+    bodyWidth: a,
+    fixedTableHeight: h,
+    mainTableHeight: c,
+    leftTableWidth: v,
+    rightTableWidth: w,
+    headerWidth: i,
+    rowsHeight: m,
+    windowHeight: l,
+    footerHeight: y,
+    emptyStyle: b,
+    rootStyle: u,
+    headerHeight: g
+  };
+}, Cn = (e) => {
+  const t = G(), o = G(0), n = G(0);
+  let s;
+  return xt(() => {
+    s = Vo(t, ([a]) => {
+      const { width: i, height: c } = a.contentRect, { paddingLeft: m, paddingRight: h, paddingTop: d, paddingBottom: v } = getComputedStyle(a.target), w = Number.parseInt(m) || 0, g = Number.parseInt(h) || 0, f = Number.parseInt(d) || 0, l = Number.parseInt(v) || 0;
+      o.value = i - w - g, n.value = c - f - l;
+    }).stop;
+  }), Qt(() => {
+    s == null || s();
+  }), Le([o, n], ([a, i]) => {
+    var c;
+    (c = e.onResize) == null || c.call(e, {
+      width: a,
+      height: i
+    });
+  }), {
+    sizer: t,
+    width: o,
+    height: n
+  };
+};
+function _n(e) {
+  const t = G(), o = G(), n = G(), {
+    columns: s,
+    columnsStyles: a,
+    columnsTotalWidth: i,
+    fixedColumnsOnLeft: c,
+    fixedColumnsOnRight: m,
+    hasFixedColumns: h,
+    mainColumns: d,
+    onColumnSorted: v
+  } = bn(e, At(e, "columns"), At(e, "fixed")), {
+    scrollTo: w,
+    scrollToLeft: g,
+    scrollToTop: f,
+    scrollToRow: l,
+    onScroll: u,
+    onVerticalScroll: y,
+    scrollPos: b
+  } = Sn(e, {
+    mainTableRef: t,
+    leftTableRef: o,
+    rightTableRef: n,
+    onMaybeEndReached: Fe
+  }), {
+    expandedRowKeys: S,
+    hoveringRowKey: x,
+    lastRenderedRowIndex: I,
+    isDynamic: T,
+    isResetting: O,
+    rowHeights: M,
+    resetAfterIndex: A,
+    onRowExpanded: C,
+    onRowHeightChange: P,
+    onRowHovered: $,
+    onRowsRendered: k
+  } = Rn(e, {
+    mainTableRef: t,
+    leftTableRef: o,
+    rightTableRef: n
+  }), { data: V, depthMap: j } = xn(e, {
+    expandedRowKeys: S,
+    lastRenderedRowIndex: I,
+    resetAfterIndex: A
+  }), {
+    bodyWidth: Z,
+    fixedTableHeight: q,
+    mainTableHeight: ce,
+    leftTableWidth: ye,
+    rightTableWidth: oe,
+    headerWidth: we,
+    rowsHeight: be,
+    windowHeight: de,
+    footerHeight: re,
+    emptyStyle: J,
+    rootStyle: Pe,
+    headerHeight: ue
+  } = En(e, {
+    columnsTotalWidth: i,
+    data: V,
+    fixedColumnsOnLeft: c,
+    fixedColumnsOnRight: m
+  }), Se = Te(!1), Oe = G(), Re = R(() => {
+    const Q = r(V).length === 0;
+    return ke(e.fixedData) ? e.fixedData.length === 0 && Q : Q;
+  });
+  function We(Q) {
+    const { estimatedRowHeight: ae, rowHeight: he, rowKey: fe } = e;
+    return ae ? r(M)[r(V)[Q][fe]] || ae : he;
+  }
+  function Fe() {
+    const { onEndReached: Q } = e;
+    if (!Q)
+      return;
+    const { scrollTop: ae } = r(b), he = r(be), fe = r(de), E = he - (ae + fe) + e.hScrollbarSize;
+    r(I) >= 0 && he === ae + r(ce) - r(ue) && Q(E);
+  }
+  return Le(() => e.expandedRowKeys, (Q) => S.value = Q, {
+    deep: !0
+  }), {
+    columns: s,
+    containerRef: Oe,
+    mainTableRef: t,
+    leftTableRef: o,
+    rightTableRef: n,
+    isDynamic: T,
+    isResetting: O,
+    isScrolling: Se,
+    hoveringRowKey: x,
+    hasFixedColumns: h,
+    columnsStyles: a,
+    columnsTotalWidth: i,
+    data: V,
+    expandedRowKeys: S,
+    depthMap: j,
+    fixedColumnsOnLeft: c,
+    fixedColumnsOnRight: m,
+    mainColumns: d,
+    bodyWidth: Z,
+    emptyStyle: J,
+    rootStyle: Pe,
+    headerWidth: we,
+    footerHeight: re,
+    mainTableHeight: ce,
+    fixedTableHeight: q,
+    leftTableWidth: ye,
+    rightTableWidth: oe,
+    showEmpty: Re,
+    getRowHeight: We,
+    onColumnSorted: v,
+    onRowHovered: $,
+    onRowExpanded: C,
+    onRowsRendered: k,
+    onRowHeightChange: P,
+    scrollTo: w,
+    scrollToLeft: g,
+    scrollToTop: f,
+    scrollToRow: l,
+    onScroll: u,
+    onVerticalScroll: y
+  };
+}
+const Tt = Symbol("tableV2"), Eo = String, Ue = {
+  type: N(Array),
+  required: !0
+}, Et = {
+  type: N(Array)
+}, Co = {
+  ...Et,
+  required: !0
+}, Hn = String, qt = {
+  type: N(Array),
+  default: () => to([])
+}, Ee = {
+  type: Number,
+  required: !0
+}, _o = {
+  type: N([String, Number, Symbol]),
+  default: "id"
+}, Ut = {
+  type: N(Object)
+}, _e = le({
+  class: String,
+  columns: Ue,
+  columnsStyles: {
+    type: N(Object),
+    required: !0
+  },
+  depth: Number,
+  expandColumnKey: Hn,
+  estimatedRowHeight: {
+    ...He.estimatedRowHeight,
+    default: void 0
+  },
+  isScrolling: Boolean,
+  onRowExpand: {
+    type: N(Function)
+  },
+  onRowHover: {
+    type: N(Function)
+  },
+  onRowHeightChange: {
+    type: N(Function)
+  },
+  rowData: {
+    type: N(Object),
+    required: !0
+  },
+  rowEventHandlers: {
+    type: N(Object)
+  },
+  rowIndex: {
+    type: Number,
+    required: !0
+  },
+  rowKey: _o,
+  style: {
+    type: N(Object)
+  }
+}), at = {
+  type: Number,
+  required: !0
+}, Ct = le({
+  class: String,
+  columns: Ue,
+  fixedHeaderData: {
+    type: N(Array)
+  },
+  headerData: {
+    type: N(Array),
+    required: !0
+  },
+  headerHeight: {
+    type: N([Number, Array]),
+    default: 50
+  },
+  rowWidth: at,
+  rowHeight: {
+    type: Number,
+    default: 50
+  },
+  height: at,
+  width: at
+}), Qe = le({
+  columns: Ue,
+  data: Co,
+  fixedData: Et,
+  estimatedRowHeight: _e.estimatedRowHeight,
+  width: Ee,
+  height: Ee,
+  headerWidth: Ee,
+  headerHeight: Ct.headerHeight,
+  bodyWidth: Ee,
+  rowHeight: Ee,
+  cache: dn.cache,
+  useIsScrolling: Boolean,
+  scrollbarAlwaysOn: He.scrollbarAlwaysOn,
+  scrollbarStartGap: He.scrollbarStartGap,
+  scrollbarEndGap: He.scrollbarEndGap,
+  class: Eo,
+  style: Ut,
+  containerStyle: Ut,
+  getRowHeight: {
+    type: N(Function),
+    required: !0
+  },
+  rowKey: _e.rowKey,
+  onRowsRendered: {
+    type: N(Function)
+  },
+  onScroll: {
+    type: N(Function)
+  }
+}), pn = le({
+  cache: Qe.cache,
+  estimatedRowHeight: _e.estimatedRowHeight,
+  rowKey: _o,
+  headerClass: {
+    type: N([
+      String,
+      Function
+    ])
+  },
+  headerProps: {
+    type: N([
+      Object,
+      Function
+    ])
+  },
+  headerCellProps: {
+    type: N([
+      Object,
+      Function
+    ])
+  },
+  headerHeight: Ct.headerHeight,
+  footerHeight: {
+    type: Number,
+    default: 0
+  },
+  rowClass: {
+    type: N([String, Function])
+  },
+  rowProps: {
+    type: N([Object, Function])
+  },
+  rowHeight: {
+    type: Number,
+    default: 50
+  },
+  cellProps: {
+    type: N([
+      Object,
+      Function
+    ])
+  },
+  columns: Ue,
+  data: Co,
+  dataGetter: {
+    type: N(Function)
+  },
+  fixedData: Et,
+  expandColumnKey: _e.expandColumnKey,
+  expandedRowKeys: qt,
+  defaultExpandedRowKeys: qt,
+  class: Eo,
+  fixed: Boolean,
+  style: {
+    type: N(Object)
+  },
+  width: Ee,
+  height: Ee,
+  maxHeight: Number,
+  useIsScrolling: Boolean,
+  indentSize: {
+    type: Number,
+    default: 12
+  },
+  iconSize: {
+    type: Number,
+    default: 12
+  },
+  hScrollbarSize: He.hScrollbarSize,
+  vScrollbarSize: He.vScrollbarSize,
+  scrollbarAlwaysOn: vo.alwaysOn,
+  sortBy: {
+    type: N(Object),
+    default: () => ({})
+  },
+  sortState: {
+    type: N(Object),
+    default: void 0
+  },
+  onColumnSort: {
+    type: N(Function)
+  },
+  onExpandedRowsChange: {
+    type: N(Function)
+  },
+  onEndReached: {
+    type: N(Function)
+  },
+  onRowExpand: _e.onRowExpand,
+  onScroll: Qe.onScroll,
+  onRowsRendered: Qe.onRowsRendered,
+  rowEventHandlers: _e.rowEventHandlers
+}), _t = (e, {
+  slots: t
+}) => {
+  var o;
+  const {
+    cellData: n,
+    style: s
+  } = e, a = ((o = n == null ? void 0 : n.toString) == null ? void 0 : o.call(n)) || "";
+  return _("div", {
+    class: e.class,
+    title: a,
+    style: s
+  }, [t.default ? t.default(e) : a]);
+};
+_t.displayName = "ElTableV2Cell";
+_t.inheritAttrs = !1;
+const Ht = (e, {
+  slots: t
+}) => {
+  var o, n;
+  return t.default ? t.default(e) : _("div", {
+    class: e.class,
+    title: (o = e.column) == null ? void 0 : o.title
+  }, [(n = e.column) == null ? void 0 : n.title]);
+};
+Ht.displayName = "ElTableV2HeaderCell";
+Ht.inheritAttrs = !1;
+const Mn = le({
+  class: String,
+  columns: Ue,
+  columnsStyles: {
+    type: N(Object),
+    required: !0
+  },
+  headerIndex: Number,
+  style: { type: N(Object) }
+}), In = ge({
+  name: "ElTableV2HeaderRow",
+  props: Mn,
+  setup(e, {
+    slots: t
+  }) {
+    return () => {
+      const {
+        columns: o,
+        columnsStyles: n,
+        headerIndex: s,
+        style: a
+      } = e;
+      let i = o.map((c, m) => t.cell({
+        columns: o,
+        column: c,
+        columnIndex: m,
+        headerIndex: s,
+        style: n[c.key]
+      }));
+      return t.header && (i = t.header({
+        cells: i.map((c) => ke(c) && c.length === 1 ? c[0] : c),
+        columns: o,
+        headerIndex: s
+      })), _("div", {
+        class: e.class,
+        style: a,
+        role: "row"
+      }, [i]);
+    };
+  }
+}), On = "ElTableV2Header", Nn = ge({
+  name: On,
+  props: Ct,
+  setup(e, {
+    slots: t,
+    expose: o
+  }) {
+    const n = De("table-v2"), s = G(), a = R(() => ve({
+      width: e.width,
+      height: e.height
+    })), i = R(() => ve({
+      width: e.rowWidth,
+      height: e.height
+    })), c = R(() => Xo(r(e.headerHeight))), m = (v) => {
+      const w = r(s);
+      Ve(() => {
+        w != null && w.scroll && w.scroll({
+          left: v
+        });
+      });
+    }, h = () => {
+      const v = n.e("fixed-header-row"), {
+        columns: w,
+        fixedHeaderData: g,
+        rowHeight: f
+      } = e;
+      return g == null ? void 0 : g.map((l, u) => {
+        var y;
+        const b = ve({
+          height: f,
+          width: "100%"
+        });
+        return (y = t.fixed) == null ? void 0 : y.call(t, {
+          class: v,
+          columns: w,
+          rowData: l,
+          rowIndex: -(u + 1),
+          style: b
+        });
+      });
+    }, d = () => {
+      const v = n.e("dynamic-header-row"), {
+        columns: w
+      } = e;
+      return r(c).map((g, f) => {
+        var l;
+        const u = ve({
+          width: "100%",
+          height: g
+        });
+        return (l = t.dynamic) == null ? void 0 : l.call(t, {
+          class: v,
+          columns: w,
+          headerIndex: f,
+          style: u
+        });
+      });
+    };
+    return o({
+      scrollToLeft: m
+    }), () => {
+      if (!(e.height <= 0))
+        return _("div", {
+          ref: s,
+          class: e.class,
+          style: r(a),
+          role: "rowgroup"
+        }, [_("div", {
+          style: r(i),
+          class: n.e("header")
+        }, [d(), h()])]);
+    };
+  }
+}), An = (e) => {
+  const {
+    isScrolling: t
+  } = eo(Tt), o = G(!1), n = G(), s = R(() => Y(e.estimatedRowHeight) && e.rowIndex >= 0), a = (m = !1) => {
+    const h = r(n);
+    if (!h)
+      return;
+    const {
+      columns: d,
+      onRowHeightChange: v,
+      rowKey: w,
+      rowIndex: g,
+      style: f
+    } = e, {
+      height: l
+    } = h.getBoundingClientRect();
+    o.value = !0, Ve(() => {
+      if (m || l !== Number.parseInt(f.height)) {
+        const u = d[0], y = (u == null ? void 0 : u.placeholderSign) === qe;
+        v == null || v({
+          rowKey: w,
+          height: l,
+          rowIndex: g
+        }, u && !y && u.fixed);
+      }
+    });
+  }, i = R(() => {
+    const {
+      rowData: m,
+      rowIndex: h,
+      rowKey: d,
+      onRowHover: v
+    } = e, w = e.rowEventHandlers || {}, g = {};
+    return Object.entries(w).forEach(([f, l]) => {
+      $e(l) && (g[f] = (u) => {
+        l({
+          event: u,
+          rowData: m,
+          rowIndex: h,
+          rowKey: d
+        });
+      });
+    }), v && [{
+      name: "onMouseleave",
+      hovered: !1
+    }, {
+      name: "onMouseenter",
+      hovered: !0
+    }].forEach(({
+      name: f,
+      hovered: l
+    }) => {
+      const u = g[f];
+      g[f] = (y) => {
+        v({
+          event: y,
+          hovered: l,
+          rowData: m,
+          rowIndex: h,
+          rowKey: d
+        }), u == null || u(y);
+      };
+    }), g;
+  }), c = (m) => {
+    const {
+      onRowExpand: h,
+      rowData: d,
+      rowIndex: v,
+      rowKey: w
+    } = e;
+    h == null || h({
+      expanded: m,
+      rowData: d,
+      rowIndex: v,
+      rowKey: w
+    });
+  };
+  return xt(() => {
+    r(s) && a(!0);
+  }), {
+    isScrolling: t,
+    measurable: s,
+    measured: o,
+    rowRef: n,
+    eventHandlers: i,
+    onExpand: c
+  };
+}, zn = "ElTableV2TableRow", Dn = ge({
+  name: zn,
+  props: _e,
+  setup(e, {
+    expose: t,
+    slots: o,
+    attrs: n
+  }) {
+    const {
+      eventHandlers: s,
+      isScrolling: a,
+      measurable: i,
+      measured: c,
+      rowRef: m,
+      onExpand: h
+    } = An(e);
+    return t({
+      onExpand: h
+    }), () => {
+      const {
+        columns: d,
+        columnsStyles: v,
+        expandColumnKey: w,
+        depth: g,
+        rowData: f,
+        rowIndex: l,
+        style: u
+      } = e;
+      let y = d.map((b, S) => {
+        const x = ke(f.children) && f.children.length > 0 && b.key === w;
+        return o.cell({
+          column: b,
+          columns: d,
+          columnIndex: S,
+          depth: g,
+          style: v[b.key],
+          rowData: f,
+          rowIndex: l,
+          isScrolling: r(a),
+          expandIconProps: x ? {
+            rowData: f,
+            rowIndex: l,
+            onExpand: h
+          } : void 0
+        });
+      });
+      if (o.row && (y = o.row({
+        cells: y.map((b) => ke(b) && b.length === 1 ? b[0] : b),
+        style: u,
+        columns: d,
+        depth: g,
+        rowData: f,
+        rowIndex: l,
+        isScrolling: r(a)
+      })), r(i)) {
+        const {
+          height: b,
+          ...S
+        } = u || {}, x = r(c);
+        return _("div", B({
+          ref: m,
+          class: e.class,
+          style: x ? u : S,
+          role: "row"
+        }, n, r(s)), [y]);
+      }
+      return _("div", B(n, {
+        ref: m,
+        class: e.class,
+        style: u,
+        role: "row"
+      }, r(s)), [y]);
+    };
+  }
+}), Ln = (e) => {
+  const {
+    sortOrder: t
+  } = e;
+  return _(lo, {
+    size: 14,
+    class: e.class
+  }, {
+    default: () => [t === Be.ASC ? _(Jo, null, null) : _(Qo, null, null)]
+  });
+}, Pn = (e) => {
+  const {
+    expanded: t,
+    expandable: o,
+    onExpand: n,
+    style: s,
+    size: a
+  } = e, i = {
+    onClick: o ? () => n(!t) : void 0,
+    class: e.class
+  };
+  return _(lo, B(i, {
+    size: a,
+    style: s
+  }), {
+    default: () => [_(en, null, null)]
+  });
+}, Wn = "ElTableV2Grid", Fn = (e) => {
+  const t = G(), o = G(), n = R(() => {
+    const {
+      data: l,
+      rowHeight: u,
+      estimatedRowHeight: y
+    } = e;
+    if (!y)
+      return l.length * u;
+  }), s = R(() => {
+    const {
+      fixedData: l,
+      rowHeight: u
+    } = e;
+    return ((l == null ? void 0 : l.length) || 0) * u;
+  }), a = R(() => Je(e.headerHeight)), i = R(() => {
+    const {
+      height: l
+    } = e;
+    return Math.max(0, l - r(a) - r(s));
+  }), c = R(() => r(a) + r(s) > 0), m = ({
+    data: l,
+    rowIndex: u
+  }) => l[u][e.rowKey];
+  function h({
+    rowCacheStart: l,
+    rowCacheEnd: u,
+    rowVisibleStart: y,
+    rowVisibleEnd: b
+  }) {
+    var S;
+    (S = e.onRowsRendered) == null || S.call(e, {
+      rowCacheStart: l,
+      rowCacheEnd: u,
+      rowVisibleStart: y,
+      rowVisibleEnd: b
+    });
+  }
+  function d(l, u) {
+    var y;
+    (y = o.value) == null || y.resetAfterRowIndex(l, u);
+  }
+  function v(l, u) {
+    const y = r(t), b = r(o);
+    !y || !b || (St(l) ? (y.scrollToLeft(l.scrollLeft), b.scrollTo(l)) : (y.scrollToLeft(l), b.scrollTo({
+      scrollLeft: l,
+      scrollTop: u
+    })));
+  }
+  function w(l) {
+    var u;
+    (u = r(o)) == null || u.scrollTo({
+      scrollTop: l
+    });
+  }
+  function g(l, u) {
+    var y;
+    (y = r(o)) == null || y.scrollToItem(l, 1, u);
+  }
+  function f() {
+    var l, u;
+    (l = r(o)) == null || l.$forceUpdate(), (u = r(t)) == null || u.$forceUpdate();
+  }
+  return {
+    bodyRef: o,
+    forceUpdate: f,
+    fixedRowHeight: s,
+    gridHeight: i,
+    hasHeader: c,
+    headerHeight: a,
+    headerRef: t,
+    totalHeight: n,
+    itemKey: m,
+    onItemRendered: h,
+    resetAfterRowIndex: d,
+    scrollTo: v,
+    scrollToTop: w,
+    scrollToRow: g
+  };
+}, pt = ge({
+  name: Wn,
+  props: Qe,
+  setup(e, {
+    slots: t,
+    expose: o
+  }) {
+    const {
+      ns: n
+    } = eo(Tt), {
+      bodyRef: s,
+      fixedRowHeight: a,
+      gridHeight: i,
+      hasHeader: c,
+      headerRef: m,
+      headerHeight: h,
+      totalHeight: d,
+      forceUpdate: v,
+      itemKey: w,
+      onItemRendered: g,
+      resetAfterRowIndex: f,
+      scrollTo: l,
+      scrollToTop: u,
+      scrollToRow: y
+    } = Fn(e);
+    o({
+      forceUpdate: v,
+      totalHeight: d,
+      scrollTo: l,
+      scrollToTop: u,
+      scrollToRow: y,
+      resetAfterRowIndex: f
+    });
+    const b = () => e.bodyWidth;
+    return () => {
+      const {
+        cache: S,
+        columns: x,
+        data: I,
+        fixedData: T,
+        useIsScrolling: O,
+        scrollbarAlwaysOn: M,
+        scrollbarEndGap: A,
+        scrollbarStartGap: C,
+        style: P,
+        rowHeight: $,
+        bodyWidth: k,
+        estimatedRowHeight: V,
+        headerWidth: j,
+        height: Z,
+        width: q,
+        getRowHeight: ce,
+        onScroll: ye
+      } = e, oe = Y(V), we = oe ? yn : fn, be = r(h);
+      return _("div", {
+        role: "table",
+        class: [n.e("table"), e.class],
+        style: P
+      }, [_(we, {
+        ref: s,
+        data: I,
+        useIsScrolling: O,
+        itemKey: w,
+        columnCache: 0,
+        columnWidth: oe ? b : k,
+        totalColumn: 1,
+        totalRow: I.length,
+        rowCache: S,
+        rowHeight: oe ? ce : $,
+        width: q,
+        height: r(i),
+        class: n.e("body"),
+        role: "rowgroup",
+        scrollbarStartGap: C,
+        scrollbarEndGap: A,
+        scrollbarAlwaysOn: M,
+        onScroll: ye,
+        onItemRendered: g,
+        perfMode: !1
+      }, {
+        default: (de) => {
+          var re;
+          const J = I[de.rowIndex];
+          return (re = t.row) == null ? void 0 : re.call(t, {
+            ...de,
+            columns: x,
+            rowData: J
+          });
+        }
+      }), r(c) && _(Nn, {
+        ref: m,
+        class: n.e("header-wrapper"),
+        columns: x,
+        headerData: I,
+        headerHeight: e.headerHeight,
+        fixedHeaderData: T,
+        rowWidth: j,
+        rowHeight: $,
+        width: q,
+        height: Math.min(be + r(a), Z)
+      }, {
+        dynamic: t.header,
+        fixed: t.row
+      })]);
+    };
+  }
+});
+function Gn(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !Ie(e);
+}
+const Kn = (e, {
+  slots: t
+}) => {
+  const {
+    mainTableRef: o,
+    ...n
+  } = e;
+  return _(pt, B({
+    ref: o
+  }, n), Gn(t) ? t : {
+    default: () => [t]
+  });
+};
+function Vn(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !Ie(e);
+}
+const $n = (e, {
+  slots: t
+}) => {
+  if (!e.columns.length)
+    return;
+  const {
+    leftTableRef: o,
+    ...n
+  } = e;
+  return _(pt, B({
+    ref: o
+  }, n), Vn(t) ? t : {
+    default: () => [t]
+  });
+};
+function kn(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !Ie(e);
+}
+const Bn = (e, {
+  slots: t
+}) => {
+  if (!e.columns.length)
+    return;
+  const {
+    rightTableRef: o,
+    ...n
+  } = e;
+  return _(pt, B({
+    ref: o
+  }, n), kn(t) ? t : {
+    default: () => [t]
+  });
+};
+function jn(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !Ie(e);
+}
+const qn = (e, {
+  slots: t
+}) => {
+  const {
+    columns: o,
+    columnsStyles: n,
+    depthMap: s,
+    expandColumnKey: a,
+    expandedRowKeys: i,
+    estimatedRowHeight: c,
+    hasFixedColumns: m,
+    hoveringRowKey: h,
+    rowData: d,
+    rowIndex: v,
+    style: w,
+    isScrolling: g,
+    rowProps: f,
+    rowClass: l,
+    rowKey: u,
+    rowEventHandlers: y,
+    ns: b,
+    onRowHovered: S,
+    onRowExpanded: x
+  } = e, I = pe(l, {
+    columns: o,
+    rowData: d,
+    rowIndex: v
+  }, ""), T = pe(f, {
+    columns: o,
+    rowData: d,
+    rowIndex: v
+  }), O = d[u], M = s[O] || 0, A = !!a, C = v < 0, P = [b.e("row"), I, {
+    [b.e(`row-depth-${M}`)]: A && v >= 0,
+    [b.is("expanded")]: A && i.includes(O),
+    [b.is("hovered")]: !g && O === h,
+    [b.is("fixed")]: !M && C,
+    [b.is("customized")]: !!t.row
+  }], $ = m ? S : void 0, k = {
+    ...T,
+    columns: o,
+    columnsStyles: n,
+    class: P,
+    depth: M,
+    expandColumnKey: a,
+    estimatedRowHeight: C ? void 0 : c,
+    isScrolling: g,
+    rowIndex: v,
+    rowData: d,
+    rowKey: O,
+    rowEventHandlers: y,
+    style: w
+  };
+  return _(Dn, B(k, {
+    onRowHover: $,
+    onRowExpand: x
+  }), jn(t) ? t : {
+    default: () => [t]
+  });
+}, bt = ({
+  columns: e,
+  column: t,
+  columnIndex: o,
+  depth: n,
+  expandIconProps: s,
+  isScrolling: a,
+  rowData: i,
+  rowIndex: c,
+  style: m,
+  expandedRowKeys: h,
+  ns: d,
+  cellProps: v,
+  expandColumnKey: w,
+  indentSize: g,
+  iconSize: f,
+  rowKey: l
+}, {
+  slots: u
+}) => {
+  const y = ve(m);
+  if (t.placeholderSign === qe)
+    return _("div", {
+      class: d.em("row-cell", "placeholder"),
+      style: y
+    }, null);
+  const {
+    cellRenderer: b,
+    dataKey: S,
+    dataGetter: x
+  } = t, T = To(b) || u.default || ((Z) => _(_t, Z, null)), O = $e(x) ? x({
+    columns: e,
+    column: t,
+    columnIndex: o,
+    rowData: i,
+    rowIndex: c
+  }) : Fo(i, S ?? ""), M = pe(v, {
+    cellData: O,
+    columns: e,
+    column: t,
+    columnIndex: o,
+    rowIndex: c,
+    rowData: i
+  }), A = {
+    class: d.e("cell-text"),
+    columns: e,
+    column: t,
+    columnIndex: o,
+    cellData: O,
+    isScrolling: a,
+    rowData: i,
+    rowIndex: c
+  }, C = T(A), P = [d.e("row-cell"), t.class, t.align === je.CENTER && d.is("align-center"), t.align === je.RIGHT && d.is("align-right")], $ = c >= 0 && w && t.key === w, k = c >= 0 && h.includes(i[l]);
+  let V;
+  const j = `margin-inline-start: ${n * g}px;`;
+  return $ && (St(s) ? V = _(Pn, B(s, {
+    class: [d.e("expand-icon"), d.is("expanded", k)],
+    size: f,
+    expanded: k,
+    style: j,
+    expandable: !0
+  }), null) : V = _("div", {
+    style: [j, `width: ${f}px; height: ${f}px;`].join(" ")
+  }, null)), _("div", B({
+    class: P,
+    style: y
+  }, M, {
+    role: "cell"
+  }), [V, C]);
+};
+bt.inheritAttrs = !1;
+function Un(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !Ie(e);
+}
+const Yn = ({
+  columns: e,
+  columnsStyles: t,
+  headerIndex: o,
+  style: n,
+  headerClass: s,
+  headerProps: a,
+  ns: i
+}, {
+  slots: c
+}) => {
+  const m = {
+    columns: e,
+    headerIndex: o
+  }, h = [i.e("header-row"), pe(s, m, ""), {
+    [i.is("customized")]: !!c.header
+  }], d = {
+    ...pe(a, m),
+    columnsStyles: t,
+    class: h,
+    columns: e,
+    headerIndex: o,
+    style: n
+  };
+  return _(In, d, Un(c) ? c : {
+    default: () => [c]
+  });
+}, Yt = (e, {
+  slots: t
+}) => {
+  const {
+    column: o,
+    ns: n,
+    style: s,
+    onColumnSorted: a
+  } = e, i = ve(s);
+  if (o.placeholderSign === qe)
+    return _("div", {
+      class: n.em("header-row-cell", "placeholder"),
+      style: i
+    }, null);
+  const {
+    headerCellRenderer: c,
+    headerClass: m,
+    sortable: h
+  } = o, d = {
+    ...e,
+    class: n.e("header-cell-text")
+  }, w = (To(c) || t.default || ((x) => _(Ht, x, null)))(d), {
+    sortBy: g,
+    sortState: f,
+    headerCellProps: l
+  } = e;
+  let u, y;
+  if (f) {
+    const x = f[o.key];
+    u = !!wt[x], y = u ? x : Be.ASC;
+  } else
+    u = o.key === g.key, y = u ? g.order : Be.ASC;
+  const b = [n.e("header-cell"), pe(m, e, ""), o.align === je.CENTER && n.is("align-center"), o.align === je.RIGHT && n.is("align-right"), h && n.is("sortable")], S = {
+    ...pe(l, e),
+    onClick: o.sortable ? a : void 0,
+    class: b,
+    style: i,
+    "data-key": o.key
+  };
+  return _("div", B(S, {
+    role: "columnheader"
+  }), [w, h && _(Ln, {
+    class: [n.e("sort-icon"), u && n.is("sorting")],
+    sortOrder: y
+  }, null)]);
+}, Ho = (e, {
+  slots: t
+}) => {
+  var o;
+  return _("div", {
+    class: e.class,
+    style: e.style
+  }, [(o = t.default) == null ? void 0 : o.call(t)]);
+};
+Ho.displayName = "ElTableV2Footer";
+const po = (e, {
+  slots: t
+}) => _("div", {
+  class: e.class,
+  style: e.style
+}, [t.default ? t.default() : _(Jt, null, null)]);
+po.displayName = "ElTableV2Empty";
+const Mo = (e, {
+  slots: t
+}) => {
+  var o;
+  return _("div", {
+    class: e.class,
+    style: e.style
+  }, [(o = t.default) == null ? void 0 : o.call(t)]);
+};
+Mo.displayName = "ElTableV2Overlay";
+function Ge(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !Ie(e);
+}
+const Zn = "ElTableV2", Xn = ge({
+  name: Zn,
+  props: pn,
+  setup(e, {
+    slots: t,
+    expose: o
+  }) {
+    const n = De("table-v2"), {
+      columnsStyles: s,
+      fixedColumnsOnLeft: a,
+      fixedColumnsOnRight: i,
+      mainColumns: c,
+      mainTableHeight: m,
+      fixedTableHeight: h,
+      leftTableWidth: d,
+      rightTableWidth: v,
+      data: w,
+      depthMap: g,
+      expandedRowKeys: f,
+      hasFixedColumns: l,
+      hoveringRowKey: u,
+      mainTableRef: y,
+      leftTableRef: b,
+      rightTableRef: S,
+      isDynamic: x,
+      isResetting: I,
+      isScrolling: T,
+      bodyWidth: O,
+      emptyStyle: M,
+      rootStyle: A,
+      headerWidth: C,
+      footerHeight: P,
+      showEmpty: $,
+      scrollTo: k,
+      scrollToLeft: V,
+      scrollToTop: j,
+      scrollToRow: Z,
+      getRowHeight: q,
+      onColumnSorted: ce,
+      onRowHeightChange: ye,
+      onRowHovered: oe,
+      onRowExpanded: we,
+      onRowsRendered: be,
+      onScroll: de,
+      onVerticalScroll: re
+    } = _n(e);
+    return o({
+      scrollTo: k,
+      scrollToLeft: V,
+      scrollToTop: j,
+      scrollToRow: Z
+    }), Bo(Tt, {
+      ns: n,
+      isResetting: I,
+      hoveringRowKey: u,
+      isScrolling: T
+    }), () => {
+      const {
+        cache: J,
+        cellProps: Pe,
+        estimatedRowHeight: ue,
+        expandColumnKey: Se,
+        fixedData: Oe,
+        headerHeight: Re,
+        headerClass: We,
+        headerProps: Fe,
+        headerCellProps: Q,
+        sortBy: ae,
+        sortState: he,
+        rowHeight: fe,
+        rowClass: E,
+        rowEventHandlers: H,
+        rowKey: p,
+        rowProps: L,
+        scrollbarAlwaysOn: z,
+        indentSize: D,
+        iconSize: W,
+        useIsScrolling: F,
+        vScrollbarSize: K,
+        width: X
+      } = e, te = r(w), ee = {
+        cache: J,
+        class: n.e("main"),
+        columns: r(c),
+        data: te,
+        fixedData: Oe,
+        estimatedRowHeight: ue,
+        bodyWidth: r(O) + K,
+        headerHeight: Re,
+        headerWidth: r(C),
+        height: r(m),
+        mainTableRef: y,
+        rowKey: p,
+        rowHeight: fe,
+        scrollbarAlwaysOn: z,
+        scrollbarStartGap: 2,
+        scrollbarEndGap: K,
+        useIsScrolling: F,
+        width: X,
+        getRowHeight: q,
+        onRowsRendered: be,
+        onScroll: de
+      }, U = r(d), Ye = r(h), nt = {
+        cache: J,
+        class: n.e("left"),
+        columns: r(a),
+        data: te,
+        estimatedRowHeight: ue,
+        leftTableRef: b,
+        rowHeight: fe,
+        bodyWidth: U,
+        headerWidth: U,
+        headerHeight: Re,
+        height: Ye,
+        rowKey: p,
+        scrollbarAlwaysOn: z,
+        scrollbarStartGap: 2,
+        scrollbarEndGap: K,
+        useIsScrolling: F,
+        width: U,
+        getRowHeight: q,
+        onScroll: re
+      }, lt = r(v) + K, Io = {
+        cache: J,
+        class: n.e("right"),
+        columns: r(i),
+        data: te,
+        estimatedRowHeight: ue,
+        rightTableRef: S,
+        rowHeight: fe,
+        bodyWidth: lt,
+        headerWidth: lt,
+        headerHeight: Re,
+        height: Ye,
+        rowKey: p,
+        scrollbarAlwaysOn: z,
+        scrollbarStartGap: 2,
+        scrollbarEndGap: K,
+        width: lt,
+        style: `--${r(n.namespace)}-table-scrollbar-size: ${K}px`,
+        useIsScrolling: F,
+        getRowHeight: q,
+        onScroll: re
+      }, Ne = r(s), Oo = {
+        ns: n,
+        depthMap: r(g),
+        columnsStyles: Ne,
+        expandColumnKey: Se,
+        expandedRowKeys: r(f),
+        estimatedRowHeight: ue,
+        hasFixedColumns: r(l),
+        hoveringRowKey: r(u),
+        rowProps: L,
+        rowClass: E,
+        rowKey: p,
+        rowEventHandlers: H,
+        onRowHovered: oe,
+        onRowExpanded: we,
+        onRowHeightChange: ye
+      }, Mt = {
+        cellProps: Pe,
+        expandColumnKey: Se,
+        indentSize: D,
+        iconSize: W,
+        rowKey: p,
+        expandedRowKeys: r(f),
+        ns: n
+      }, No = {
+        ns: n,
+        headerClass: We,
+        headerProps: Fe,
+        columnsStyles: Ne
+      }, It = {
+        ns: n,
+        sortBy: ae,
+        sortState: he,
+        headerCellProps: Q,
+        onColumnSorted: ce
+      }, se = {
+        row: (rt) => _(qn, B(rt, Oo), {
+          row: t.row,
+          cell: (ne) => {
+            let xe;
+            return t.cell ? _(bt, B(ne, Mt, {
+              style: Ne[ne.column.key]
+            }), Ge(xe = t.cell(ne)) ? xe : {
+              default: () => [xe]
+            }) : _(bt, B(ne, Mt, {
+              style: Ne[ne.column.key]
+            }), null);
+          }
+        }),
+        header: (rt) => _(Yn, B(rt, No), {
+          header: t.header,
+          cell: (ne) => {
+            let xe;
+            return t["header-cell"] ? _(Yt, B(ne, It, {
+              style: Ne[ne.column.key]
+            }), Ge(xe = t["header-cell"](ne)) ? xe : {
+              default: () => [xe]
+            }) : _(Yt, B(ne, It, {
+              style: Ne[ne.column.key]
+            }), null);
+          }
+        })
+      }, Ao = [e.class, n.b(), n.e("root"), {
+        [n.is("dynamic")]: r(x)
+      }], zo = {
+        class: n.e("footer"),
+        style: r(P)
+      };
+      return _("div", {
+        class: Ao,
+        style: r(A)
+      }, [_(Kn, ee, Ge(se) ? se : {
+        default: () => [se]
+      }), _($n, nt, Ge(se) ? se : {
+        default: () => [se]
+      }), _(Bn, Io, Ge(se) ? se : {
+        default: () => [se]
+      }), t.footer && _(Ho, zo, {
+        default: t.footer
+      }), r($) && _(po, {
+        class: n.e("empty"),
+        style: r(M)
+      }, {
+        default: t.empty
+      }), t.overlay && _(Mo, {
+        class: n.e("overlay")
+      }, {
+        default: t.overlay
+      })]);
+    };
+  }
+}), Jn = le({
+  disableWidth: Boolean,
+  disableHeight: Boolean,
+  onResize: {
+    type: N(Function)
+  }
+}), Qn = ge({
+  name: "ElAutoResizer",
+  props: Jn,
+  setup(e, {
+    slots: t
+  }) {
+    const o = De("auto-resizer"), {
+      height: n,
+      width: s,
+      sizer: a
+    } = Cn(e), i = {
+      width: "100%",
+      height: "100%"
+    };
+    return () => {
+      var c;
+      return _("div", {
+        ref: a,
+        class: o.b(),
+        style: i
+      }, [(c = t.default) == null ? void 0 : c.call(t, {
+        height: n.value,
+        width: s.value
+      })]);
+    };
+  }
+}), el = Xt(Xn), tl = Xt(Qn);
+const ol = {
+  __name: "index",
+  props: /* @__PURE__ */ zt({
+    // 表格数据
+    data: {
+      type: Array,
+      default: () => [{
+        featureName: "第一个"
+      }, {
+        featureName: "第二个"
+      }, {
+        featureName: "第三个"
+      }]
+    },
+    // 表格渲染DOM结构
+    columns: {
+      type: Array,
+      default: () => [{
+        key: "code",
+        title: "品种",
+        dataKey: "code",
+        width: 120,
+        fixed: !0,
+        cellRenderer: ({
+          rowData: e
+        }) => {
+          const {
+            featureName: t
+          } = e;
+          return _("div", {
+            class: "overflowText",
+            title: `${t}`
+          }, [t]);
+        }
+      }]
+    },
+    // 功能配置项
+    config: {
+      type: Object,
+      default: () => {
+      }
+    }
+  }, {
+    activeData: {
+      default: () => []
+    },
+    activeDataModifiers: {}
+  }),
+  emits: /* @__PURE__ */ zt(["scrollCallBack"], ["update:activeData"]),
+  setup(e, {
+    emit: t
+  }) {
+    const o = t, n = e, s = R(() => ({
+      activeRowNum: 1,
+      // 激活行数量, 默认1
+      activeRowKey: "id",
+      // 激活行key, 默认id
+      isOpenPageUpDown: !0,
+      // 是否开启键盘pageUp,pageDown移动选择行功能
+      ...n.config
+    })), a = G(null), i = jo(e, "activeData"), c = R(() => {
+      const {
+        activeRowKey: f
+      } = s.value;
+      return i.value.map((l) => l[f]);
+    }), m = ({
+      rowData: f
+    }) => {
+      const {
+        activeRowNum: l,
+        activeRowKey: u
+      } = s.value;
+      if (!l || !i.value.length)
+        return;
+      let y = "";
+      return f[u] === c.value[0] && (y += " virtualTable-active-Area-start"), f[u] === c.value[c.value.length - 1] && (y += " virtualTable-active-Area-end"), c.value.includes(f[u]) && (y += " virtualTable-active-Area-row"), y;
+    }, h = ({
+      rowData: f,
+      rowIndex: l
+    }) => {
+      const {
+        activeRowNum: u,
+        activeRowKey: y
+      } = s.value;
+      if (!u || c.value.includes(f[y]))
+        return;
+      const b = Math.floor(l / u) * u;
+      i.value = n.data.slice(b, b + u);
+    };
+    let d = !1, v = 0;
+    const w = (f) => {
+      let l = !1;
+      const u = document.querySelector("#VirtualTable").querySelector(".el-table-v2__body").querySelector("div").querySelector("div"), y = Number(u.style.height.split("px")[0]), b = document.querySelector("#VirtualTable").querySelector(".el-table-v2__body").querySelector("div"), S = Number(b.style.height.split("px")[0]);
+      y - f.scrollTop === S && (l = !0), d === !1 && (v = f.scrollLeft), o("scrollCallBack", {
+        ...f,
+        isTouchBottom: l
+      });
+    }, g = ({
+      code: f
+    }) => {
+      var S, x, I, T;
+      const {
+        data: l
+      } = n, {
+        activeRowNum: u,
+        activeRowKey: y
+      } = s.value;
+      if (!l.length)
+        return;
+      const b = l.findIndex((O) => O[y] === c.value[0]);
+      if (f === "PageUp") {
+        const O = b - u;
+        O >= 0 && (i.value = l.slice(O, b), d = !0, (S = a.value) == null || S.scrollToRow(O), (x = a.value) == null || x.scrollToLeft(v), d = !1);
+        return;
+      } else if (f === "PageDown")
+        if (i.value[i.value.length - 1][y] === l[l.length - 1][y])
+          o("scrollCallBack", {
+            yAxisScrollDir: "forward",
+            isTouchBottom: !0
+          });
+        else {
+          const O = b + u;
+          i.value = l.slice(O, O + u), d = !0, (I = a.value) == null || I.scrollToRow(O + i.value.length - 1), (T = a.value) == null || T.scrollToLeft(v), d = !1;
+        }
+    };
+    return Le(() => s.value.isOpenPageUpDown, (f) => {
+      f && s.value.activeRowNum && window.addEventListener("keydown", g);
+    }, {
+      immediate: !0
+    }), qo(() => {
+      window.removeEventListener("keydown", g);
+    }), (f, l) => {
+      const u = Jt, y = el, b = tl;
+      return Uo(), Yo(b, null, {
+        default: Dt(({
+          height: S,
+          width: x
+        }) => [_(y, {
+          id: "VirtualTable",
+          ref_key: "tableRef",
+          ref: a,
+          width: x,
+          height: S,
+          data: e.data,
+          columns: e.columns,
+          "row-class": m,
+          "row-event-handlers": {
+            onClick: h
+          },
+          fixed: "",
+          border: "",
+          onScroll: w
+        }, {
+          empty: Dt(() => [_(u, {
+            description: "暂无数据",
+            style: {
+              height: "100%"
+            }
+          })]),
+          _: 2
+        }, 1032, ["width", "height", "data", "columns", "row-event-handlers"])]),
+        _: 1
+      });
+    };
+  }
+};
+const Zt = /* @__PURE__ */ tn(ol, [["__scopeId", "data-v-7b74bdcc"]]);
+Zt.install = (e) => {
+  e.component("st-virtualTable", Zt);
+};
+export {
+  Zt as default
+};