st-comp 0.0.147 → 0.0.148

package/es/VirtualTable.js

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