st-comp 0.0.75 → 0.0.76

package/es/VirtualTable.js

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