st-comp 0.0.279 → 0.0.280

package/es/VirtualTable.js

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