st-comp 0.0.279 → 0.0.280

package/es/el-table-column-e2be313e.js

@@ -0,0 +1,3651 @@
+import { H as Bt, I as Sn, J as xn, K as En, L as Rn, E as ze, i as be, s as je, a as we, B as Ce, m as ie, t as Nn, q as $e, k as vt, u as Ee, y as Ze, C as Je, h as pt, F as Ln, j as ut, r as et, v as On, w as Tn, n as Fn } from "./base-dd156b8e.js";
+import { e as El, i as Rt, b as Mn, g as ol, u as Ct } from "./index-a181f161.js";
+import { E as Rl, i as St } from "./index-a0522466.js";
+import { g as Nl, a as Dt } from "./use-global-config-17dafd40.js";
+import { n as Wn, o as rl, h as kn, b as sl, u as il, e as Hn } from "./use-form-item-187cd7db.js";
+import { s as An, o as $n, m as In, n as zn, E as Ll, b as Kn, g as Bn, a as We, _ as Dn } from "./el-popper-852446fd.js";
+import { createVNode as xe, render as ul, isVNode as Ol, Comment as Tl, Fragment as tt, getCurrentInstance as he, ref as L, unref as S, computed as Y, watch as ne, toRefs as Pn, nextTick as Ye, isRef as Vn, inject as Oe, defineComponent as De, resolveComponent as ke, openBlock as te, createBlock as Ke, withCtx as Ae, createElementBlock as ye, normalizeClass as G, createElementVNode as fe, renderList as cl, createTextVNode as Pt, toDisplayString as Pe, renderSlot as Be, onBeforeMount as Fl, onMounted as lt, onUpdated as jn, onUnmounted as Vt, reactive as _n, onBeforeUnmount as jt, h as P, watchEffect as Nt, provide as Yn, normalizeStyle as Qe, withDirectives as xt, createCommentVNode as He, vShow as dl, useSlots as qn } from "vue";
+import { a as bt, k as Un, b as Xn, c as Gn, S as Qn } from "./index-47d30a52.js";
+import { c as Jn, k as Ml, a as Zn, b as ea, d as ta, i as la } from "./_baseClone-98af8b33.js";
+import { b as na } from "./el-tag-9bcfae32.js";
+import { c as Wl } from "./castArray-18eb6a41.js";
+import { d as mt } from "./debounce-0a98a9c6.js";
+import { E as yt, a as aa } from "./el-checkbox-c328b097.js";
+import { E as _t, f as oa, D as ra, g as kl, l as sa } from "./index-60900c6c.js";
+import { r as ia } from "./raf-b4fd1e12.js";
+function ua(e, t) {
+  return An($n(e, t, In), e + "");
+}
+function ca(e, t, l) {
+  if (!Bt(l))
+    return !1;
+  var n = typeof t;
+  return (n == "number" ? bt(l) && Wn(t, l.length) : n == "string" && t in l) ? El(l[t], e) : !1;
+}
+function da(e) {
+  return ua(function(t, l) {
+    var n = -1, a = l.length, u = a > 1 ? l[a - 1] : void 0, c = a > 2 ? l[2] : void 0;
+    for (u = e.length > 3 && typeof u == "function" ? (a--, u) : void 0, c && ca(l[0], l[1], c) && (u = a < 3 ? void 0 : u, a = 1), t = Object(t); ++n < a; ) {
+      var o = l[n];
+      o && e(t, o, n, u);
+    }
+    return t;
+  });
+}
+function fa(e) {
+  return function(t, l, n) {
+    for (var a = -1, u = Object(t), c = n(t), o = c.length; o--; ) {
+      var r = c[e ? o : ++a];
+      if (l(u[r], r, u) === !1)
+        break;
+    }
+    return t;
+  };
+}
+var ha = fa();
+const Hl = ha;
+function ga(e, t) {
+  return e && Hl(e, t, Un);
+}
+function va(e, t) {
+  return function(l, n) {
+    if (l == null)
+      return l;
+    if (!bt(l))
+      return e(l, n);
+    for (var a = l.length, u = t ? a : -1, c = Object(l); (t ? u-- : ++u < a) && n(c[u], u, c) !== !1; )
+      ;
+    return l;
+  };
+}
+var pa = va(ga);
+const ma = pa;
+function Lt(e, t, l) {
+  (l !== void 0 && !El(e[t], l) || l === void 0 && !(t in e)) && Sn(e, t, l);
+}
+function ya(e) {
+  return xn(e) && bt(e);
+}
+function Ot(e, t) {
+  if (!(t === "constructor" && typeof e[t] == "function") && t != "__proto__")
+    return e[t];
+}
+function Ca(e) {
+  return Jn(e, Ml(e));
+}
+function ba(e, t, l, n, a, u, c) {
+  var o = Ot(e, l), r = Ot(t, l), s = c.get(r);
+  if (s) {
+    Lt(e, l, s);
+    return;
+  }
+  var i = u ? u(o, r, l + "", e, t, c) : void 0, d = i === void 0;
+  if (d) {
+    var p = Rt(r), h = !p && Xn(r), v = !p && !h && Gn(r);
+    i = r, p || h || v ? Rt(o) ? i = o : ya(o) ? i = Zn(o) : h ? (d = !1, i = ea(r, !0)) : v ? (d = !1, i = ta(r, !0)) : i = [] : En(r) || rl(r) ? (i = o, rl(o) ? i = Ca(o) : (!Bt(o) || Rn(o)) && (i = la(r))) : d = !1;
+  }
+  d && (c.set(r, i), a(i, r, n, u, c), c.delete(r)), Lt(e, l, i);
+}
+function Al(e, t, l, n, a) {
+  e !== t && Hl(t, function(u, c) {
+    if (a || (a = new Qn()), Bt(u))
+      ba(e, t, c, l, Al, n, a);
+    else {
+      var o = n ? n(Ot(e, c), u, c + "", e, t, a) : void 0;
+      o === void 0 && (o = u), Lt(e, c, o);
+    }
+  }, Ml);
+}
+function wa(e, t) {
+  var l = -1, n = bt(e) ? Array(e.length) : [];
+  return ma(e, function(a, u, c) {
+    n[++l] = t(a, u, c);
+  }), n;
+}
+function Sa(e, t) {
+  var l = Rt(e) ? Mn : wa;
+  return l(e, na(t));
+}
+function $l(e, t) {
+  return zn(Sa(e, t), 1);
+}
+function wt(e) {
+  return e === null;
+}
+var xa = da(function(e, t, l) {
+  Al(e, t, l);
+});
+const Il = xa;
+var fl = !1, Ie, Tt, Ft, ct, dt, zl, ft, Mt, Wt, kt, Kl, Ht, At, Bl, Dl;
+function de() {
+  if (!fl) {
+    fl = !0;
+    var e = navigator.userAgent, t = /(?:MSIE.(\d+\.\d+))|(?:(?:Firefox|GranParadiso|Iceweasel).(\d+\.\d+))|(?:Opera(?:.+Version.|.)(\d+\.\d+))|(?:AppleWebKit.(\d+(?:\.\d+)?))|(?:Trident\/\d+\.\d+.*rv:(\d+\.\d+))/.exec(e), l = /(Mac OS X)|(Windows)|(Linux)/.exec(e);
+    if (Ht = /\b(iPhone|iP[ao]d)/.exec(e), At = /\b(iP[ao]d)/.exec(e), kt = /Android/i.exec(e), Bl = /FBAN\/\w+;/i.exec(e), Dl = /Mobile/i.exec(e), Kl = !!/Win64/.exec(e), t) {
+      Ie = t[1] ? parseFloat(t[1]) : t[5] ? parseFloat(t[5]) : NaN, Ie && document && document.documentMode && (Ie = document.documentMode);
+      var n = /(?:Trident\/(\d+.\d+))/.exec(e);
+      zl = n ? parseFloat(n[1]) + 4 : Ie, Tt = t[2] ? parseFloat(t[2]) : NaN, Ft = t[3] ? parseFloat(t[3]) : NaN, ct = t[4] ? parseFloat(t[4]) : NaN, ct ? (t = /(?:Chrome\/(\d+\.\d+))/.exec(e), dt = t && t[1] ? parseFloat(t[1]) : NaN) : dt = NaN;
+    } else
+      Ie = Tt = Ft = dt = ct = NaN;
+    if (l) {
+      if (l[1]) {
+        var a = /(?:Mac OS X (\d+(?:[._]\d+)?))/.exec(e);
+        ft = a ? parseFloat(a[1].replace("_", ".")) : !0;
+      } else
+        ft = !1;
+      Mt = !!l[2], Wt = !!l[3];
+    } else
+      ft = Mt = Wt = !1;
+  }
+}
+var $t = { ie: function() {
+  return de() || Ie;
+}, ieCompatibilityMode: function() {
+  return de() || zl > Ie;
+}, ie64: function() {
+  return $t.ie() && Kl;
+}, firefox: function() {
+  return de() || Tt;
+}, opera: function() {
+  return de() || Ft;
+}, webkit: function() {
+  return de() || ct;
+}, safari: function() {
+  return $t.webkit();
+}, chrome: function() {
+  return de() || dt;
+}, windows: function() {
+  return de() || Mt;
+}, osx: function() {
+  return de() || ft;
+}, linux: function() {
+  return de() || Wt;
+}, iphone: function() {
+  return de() || Ht;
+}, mobile: function() {
+  return de() || Ht || At || kt || Dl;
+}, nativeApp: function() {
+  return de() || Bl;
+}, android: function() {
+  return de() || kt;
+}, ipad: function() {
+  return de() || At;
+} }, Ea = $t, it = !!(typeof window < "u" && window.document && window.document.createElement), Ra = { canUseDOM: it, canUseWorkers: typeof Worker < "u", canUseEventListeners: it && !!(window.addEventListener || window.attachEvent), canUseViewport: it && !!window.screen, isInWorker: !it }, Pl = Ra, Vl;
+Pl.canUseDOM && (Vl = document.implementation && document.implementation.hasFeature && document.implementation.hasFeature("", "") !== !0);
+function Na(e, t) {
+  if (!Pl.canUseDOM || t && !("addEventListener" in document))
+    return !1;
+  var l = "on" + e, n = l in document;
+  if (!n) {
+    var a = document.createElement("div");
+    a.setAttribute(l, "return;"), n = typeof a[l] == "function";
+  }
+  return !n && Vl && e === "wheel" && (n = document.implementation.hasFeature("Events.wheel", "3.0")), n;
+}
+var La = Na, hl = 10, gl = 40, vl = 800;
+function jl(e) {
+  var t = 0, l = 0, n = 0, a = 0;
+  return "detail" in e && (l = e.detail), "wheelDelta" in e && (l = -e.wheelDelta / 120), "wheelDeltaY" in e && (l = -e.wheelDeltaY / 120), "wheelDeltaX" in e && (t = -e.wheelDeltaX / 120), "axis" in e && e.axis === e.HORIZONTAL_AXIS && (t = l, l = 0), n = t * hl, a = l * hl, "deltaY" in e && (a = e.deltaY), "deltaX" in e && (n = e.deltaX), (n || a) && e.deltaMode && (e.deltaMode == 1 ? (n *= gl, a *= gl) : (n *= vl, a *= vl)), n && !t && (t = n < 1 ? -1 : 1), a && !l && (l = a < 1 ? -1 : 1), { spinX: t, spinY: l, pixelX: n, pixelY: a };
+}
+jl.getEventType = function() {
+  return Ea.firefox() ? "DOMMouseScroll" : La("wheel") ? "wheel" : "mousewheel";
+};
+var Oa = jl;
+/**
+* Checks if an event is supported in the current execution environment.
+*
+* NOTE: This will not work correctly for non-generic events such as `change`,
+* `reset`, `load`, `error`, and `select`.
+*
+* Borrows from Modernizr.
+*
+* @param {string} eventNameSuffix Event name, e.g. "click".
+* @param {?boolean} capture Check if the capture phase is supported.
+* @return {boolean} True if the event is supported.
+* @internal
+* @license Modernizr 3.0.0pre (Custom Build) | MIT
+*/
+const It = "_Mousewheel", pl = function(e, t) {
+  if (e && e.addEventListener) {
+    _l(e);
+    const l = function(n) {
+      const a = Oa(n);
+      t && Reflect.apply(t, this, [n, a]);
+    };
+    e[It] = { wheelHandler: l }, e.addEventListener("wheel", l, { passive: !0 });
+  }
+}, _l = (e) => {
+  var t;
+  (t = e._Mousewheel) != null && t.wheelHandler && (e.removeEventListener("wheel", e[It].wheelHandler), e[It] = null);
+}, ml = {
+  beforeMount(e, t) {
+    pl(e, t.value);
+  },
+  unmounted(e) {
+    _l(e);
+  },
+  updated(e, t) {
+    t.value !== t.oldValue && pl(e, t.value);
+  }
+}, Ta = {
+  /**
+  * @description table data
+  */
+  data: {
+    type: Array,
+    default: () => []
+  },
+  /**
+  * @description size of Table
+  */
+  size: kn,
+  width: [String, Number],
+  /**
+  * @description table's height. By default it has an `auto` height. If its value is a number, the height is measured in pixels; if its value is a string, the value will be assigned to element's style.height, the height is affected by external styles
+  */
+  height: [String, Number],
+  /**
+  * @description table's max-height. The legal value is a number or the height in px
+  */
+  maxHeight: [String, Number],
+  /**
+  * @description whether width of column automatically fits its container
+  */
+  fit: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description whether Table is striped
+  */
+  stripe: Boolean,
+  /**
+  * @description whether Table has vertical border
+  */
+  border: Boolean,
+  /**
+  * @description key of row data, used for optimizing rendering. Required if `reserve-selection` is on or display tree data. When its type is String, multi-level access is supported, e.g. `user.info.id`, but `user.info[0].id` is not supported, in which case `Function` should be used
+  */
+  rowKey: [String, Function],
+  /**
+  * @description whether Table header is visible
+  */
+  showHeader: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description whether to display a summary row
+  */
+  showSummary: Boolean,
+  /**
+  * @description displayed text for the first column of summary row
+  */
+  sumText: String,
+  /**
+  * @description custom summary method
+  */
+  summaryMethod: Function,
+  /**
+  * @description function that returns custom class names for a row, or a string assigning class names for every row
+  */
+  rowClassName: [String, Function],
+  /**
+  * @description function that returns custom style for a row, or an object assigning custom style for every row
+  */
+  rowStyle: [Object, Function],
+  /**
+  * @description function that returns custom class names for a cell, or a string assigning class names for every cell
+  */
+  cellClassName: [String, Function],
+  /**
+  * @description function that returns custom style for a cell, or an object assigning custom style for every cell
+  */
+  cellStyle: [Object, Function],
+  /**
+  * @description function that returns custom class names for a row in table header, or a string assigning class names for every row in table header
+  */
+  headerRowClassName: [String, Function],
+  /**
+  * @description function that returns custom style for a row in table header, or an object assigning custom style for every row in table header
+  */
+  headerRowStyle: [Object, Function],
+  /**
+  * @description function that returns custom class names for a cell in table header, or a string assigning class names for every cell in table header
+  */
+  headerCellClassName: [String, Function],
+  /**
+  * @description function that returns custom style for a cell in table header, or an object assigning custom style for every cell in table header
+  */
+  headerCellStyle: [Object, Function],
+  /**
+  * @description whether current row is highlighted
+  */
+  highlightCurrentRow: Boolean,
+  /**
+  * @description key of current row, a set only prop
+  */
+  currentRowKey: [String, Number],
+  /**
+  * @description displayed text when data is empty. You can customize this area with `#empty`
+  */
+  emptyText: String,
+  /**
+  * @description set expanded rows by this prop, prop's value is the keys of expand rows, you should set row-key before using this prop
+  */
+  expandRowKeys: Array,
+  /**
+  * @description whether expand all rows by default, works when the table has a column type="expand" or contains tree structure data
+  */
+  defaultExpandAll: Boolean,
+  /**
+  * @description enable expandable rows, works when the table has a column type="expand"
+  */
+  rowExpandable: { type: Function },
+  /**
+  * @description set the default sort column and order. property `prop` is used to set default sort column, property `order` is used to set default sort order
+  */
+  defaultSort: Object,
+  /**
+  * @description the `effect` of the overflow tooltip
+  */
+  tooltipEffect: String,
+  /**
+  * @description the options for the overflow tooltip, [see the following tooltip component](tooltip.html#attributes)
+  */
+  tooltipOptions: Object,
+  /**
+  * @description method that returns rowspan and colspan
+  */
+  spanMethod: Function,
+  /**
+  * @description controls the behavior of master checkbox in multi-select tables when only some rows are selected (but not all). If true, all rows will be selected, else deselected
+  */
+  selectOnIndeterminate: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description horizontal indentation of tree data
+  */
+  indent: {
+    type: Number,
+    default: 16
+  },
+  /**
+  * @description configuration for rendering nested data
+  */
+  treeProps: {
+    type: Object,
+    default: () => ({
+      hasChildren: "hasChildren",
+      children: "children",
+      checkStrictly: !1
+    })
+  },
+  /**
+  * @description whether to lazy loading data
+  */
+  lazy: Boolean,
+  /**
+  * @description method for loading child row data, only works when `lazy` is true
+  */
+  load: Function,
+  style: {
+    type: [
+      String,
+      Object,
+      Array,
+      Boolean
+    ],
+    default: () => ({})
+  },
+  className: {
+    type: String,
+    default: ""
+  },
+  /**
+  * @description sets the algorithm used to lay out table cells, rows, and columns
+  */
+  tableLayout: {
+    type: String,
+    default: "fixed"
+  },
+  /**
+  * @description always show scrollbar
+  */
+  scrollbarAlwaysOn: Boolean,
+  /**
+  * @description ensure main axis minimum-size doesn't follow the content
+  */
+  flexible: Boolean,
+  /**
+  * @description whether to hide extra content and show them in a tooltip when hovering on the cell.It will affect all the table columns
+  */
+  showOverflowTooltip: {
+    type: [Boolean, Object],
+    default: void 0
+  },
+  /**
+  * @description function that formats cell tooltip content, works when `show-overflow-tooltip` is `true`
+  */
+  tooltipFormatter: Function,
+  appendFilterPanelTo: String,
+  scrollbarTabindex: {
+    type: [Number, String],
+    default: void 0
+  },
+  /**
+  * @description whether to allow drag the last column
+  */
+  allowDragLastColumn: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description whether to preserve expanded row content in DOM when collapsed
+  */
+  preserveExpandedContent: Boolean,
+  /**
+  * @description whether to use native scrollbars
+  */
+  nativeScrollbar: Boolean
+};
+let Fa = 1, Ma = 1;
+const Wa = (e) => `${e}-table_${Fa++}`, ka = (e) => `${e}_column_${Ma++}`, Et = function(e) {
+  var t;
+  return (t = e.target) == null ? void 0 : t.closest("td");
+}, Ha = function(e, t, l, n, a) {
+  if (!t && !n && (!a || ie(a) && !a.length))
+    return e;
+  we(l) ? l = l === "descending" ? -1 : 1 : l = l && l < 0 ? -1 : 1;
+  const u = n ? null : function(o, r) {
+    return a ? $l(Wl(a), (s) => we(s) ? ol(o, s) : s(o, r, e)) : (t !== "$key" && vt(o) && "$value" in o && (o = o.$value), [vt(o) ? t ? ol(o, t) : null : o]);
+  }, c = function(o, r) {
+    var s, i, d, p, h;
+    if (n)
+      return n(o.value, r.value);
+    for (let v = 0, b = ((s = o.key) == null ? void 0 : s.length) ?? 0; v < b; v++) {
+      if (((i = o.key) == null ? void 0 : i[v]) < ((d = r.key) == null ? void 0 : d[v]))
+        return -1;
+      if (((p = o.key) == null ? void 0 : p[v]) > ((h = r.key) == null ? void 0 : h[v]))
+        return 1;
+    }
+    return 0;
+  };
+  return e.map((o, r) => ({
+    value: o,
+    index: r,
+    key: u ? u(o, r) : null
+  })).sort((o, r) => {
+    let s = c(o, r);
+    return s || (s = o.index - r.index), s * +l;
+  }).map((o) => o.value);
+}, Yl = function(e, t) {
+  let l = null;
+  return e.columns.forEach((n) => {
+    n.id === t && (l = n);
+  }), l;
+}, Aa = function(e, t) {
+  let l = null;
+  for (let n = 0; n < e.columns.length; n++) {
+    const a = e.columns[n];
+    if (a.columnKey === t) {
+      l = a;
+      break;
+    }
+  }
+  return l || Nn("ElTable", `No column matching with column-key: ${t}`), l;
+}, yl = function(e, t, l) {
+  const n = (t.className || "").match(new RegExp(`${l}-table_[^\\s]+`, "gm"));
+  return n ? Yl(e, n[0]) : null;
+}, U = (e, t) => {
+  if (!e)
+    throw new Error("Row is required when get row identity");
+  if (we(t)) {
+    if (!t.includes("."))
+      return `${e[t]}`;
+    const l = t.split(".");
+    let n = e;
+    for (const a of l)
+      n = n[a];
+    return `${n}`;
+  } else if (Ce(t))
+    return t.call(null, e);
+  return "";
+}, _e = function(e, t, l = !1, n = "children") {
+  const a = e || [], u = {};
+  return a.forEach((c, o) => {
+    if (u[U(c, t)] = {
+      row: c,
+      index: o
+    }, l) {
+      const r = c[n];
+      ie(r) && Object.assign(u, _e(r, t, !0, n));
+    }
+  }), u;
+};
+function $a(e, t) {
+  const l = {};
+  let n;
+  for (n in e)
+    l[n] = e[n];
+  for (n in t)
+    if (ze(t, n)) {
+      const a = t[n];
+      be(a) || (l[n] = a);
+    }
+  return l;
+}
+function Yt(e) {
+  return e === "" || be(e) || (e = Number.parseInt(e, 10), Number.isNaN(e) && (e = "")), e;
+}
+function ql(e) {
+  return e === "" || be(e) || (e = Yt(e), Number.isNaN(e) && (e = 80)), e;
+}
+function Ia(e) {
+  return je(e) ? e : we(e) ? /^\d+(?:px)?$/.test(e) ? Number.parseInt(e, 10) : e : null;
+}
+function za(...e) {
+  return e.length === 0 ? (t) => t : e.length === 1 ? e[0] : e.reduce((t, l) => (...n) => t(l(...n)));
+}
+function Ve(e, t, l, n, a, u, c) {
+  let o = u ?? 0, r = !1;
+  const i = (() => {
+    if (!c)
+      return e.indexOf(t);
+    const b = U(t, c);
+    return e.findIndex((w) => U(w, c) === b);
+  })(), d = i !== -1, p = a == null ? void 0 : a.call(null, t, o), h = (b) => {
+    b === "add" ? e.push(t) : e.splice(i, 1), r = !0;
+  }, v = (b) => {
+    let w = 0;
+    const F = (n == null ? void 0 : n.children) && b[n.children];
+    return F && ie(F) && (w += F.length, F.forEach((O) => {
+      w += v(O);
+    })), w;
+  };
+  return (!a || p) && ($e(l) ? l && !d ? h("add") : !l && d && h("remove") : h(d ? "remove" : "add")), !(n != null && n.checkStrictly) && (n != null && n.children) && ie(t[n.children]) && t[n.children].forEach((b) => {
+    const w = Ve(e, b, l ?? !d, n, a, o + 1, c);
+    o += v(b) + 1, w && (r = w);
+  }), r;
+}
+function Ka(e, t, l = "children", n = "hasChildren", a = !1) {
+  const u = (o) => !(ie(o) && o.length);
+  function c(o, r, s) {
+    t(o, r, s), r.forEach((i) => {
+      if (i[n] && a) {
+        t(i, null, s + 1);
+        return;
+      }
+      const d = i[l];
+      u(d) || c(i, d, s + 1);
+    });
+  }
+  e.forEach((o) => {
+    if (o[n] && a) {
+      t(o, null, 0);
+      return;
+    }
+    const r = o[l];
+    u(r) || c(o, r, 0);
+  });
+}
+const Ba = (e, t, l, n) => {
+  const a = Ce(n == null ? void 0 : n.tooltipFormatter) ? n.tooltipFormatter({
+    row: l,
+    column: n,
+    cellValue: Nl(l, n.property).value
+  }) : void 0;
+  return Ol(a) ? {
+    slotContent: a,
+    content: null,
+    strategy: "fixed",
+    ...e
+  } : {
+    slotContent: null,
+    content: a ?? t,
+    strategy: "fixed",
+    ...e
+  };
+};
+let q = null;
+function Da(e, t, l, n, a, u) {
+  var h;
+  const c = Ba(e, t, l, n), o = {
+    ...c,
+    slotContent: void 0
+  };
+  if ((q == null ? void 0 : q.trigger) === a) {
+    const v = (h = q.vm) == null ? void 0 : h.component;
+    Il(v == null ? void 0 : v.props, o), v && c.slotContent && (v.slots.content = () => [c.slotContent]);
+    return;
+  }
+  q == null || q();
+  const r = u == null ? void 0 : u.refs.tableWrapper, s = r == null ? void 0 : r.dataset.prefix, i = xe(Ll, {
+    virtualTriggering: !0,
+    virtualRef: a,
+    appendTo: r,
+    placement: "top",
+    transition: "none",
+    offset: 0,
+    hideAfter: 0,
+    ...o
+  }, c.slotContent ? { content: () => c.slotContent } : void 0);
+  i.appContext = {
+    ...u.appContext,
+    ...u
+  };
+  const d = document.createElement("div");
+  ul(i, d), i.component.exposed.onOpen();
+  const p = r == null ? void 0 : r.querySelector(`.${s}-scrollbar__wrap`);
+  q = () => {
+    var b, w;
+    (w = (b = i.component) == null ? void 0 : b.exposed) != null && w.onClose && i.component.exposed.onClose(), ul(null, d);
+    const v = q;
+    p == null || p.removeEventListener("scroll", v), v.trigger = void 0, v.vm = void 0, q = null;
+  }, q.trigger = a ?? void 0, q.vm = i, p == null || p.addEventListener("scroll", q);
+}
+function Ul(e) {
+  return e.children ? $l(e.children, Ul) : [e];
+}
+function Cl(e, t) {
+  return e + t.colSpan;
+}
+const Xl = (e, t, l, n) => {
+  let a = 0, u = e;
+  const c = l.states.columns.value;
+  if (n) {
+    const r = Ul(n[e]);
+    a = c.slice(0, c.indexOf(r[0])).reduce(Cl, 0), u = a + r.reduce(Cl, 0) - 1;
+  } else
+    a = e;
+  let o;
+  switch (t) {
+    case "left":
+      u < l.states.fixedLeafColumnsLength.value && (o = "left");
+      break;
+    case "right":
+      a >= c.length - l.states.rightFixedLeafColumnsLength.value && (o = "right");
+      break;
+    default:
+      u < l.states.fixedLeafColumnsLength.value ? o = "left" : a >= c.length - l.states.rightFixedLeafColumnsLength.value && (o = "right");
+  }
+  return o ? {
+    direction: o,
+    start: a,
+    after: u
+  } : {};
+}, qt = (e, t, l, n, a, u = 0) => {
+  const c = [], { direction: o, start: r, after: s } = Xl(t, l, n, a);
+  if (o) {
+    const i = o === "left";
+    c.push(`${e}-fixed-column--${o}`), i && s + u === n.states.fixedLeafColumnsLength.value - 1 ? c.push("is-last-column") : !i && r - u === n.states.columns.value.length - n.states.rightFixedLeafColumnsLength.value && c.push("is-first-column");
+  }
+  return c;
+};
+function bl(e, t) {
+  return e + (wt(t.realWidth) || Number.isNaN(t.realWidth) ? Number(t.width) : t.realWidth);
+}
+const Ut = (e, t, l, n) => {
+  const { direction: a, start: u = 0, after: c = 0 } = Xl(e, t, l, n);
+  if (!a)
+    return;
+  const o = {}, r = a === "left", s = l.states.columns.value;
+  return r ? o.left = s.slice(0, u).reduce(bl, 0) : o.right = s.slice(c + 1).reverse().reduce(bl, 0), o;
+}, qe = (e, t) => {
+  e && (Number.isNaN(e[t]) || (e[t] = `${e[t]}px`));
+};
+function Gl(e) {
+  return e.some((t) => Ol(t) ? !(t.type === Tl || t.type === tt && !Gl(t.children)) : !0) ? e : null;
+}
+function Pa(e) {
+  const t = he(), l = L(!1), n = L([]), a = (s, i) => {
+    const d = t.store.states.rowExpandable.value;
+    return (d == null ? void 0 : d(s, i)) ?? !0;
+  };
+  return {
+    updateExpandRows: () => {
+      const s = e.data.value || [], i = e.rowKey.value;
+      if (l.value)
+        n.value = t.store.states.rowExpandable.value ? s.filter(a) : s.slice();
+      else if (i) {
+        const d = _e(n.value, i);
+        n.value = s.filter((p, h) => !!d[U(p, i)] && a(p, h));
+      } else
+        n.value = [];
+    },
+    toggleRowExpansion: (s, i) => {
+      const d = (e.data.value || []).indexOf(s);
+      d > -1 && !a(s, d) || Ve(n.value, s, i, void 0, void 0, void 0, e.rowKey.value) && t.emit("expand-change", s, n.value.slice());
+    },
+    setExpandRowKeys: (s) => {
+      t.store.assertRowKey();
+      const i = e.data.value || [], d = e.rowKey.value, p = _e(i, d);
+      n.value = s.reduce((h, v) => {
+        const b = p[v];
+        return b && a(b.row, b.index) && h.push(b.row), h;
+      }, []);
+    },
+    isRowExpanded: (s) => {
+      const i = e.rowKey.value;
+      return i ? !!_e(n.value, i)[U(s, i)] : n.value.includes(s);
+    },
+    states: {
+      expandRows: n,
+      defaultExpandAll: l
+    }
+  };
+}
+function Va(e) {
+  const t = he(), l = L(null), n = L(null), a = (s) => {
+    t.store.assertRowKey(), l.value = s, c(s);
+  }, u = () => {
+    l.value = null;
+  }, c = (s) => {
+    const { data: i, rowKey: d } = e, p = n.value;
+    let h = null;
+    d.value && (h = (S(i) || []).find((v) => U(v, d.value) === s) ?? null), n.value = h ?? null, t.emit("current-change", n.value, p);
+  };
+  return {
+    setCurrentRowKey: a,
+    restoreCurrentRowKey: u,
+    setCurrentRowByKey: c,
+    updateCurrentRow: (s) => {
+      const i = n.value;
+      if (s && s !== i) {
+        n.value = s, t.emit("current-change", n.value, i);
+        return;
+      }
+      !s && i && (n.value = null, t.emit("current-change", null, i));
+    },
+    updateCurrentRowData: () => {
+      const s = e.rowKey.value, i = e.data.value || [], d = n.value;
+      d && !i.includes(d) ? s ? c(U(d, s)) : (n.value = null, t.emit("current-change", null, d)) : l.value && (c(l.value), u());
+    },
+    states: {
+      _currentRowKey: l,
+      currentRow: n
+    }
+  };
+}
+function ja(e) {
+  const t = L([]), l = L({}), n = L(16), a = L(!1), u = L({}), c = L("hasChildren"), o = L("children"), r = L(!1), s = he(), i = Y(() => e.rowKey.value ? p(e.data.value || []) : {}), d = Y(() => {
+    const f = e.rowKey.value, g = Object.keys(u.value), y = {};
+    return g.length && g.forEach((C) => {
+      if (u.value[C].length) {
+        const m = { children: [] };
+        u.value[C].forEach((x) => {
+          const R = U(x, f);
+          m.children.push(R), x[c.value] && !y[R] && (y[R] = { children: [] });
+        }), y[C] = m;
+      }
+    }), y;
+  }), p = (f) => {
+    const g = e.rowKey.value, y = {};
+    return Ka(f, (C, m, x) => {
+      const R = U(C, g);
+      ie(m) ? y[R] = {
+        children: m.map((k) => U(k, g)),
+        level: x
+      } : a.value && (y[R] = {
+        children: [],
+        lazy: !0,
+        level: x
+      });
+    }, o.value, c.value, a.value), y;
+  }, h = (f = !1, g) => {
+    var R, k;
+    g || (g = (R = s.store) == null ? void 0 : R.states.defaultExpandAll.value);
+    const y = i.value, C = d.value, m = Object.keys(y), x = {};
+    if (m.length) {
+      const D = S(l), V = [], X = (T, z) => {
+        if (f)
+          return t.value ? g || t.value.includes(z) : !!(g || T != null && T.expanded);
+        {
+          const $ = g || t.value && t.value.includes(z);
+          return !!(T != null && T.expanded || $);
+        }
+      };
+      m.forEach((T) => {
+        const z = D[T], $ = { ...y[T] };
+        if ($.expanded = X(z, T), $.lazy) {
+          const { loaded: M = !1, loading: j = !1 } = z || {};
+          $.loaded = !!M, $.loading = !!j, V.push(T);
+        }
+        x[T] = $;
+      });
+      const W = Object.keys(C);
+      a.value && W.length && V.length && W.forEach((T) => {
+        var M;
+        const z = D[T], $ = C[T].children;
+        if (V.includes(T)) {
+          if (((M = x[T].children) == null ? void 0 : M.length) !== 0)
+            throw new Error("[ElTable]children must be an empty array.");
+          x[T].children = $;
+        } else {
+          const { loaded: j = !1, loading: J = !1 } = z || {};
+          x[T] = {
+            lazy: !0,
+            loaded: !!j,
+            loading: !!J,
+            expanded: X(z, T),
+            children: $,
+            level: void 0
+          };
+        }
+      });
+    }
+    l.value = x, (k = s.store) == null || k.updateTableScrollY();
+  };
+  ne(() => t.value, () => {
+    h(!0);
+  }, { deep: !0 }), ne(() => i.value, () => {
+    h();
+  }), ne(() => d.value, () => {
+    h();
+  });
+  const v = (f) => {
+    t.value = f, h();
+  }, b = (f) => a.value && f && "loaded" in f && !f.loaded, w = (f, g) => {
+    s.store.assertRowKey();
+    const y = e.rowKey.value, C = U(f, y), m = C && l.value[C];
+    if (C && m && "expanded" in m) {
+      const x = m.expanded;
+      g = be(g) ? !m.expanded : g, l.value[C].expanded = g, x !== g && s.emit("expand-change", f, g), g && b(m) && O(f, C, m), s.store.updateTableScrollY();
+    }
+  }, F = (f) => {
+    s.store.assertRowKey();
+    const g = e.rowKey.value, y = U(f, g), C = l.value[y];
+    b(C) ? O(f, y, C) : w(f, void 0);
+  }, O = (f, g, y) => {
+    const { load: C } = s.props;
+    C && !l.value[g].loaded && (l.value[g].loading = !0, C(f, y, (m) => {
+      if (!ie(m))
+        throw new TypeError("[ElTable] data must be an array");
+      l.value[g].loading = !1, l.value[g].loaded = !0, l.value[g].expanded = !0, m.length && (u.value = {
+        ...u.value,
+        [g]: m
+      }), s.emit("expand-change", f, !0);
+    }));
+  };
+  return {
+    loadData: O,
+    loadOrToggle: F,
+    toggleTreeExpansion: w,
+    updateTreeExpandKeys: v,
+    updateTreeData: h,
+    updateKeyChildren: (f, g) => {
+      const { lazy: y, rowKey: C } = s.props;
+      if (y) {
+        if (!C)
+          throw new Error("[Table] rowKey is required in updateKeyChild");
+        u.value[f] && (u.value = {
+          ...u.value,
+          [f]: g
+        });
+      }
+    },
+    normalize: p,
+    states: {
+      expandRowKeys: t,
+      treeData: l,
+      indent: n,
+      lazy: a,
+      lazyTreeNodeMap: u,
+      lazyColumnIdentifier: c,
+      childrenColumnName: o,
+      checkStrictly: r
+    }
+  };
+}
+const _a = (e, t) => {
+  const l = t.sortingColumn;
+  return !l || we(l.sortable) ? e : Ha(e, t.sortProp, t.sortOrder, l.sortMethod, l.sortBy);
+}, ht = (e) => {
+  const t = [];
+  return e.forEach((l) => {
+    l.children && l.children.length > 0 ? t.push.apply(t, ht(l.children)) : t.push(l);
+  }), t;
+};
+function Ya() {
+  var tl;
+  const e = he(), { size: t } = Pn((tl = e.proxy) == null ? void 0 : tl.$props), l = L(null), n = L([]), a = L([]), u = L(!1), c = L([]), o = L([]), r = L([]), s = L([]), i = L([]), d = L([]), p = L([]), h = L([]), v = [], b = L(0), w = L(0), F = L(0), O = L(!1), N = L([]), f = L({}), g = L(!1), y = L(!1), C = L(null), m = L(null), x = L({}), R = L(null), k = L(null), D = L(null), V = L(null), X = L(null);
+  let W = [];
+  const T = Y(() => l.value ? _e(N.value, l.value) : void 0), z = (E) => {
+    var _;
+    const { childrenColumnName: H, lazyTreeNodeMap: I } = e.store.states, A = E[H.value] ?? [];
+    if (!l.value)
+      return A;
+    const B = U(E, l.value);
+    return [...((_ = I.value) == null ? void 0 : _[B]) ?? [], ...A];
+  };
+  ne(n, () => {
+    var E;
+    e.state && (J(!1), e.props.tableLayout === "auto" && ((E = e.refs.tableHeaderRef) == null || E.updateFixedColumnStyle()));
+  }, { deep: !0 });
+  const $ = () => {
+    if (!l.value)
+      throw new Error("[ElTable] prop row-key is required");
+  }, M = (E) => {
+    var H;
+    (H = E.children) == null || H.forEach((I) => {
+      I.fixed = E.fixed, M(I);
+    });
+  }, j = () => {
+    c.value.forEach((K) => {
+      M(K);
+    }), s.value = c.value.filter((K) => [!0, "left"].includes(K.fixed));
+    const E = c.value.find((K) => K.type === "selection");
+    let H;
+    E && E.fixed !== "right" && !s.value.includes(E) && c.value.indexOf(E) === 0 && s.value.length && (s.value.unshift(E), H = !0), i.value = c.value.filter((K) => K.fixed === "right");
+    const I = c.value.filter((K) => (H ? K.type !== "selection" : !0) && !K.fixed);
+    o.value = Array.from(s.value).concat(I).concat(i.value);
+    const A = ht(I), B = ht(s.value), _ = ht(i.value);
+    b.value = A.length, w.value = B.length, F.value = _.length, r.value = Array.from(B).concat(A).concat(_), u.value = s.value.length > 0 || i.value.length > 0;
+  }, J = (E, H = !1) => {
+    E && j(), H ? e.state.doLayout() : e.state.debouncedUpdateLayout();
+  }, Q = (E) => T.value ? !!T.value[U(E, l.value)] : N.value.includes(E), le = Y(() => {
+    const E = /* @__PURE__ */ new Map();
+    if (!l.value || !C.value)
+      return E;
+    let H = 0;
+    const I = (A) => {
+      ie(A) && A.forEach((B) => {
+        const _ = U(B, l.value);
+        E.set(_, H), H += 1;
+        const K = z(B);
+        K.length && I(K);
+      });
+    };
+    return I(n.value || []), E;
+  }), Z = (E = {}) => {
+    const { emitChange: H = !0 } = E;
+    if (ue.checkStrictly.value || !l.value) {
+      f.value = {}, W = [];
+      return;
+    }
+    const I = l.value, A = E.rowIndexMap ?? le.value, B = C.value, _ = /* @__PURE__ */ new WeakMap(), K = (me) => {
+      const re = _.get(me);
+      if (re)
+        return re;
+      const Le = U(me, I);
+      return _.set(me, Le), Le;
+    }, ae = {}, oe = [], ee = new Set(N.value.map((me) => K(me))), ce = [];
+    let Ne = !1;
+    const wn = (me, re, Le) => {
+      const Fe = ee.has(re);
+      Le && !Fe ? (ce.push(me), ee.add(re), Ne = !0) : !Le && Fe && (ee.delete(re), Ne = !0);
+    }, ll = (me) => {
+      let re = 0, Le = 0;
+      return ie(me) ? (me.forEach((Fe) => {
+        const ot = K(Fe), nl = z(Fe);
+        let rt = 0, st = 0;
+        if (nl.length) {
+          const Ge = ll(nl);
+          rt = Ge.selectedCount, st = Ge.selectableCount;
+        }
+        const al = B ? B.call(null, Fe, A.get(ot) ?? 0) : !0;
+        if (al && st > 0) {
+          const Ge = rt === st;
+          !Ge && rt !== 0 && (ae[ot] = !0, oe.push(Fe)), wn(Fe, ot, Ge);
+        }
+        al && (Le += 1, ee.has(ot) && (re += 1)), re += rt, Le += st;
+      }), {
+        selectedCount: re,
+        selectableCount: Le
+      }) : {
+        selectedCount: re,
+        selectableCount: Le
+      };
+    };
+    if (ll(n.value || []), Ne) {
+      const me = N.value.filter((re) => ee.has(K(re)));
+      ce.forEach((re) => {
+        ee.has(K(re)) && me.push(re);
+      }), N.value = me;
+    }
+    f.value = ae, W = oe, Ne && H && e.emit("selection-change", N.value ? N.value.slice() : []);
+  }, se = () => {
+    O.value = !1;
+    const E = N.value;
+    N.value = [], f.value = {}, W = [], E.length && e.emit("selection-change", []);
+  }, ge = () => {
+    var H, I;
+    let E;
+    if (l.value) {
+      E = [];
+      const A = (I = (H = e == null ? void 0 : e.store) == null ? void 0 : H.states) == null ? void 0 : I.childrenColumnName.value, B = _e(n.value, l.value, !0, A), { lazyTreeNodeMap: _ } = e.store.states;
+      _.value && Object.entries(_.value).forEach(([K, ae]) => {
+        B[K] && ae.forEach((oe) => {
+          const ee = U(oe, l.value);
+          B[ee] || (B[ee] = {
+            row: oe,
+            index: -1
+          });
+        });
+      });
+      for (const K in T.value)
+        ze(T.value, K) && !B[K] && E.push(T.value[K].row);
+    } else
+      E = N.value.filter((A) => !n.value.includes(A));
+    if (E.length) {
+      const A = N.value.filter((B) => !E.includes(B));
+      N.value = A, Z({ emitChange: !1 }), e.emit("selection-change", [...A]);
+    }
+  }, ve = () => (N.value || []).slice(), Se = () => W.slice(), Te = (E, H, I) => {
+    var ee;
+    if (!l.value || ue.checkStrictly.value || !ue.lazy.value)
+      return;
+    const { lazyTreeNodeMap: A, childrenColumnName: B } = e.store.states, _ = U(E, l.value), K = ((ee = A.value) == null ? void 0 : ee[_]) ?? [], ae = E[B.value] ?? [], oe = {
+      children: B.value,
+      checkStrictly: !1
+    };
+    for (const ce of K) {
+      const Ne = I.get(U(ce, l.value)) ?? 0;
+      Ve(N.value, ce, H, oe, C.value, Ne, l.value), Te(ce, H, I);
+    }
+    for (const ce of ae)
+      Te(ce, H, I);
+  }, nt = (E, H, I = !0, A = !1) => {
+    var _, K, ae, oe;
+    const B = {
+      children: (K = (_ = e == null ? void 0 : e.store) == null ? void 0 : _.states) == null ? void 0 : K.childrenColumnName.value,
+      checkStrictly: (oe = (ae = e == null ? void 0 : e.store) == null ? void 0 : ae.states) == null ? void 0 : oe.checkStrictly.value
+    };
+    if (Ve(N.value, E, H, B, A ? void 0 : C.value, n.value.indexOf(E), l.value)) {
+      ue.lazy.value && !ue.checkStrictly.value ? (Te(E, H ?? Q(E), le.value), Z({
+        emitChange: !1,
+        rowIndexMap: le.value
+      })) : Z({ emitChange: !1 });
+      const ee = (N.value || []).slice();
+      I && e.emit("select", ee, E), e.emit("selection-change", ee);
+    }
+  }, at = () => {
+    var ae, oe;
+    const E = y.value ? !O.value : !(O.value || N.value.length);
+    O.value = E;
+    let H = !1, I = 0;
+    const A = (oe = (ae = e == null ? void 0 : e.store) == null ? void 0 : ae.states) == null ? void 0 : oe.rowKey.value, { childrenColumnName: B } = e.store.states, _ = {
+      children: B.value,
+      checkStrictly: !1
+    };
+    n.value.forEach((ee, ce) => {
+      const Ne = ce + I;
+      Ve(N.value, ee, E, _, C.value, Ne, A) && (H = !0), I += Me(U(ee, A));
+    });
+    const K = le.value;
+    if (ue.lazy.value && !ue.checkStrictly.value && A)
+      for (const ee of Object.values(ue.lazyTreeNodeMap.value))
+        for (const ce of ee) {
+          const Ne = K.get(U(ce, A)) ?? 0;
+          Ve(N.value, ce, E, _, C.value, Ne, A) && (H = !0), Te(ce, E, K);
+        }
+    Z({
+      emitChange: !1,
+      rowIndexMap: K
+    }), H && e.emit("selection-change", N.value ? [...N.value] : []), e.emit("select-all", (N.value || []).slice());
+  }, Ue = () => {
+    var B;
+    if (((B = n.value) == null ? void 0 : B.length) === 0) {
+      O.value = !1;
+      return;
+    }
+    let E = 0, H = 0;
+    const I = (_) => {
+      for (const K of _) {
+        const ae = C.value && C.value.call(null, K, E);
+        if (Q(K))
+          H++;
+        else if (!C.value || ae)
+          return !1;
+        E++;
+        const oe = z(K);
+        if (oe.length && !I(oe))
+          return !1;
+      }
+      return !0;
+    }, A = I(n.value || []);
+    O.value = H === 0 ? !1 : A;
+  }, pe = (E) => {
+    if (!l.value)
+      return !1;
+    const H = U(E, l.value);
+    return !!f.value[H];
+  }, Me = (E) => {
+    var B;
+    if (!e || !e.store)
+      return 0;
+    const { treeData: H } = e.store.states;
+    let I = 0;
+    const A = (B = H.value[E]) == null ? void 0 : B.children;
+    return A && (I += A.length, A.forEach((_) => {
+      I += Me(_);
+    })), I;
+  }, Xe = (E, H) => {
+    const I = {};
+    return Wl(E).forEach((A) => {
+      x.value[A.id] = H, I[A.columnKey || A.id] = H;
+    }), I;
+  }, Qt = (E, H, I) => {
+    k.value && k.value !== E && (k.value.order = null), k.value = E, D.value = H, V.value = I;
+  }, Jt = () => {
+    let E = S(a);
+    Object.keys(x.value).forEach((H) => {
+      const I = x.value[H];
+      if (!I || I.length === 0)
+        return;
+      const A = Yl({ columns: r.value }, H);
+      A && A.filterMethod && (E = E.filter((B) => I.some((_) => A.filterMethod.call(null, _, B, A))));
+    }), R.value = E;
+  }, Zt = () => {
+    n.value = _a(R.value ?? [], {
+      sortingColumn: k.value,
+      sortProp: D.value,
+      sortOrder: V.value
+    });
+  }, ln = (E = void 0) => {
+    E != null && E.filter || Jt(), Zt();
+  }, nn = (E) => {
+    const { tableHeaderRef: H } = e.refs;
+    if (!H)
+      return;
+    const I = Object.assign({}, H.filterPanels), A = Object.keys(I);
+    if (A.length)
+      if (we(E) && (E = [E]), ie(E)) {
+        const B = E.map((_) => Aa({ columns: r.value }, _));
+        A.forEach((_) => {
+          const K = B.find((ae) => ae.id === _);
+          K && (K.filteredValue = []);
+        }), e.store.commit("filterChange", {
+          column: B,
+          values: [],
+          silent: !0,
+          multi: !0
+        });
+      } else
+        A.forEach((B) => {
+          const _ = r.value.find((K) => K.id === B);
+          _ && (_.filteredValue = []);
+        }), x.value = {}, e.store.commit("filterChange", {
+          column: {},
+          values: [],
+          silent: !0
+        });
+  }, an = () => {
+    k.value && (Qt(null, null, null), e.store.commit("changeSortCondition", { silent: !0 }));
+  }, { setExpandRowKeys: on, toggleRowExpansion: el, updateExpandRows: rn, states: sn, isRowExpanded: un } = Pa({
+    data: n,
+    rowKey: l
+  }), { updateTreeExpandKeys: cn, toggleTreeExpansion: dn, updateTreeData: fn, updateKeyChildren: hn, loadOrToggle: gn, states: ue } = ja({
+    data: n,
+    rowKey: l
+  }), { updateCurrentRowData: vn, updateCurrentRow: pn, setCurrentRowKey: mn, states: yn } = Va({
+    data: n,
+    rowKey: l
+  }), Cn = (E) => {
+    on(E), cn(E);
+  }, bn = (E, H) => {
+    r.value.some(({ type: I }) => I === "expand") ? el(E, H) : dn(E, H);
+  };
+  return ne(() => ue.checkStrictly.value, (E) => {
+    E ? (f.value = {}, W = []) : Z({ emitChange: !1 }), Ue();
+  }), ne(() => ue.lazyTreeNodeMap.value, () => {
+    var A;
+    if (!ue.lazy.value || ue.checkStrictly.value || !l.value)
+      return;
+    const E = le.value, H = N.value.length;
+    for (const B of Object.keys(ue.lazyTreeNodeMap.value))
+      (A = T.value) != null && A[B] && Te(T.value[B].row, !0, E);
+    const I = N.value.length !== H;
+    Z({
+      emitChange: !I,
+      rowIndexMap: E
+    }), Ue(), I && e.emit("selection-change", [...N.value]);
+  }), {
+    assertRowKey: $,
+    updateColumns: j,
+    scheduleLayout: J,
+    isSelected: Q,
+    clearSelection: se,
+    cleanSelection: ge,
+    getSelectionRows: ve,
+    getHalfSelectionRows: Se,
+    toggleRowSelection: nt,
+    _toggleAllSelection: at,
+    toggleAllSelection: null,
+    updateAllSelected: Ue,
+    updateSelectionByChildren: Z,
+    getRowIndeterminate: pe,
+    updateFilters: Xe,
+    updateCurrentRow: pn,
+    updateSort: Qt,
+    execFilter: Jt,
+    execSort: Zt,
+    execQuery: ln,
+    clearFilter: nn,
+    clearSort: an,
+    toggleRowExpansion: el,
+    setExpandRowKeysAdapter: Cn,
+    setCurrentRowKey: mn,
+    toggleRowExpansionAdapter: bn,
+    isRowExpanded: un,
+    updateExpandRows: rn,
+    updateCurrentRowData: vn,
+    loadOrToggle: gn,
+    updateTreeData: fn,
+    updateKeyChildren: hn,
+    states: {
+      tableSize: t,
+      rowKey: l,
+      data: n,
+      _data: a,
+      isComplex: u,
+      _columns: c,
+      originColumns: o,
+      columns: r,
+      fixedColumns: s,
+      rightFixedColumns: i,
+      leafColumns: d,
+      fixedLeafColumns: p,
+      rightFixedLeafColumns: h,
+      updateOrderFns: v,
+      leafColumnsLength: b,
+      fixedLeafColumnsLength: w,
+      rightFixedLeafColumnsLength: F,
+      isAllSelected: O,
+      selection: N,
+      selectionIndeterminate: f,
+      reserveSelection: g,
+      selectOnIndeterminate: y,
+      selectable: C,
+      rowExpandable: m,
+      filters: x,
+      filteredData: R,
+      sortingColumn: k,
+      sortProp: D,
+      sortOrder: V,
+      hoverRow: X,
+      ...sn,
+      ...ue,
+      ...yn
+    }
+  };
+}
+function zt(e, t) {
+  return e.map((l) => {
+    var n;
+    return l.id === t.id ? t : ((n = l.children) != null && n.length && (l.children = zt(l.children, t)), l);
+  });
+}
+function Kt(e) {
+  e.forEach((t) => {
+    var l, n;
+    t.no = (l = t.getColumnIndex) == null ? void 0 : l.call(t), (n = t.children) != null && n.length && Kt(t.children);
+  }), e.sort((t, l) => t.no - l.no);
+}
+function qa() {
+  const e = he(), t = Ya(), l = Ee("table"), { t: n } = Ct();
+  return {
+    ns: l,
+    t: n,
+    ...t,
+    mutations: {
+      setData(o, r) {
+        const s = S(o._data) !== r;
+        o.data.value = r, o._data.value = r, e.store.execQuery(), e.store.updateCurrentRowData(), e.store.updateExpandRows(), e.store.updateTreeData(e.store.states.defaultExpandAll.value), S(o.reserveSelection) ? e.store.assertRowKey() : s ? e.store.clearSelection() : e.store.cleanSelection(), e.store.updateSelectionByChildren({ emitChange: !1 }), e.store.updateAllSelected(), e.$ready && e.store.scheduleLayout();
+      },
+      insertColumn(o, r, s, i) {
+        var h;
+        const d = S(o._columns);
+        let p = [];
+        s ? (s && !s.children && (s.children = []), (h = s.children) == null || h.push(r), p = zt(d, s)) : (d.push(r), p = d), Kt(p), o._columns.value = p, o.updateOrderFns.push(i), r.type === "selection" && (o.selectable.value = r.selectable, o.reserveSelection.value = r.reserveSelection), e.$ready && (e.store.updateColumns(), e.store.scheduleLayout());
+      },
+      updateColumnOrder(o, r) {
+        var s;
+        ((s = r.getColumnIndex) == null ? void 0 : s.call(r)) !== r.no && (Kt(o._columns.value), e.$ready && e.store.updateColumns());
+      },
+      removeColumn(o, r, s, i) {
+        var h;
+        const d = S(o._columns) || [];
+        if (s)
+          (h = s.children) == null || h.splice(s.children.findIndex((v) => v.id === r.id), 1), Ye(() => {
+            var v;
+            ((v = s.children) == null ? void 0 : v.length) === 0 && delete s.children;
+          }), o._columns.value = zt(d, s);
+        else {
+          const v = d.indexOf(r);
+          v > -1 && (d.splice(v, 1), o._columns.value = d);
+        }
+        const p = o.updateOrderFns.indexOf(i);
+        p > -1 && o.updateOrderFns.splice(p, 1), e.$ready && (e.store.updateColumns(), e.store.scheduleLayout());
+      },
+      sort(o, r) {
+        const { prop: s, order: i, init: d } = r;
+        if (s) {
+          const p = S(o.columns).find((h) => h.property === s);
+          p && (p.order = i, e.store.updateSort(p, s, i), e.store.commit("changeSortCondition", { init: d }));
+        }
+      },
+      changeSortCondition(o, r) {
+        const { sortingColumn: s, sortProp: i, sortOrder: d } = o, p = S(s), h = S(i), v = S(d);
+        wt(v) && (o.sortingColumn.value = null, o.sortProp.value = null), e.store.execQuery({ filter: !0 }), (!r || !(r.silent || r.init)) && e.emit("sort-change", {
+          column: p,
+          prop: h,
+          order: v
+        }), e.store.updateTableScrollY();
+      },
+      filterChange(o, r) {
+        const { column: s, values: i, silent: d } = r, p = e.store.updateFilters(s, i);
+        e.store.execQuery(), d || e.emit("filter-change", p), e.store.updateTableScrollY();
+      },
+      toggleAllSelection() {
+        var o, r;
+        (r = (o = e.store).toggleAllSelection) == null || r.call(o);
+      },
+      rowSelectedChanged(o, r) {
+        e.store.toggleRowSelection(r), e.store.updateAllSelected();
+      },
+      setHoverRow(o, r) {
+        o.hoverRow.value = r;
+      },
+      setCurrentRow(o, r) {
+        e.store.updateCurrentRow(r);
+      }
+    },
+    commit: function(o, ...r) {
+      const s = e.store.mutations;
+      if (s[o])
+        s[o].apply(e, [e.store.states, ...r]);
+      else
+        throw new Error(`Action not found: ${o}`);
+    },
+    updateTableScrollY: function() {
+      Ye(() => e.layout.updateScrollY.apply(e.layout));
+    }
+  };
+}
+const Xt = {
+  rowKey: "rowKey",
+  defaultExpandAll: "defaultExpandAll",
+  rowExpandable: "rowExpandable",
+  selectOnIndeterminate: "selectOnIndeterminate",
+  indent: "indent",
+  lazy: "lazy",
+  "treeProps.hasChildren": {
+    key: "lazyColumnIdentifier",
+    default: "hasChildren"
+  },
+  "treeProps.children": {
+    key: "childrenColumnName",
+    default: "children"
+  },
+  "treeProps.checkStrictly": {
+    key: "checkStrictly",
+    default: !1
+  }
+};
+function Ua(e, t) {
+  if (!e)
+    throw new Error("Table is required.");
+  const l = qa();
+  return l.toggleAllSelection = mt(l._toggleAllSelection, 10), Object.keys(Xt).forEach((n) => {
+    Ql(Jl(t, n), n, l);
+  }), Xa(l, t), l;
+}
+function Xa(e, t) {
+  Object.keys(Xt).forEach((l) => {
+    ne(() => Jl(t, l), (n) => {
+      Ql(n, l, e);
+    });
+  });
+}
+function Ql(e, t, l) {
+  let n = e, a = Xt[t];
+  vt(a) && (n = n || a.default, a = a.key), l.states[a].value = n;
+}
+function Jl(e, t) {
+  if (t.includes(".")) {
+    const l = t.split(".");
+    let n = e;
+    return l.forEach((a) => {
+      n = n[a];
+    }), n;
+  } else
+    return e[t];
+}
+var Ga = class {
+  constructor(e) {
+    this.observers = [], this.table = null, this.store = null, this.columns = [], this.fit = !0, this.showHeader = !0, this.heightMap = {}, this.height = L(null), this.scrollX = L(!1), this.scrollY = L(!1), this.bodyWidth = L(null), this.fixedWidth = L(null), this.rightFixedWidth = L(null), this.gutterWidth = 0;
+    for (const t in e)
+      ze(e, t) && (Vn(this[t]) ? this[t].value = e[t] : this[t] = e[t]);
+    if (!this.table)
+      throw new Error("Table is required for Table Layout");
+    if (!this.store)
+      throw new Error("Store is required for Table Layout");
+  }
+  updateScrollY() {
+    const e = this.height.value;
+    if (wt(e))
+      return !1;
+    const t = this.table.refs.scrollBarRef;
+    if (this.table.vnode.el && (t != null && t.wrapRef)) {
+      let l = !0;
+      const n = this.scrollY.value;
+      return l = t.wrapRef.scrollHeight > t.wrapRef.clientHeight, this.scrollY.value = l, n !== l;
+    }
+    return !1;
+  }
+  setHeight(e, t = "height") {
+    if (!Ze)
+      return;
+    const l = this.table.vnode.el;
+    if (e = Ia(e), this.height.value = Number(e), this.heightMap[t] = e, !l && (e || e === 0)) {
+      Ye(() => {
+        this.heightMap[t] === e && this.setHeight(e, t);
+      });
+      return;
+    }
+    l && je(e) ? (l.style[t] = `${e}px`, this.updateElsHeight()) : l && we(e) && (l.style[t] = e, this.updateElsHeight());
+  }
+  setMaxHeight(e) {
+    this.setHeight(e, "max-height");
+  }
+  getFlattenColumns() {
+    const e = [];
+    return this.table.store.states.columns.value.forEach((t) => {
+      t.isColumnGroup ? e.push.apply(e, t.columns) : e.push(t);
+    }), e;
+  }
+  updateElsHeight() {
+    this.updateScrollY(), this.notifyObservers("scrollable");
+  }
+  headerDisplayNone(e) {
+    if (!e)
+      return !0;
+    let t = e;
+    for (; t.tagName !== "DIV"; ) {
+      if (getComputedStyle(t).display === "none")
+        return !0;
+      t = t.parentElement;
+    }
+    return !1;
+  }
+  updateColumnsWidth() {
+    var o;
+    if (!Ze)
+      return;
+    const e = this.fit, t = (o = this.table.vnode.el) == null ? void 0 : o.clientWidth;
+    let l = 0;
+    const n = this.getFlattenColumns(), a = n.filter((r) => !je(r.width));
+    if (n.forEach((r) => {
+      je(r.width) && r.realWidth && (r.realWidth = null);
+    }), a.length > 0 && e) {
+      if (n.forEach((r) => {
+        l += Number(r.width || r.minWidth || 80);
+      }), l <= t) {
+        this.scrollX.value = !1;
+        const r = t - l;
+        if (a.length === 1)
+          a[0].realWidth = Number(a[0].minWidth || 80) + r;
+        else {
+          const s = r / a.reduce((d, p) => d + Number(p.minWidth || 80), 0);
+          let i = 0;
+          a.forEach((d, p) => {
+            if (p === 0)
+              return;
+            const h = Math.floor(Number(d.minWidth || 80) * s);
+            i += h, d.realWidth = Number(d.minWidth || 80) + h;
+          }), a[0].realWidth = Number(a[0].minWidth || 80) + r - i;
+        }
+      } else
+        this.scrollX.value = !0, a.forEach((r) => {
+          r.realWidth = Number(r.minWidth);
+        });
+      this.bodyWidth.value = Math.max(l, t), this.table.state.resizeState.value.width = this.bodyWidth.value;
+    } else
+      n.forEach((r) => {
+        !r.width && !r.minWidth ? r.realWidth = 80 : r.realWidth = Number(r.width || r.minWidth), l += r.realWidth;
+      }), this.scrollX.value = l > t, this.bodyWidth.value = l;
+    const u = this.store.states.fixedColumns.value;
+    if (u.length > 0) {
+      let r = 0;
+      u.forEach((s) => {
+        r += Number(s.realWidth || s.width);
+      }), this.fixedWidth.value = r;
+    }
+    const c = this.store.states.rightFixedColumns.value;
+    if (c.length > 0) {
+      let r = 0;
+      c.forEach((s) => {
+        r += Number(s.realWidth || s.width);
+      }), this.rightFixedWidth.value = r;
+    }
+    this.notifyObservers("columns");
+  }
+  addObserver(e) {
+    this.observers.push(e);
+  }
+  removeObserver(e) {
+    const t = this.observers.indexOf(e);
+    t !== -1 && this.observers.splice(t, 1);
+  }
+  notifyObservers(e) {
+    this.observers.forEach((t) => {
+      var l, n;
+      switch (e) {
+        case "columns":
+          (l = t.state) == null || l.onColumnsChange(this);
+          break;
+        case "scrollable":
+          (n = t.state) == null || n.onScrollableChange(this);
+          break;
+        default:
+          throw new Error(`Table Layout don't have event ${e}.`);
+      }
+    });
+  }
+};
+const Re = Symbol("ElTable"), Zl = (e) => {
+  const t = [];
+  return e.forEach((l) => {
+    l.children ? (t.push(l), t.push.apply(t, Zl(l.children))) : t.push(l);
+  }), t;
+}, en = (e) => {
+  let t = 1;
+  const l = (a, u) => {
+    if (u && (a.level = u.level + 1, t < a.level && (t = a.level)), a.children) {
+      let c = 0;
+      a.children.forEach((o) => {
+        l(o, a), c += o.colSpan;
+      }), a.colSpan = c;
+    } else
+      a.colSpan = 1;
+  };
+  e.forEach((a) => {
+    a.level = 1, l(a, void 0);
+  });
+  const n = [];
+  for (let a = 0; a < t; a++)
+    n.push([]);
+  return Zl(e).forEach((a) => {
+    a.children ? (a.rowSpan = 1, a.children.forEach((u) => u.isSubColumn = !0)) : a.rowSpan = t - a.level + 1, n[a.level - 1].push(a);
+  }), n;
+};
+function Qa(e) {
+  const t = Oe(Re), l = Y(() => en(e.store.states.originColumns.value));
+  return {
+    isGroup: Y(() => {
+      const u = l.value.length > 1;
+      return u && t && (t.state.isGroup.value = !0), u;
+    }),
+    toggleAllSelection: (u) => {
+      u.stopPropagation(), t == null || t.store.commit("toggleAllSelection");
+    },
+    columnRows: l
+  };
+}
+var Ja = De({
+  name: "ElTableFilterPanel",
+  components: {
+    ElCheckbox: yt,
+    ElCheckboxGroup: aa,
+    ElScrollbar: Rl,
+    ElTooltip: Ll,
+    ElIcon: _t,
+    ArrowDown: oa,
+    ArrowUp: ra
+  },
+  props: {
+    placement: {
+      type: String,
+      default: "bottom-start"
+    },
+    store: { type: Object },
+    column: { type: Object },
+    upDataColumn: { type: Function },
+    appendTo: Kn.appendTo
+  },
+  setup(e) {
+    const t = he(), { t: l } = Ct(), n = Ee("table-filter"), a = t == null ? void 0 : t.parent;
+    e.column && !a.filterPanels.value[e.column.id] && (a.filterPanels.value[e.column.id] = t);
+    const u = L(null), c = L(null), o = L(0), r = Y(() => e.column && e.column.filters), s = Y(() => e.column && e.column.filterClassName ? `${n.b()} ${e.column.filterClassName}` : n.b()), i = Y({
+      get: () => {
+        var C;
+        return (((C = e.column) == null ? void 0 : C.filteredValue) || [])[0];
+      },
+      set: (C) => {
+        var m;
+        if (e.column) {
+          const x = [...e.column.filteredValue ?? []];
+          Je(C) ? x.splice(0, 1) : x.splice(0, 1, C), (m = e.upDataColumn) == null || m.call(e, "filteredValue", x);
+        }
+      }
+    }), d = Y({
+      get() {
+        return e.column ? e.column.filteredValue || [] : [];
+      },
+      set(C) {
+        var m;
+        e.column && ((m = e.upDataColumn) == null || m.call(e, "filteredValue", C));
+      }
+    }), p = Y(() => e.column ? e.column.filterMultiple : !0), h = (C) => C.value === i.value, v = () => {
+      var C;
+      (C = u.value) == null || C.onClose();
+    }, b = () => {
+      O(d.value), v();
+    }, w = () => {
+      d.value = [], O(d.value), v();
+    }, F = (C, m) => {
+      i.value = C, o.value = m, Je(C) ? O([]) : O(d.value), v();
+    }, O = (C) => {
+      var m, x;
+      (m = e.store) == null || m.commit("filterChange", {
+        column: e.column,
+        values: C
+      }), (x = e.store) == null || x.updateAllSelected();
+    }, N = () => {
+      var C, m;
+      (C = c.value) == null || C.focus(), !p.value && g(), e.column && ((m = e.upDataColumn) == null || m.call(e, "filterOpened", !0));
+    }, f = () => {
+      var C;
+      e.column && ((C = e.upDataColumn) == null || C.call(e, "filterOpened", !1));
+    }, g = () => {
+      if (Je(i)) {
+        o.value = 0;
+        return;
+      }
+      const C = (r.value || []).findIndex((m) => m.value === i.value);
+      o.value = C >= 0 ? C + 1 : 0;
+    };
+    return {
+      multiple: p,
+      filterClassName: s,
+      filteredValue: d,
+      filterValue: i,
+      filters: r,
+      handleConfirm: b,
+      handleReset: w,
+      handleSelect: F,
+      isPropAbsent: Je,
+      isActive: h,
+      t: l,
+      ns: n,
+      tooltipRef: u,
+      rootRef: c,
+      checkedIndex: o,
+      handleShowTooltip: N,
+      handleHideTooltip: f,
+      handleKeydown: (C) => {
+        var D, V;
+        const m = Bn(C), x = (r.value ? r.value.length : 0) + 1;
+        let R = o.value, k = !0;
+        switch (m) {
+          case We.down:
+          case We.right:
+            R = (R + 1) % x;
+            break;
+          case We.up:
+          case We.left:
+            R = (R - 1 + x) % x;
+            break;
+          case We.tab:
+            v(), k = !1;
+            break;
+          case We.enter:
+          case We.space:
+            if (R === 0)
+              F(null, 0);
+            else {
+              const X = (r.value || [])[R - 1];
+              X.value && F(X.value, R);
+            }
+            break;
+          default:
+            k = !1;
+            break;
+        }
+        k && C.preventDefault(), o.value = R, (V = (D = c.value) == null ? void 0 : D.querySelector(`.${n.e("list-item")}:nth-child(${R + 1})`)) == null || V.focus();
+      }
+    };
+  }
+});
+const Za = ["disabled"], eo = ["tabindex", "aria-checked"], to = [
+  "tabindex",
+  "aria-checked",
+  "onClick"
+], lo = ["aria-label"];
+function no(e, t, l, n, a, u) {
+  const c = ke("el-checkbox"), o = ke("el-checkbox-group"), r = ke("el-scrollbar"), s = ke("arrow-up"), i = ke("arrow-down"), d = ke("el-icon"), p = ke("el-tooltip");
+  return te(), Ke(p, {
+    ref: "tooltipRef",
+    offset: 0,
+    placement: e.placement,
+    "show-arrow": !1,
+    trigger: "click",
+    role: "dialog",
+    teleported: "",
+    effect: "light",
+    pure: "",
+    loop: "",
+    "popper-class": e.filterClassName,
+    persistent: "",
+    "append-to": e.appendTo,
+    onShow: e.handleShowTooltip,
+    onHide: e.handleHideTooltip
+  }, {
+    content: Ae(() => [e.multiple ? (te(), ye("div", {
+      key: 0,
+      ref: "rootRef",
+      tabindex: "-1",
+      class: G(e.ns.e("multiple"))
+    }, [fe("div", { class: G(e.ns.e("content")) }, [xe(r, { "wrap-class": e.ns.e("wrap") }, {
+      default: Ae(() => [xe(o, {
+        modelValue: e.filteredValue,
+        "onUpdate:modelValue": t[0] || (t[0] = (h) => e.filteredValue = h),
+        class: G(e.ns.e("checkbox-group"))
+      }, {
+        default: Ae(() => [(te(!0), ye(tt, null, cl(e.filters, (h) => (te(), Ke(c, {
+          key: h.value,
+          value: h.value
+        }, {
+          default: Ae(() => [Pt(Pe(h.text), 1)]),
+          _: 2
+        }, 1032, ["value"]))), 128))]),
+        _: 1
+      }, 8, ["modelValue", "class"])]),
+      _: 1
+    }, 8, ["wrap-class"])], 2), fe("div", { class: G(e.ns.e("bottom")) }, [fe("button", {
+      class: G(e.ns.is("disabled", e.filteredValue.length === 0)),
+      disabled: e.filteredValue.length === 0,
+      type: "button",
+      onClick: t[1] || (t[1] = (...h) => e.handleConfirm && e.handleConfirm(...h))
+    }, Pe(e.t("el.table.confirmFilter")), 11, Za), fe("button", {
+      type: "button",
+      onClick: t[2] || (t[2] = (...h) => e.handleReset && e.handleReset(...h))
+    }, Pe(e.t("el.table.resetFilter")), 1)], 2)], 2)) : (te(), ye("ul", {
+      key: 1,
+      ref: "rootRef",
+      tabindex: "-1",
+      role: "radiogroup",
+      class: G(e.ns.e("list")),
+      onKeydown: t[4] || (t[4] = (...h) => e.handleKeydown && e.handleKeydown(...h))
+    }, [fe("li", {
+      role: "radio",
+      class: G([e.ns.e("list-item"), e.ns.is("active", e.isPropAbsent(e.filterValue))]),
+      tabindex: e.checkedIndex === 0 ? 0 : -1,
+      "aria-checked": e.isPropAbsent(e.filterValue),
+      onClick: t[3] || (t[3] = (h) => e.handleSelect(null, 0))
+    }, Pe(e.t("el.table.clearFilter")), 11, eo), (te(!0), ye(tt, null, cl(e.filters, (h, v) => (te(), ye("li", {
+      key: h.value,
+      role: "radio",
+      class: G([e.ns.e("list-item"), e.ns.is("active", e.isActive(h))]),
+      tabindex: e.checkedIndex === v + 1 ? 0 : -1,
+      "aria-checked": e.isActive(h),
+      onClick: (b) => e.handleSelect(h.value, v + 1)
+    }, Pe(h.text), 11, to))), 128))], 34))]),
+    default: Ae(() => {
+      var h;
+      return [fe("button", {
+        type: "button",
+        class: G(`${e.ns.namespace.value}-table__column-filter-trigger`),
+        "aria-label": e.t("el.table.filterLabel", { column: ((h = e.column) == null ? void 0 : h.label) || "" })
+      }, [xe(d, null, {
+        default: Ae(() => [Be(e.$slots, "filter-icon", {}, () => {
+          var v;
+          return [(v = e.column) != null && v.filterOpened ? (te(), Ke(s, { key: 0 })) : (te(), Ke(i, { key: 1 }))];
+        })]),
+        _: 3
+      })], 10, lo)];
+    }),
+    _: 3
+  }, 8, [
+    "placement",
+    "popper-class",
+    "append-to",
+    "onShow",
+    "onHide"
+  ]);
+}
+var ao = /* @__PURE__ */ Dn(Ja, [["render", no]]);
+function Gt(e) {
+  const t = he();
+  Fl(() => {
+    l.value.addObserver(t);
+  }), lt(() => {
+    n(l.value), a(l.value);
+  }), jn(() => {
+    n(l.value), a(l.value);
+  }), Vt(() => {
+    l.value.removeObserver(t);
+  });
+  const l = Y(() => {
+    const u = e.layout;
+    if (!u)
+      throw new Error("Can not find table layout.");
+    return u;
+  }), n = (u) => {
+    var s;
+    const c = ((s = e.vnode.el) == null ? void 0 : s.querySelectorAll("colgroup > col")) || [];
+    if (!c.length)
+      return;
+    const o = u.getFlattenColumns(), r = {};
+    o.forEach((i) => {
+      r[i.id] = i;
+    });
+    for (let i = 0, d = c.length; i < d; i++) {
+      const p = c[i], h = r[p.getAttribute("name")];
+      h && p.setAttribute("width", h.realWidth || h.width);
+    }
+  }, a = (u) => {
+    var r, s;
+    const c = ((r = e.vnode.el) == null ? void 0 : r.querySelectorAll("colgroup > col[name=gutter]")) || [];
+    for (let i = 0, d = c.length; i < d; i++)
+      c[i].setAttribute("width", u.scrollY.value ? u.gutterWidth : "0");
+    const o = ((s = e.vnode.el) == null ? void 0 : s.querySelectorAll("th.gutter")) || [];
+    for (let i = 0, d = o.length; i < d; i++) {
+      const p = o[i];
+      p.style.width = u.scrollY.value ? `${u.gutterWidth}px` : "0", p.style.display = u.scrollY.value ? "" : "none";
+    }
+  };
+  return {
+    tableLayout: l.value,
+    onColumnsChange: n,
+    onScrollableChange: a
+  };
+}
+function oo(e, t) {
+  const l = he(), n = Oe(Re), a = (b) => {
+    b.stopPropagation();
+  }, u = (b, w) => {
+    !w.filters && w.sortable ? v(b, w, !1) : w.filterable && !w.sortable && a(b), n == null || n.emit("header-click", w, b);
+  }, c = (b, w) => {
+    n == null || n.emit("header-contextmenu", w, b);
+  }, o = L(null), r = L(!1), s = L(), i = (b, w) => {
+    var F, O, N;
+    if (Ze && !(w.children && w.children.length > 0) && o.value && e.border && o.value.id === w.id) {
+      r.value = !0;
+      const f = n;
+      t("set-drag-visible", !0);
+      const g = (F = f == null ? void 0 : f.vnode.el) == null ? void 0 : F.getBoundingClientRect().left, y = (N = (O = l == null ? void 0 : l.vnode) == null ? void 0 : O.el) == null ? void 0 : N.querySelector(`th.${w.id}`), C = y.getBoundingClientRect(), m = C.left - g + 30;
+      pt(y, "noclick"), s.value = {
+        startMouseLeft: b.clientX,
+        startLeft: C.right - g,
+        startColumnLeft: C.left - g,
+        tableLeft: g
+      };
+      const x = f == null ? void 0 : f.refs.resizeProxy;
+      x.style.left = `${s.value.startLeft}px`, document.onselectstart = function() {
+        return !1;
+      }, document.ondragstart = function() {
+        return !1;
+      };
+      const R = (D) => {
+        const V = D.clientX - s.value.startMouseLeft, X = s.value.startLeft + V;
+        x.style.left = `${Math.max(m, X)}px`;
+      }, k = () => {
+        if (r.value) {
+          const { startColumnLeft: D, startLeft: V } = s.value;
+          w.width = w.realWidth = Number.parseInt(x.style.left, 10) - D, f == null || f.emit("header-dragend", w.width, V - D, w, b), requestAnimationFrame(() => {
+            e.store.scheduleLayout(!1, !0);
+          }), document.body.style.cursor = "", r.value = !1, o.value = null, s.value = void 0, t("set-drag-visible", !1);
+        }
+        document.removeEventListener("mousemove", R), document.removeEventListener("mouseup", k), document.onselectstart = null, document.ondragstart = null, setTimeout(() => {
+          et(y, "noclick");
+        }, 0);
+      };
+      document.addEventListener("mousemove", R), document.addEventListener("mouseup", k);
+    }
+  }, d = (b, w) => {
+    var x;
+    if (!e.border || w.children && w.children.length > 0)
+      return;
+    const F = b.target, O = Ln(F) ? F.closest("th") : null;
+    if (!O)
+      return;
+    const N = ut(O, "is-sortable");
+    if (N) {
+      const R = r.value ? "col-resize" : "";
+      O.style.cursor = R;
+      const k = O.querySelector(".caret-wrapper");
+      k && (k.style.cursor = R);
+    }
+    if (!w.resizable || r.value) {
+      o.value = null;
+      return;
+    }
+    const f = O.getBoundingClientRect(), g = ((x = O.parentNode) == null ? void 0 : x.lastElementChild) === O, y = e.allowDragLastColumn || !g, C = f.width > 12 && f.right - b.clientX < 8 && y, m = C ? "col-resize" : "";
+    document.body.style.cursor = m, o.value = C ? w : null, N && (O.style.cursor = m);
+  }, p = () => {
+    !Ze || r.value || (document.body.style.cursor = "");
+  }, h = ({ order: b, sortOrders: w }) => {
+    if (b === "")
+      return w[0];
+    const F = w.indexOf(b || null);
+    return w[F > w.length - 2 ? 0 : F + 1];
+  }, v = (b, w, F) => {
+    var x;
+    b.stopPropagation();
+    const O = w.order === F ? null : F || h(w), N = (x = b.target) == null ? void 0 : x.closest("th");
+    if (N && ut(N, "noclick")) {
+      et(N, "noclick");
+      return;
+    }
+    if (!w.sortable)
+      return;
+    const f = b.currentTarget;
+    if (["ascending", "descending"].some((R) => ut(f, R) && !w.sortOrders.includes(R)))
+      return;
+    const g = e.store.states;
+    let y = g.sortProp.value, C;
+    const m = g.sortingColumn.value;
+    (m !== w || m === w && wt(m.order)) && (m && (m.order = null), g.sortingColumn.value = w, y = w.property ?? null), O ? C = w.order = O : C = w.order = null, g.sortProp.value = y, g.sortOrder.value = C, n == null || n.store.commit("changeSortCondition");
+  };
+  return {
+    handleHeaderClick: u,
+    handleHeaderContextMenu: c,
+    handleMouseDown: i,
+    handleMouseMove: d,
+    handleMouseOut: p,
+    handleSortClick: v,
+    handleFilterClick: a
+  };
+}
+function ro(e) {
+  const t = Oe(Re), l = Ee("table");
+  return {
+    getHeaderRowStyle: (o) => {
+      const r = t == null ? void 0 : t.props.headerRowStyle;
+      return Ce(r) ? r.call(null, { rowIndex: o }) : r;
+    },
+    getHeaderRowClass: (o) => {
+      const r = [], s = t == null ? void 0 : t.props.headerRowClassName;
+      return we(s) ? r.push(s) : Ce(s) && r.push(s.call(null, { rowIndex: o })), r.join(" ");
+    },
+    getHeaderCellStyle: (o, r, s, i) => {
+      let d = (t == null ? void 0 : t.props.headerCellStyle) ?? {};
+      Ce(d) && (d = d.call(null, {
+        rowIndex: o,
+        columnIndex: r,
+        row: s,
+        column: i
+      }));
+      const p = Ut(r, i.fixed, e.store, s);
+      return qe(p, "left"), qe(p, "right"), Object.assign({}, d, p);
+    },
+    getHeaderCellClass: (o, r, s, i) => {
+      const d = qt(l.b(), r, i.fixed, e.store, s), p = [
+        i.id,
+        i.order,
+        i.headerAlign,
+        i.className,
+        i.labelClassName,
+        ...d
+      ];
+      i.children || p.push("is-leaf"), i.sortable && p.push("is-sortable");
+      const h = t == null ? void 0 : t.props.headerCellClassName;
+      return we(h) ? p.push(h) : Ce(h) && p.push(h.call(null, {
+        rowIndex: o,
+        columnIndex: r,
+        row: s,
+        column: i
+      })), p.push(l.e("cell")), p.filter((v) => !!v).join(" ");
+    }
+  };
+}
+var wl = De({
+  name: "ElTableHeader",
+  components: { ElCheckbox: yt },
+  props: {
+    fixed: {
+      type: String,
+      default: ""
+    },
+    store: {
+      required: !0,
+      type: Object
+    },
+    border: Boolean,
+    defaultSort: {
+      type: Object,
+      default: () => ({
+        prop: "",
+        order: ""
+      })
+    },
+    appendFilterPanelTo: { type: String },
+    allowDragLastColumn: { type: Boolean }
+  },
+  setup(e, { emit: t }) {
+    const l = he(), n = Oe(Re), a = Ee("table"), u = L({}), { onColumnsChange: c, onScrollableChange: o } = Gt(n), r = (n == null ? void 0 : n.props.tableLayout) === "auto", s = _n(/* @__PURE__ */ new Map()), i = L();
+    let d;
+    const p = () => {
+      d && (clearTimeout(d), d = void 0), d = setTimeout(() => {
+        d = void 0;
+        const D = i.value;
+        D && s.size > 0 && (s.forEach((V, X) => {
+          const W = D.querySelector(`.${X.replace(/\s/g, ".")}`);
+          W && (V.width = W.getBoundingClientRect().width || V.width);
+        }), s.clear());
+      });
+    };
+    ne(s, p), jt(() => {
+      d && (clearTimeout(d), d = void 0);
+    }), lt(async () => {
+      await Ye(), await Ye();
+      const { prop: D, order: V } = e.defaultSort;
+      n == null || n.store.commit("sort", {
+        prop: D,
+        order: V,
+        init: !0
+      }), p();
+    });
+    const { handleHeaderClick: h, handleHeaderContextMenu: v, handleMouseDown: b, handleMouseMove: w, handleMouseOut: F, handleSortClick: O, handleFilterClick: N } = oo(e, t), { getHeaderRowStyle: f, getHeaderRowClass: g, getHeaderCellStyle: y, getHeaderCellClass: C } = ro(e), { isGroup: m, toggleAllSelection: x, columnRows: R } = Qa(e), { t: k } = Ct();
+    return l.state = {
+      onColumnsChange: c,
+      onScrollableChange: o
+    }, l.filterPanels = u, {
+      ns: a,
+      t: k,
+      filterPanels: u,
+      onColumnsChange: c,
+      onScrollableChange: o,
+      columnRows: R,
+      getHeaderRowClass: g,
+      getHeaderRowStyle: f,
+      getHeaderCellClass: C,
+      getHeaderCellStyle: y,
+      handleHeaderClick: h,
+      handleHeaderContextMenu: v,
+      handleMouseDown: b,
+      handleMouseMove: w,
+      handleMouseOut: F,
+      handleSortClick: O,
+      handleFilterClick: N,
+      isGroup: m,
+      toggleAllSelection: x,
+      saveIndexSelection: s,
+      isTableLayoutAuto: r,
+      theadRef: i,
+      updateFixedColumnStyle: p
+    };
+  },
+  render() {
+    const { ns: e, t, isGroup: l, columnRows: n, getHeaderCellStyle: a, getHeaderCellClass: u, getHeaderRowClass: c, getHeaderRowStyle: o, handleHeaderClick: r, handleHeaderContextMenu: s, handleMouseDown: i, handleMouseMove: d, handleSortClick: p, handleMouseOut: h, store: v, $parent: b, saveIndexSelection: w, isTableLayoutAuto: F } = this;
+    let O = 1;
+    return P("thead", {
+      ref: "theadRef",
+      class: e.is("group", l)
+    }, n.map((N, f) => P("tr", {
+      class: c(f),
+      key: f,
+      style: o(f)
+    }, N.map((g, y) => {
+      g.rowSpan > O && (O = g.rowSpan);
+      const C = u(f, y, N, g);
+      return F && g.fixed && w.set(C, g), P("th", {
+        class: C,
+        colspan: g.colSpan,
+        key: `${g.id}-thead`,
+        rowspan: g.rowSpan,
+        scope: g.colSpan > 1 ? "colgroup" : "col",
+        ariaSort: g.sortable ? g.order : void 0,
+        style: a(f, y, N, g),
+        onClick: (m) => {
+          var x;
+          (x = m.currentTarget) != null && x.classList.contains("noclick") || r(m, g);
+        },
+        onContextmenu: (m) => s(m, g),
+        onMousedown: (m) => i(m, g),
+        onMousemove: (m) => d(m, g),
+        onMouseout: h
+      }, [P("div", { class: ["cell", g.filteredValue && g.filteredValue.length > 0 ? "highlight" : ""] }, [
+        g.renderHeader ? g.renderHeader({
+          column: g,
+          $index: y,
+          store: v,
+          _self: b
+        }) : g.label,
+        g.sortable && P("button", {
+          type: "button",
+          class: "caret-wrapper",
+          "aria-label": t("el.table.sortLabel", { column: g.label || "" }),
+          onClick: (m) => p(m, g)
+        }, [P("i", {
+          onClick: (m) => p(m, g, "ascending"),
+          class: "sort-caret ascending"
+        }), P("i", {
+          onClick: (m) => p(m, g, "descending"),
+          class: "sort-caret descending"
+        })]),
+        g.filterable && P(ao, {
+          store: v,
+          placement: g.filterPlacement || "bottom-start",
+          appendTo: b == null ? void 0 : b.appendFilterPanelTo,
+          column: g,
+          upDataColumn: (m, x) => {
+            g[m] = x;
+          }
+        }, { "filter-icon": () => g.renderFilterIcon ? g.renderFilterIcon({ filterOpened: g.filterOpened }) : null })
+      ])]);
+    }))));
+  }
+});
+function so(e) {
+  const t = Oe(Re), l = L(""), n = L(P("div")), a = (v, b, w) => {
+    var g, y;
+    const F = t, O = Et(v);
+    let N = null;
+    const f = (g = F == null ? void 0 : F.vnode.el) == null ? void 0 : g.dataset.prefix;
+    O && (N = yl({ columns: ((y = e.store) == null ? void 0 : y.states.columns.value) ?? [] }, O, f), N && (F == null || F.emit(`cell-${w}`, b, N, O, v))), F == null || F.emit(`row-${w}`, b, N, v);
+  }, u = (v, b) => {
+    a(v, b, "dblclick");
+  }, c = (v, b) => {
+    var w;
+    (w = e.store) == null || w.commit("setCurrentRow", b), a(v, b, "click");
+  }, o = (v, b) => {
+    a(v, b, "contextmenu");
+  }, r = mt((v) => {
+    var b;
+    (b = e.store) == null || b.commit("setHoverRow", v);
+  }, 30), s = mt(() => {
+    var v;
+    (v = e.store) == null || v.commit("setHoverRow", null);
+  }, 30), i = (v) => {
+    const b = window.getComputedStyle(v, null);
+    return {
+      left: Number.parseInt(b.paddingLeft, 10) || 0,
+      right: Number.parseInt(b.paddingRight, 10) || 0,
+      top: Number.parseInt(b.paddingTop, 10) || 0,
+      bottom: Number.parseInt(b.paddingBottom, 10) || 0
+    };
+  }, d = (v, b, w) => {
+    var O;
+    let F = (O = b == null ? void 0 : b.target) == null ? void 0 : O.parentNode;
+    for (; v > 1 && (F = F == null ? void 0 : F.nextSibling, !(!F || F.nodeName !== "TR")); )
+      w(F, "hover-row hover-fixed-row"), v--;
+  };
+  return {
+    handleDoubleClick: u,
+    handleClick: c,
+    handleContextMenu: o,
+    handleMouseEnter: r,
+    handleMouseLeave: s,
+    handleCellMouseEnter: (v, b, w) => {
+      var z, $, M;
+      if (!t)
+        return;
+      const F = t, O = Et(v), N = (z = F == null ? void 0 : F.vnode.el) == null ? void 0 : z.dataset.prefix;
+      let f = null;
+      if (O) {
+        if (f = yl({ columns: (($ = e.store) == null ? void 0 : $.states.columns.value) ?? [] }, O, N), !f)
+          return;
+        O.rowSpan > 1 && d(O.rowSpan, v, pt);
+        const j = F.hoverState = {
+          cell: O,
+          column: f,
+          row: b
+        };
+        F == null || F.emit("cell-mouse-enter", j.row, j.column, j.cell, v);
+      }
+      if (!w) {
+        (q == null ? void 0 : q.trigger) === O && (q == null || q());
+        return;
+      }
+      const g = v.target.querySelector(".cell");
+      if (!(ut(g, `${N}-tooltip`) && g.childNodes.length && ((M = g.textContent) != null && M.trim())))
+        return;
+      const y = document.createRange();
+      y.setStart(g, 0), y.setEnd(g, g.childNodes.length);
+      const { width: C, height: m } = y.getBoundingClientRect(), { width: x, height: R } = g.getBoundingClientRect(), { top: k, left: D, right: V, bottom: X } = i(g), W = D + V, T = k + X;
+      St(C + W, x) || St(m + T, R) || St(g.scrollWidth, x) ? Da(w, ((O == null ? void 0 : O.innerText) || (O == null ? void 0 : O.textContent)) ?? "", b, f, O, F) : (q == null ? void 0 : q.trigger) === O && (q == null || q());
+    },
+    handleCellMouseLeave: (v) => {
+      const b = Et(v);
+      if (!b)
+        return;
+      b.rowSpan > 1 && d(b.rowSpan, v, et);
+      const w = t == null ? void 0 : t.hoverState;
+      t == null || t.emit("cell-mouse-leave", w == null ? void 0 : w.row, w == null ? void 0 : w.column, w == null ? void 0 : w.cell, v);
+    },
+    tooltipContent: l,
+    tooltipTrigger: n
+  };
+}
+function io(e) {
+  const t = Oe(Re), l = Ee("table");
+  return {
+    getRowStyle: (s, i) => {
+      const d = t == null ? void 0 : t.props.rowStyle;
+      return Ce(d) ? d.call(null, {
+        row: s,
+        rowIndex: i
+      }) : d || null;
+    },
+    getRowClass: (s, i, d) => {
+      var v;
+      const p = [l.e("row")];
+      t != null && t.props.highlightCurrentRow && s === ((v = e.store) == null ? void 0 : v.states.currentRow.value) && p.push("current-row"), e.stripe && d % 2 === 1 && p.push(l.em("row", "striped"));
+      const h = t == null ? void 0 : t.props.rowClassName;
+      return we(h) ? p.push(h) : Ce(h) && p.push(h.call(null, {
+        row: s,
+        rowIndex: i
+      })), p;
+    },
+    getCellStyle: (s, i, d, p) => {
+      const h = t == null ? void 0 : t.props.cellStyle;
+      let v = h ?? {};
+      Ce(h) && (v = h.call(null, {
+        rowIndex: s,
+        columnIndex: i,
+        row: d,
+        column: p
+      }));
+      const b = Ut(i, e == null ? void 0 : e.fixed, e.store);
+      return qe(b, "left"), qe(b, "right"), Object.assign({}, v, b);
+    },
+    getCellClass: (s, i, d, p, h) => {
+      const v = qt(l.b(), i, e == null ? void 0 : e.fixed, e.store, void 0, h), b = [
+        p.id,
+        p.align,
+        p.className,
+        ...v
+      ], w = t == null ? void 0 : t.props.cellClassName;
+      return we(w) ? b.push(w) : Ce(w) && b.push(w.call(null, {
+        rowIndex: s,
+        columnIndex: i,
+        row: d,
+        column: p
+      })), b.push(l.e("cell")), b.filter((F) => !!F).join(" ");
+    },
+    getSpan: (s, i, d, p) => {
+      let h = 1, v = 1;
+      const b = t == null ? void 0 : t.props.spanMethod;
+      if (Ce(b)) {
+        const w = b({
+          row: s,
+          column: i,
+          rowIndex: d,
+          columnIndex: p
+        });
+        ie(w) ? (h = w[0], v = w[1]) : vt(w) && (h = w.rowspan, v = w.colspan);
+      }
+      return {
+        rowspan: h,
+        colspan: v
+      };
+    },
+    getColspanRealWidth: (s, i, d) => {
+      if (i < 1)
+        return s[d].realWidth;
+      const p = s.map(({ realWidth: h, width: v }) => h || v).slice(d, d + i);
+      return Number(p.reduce((h, v) => Number(h) + Number(v), -1));
+    }
+  };
+}
+const uo = ["colspan", "rowspan"];
+var co = /* @__PURE__ */ De({
+  name: "TableTdWrapper",
+  __name: "td-wrapper",
+  props: {
+    colspan: {
+      type: Number,
+      default: 1
+    },
+    rowspan: {
+      type: Number,
+      default: 1
+    }
+  },
+  setup(e) {
+    return (t, l) => (te(), ye("td", {
+      colspan: e.colspan,
+      rowspan: e.rowspan
+    }, [Be(t.$slots, "default")], 8, uo));
+  }
+}), fo = co;
+function ho(e) {
+  const t = Oe(Re), l = Ee("table"), { handleDoubleClick: n, handleClick: a, handleContextMenu: u, handleMouseEnter: c, handleMouseLeave: o, handleCellMouseEnter: r, handleCellMouseLeave: s, tooltipContent: i, tooltipTrigger: d } = so(e), { getRowStyle: p, getRowClass: h, getCellStyle: v, getCellClass: b, getSpan: w, getColspanRealWidth: F } = io(e);
+  let O = -1;
+  const N = Y(() => {
+    var m;
+    return (m = e.store) == null ? void 0 : m.states.columns.value.findIndex(({ type: x }) => x === "default");
+  }), f = (m, x) => {
+    var k;
+    const R = (k = t == null ? void 0 : t.props) == null ? void 0 : k.rowKey;
+    return R ? U(m, R) : x;
+  }, g = (m, x, R, k = !1) => {
+    const { tooltipEffect: D, tooltipOptions: V, store: X } = e, { indent: W, columns: T } = X.states, z = [];
+    let $ = !0;
+    return R && (z.push(l.em("row", `level-${R.level}`)), $ = !!R.display), x === 0 && (O = -1), e.stripe && $ && O++, z.push(...h(m, x, O)), P("tr", {
+      style: [$ ? null : { display: "none" }, p(m, x)],
+      class: z,
+      key: f(m, x),
+      onDblclick: (M) => n(M, m),
+      onClick: (M) => a(M, m),
+      onContextmenu: (M) => u(M, m),
+      onMouseenter: () => c(x),
+      onMouseleave: o
+    }, T.value.map((M, j) => {
+      const { rowspan: J, colspan: Q } = w(m, M, x, j);
+      if (!J || !Q)
+        return null;
+      const le = Object.assign({}, M);
+      le.realWidth = F(T.value, Q, j);
+      const Z = {
+        store: X,
+        _self: e.context || t,
+        column: le,
+        row: m,
+        $index: x,
+        cellIndex: j,
+        expanded: k
+      };
+      j === N.value && R && (Z.treeNode = {
+        indent: R.level && R.level * W.value,
+        level: R.level
+      }, $e(R.expanded) && (Z.treeNode.expanded = R.expanded, "loading" in R && (Z.treeNode.loading = R.loading), "noLazyChildren" in R && (Z.treeNode.noLazyChildren = R.noLazyChildren)));
+      const se = `${f(m, x)},${j}`, ge = le.columnKey || le.rawColumnKey || "", ve = M.showOverflowTooltip && Il({ effect: D }, V, M.showOverflowTooltip);
+      return P(fo, {
+        style: v(x, j, m, M),
+        class: b(x, j, m, M, Q - 1),
+        key: `${ge}${se}`,
+        rowspan: J,
+        colspan: Q,
+        onMouseenter: (Se) => r(Se, m, ve),
+        onMouseleave: s
+      }, { default: () => y(j, M, Z) });
+    }));
+  }, y = (m, x, R) => x.renderCell(R);
+  return {
+    wrappedRowRender: (m, x) => {
+      const R = e.store, { isRowExpanded: k, assertRowKey: D } = R, { treeData: V, lazyTreeNodeMap: X, childrenColumnName: W, rowKey: T } = R.states, z = R.states.columns.value;
+      if (z.some(({ type: $ }) => $ === "expand")) {
+        const $ = k(m), M = g(m, x, void 0, $), j = t == null ? void 0 : t.renderExpanded;
+        if (!j)
+          return console.error("[Element Error]renderExpanded is required."), M;
+        const J = [[M]];
+        return (t.props.preserveExpandedContent || $) && J[0].push(P("tr", {
+          key: `expanded-row__${M.key}`,
+          style: { display: $ ? "" : "none" }
+        }, [P("td", {
+          colspan: z.length,
+          class: `${l.e("cell")} ${l.e("expanded-cell")}`
+        }, [j({
+          row: m,
+          $index: x,
+          store: R,
+          expanded: $
+        })])])), J;
+      } else if (Object.keys(V.value).length) {
+        D();
+        const $ = U(m, T.value);
+        let M = V.value[$], j = null;
+        M && (j = {
+          expanded: M.expanded,
+          level: M.level,
+          display: !0,
+          noLazyChildren: void 0,
+          loading: void 0
+        }, $e(M.lazy) && (j && $e(M.loaded) && M.loaded && (j.noLazyChildren = !(M.children && M.children.length)), j.loading = M.loading));
+        const J = [g(m, x, j ?? void 0)];
+        if (M) {
+          let Q = 0;
+          const le = (Z, se) => {
+            Z && Z.length && se && Z.forEach((ge) => {
+              const ve = {
+                display: se.display && se.expanded,
+                level: se.level + 1,
+                expanded: !1,
+                noLazyChildren: !1,
+                loading: !1
+              }, Se = U(ge, T.value);
+              if (Je(Se))
+                throw new Error("For nested data item, row-key is required.");
+              M = { ...V.value[Se] }, M && (ve.expanded = M.expanded, M.level = M.level || ve.level, M.display = !!(M.expanded && ve.display), $e(M.lazy) && ($e(M.loaded) && M.loaded && (ve.noLazyChildren = !(M.children && M.children.length)), ve.loading = M.loading)), Q++, J.push(g(ge, x + Q, ve)), M && le(X.value[Se] || ge[W.value], M);
+            });
+          };
+          M.display = !0, le(X.value[$] || m[W.value], M);
+        }
+        return J;
+      } else
+        return g(m, x, void 0);
+    },
+    tooltipContent: i,
+    tooltipTrigger: d
+  };
+}
+const go = {
+  store: {
+    required: !0,
+    type: Object
+  },
+  stripe: Boolean,
+  tooltipEffect: String,
+  tooltipOptions: { type: Object },
+  context: {
+    default: () => ({}),
+    type: Object
+  },
+  rowClassName: [String, Function],
+  rowStyle: [Object, Function],
+  fixed: {
+    type: String,
+    default: ""
+  },
+  highlight: Boolean
+};
+var vo = De({
+  name: "ElTableBody",
+  props: go,
+  setup(e) {
+    var i;
+    const t = he(), l = Oe(Re), n = Ee("table"), { wrappedRowRender: a, tooltipContent: u, tooltipTrigger: c } = ho(e), { onColumnsChange: o, onScrollableChange: r } = Gt(l), s = [];
+    return ne((i = e.store) == null ? void 0 : i.states.hoverRow, (d, p) => {
+      var F, O;
+      const h = t == null ? void 0 : t.vnode.el, v = Array.from((h == null ? void 0 : h.children) || []).filter((N) => N == null ? void 0 : N.classList.contains(`${n.e("row")}`));
+      let b = d;
+      const w = (F = v[b]) == null ? void 0 : F.childNodes;
+      if (w != null && w.length) {
+        let N = 0;
+        Array.from(w).reduce((f, g, y) => {
+          var C, m;
+          return ((C = w[y]) == null ? void 0 : C.colSpan) > 1 && (N = (m = w[y]) == null ? void 0 : m.colSpan), g.nodeName !== "TD" && N === 0 && f.push(y), N > 0 && N--, f;
+        }, []).forEach((f) => {
+          var g;
+          for (b = d; b > 0; ) {
+            const y = (g = v[b - 1]) == null ? void 0 : g.childNodes;
+            if (y[f] && y[f].nodeName === "TD" && y[f].rowSpan > 1) {
+              pt(y[f], "hover-cell"), s.push(y[f]);
+              break;
+            }
+            b--;
+          }
+        });
+      } else
+        s.forEach((N) => et(N, "hover-cell")), s.length = 0;
+      !((O = e.store) != null && O.states.isComplex.value) || !Ze || ia(() => {
+        const N = v[p], f = v[d];
+        N && !N.classList.contains("hover-fixed-row") && et(N, "hover-row"), f && pt(f, "hover-row");
+      });
+    }), Vt(() => {
+      q == null || q();
+    }), {
+      ns: n,
+      onColumnsChange: o,
+      onScrollableChange: r,
+      wrappedRowRender: a,
+      tooltipContent: u,
+      tooltipTrigger: c
+    };
+  },
+  render() {
+    const { wrappedRowRender: e, store: t } = this;
+    return P("tbody", { tabIndex: -1 }, [((t == null ? void 0 : t.states.data.value) || []).reduce((l, n) => l.concat(e(n, l.length)), [])]);
+  }
+});
+function po() {
+  var t;
+  const e = (t = Oe(Re)) == null ? void 0 : t.store;
+  return {
+    leftFixedLeafCount: Y(() => (e == null ? void 0 : e.states.fixedLeafColumnsLength.value) ?? 0),
+    rightFixedLeafCount: Y(() => (e == null ? void 0 : e.states.rightFixedColumns.value.length) ?? 0),
+    columnsCount: Y(() => (e == null ? void 0 : e.states.columns.value.length) ?? 0),
+    leftFixedCount: Y(() => (e == null ? void 0 : e.states.fixedColumns.value.length) ?? 0),
+    rightFixedCount: Y(() => (e == null ? void 0 : e.states.rightFixedColumns.value.length) ?? 0),
+    columns: Y(() => (e == null ? void 0 : e.states.columns.value) ?? [])
+  };
+}
+function mo(e) {
+  const { columns: t } = po(), l = Ee("table");
+  return {
+    getCellClasses: (u, c) => {
+      const o = u[c], r = [
+        l.e("cell"),
+        o.id,
+        o.align,
+        o.labelClassName,
+        ...qt(l.b(), c, o.fixed, e.store)
+      ];
+      return o.className && r.push(o.className), o.children || r.push(l.is("leaf")), r;
+    },
+    getCellStyles: (u, c) => {
+      const o = Ut(c, u.fixed, e.store);
+      return qe(o, "left"), qe(o, "right"), o;
+    },
+    columns: t
+  };
+}
+var Sl = De({
+  name: "ElTableFooter",
+  props: {
+    fixed: {
+      type: String,
+      default: ""
+    },
+    store: {
+      required: !0,
+      type: Object
+    },
+    summaryMethod: Function,
+    sumText: String,
+    border: Boolean,
+    defaultSort: {
+      type: Object,
+      default: () => ({
+        prop: "",
+        order: ""
+      })
+    }
+  },
+  setup(e) {
+    const t = Oe(Re), l = Ee("table"), { getCellClasses: n, getCellStyles: a, columns: u } = mo(e), { onScrollableChange: c, onColumnsChange: o } = Gt(t);
+    return {
+      ns: l,
+      onScrollableChange: c,
+      onColumnsChange: o,
+      getCellClasses: n,
+      getCellStyles: a,
+      columns: u
+    };
+  },
+  render() {
+    const { columns: e, getCellStyles: t, getCellClasses: l, summaryMethod: n, sumText: a } = this, u = this.store.states.data.value;
+    let c = [];
+    return n ? c = n({
+      columns: e,
+      data: u
+    }) : e.forEach((o, r) => {
+      if (r === 0) {
+        c[r] = a;
+        return;
+      }
+      const s = u.map((h) => Number(h[o.property])), i = [];
+      let d = !0;
+      s.forEach((h) => {
+        if (!Number.isNaN(+h)) {
+          d = !1;
+          const v = `${h}`.split(".")[1];
+          i.push(v ? v.length : 0);
+        }
+      });
+      const p = Math.max.apply(null, i);
+      d ? c[r] = "" : c[r] = s.reduce((h, v) => {
+        const b = Number(v);
+        return Number.isNaN(+b) ? h : Number.parseFloat((h + v).toFixed(Math.min(p, 20)));
+      }, 0);
+    }), P(P("tfoot", [P("tr", {}, [...e.map((o, r) => P("td", {
+      key: r,
+      colspan: o.colSpan,
+      rowspan: o.rowSpan,
+      class: l(e, r),
+      style: t(o, r)
+    }, [P("div", { class: ["cell", o.labelClassName] }, [c[r]])]))])]));
+  }
+});
+function yo(e) {
+  return {
+    setCurrentRow: (p) => {
+      e.commit("setCurrentRow", p);
+    },
+    getSelectionRows: () => e.getSelectionRows(),
+    getHalfSelectionRows: () => e.getHalfSelectionRows(),
+    toggleRowSelection: (p, h, v = !0) => {
+      e.toggleRowSelection(p, h, !1, v), e.updateAllSelected();
+    },
+    clearSelection: () => {
+      e.clearSelection();
+    },
+    clearFilter: (p) => {
+      e.clearFilter(p);
+    },
+    toggleAllSelection: () => {
+      e.commit("toggleAllSelection");
+    },
+    toggleRowExpansion: (p, h) => {
+      e.toggleRowExpansionAdapter(p, h);
+    },
+    clearSort: () => {
+      e.clearSort();
+    },
+    sort: (p, h) => {
+      e.commit("sort", {
+        prop: p,
+        order: h
+      });
+    },
+    updateKeyChildren: (p, h) => {
+      e.updateKeyChildren(p, h);
+    }
+  };
+}
+function Co(e, t, l, n) {
+  const a = L(!1), u = L(null), c = L(!1), o = (W) => {
+    c.value = W;
+  }, r = L({
+    width: null,
+    height: null,
+    headerHeight: null
+  }), s = L(!1), i = {
+    display: "inline-block",
+    verticalAlign: "middle"
+  }, d = L(), p = L(0), h = L(0), v = L(0), b = L(0), w = L(0);
+  ne(() => e.height, (W) => {
+    t.setHeight(W ?? null);
+  }, { immediate: !0 }), ne(() => e.maxHeight, (W) => {
+    t.setMaxHeight(W ?? null);
+  }, { immediate: !0 }), ne(() => [e.currentRowKey, l.states.rowKey], ([W, T]) => {
+    !S(T) || !S(W) || l.setCurrentRowKey(`${W}`);
+  }, { immediate: !0 }), ne(() => e.data, (W) => {
+    n.store.commit("setData", W);
+  }, {
+    immediate: !0,
+    deep: !0
+  }), Nt(() => {
+    e.expandRowKeys && l.setExpandRowKeysAdapter(e.expandRowKeys);
+  });
+  const F = () => {
+    n.store.commit("setHoverRow", null), n.hoverState && (n.hoverState = null);
+  }, O = (W, T) => {
+    const { pixelX: z, pixelY: $ } = T;
+    Math.abs(z) >= Math.abs($) && (n.refs.bodyWrapper.scrollLeft += T.pixelX / 5);
+  }, N = Y(() => e.height || e.maxHeight || l.states.fixedColumns.value.length > 0 || l.states.rightFixedColumns.value.length > 0), f = Y(() => ({ width: t.bodyWidth.value ? `${t.bodyWidth.value}px` : "" })), g = () => {
+    N.value && t.updateElsHeight(), t.updateColumnsWidth(), !(typeof window > "u") && requestAnimationFrame(x);
+  };
+  lt(async () => {
+    await Ye(), l.updateColumns(), R(), requestAnimationFrame(g);
+    const W = n.vnode.el, T = n.refs.headerWrapper;
+    e.flexible && W && W.parentElement && (W.parentElement.style.minWidth = "0"), r.value = {
+      width: d.value = W.offsetWidth,
+      height: W.offsetHeight,
+      headerHeight: e.showHeader && T ? T.offsetHeight : null
+    }, l.states.columns.value.forEach((z) => {
+      z.filteredValue && z.filteredValue.length && n.store.commit("filterChange", {
+        column: z,
+        values: z.filteredValue,
+        silent: !0
+      });
+    }), n.$ready = !0;
+  });
+  const y = (W, T) => {
+    if (!W)
+      return;
+    const z = Array.from(W.classList).filter(($) => !$.startsWith("is-scrolling-"));
+    z.push(t.scrollX.value ? T : "is-scrolling-none"), W.className = z.join(" ");
+  }, C = (W) => {
+    const { tableWrapper: T } = n.refs;
+    y(T, W);
+  }, m = (W) => {
+    const { tableWrapper: T } = n.refs;
+    return !!(T && T.classList.contains(W));
+  }, x = function() {
+    if (!n.refs.scrollBarRef)
+      return;
+    if (!t.scrollX.value) {
+      const J = "is-scrolling-none";
+      m(J) || C(J);
+      return;
+    }
+    const W = n.refs.scrollBarRef.wrapRef;
+    if (!W)
+      return;
+    const { scrollLeft: T, offsetWidth: z, scrollWidth: $ } = W, { headerWrapper: M, footerWrapper: j } = n.refs;
+    M && (M.scrollLeft = T), j && (j.scrollLeft = T), T >= $ - z - 1 ? C("is-scrolling-right") : C(T === 0 ? "is-scrolling-left" : "is-scrolling-middle");
+  }, R = () => {
+    n.refs.scrollBarRef && (n.refs.scrollBarRef.wrapRef && sl(n.refs.scrollBarRef.wrapRef, "scroll", x, { passive: !0 }), e.fit ? il(n.vnode.el, k) : sl(window, "resize", k), il(n.refs.tableInnerWrapper, () => {
+      var W, T;
+      k(), (T = (W = n.refs) == null ? void 0 : W.scrollBarRef) == null || T.update();
+    }));
+  }, k = () => {
+    var le, Z, se, ge;
+    const W = n.vnode.el;
+    if (!n.$ready || !W)
+      return;
+    let T = !1;
+    const { width: z, height: $, headerHeight: M } = r.value, j = d.value = W.offsetWidth;
+    z !== j && (T = !0);
+    const J = W.offsetHeight;
+    (e.height || N.value) && $ !== J && (T = !0);
+    const Q = e.tableLayout === "fixed" ? n.refs.headerWrapper : (le = n.refs.tableHeaderRef) == null ? void 0 : le.$el;
+    e.showHeader && (Q == null ? void 0 : Q.offsetHeight) !== M && (T = !0), p.value = ((Z = n.refs.tableWrapper) == null ? void 0 : Z.scrollHeight) || 0, v.value = (Q == null ? void 0 : Q.scrollHeight) || 0, b.value = ((se = n.refs.footerWrapper) == null ? void 0 : se.offsetHeight) || 0, w.value = ((ge = n.refs.appendWrapper) == null ? void 0 : ge.offsetHeight) || 0, h.value = p.value - v.value - b.value - w.value, T && (r.value = {
+      width: j,
+      height: J,
+      headerHeight: e.showHeader && (Q == null ? void 0 : Q.offsetHeight) || 0
+    }, g());
+  }, D = Hn(), V = Y(() => {
+    const { bodyWidth: W, scrollY: T, gutterWidth: z } = t;
+    return W.value ? `${W.value - (T.value ? z : 0)}px` : "";
+  }), X = Y(() => e.maxHeight ? "fixed" : e.tableLayout);
+  return {
+    isHidden: a,
+    renderExpanded: u,
+    setDragVisible: o,
+    isGroup: s,
+    handleMouseLeave: F,
+    handleHeaderFooterMousewheel: O,
+    tableSize: D,
+    emptyBlockStyle: Y(() => {
+      if (e.data && e.data.length)
+        return;
+      let W = "100%";
+      e.height && h.value && (W = `${h.value}px`);
+      const T = d.value;
+      return {
+        width: T ? `${T}px` : "",
+        height: W
+      };
+    }),
+    resizeProxyVisible: c,
+    bodyWidth: V,
+    resizeState: r,
+    doLayout: g,
+    tableBodyStyles: f,
+    tableLayout: X,
+    scrollbarViewStyle: i,
+    scrollbarStyle: Y(() => e.height ? { height: "100%" } : e.maxHeight ? Number.isNaN(Number(e.maxHeight)) ? { maxHeight: `calc(${e.maxHeight} - ${v.value + b.value}px)` } : { maxHeight: `${+e.maxHeight - v.value - b.value}px` } : {})
+  };
+}
+function bo(e) {
+  let t;
+  const l = () => {
+    const n = e.vnode.el.querySelector(".hidden-columns"), a = {
+      childList: !0,
+      subtree: !0
+    }, u = e.store.states.updateOrderFns;
+    t = new MutationObserver(() => {
+      u.forEach((c) => c());
+    }), t.observe(n, a);
+  };
+  lt(() => {
+    l();
+  }), Vt(() => {
+    t == null || t.disconnect();
+  });
+}
+function gt(e) {
+  const t = e.tableLayout === "auto";
+  let l = e.columns || [];
+  t && l.every(({ width: a }) => be(a)) && (l = []);
+  const n = (a) => {
+    const u = {
+      key: `${e.tableLayout}_${a.id}`,
+      style: {},
+      name: void 0
+    };
+    return t ? u.style = { width: `${a.width}px` } : u.name = a.id, u;
+  };
+  return P("colgroup", {}, l.map((a) => P("col", n(a))));
+}
+gt.props = ["columns", "tableLayout"];
+const wo = () => {
+  const e = L(), t = (u, c) => {
+    const o = e.value;
+    o && o.scrollTo(u, c);
+  }, l = (u, c) => {
+    const o = e.value;
+    o && je(c) && ["Top", "Left"].includes(u) && o[`setScroll${u}`](c);
+  };
+  return {
+    scrollBarRef: e,
+    scrollTo: t,
+    setScrollTop: (u) => l("Top", u),
+    setScrollLeft: (u) => l("Left", u)
+  };
+}, So = ["data-prefix"], xo = {
+  ref: "hiddenColumns",
+  class: "hidden-columns"
+};
+var Eo = /* @__PURE__ */ De({
+  name: "ElTable",
+  __name: "table",
+  props: Ta,
+  emits: [
+    "select",
+    "select-all",
+    "selection-change",
+    "cell-mouse-enter",
+    "cell-mouse-leave",
+    "cell-dblclick",
+    "cell-contextmenu",
+    "cell-click",
+    "row-dblclick",
+    "row-click",
+    "row-contextmenu",
+    "header-click",
+    "header-contextmenu",
+    "sort-change",
+    "filter-change",
+    "current-change",
+    "header-dragend",
+    "expand-change",
+    "scroll"
+  ],
+  setup(e, { expose: t }) {
+    const l = e, { t: n } = Ct(), a = Ee("table"), u = Dt("table"), c = he();
+    Yn(Re, c);
+    const o = Ua(c, l);
+    c.store = o;
+    const r = new Ga({
+      store: c.store,
+      table: c,
+      fit: l.fit,
+      showHeader: l.showHeader
+    });
+    c.layout = r;
+    const s = Y(() => (o.states.data.value || []).length === 0), { setCurrentRow: i, getSelectionRows: d, getHalfSelectionRows: p, toggleRowSelection: h, clearSelection: v, clearFilter: b, toggleAllSelection: w, toggleRowExpansion: F, clearSort: O, sort: N, updateKeyChildren: f } = yo(o), { isHidden: g, renderExpanded: y, setDragVisible: C, isGroup: m, handleMouseLeave: x, handleHeaderFooterMousewheel: R, tableSize: k, emptyBlockStyle: D, resizeProxyVisible: V, bodyWidth: X, resizeState: W, doLayout: T, tableBodyStyles: z, tableLayout: $, scrollbarViewStyle: M, scrollbarStyle: j } = Co(l, r, o, c), { scrollBarRef: J, scrollTo: Q, setScrollLeft: le, setScrollTop: Z } = wo(), se = mt(T, 50), ge = Wa(a.namespace.value), ve = c;
+    c.tableId = ge, c.state = {
+      isGroup: m,
+      resizeState: W,
+      doLayout: T,
+      debouncedUpdateLayout: se
+    };
+    const Se = Y(() => l.sumText ?? n("el.table.sumText")), Te = Y(() => l.emptyText ?? n("el.table.emptyText")), nt = Y(() => {
+      var pe;
+      return l.tooltipEffect ?? ((pe = u.value) == null ? void 0 : pe.tooltipEffect);
+    }), at = Y(() => {
+      var pe;
+      return l.tooltipOptions ?? ((pe = u.value) == null ? void 0 : pe.tooltipOptions);
+    }), Ue = Y(() => en(o.states.originColumns.value)[0]);
+    return bo(c), jt(() => {
+      se.cancel();
+    }), t({
+      ns: a,
+      layout: r,
+      store: o,
+      columns: Ue,
+      handleHeaderFooterMousewheel: R,
+      handleMouseLeave: x,
+      tableId: ge,
+      tableSize: k,
+      isHidden: g,
+      isEmpty: s,
+      renderExpanded: y,
+      resizeProxyVisible: V,
+      resizeState: W,
+      isGroup: m,
+      bodyWidth: X,
+      tableBodyStyles: z,
+      emptyBlockStyle: D,
+      debouncedUpdateLayout: se,
+      /**
+      * @description used in single selection Table, set a certain row selected. If called without any parameter, it will clear selection
+      */
+      setCurrentRow: i,
+      /**
+      * @description returns the currently selected rows
+      */
+      getSelectionRows: d,
+      /**
+      * @description returns the currently half-selected rows
+      */
+      getHalfSelectionRows: p,
+      /**
+      * @description used in multiple selection Table, toggle if a certain row is selected. With the second parameter, you can directly set if this row is selected
+      */
+      toggleRowSelection: h,
+      /**
+      * @description used in multiple selection Table, clear user selection
+      */
+      clearSelection: v,
+      /**
+      * @description clear filters of the columns whose `columnKey` are passed in. If no params, clear all filters
+      */
+      clearFilter: b,
+      /**
+      * @description used in multiple selection Table, toggle select all and deselect all
+      */
+      toggleAllSelection: w,
+      /**
+      * @description used in expandable Table or tree Table, toggle if a certain row is expanded. With the second parameter, you can directly set if this row is expanded or collapsed
+      */
+      toggleRowExpansion: F,
+      /**
+      * @description clear sorting, restore data to the original order
+      */
+      clearSort: O,
+      /**
+      * @description refresh the layout of Table. When the visibility of Table changes, you may need to call this method to get a correct layout
+      */
+      doLayout: T,
+      /**
+      * @description sort Table manually. Property `prop` is used to set sort column, property `order` is used to set sort order
+      */
+      sort: N,
+      /**
+      * @description used in lazy Table, must set `rowKey`, update key children
+      */
+      updateKeyChildren: f,
+      t: n,
+      setDragVisible: C,
+      context: ve,
+      computedSumText: Se,
+      computedEmptyText: Te,
+      computedTooltipEffect: nt,
+      computedTooltipOptions: at,
+      tableLayout: $,
+      scrollbarViewStyle: M,
+      scrollbarStyle: j,
+      scrollBarRef: J,
+      /**
+      * @description scrolls to a particular set of coordinates
+      */
+      scrollTo: Q,
+      /**
+      * @description set horizontal scroll position
+      */
+      setScrollLeft: le,
+      /**
+      * @description set vertical scroll position
+      */
+      setScrollTop: Z,
+      /**
+      * @description whether to allow drag the last column
+      */
+      allowDragLastColumn: l.allowDragLastColumn
+    }), (pe, Me) => (te(), ye("div", {
+      ref: "tableWrapper",
+      class: G([
+        {
+          [S(a).m("fit")]: e.fit,
+          [S(a).m("striped")]: e.stripe,
+          [S(a).m("border")]: e.border || S(m),
+          [S(a).m("hidden")]: S(g),
+          [S(a).m("group")]: S(m),
+          [S(a).m("fluid-height")]: e.maxHeight,
+          [S(a).m("scrollable-x")]: S(r).scrollX.value,
+          [S(a).m("scrollable-y")]: S(r).scrollY.value,
+          [S(a).m("enable-row-hover")]: !S(o).states.isComplex.value,
+          [S(a).m("enable-row-transition")]: (S(o).states.data.value || []).length !== 0 && (S(o).states.data.value || []).length < 100,
+          "has-footer": e.showSummary
+        },
+        S(a).m(S(k)),
+        e.className,
+        S(a).b(),
+        S(a).m(`layout-${S($)}`)
+      ]),
+      style: Qe(e.style),
+      "data-prefix": S(a).namespace.value,
+      onMouseleave: Me[1] || (Me[1] = (...Xe) => S(x) && S(x)(...Xe))
+    }, [fe("div", {
+      ref: "tableInnerWrapper",
+      class: G(S(a).e("inner-wrapper"))
+    }, [
+      fe("div", xo, [Be(pe.$slots, "default")], 512),
+      e.showHeader && S($) === "fixed" ? xt((te(), ye("div", {
+        key: 0,
+        ref: "headerWrapper",
+        class: G(S(a).e("header-wrapper"))
+      }, [fe("table", {
+        ref: "tableHeader",
+        class: G(S(a).e("header")),
+        style: Qe(S(z)),
+        border: "0",
+        cellpadding: "0",
+        cellspacing: "0"
+      }, [xe(S(gt), {
+        columns: S(o).states.columns.value,
+        "table-layout": S($)
+      }, null, 8, ["columns", "table-layout"]), xe(S(wl), {
+        ref: "tableHeaderRef",
+        border: e.border,
+        "default-sort": e.defaultSort,
+        store: S(o),
+        "append-filter-panel-to": e.appendFilterPanelTo,
+        "allow-drag-last-column": e.allowDragLastColumn,
+        onSetDragVisible: S(C)
+      }, null, 8, [
+        "border",
+        "default-sort",
+        "store",
+        "append-filter-panel-to",
+        "allow-drag-last-column",
+        "onSetDragVisible"
+      ])], 6)], 2)), [[S(ml), S(R)]]) : He("v-if", !0),
+      fe("div", {
+        ref: "bodyWrapper",
+        class: G(S(a).e("body-wrapper"))
+      }, [xe(S(Rl), {
+        ref_key: "scrollBarRef",
+        ref: J,
+        "view-style": S(M),
+        "wrap-style": S(j),
+        always: e.scrollbarAlwaysOn,
+        tabindex: e.scrollbarTabindex,
+        native: e.nativeScrollbar,
+        onScroll: Me[0] || (Me[0] = (Xe) => pe.$emit("scroll", Xe))
+      }, {
+        default: Ae(() => [
+          fe("table", {
+            ref: "tableBody",
+            class: G(S(a).e("body")),
+            cellspacing: "0",
+            cellpadding: "0",
+            border: "0",
+            style: Qe({
+              width: S(X),
+              tableLayout: S($)
+            })
+          }, [
+            xe(S(gt), {
+              columns: S(o).states.columns.value,
+              "table-layout": S($)
+            }, null, 8, ["columns", "table-layout"]),
+            e.showHeader && S($) === "auto" ? (te(), Ke(S(wl), {
+              key: 0,
+              ref: "tableHeaderRef",
+              class: G(S(a).e("body-header")),
+              border: e.border,
+              "default-sort": e.defaultSort,
+              store: S(o),
+              "append-filter-panel-to": e.appendFilterPanelTo,
+              onSetDragVisible: S(C)
+            }, null, 8, [
+              "class",
+              "border",
+              "default-sort",
+              "store",
+              "append-filter-panel-to",
+              "onSetDragVisible"
+            ])) : He("v-if", !0),
+            xe(S(vo), {
+              context: S(ve),
+              highlight: e.highlightCurrentRow,
+              "row-class-name": e.rowClassName,
+              "tooltip-effect": nt.value,
+              "tooltip-options": at.value,
+              "row-style": e.rowStyle,
+              store: S(o),
+              stripe: e.stripe
+            }, null, 8, [
+              "context",
+              "highlight",
+              "row-class-name",
+              "tooltip-effect",
+              "tooltip-options",
+              "row-style",
+              "store",
+              "stripe"
+            ]),
+            e.showSummary && S($) === "auto" ? (te(), Ke(S(Sl), {
+              key: 1,
+              class: G(S(a).e("body-footer")),
+              border: e.border,
+              "default-sort": e.defaultSort,
+              store: S(o),
+              "sum-text": Se.value,
+              "summary-method": e.summaryMethod
+            }, null, 8, [
+              "class",
+              "border",
+              "default-sort",
+              "store",
+              "sum-text",
+              "summary-method"
+            ])) : He("v-if", !0)
+          ], 6),
+          s.value ? (te(), ye("div", {
+            key: 0,
+            ref: "emptyBlock",
+            style: Qe(S(D)),
+            class: G(S(a).e("empty-block"))
+          }, [fe("span", { class: G(S(a).e("empty-text")) }, [Be(pe.$slots, "empty", {}, () => [Pt(Pe(Te.value), 1)])], 2)], 6)) : He("v-if", !0),
+          pe.$slots.append ? (te(), ye("div", {
+            key: 1,
+            ref: "appendWrapper",
+            class: G(S(a).e("append-wrapper"))
+          }, [Be(pe.$slots, "append")], 2)) : He("v-if", !0)
+        ]),
+        _: 3
+      }, 8, [
+        "view-style",
+        "wrap-style",
+        "always",
+        "tabindex",
+        "native"
+      ])], 2),
+      e.showSummary && S($) === "fixed" ? xt((te(), ye("div", {
+        key: 1,
+        ref: "footerWrapper",
+        class: G(S(a).e("footer-wrapper"))
+      }, [fe("table", {
+        class: G(S(a).e("footer")),
+        cellspacing: "0",
+        cellpadding: "0",
+        border: "0",
+        style: Qe(S(z))
+      }, [xe(S(gt), {
+        columns: S(o).states.columns.value,
+        "table-layout": S($)
+      }, null, 8, ["columns", "table-layout"]), xe(S(Sl), {
+        border: e.border,
+        "default-sort": e.defaultSort,
+        store: S(o),
+        "sum-text": Se.value,
+        "summary-method": e.summaryMethod
+      }, null, 8, [
+        "border",
+        "default-sort",
+        "store",
+        "sum-text",
+        "summary-method"
+      ])], 6)], 2)), [[dl, !s.value], [S(ml), S(R)]]) : He("v-if", !0),
+      e.border || S(m) ? (te(), ye("div", {
+        key: 2,
+        class: G(S(a).e("border-left-patch"))
+      }, null, 2)) : He("v-if", !0)
+    ], 2), xt(fe("div", {
+      ref: "resizeProxy",
+      class: G(S(a).e("column-resize-proxy"))
+    }, null, 2), [[dl, S(V)]])], 46, So));
+  }
+}), Ro = Eo;
+const No = {
+  /**
+  * @description type of the column. If set to `selection`, the column will display checkbox. If set to `index`, the column will display index of the row (staring from 1). If set to `expand`, the column will display expand icon
+  */
+  type: {
+    type: String,
+    default: "default"
+  },
+  /**
+  * @description column label
+  */
+  label: String,
+  /**
+  * @description class name of cells in the column
+  */
+  className: String,
+  /**
+  * @description class name of the label of this column
+  */
+  labelClassName: String,
+  /**
+  * @description
+  */
+  property: String,
+  /**
+  * @description field name. You can also use its alias: `property`
+  */
+  prop: String,
+  /**
+  * @description column width
+  */
+  width: {
+    type: [String, Number],
+    default: ""
+  },
+  /**
+  * @description column minimum width. Columns with `width` has a fixed width, while columns with `min-width` has a width that is distributed in proportion
+  */
+  minWidth: {
+    type: [String, Number],
+    default: ""
+  },
+  /**
+  * @description render function for table header of this column
+  */
+  renderHeader: Function,
+  /**
+  * @description whether column can be sorted. Remote sorting can be done by setting this attribute to 'custom' and listening to the `sort-change` event of Table
+  */
+  sortable: {
+    type: [Boolean, String],
+    default: !1
+  },
+  /**
+  * @description sorting method, works when `sortable` is `true`. Should return a number, just like Array.sort
+  */
+  sortMethod: Function,
+  /**
+  * @description specify which property to sort by, works when `sortable` is `true` and `sort-method` is `undefined`. If set to an Array, the column will sequentially sort by the next property if the previous one is equal
+  */
+  sortBy: [
+    String,
+    Function,
+    Array
+  ],
+  /**
+  * @description whether column width can be resized, works when `border` of `el-table` is `true`
+  */
+  resizable: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description column's key. If you need to use the filter-change event, you need this attribute to identify which column is being filtered
+  */
+  columnKey: String,
+  /**
+  * @description alignment, the value should be 'left' \/ 'center' \/ 'right'
+  */
+  align: String,
+  /**
+  * @description alignment of the table header. If omitted, the value of the above `align` attribute will be applied, the value should be 'left' \/ 'center' \/ 'right'
+  */
+  headerAlign: String,
+  /**
+  * @description whether to hide extra content and show them in a tooltip when hovering on the cell
+  */
+  showOverflowTooltip: {
+    type: [Boolean, Object],
+    default: void 0
+  },
+  /**
+  * @description function that formats cell tooltip content, works when `show-overflow-tooltip` is `true`
+  */
+  tooltipFormatter: Function,
+  /**
+  * @description whether column is fixed at left / right. Will be fixed at left if `true`
+  */
+  fixed: [Boolean, String],
+  /**
+  * @description function that formats cell content
+  */
+  formatter: Function,
+  /**
+  * @description function that determines if a certain row can be selected, works when `type` is 'selection'
+  */
+  selectable: Function,
+  /**
+  * @description whether to reserve selection after data refreshing, works when `type` is 'selection'. Note that `row-key` is required for this to work
+  */
+  reserveSelection: Boolean,
+  /**
+  * @description data filtering method. If `filter-multiple` is on, this method will be called multiple times for each row, and a row will display if one of the calls returns `true`
+  */
+  filterMethod: Function,
+  /**
+  * @description filter value for selected data, might be useful when table header is rendered with `render-header`
+  */
+  filteredValue: Array,
+  /**
+  * @description an array of data filtering options. For each element in this array, `text` and `value` are required
+  */
+  filters: Array,
+  /**
+  * @description placement for the filter dropdown
+  */
+  filterPlacement: String,
+  /**
+  * @description whether data filtering supports multiple options
+  */
+  filterMultiple: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description className for the filter dropdown
+  */
+  filterClassName: String,
+  /**
+  * @description customize indices for each row, works on columns with `type=index`
+  */
+  index: [Number, Function],
+  /**
+  * @description the order of the sorting strategies used when sorting the data, works when `sortable` is `true`. Accepts an array, as the user clicks on the header, the column is sorted in order of the elements in the array
+  */
+  sortOrders: {
+    type: Array,
+    default: () => [
+      "ascending",
+      "descending",
+      null
+    ],
+    validator: (e) => e.every((t) => [
+      "ascending",
+      "descending",
+      null
+    ].includes(t))
+  }
+}, Lo = {
+  selection: "table-column--selection",
+  expand: "table__expand-column"
+}, Oo = {
+  default: { order: "" },
+  selection: {
+    width: 48,
+    minWidth: 48,
+    realWidth: 48,
+    order: ""
+  },
+  expand: {
+    width: 48,
+    minWidth: 48,
+    realWidth: 48,
+    order: ""
+  },
+  index: {
+    width: 48,
+    minWidth: 48,
+    realWidth: 48,
+    order: ""
+  }
+}, To = (e) => Lo[e] || "", Fo = {
+  selection: {
+    renderHeader({ store: e }) {
+      function t() {
+        return e.states.data.value && e.states.data.value.length === 0;
+      }
+      return P(yt, {
+        disabled: t(),
+        size: e.states.tableSize.value,
+        indeterminate: e.states.selection.value.length > 0 && !e.states.isAllSelected.value,
+        "onUpdate:modelValue": e.toggleAllSelection ?? void 0,
+        modelValue: e.states.isAllSelected.value,
+        ariaLabel: e.t("el.table.selectAllLabel")
+      });
+    },
+    renderCell({ row: e, column: t, store: l, $index: n }) {
+      return P(yt, {
+        disabled: t.selectable ? !t.selectable.call(null, e, n) : !1,
+        size: l.states.tableSize.value,
+        onChange: () => {
+          l.commit("rowSelectedChanged", e);
+        },
+        onClick: (a) => a.stopPropagation(),
+        modelValue: l.isSelected(e),
+        indeterminate: l.getRowIndeterminate(e),
+        ariaLabel: l.t("el.table.selectRowLabel")
+      });
+    },
+    sortable: !1,
+    resizable: !1
+  },
+  index: {
+    renderHeader({ column: e }) {
+      return e.label || "#";
+    },
+    renderCell({ column: e, $index: t }) {
+      let l = t + 1;
+      const n = e.index;
+      return je(n) ? l = t + n : Ce(n) && (l = n(t)), P("div", {}, [l]);
+    },
+    sortable: !1
+  },
+  expand: {
+    renderHeader({ column: e }) {
+      return e.label || "";
+    },
+    renderCell({ column: e, row: t, store: l, expanded: n, $index: a }) {
+      var s, i;
+      const { ns: u } = l, c = [u.e("expand-icon")];
+      !e.renderExpand && n && c.push(u.em("expand-icon", "expanded"));
+      const o = function(d) {
+        d.stopPropagation(), l.toggleRowExpansion(t);
+      }, r = ((i = (s = l.states.rowExpandable).value) == null ? void 0 : i.call(s, t, a)) ?? !0;
+      return r || c.push(u.is("disabled")), P("button", {
+        type: "button",
+        disabled: !r,
+        "aria-label": l.t(n ? "el.table.collapseRowLabel" : "el.table.expandRowLabel"),
+        "aria-expanded": n,
+        class: c,
+        onClick: o
+      }, { default: () => e.renderExpand ? [e.renderExpand({
+        expanded: n,
+        expandable: r
+      })] : [P(_t, null, { default: () => [P(kl)] })] });
+    },
+    sortable: !1,
+    resizable: !1
+  }
+};
+function Mo({ row: e, column: t, $index: l }) {
+  var u;
+  const n = t.property, a = n && Nl(e, n).value;
+  return t && t.formatter ? t.formatter(e, t, a, l) : ((u = a == null ? void 0 : a.toString) == null ? void 0 : u.call(a)) || "";
+}
+function Wo({ row: e, treeNode: t, store: l }, n = !1) {
+  const { ns: a } = l;
+  if (!t)
+    return n ? [P("span", { class: a.e("placeholder") })] : null;
+  const u = [], c = function(o) {
+    o.stopPropagation(), !t.loading && l.loadOrToggle(e);
+  };
+  if (t.indent && u.push(P("span", {
+    class: a.e("indent"),
+    style: { "padding-left": `${t.indent}px` }
+  })), $e(t.expanded) && !t.noLazyChildren) {
+    const o = [a.e("expand-icon"), t.expanded ? a.em("expand-icon", "expanded") : ""];
+    let r = kl;
+    t.loading && (r = sa), u.push(P("button", {
+      type: "button",
+      "aria-label": l.t(t.expanded ? "el.table.collapseRowLabel" : "el.table.expandRowLabel"),
+      "aria-expanded": t.expanded,
+      class: o,
+      onClick: c
+    }, { default: () => [P(_t, { class: a.is("loading", t.loading) }, { default: () => [P(r)] })] }));
+  } else
+    u.push(P("span", { class: a.e("placeholder") }));
+  return u;
+}
+function xl(e, t) {
+  return e.reduce((l, n) => (l[n] = n, l), t);
+}
+function ko(e, t) {
+  const l = he();
+  return {
+    registerComplexWatchers: () => {
+      const u = ["fixed"], c = {
+        realWidth: "width",
+        realMinWidth: "minWidth"
+      }, o = xl(u, c);
+      Object.keys(o).forEach((r) => {
+        const s = c[r];
+        ze(t, s) && ne(() => t[s], (i) => {
+          let d = i;
+          s === "width" && r === "realWidth" && (d = Yt(i)), s === "minWidth" && r === "realMinWidth" && (d = ql(i)), l.columnConfig.value[s] = d, l.columnConfig.value[r] = d;
+          const p = s === "fixed";
+          e.value.store.scheduleLayout(p);
+        });
+      });
+    },
+    registerNormalWatchers: () => {
+      const u = [
+        "label",
+        "filters",
+        "filterMultiple",
+        "filteredValue",
+        "sortable",
+        "index",
+        "formatter",
+        "className",
+        "labelClassName",
+        "filterClassName",
+        "showOverflowTooltip",
+        "tooltipFormatter",
+        "resizable"
+      ], c = ["showOverflowTooltip"], o = {
+        property: "prop",
+        align: "realAlign",
+        headerAlign: "realHeaderAlign"
+      }, r = xl(u, o);
+      Object.keys(r).forEach((i) => {
+        const d = o[i];
+        ze(t, d) && ne(() => t[d], (p) => {
+          l.columnConfig.value[i] = p, (i === "filters" || i === "filterMethod") && (l.columnConfig.value.filterable = !!(l.columnConfig.value.filters || l.columnConfig.value.filterMethod));
+        });
+      }), c.forEach((i) => {
+        ze(e.value.props, i) && ne(() => e.value.props[i], (d) => {
+          l.columnConfig.value.type !== "selection" && be(t[i]) && (l.columnConfig.value[i] = d);
+        });
+      });
+      const s = Dt("table");
+      s.value && ze(s.value, "showOverflowTooltip") && ne(() => {
+        var i;
+        return (i = s.value) == null ? void 0 : i.showOverflowTooltip;
+      }, (i) => {
+        l.columnConfig.value.type !== "selection" && (!be(t.showOverflowTooltip) || !be(e.value.props.showOverflowTooltip) || (l.columnConfig.value.showOverflowTooltip = i));
+      });
+    }
+  };
+}
+function Ho(e, t, l) {
+  const n = he(), a = L(""), u = L(!1), c = L(), o = L(), r = Ee("table");
+  Nt(() => {
+    c.value = e.align ? `is-${e.align}` : null, c.value;
+  }), Nt(() => {
+    o.value = e.headerAlign ? `is-${e.headerAlign}` : c.value, o.value;
+  });
+  const s = Y(() => {
+    let f = n.vnode.vParent || n.parent;
+    for (; f && !f.tableId && !f.columnId; )
+      f = f.vnode.vParent || f.parent;
+    return f;
+  }), i = Y(() => {
+    const { store: f } = n.parent;
+    if (!f)
+      return !1;
+    const { treeData: g } = f.states, y = g.value;
+    return y && Object.keys(y).length > 0;
+  }), d = L(Yt(e.width)), p = L(ql(e.minWidth)), h = (f) => (d.value && (f.width = d.value), p.value && (f.minWidth = p.value), !d.value && p.value && (f.width = void 0), f.minWidth || (f.minWidth = 80), f.realWidth = Number(be(f.width) ? f.minWidth : f.width), f), v = (f) => {
+    const g = f.type, y = Fo[g] || {};
+    Object.keys(y).forEach((m) => {
+      const x = y[m];
+      m !== "className" && !be(x) && (f[m] = x);
+    });
+    const C = To(g);
+    if (C) {
+      const m = `${S(r.namespace)}-${C}`;
+      f.className = f.className ? `${f.className} ${m}` : m;
+    }
+    return f;
+  }, b = (f) => {
+    ie(f) ? f.forEach((y) => g(y)) : g(f);
+    function g(y) {
+      var C;
+      ((C = y == null ? void 0 : y.type) == null ? void 0 : C.name) === "ElTableColumn" && (y.vParent = n);
+    }
+  };
+  return {
+    columnId: a,
+    realAlign: c,
+    isSubColumn: u,
+    realHeaderAlign: o,
+    columnOrTableParent: s,
+    setColumnWidth: h,
+    setColumnForcedProps: v,
+    setColumnRenders: (f) => {
+      e.renderHeader ? On("TableColumn", "Comparing to render-header, scoped-slot header is easier to use. We recommend users to use scoped-slot header.") : f.type !== "selection" && (f.renderHeader = (y) => {
+        if (n.columnConfig.value.label, t.header) {
+          const C = t.header(y);
+          if (Gl(C))
+            return P(tt, C);
+        }
+        return Pt(f.label);
+      }), t["filter-icon"] && (f.renderFilterIcon = (y) => Be(t, "filter-icon", y)), t.expand && (f.renderExpand = (y) => Be(t, "expand", y));
+      let g = f.renderCell;
+      return f.type === "expand" ? (f.renderCell = (y) => P("div", { class: "cell" }, [g(y)]), l.value.renderExpanded = (y) => t.default ? t.default(y) : t.default) : (g = g || Mo, f.renderCell = (y) => {
+        let C = null;
+        if (t.default) {
+          const D = t.default(y);
+          C = D.some((V) => V.type !== Tl) ? D : g(y);
+        } else
+          C = g(y);
+        const { columns: m } = l.value.store.states, x = m.value.findIndex((D) => D.type === "default"), R = Wo(y, i.value && y.cellIndex === x), k = {
+          class: "cell",
+          style: {}
+        };
+        return f.showOverflowTooltip && (k.class = `${k.class} ${S(r.namespace)}-tooltip`, k.style = { width: `${(y.column.realWidth || Number(y.column.width)) - 1}px` }), b(C), P("div", k, [R, C]);
+      }), f;
+    },
+    getPropsData: (...f) => f.reduce((g, y) => (ie(y) && y.forEach((C) => {
+      g[C] = e[C];
+    }), g), {}),
+    getColumnElIndex: (f, g) => Array.prototype.indexOf.call(f, g),
+    updateColumnOrder: () => {
+      l.value.store.commit("updateColumnOrder", n.columnConfig.value);
+    }
+  };
+}
+var Ao = /* @__PURE__ */ De({
+  name: "ElTableColumn",
+  __name: "index",
+  props: No,
+  setup(e) {
+    const t = e, l = qn(), n = he(), a = Dt("table"), u = L({}), c = Y(() => {
+      let y = n.parent;
+      for (; y && !y.tableId; )
+        y = y.parent;
+      return y;
+    }), { registerNormalWatchers: o, registerComplexWatchers: r } = ko(c, t), { columnId: s, isSubColumn: i, realHeaderAlign: d, columnOrTableParent: p, setColumnWidth: h, setColumnForcedProps: v, setColumnRenders: b, getPropsData: w, getColumnElIndex: F, realAlign: O, updateColumnOrder: N } = Ho(t, l, c), f = p.value;
+    s.value = ka("tableId" in f ? f.tableId : f.columnId), Fl(() => {
+      var D, V;
+      i.value = c.value !== f;
+      const y = t.type || "default", C = t.sortable === "" ? !0 : t.sortable, m = y === "selection" ? !1 : be(t.showOverflowTooltip) ? f.props.showOverflowTooltip ?? ((D = a.value) == null ? void 0 : D.showOverflowTooltip) : t.showOverflowTooltip, x = be(t.tooltipFormatter) ? f.props.tooltipFormatter ?? ((V = a.value) == null ? void 0 : V.tooltipFormatter) : t.tooltipFormatter, R = {
+        ...Oo[y],
+        id: s.value,
+        type: y,
+        property: t.prop || t.property,
+        align: O,
+        headerAlign: d,
+        showOverflowTooltip: m,
+        tooltipFormatter: x,
+        filterable: t.filters || t.filterMethod,
+        filteredValue: [],
+        filterPlacement: "",
+        filterClassName: "",
+        isColumnGroup: !1,
+        isSubColumn: !1,
+        filterOpened: !1,
+        sortable: C,
+        index: t.index,
+        rawColumnKey: n.vnode.key
+      };
+      let k = w([
+        "columnKey",
+        "label",
+        "className",
+        "labelClassName",
+        "type",
+        "renderHeader",
+        "formatter",
+        "fixed",
+        "resizable"
+      ], [
+        "sortMethod",
+        "sortBy",
+        "sortOrders"
+      ], ["selectable", "reserveSelection"], [
+        "filterMethod",
+        "filters",
+        "filterMultiple",
+        "filterOpened",
+        "filteredValue",
+        "filterPlacement",
+        "filterClassName"
+      ]);
+      k = $a(R, k), k = za(b, h, v)(k), u.value = k, o(), r();
+    }), lt(() => {
+      var x, R;
+      const y = p.value, C = i.value ? (x = y.vnode.el) == null ? void 0 : x.children : (R = y.refs.hiddenColumns) == null ? void 0 : R.children, m = () => F(C || [], n.vnode.el);
+      u.value.getColumnIndex = m, m() > -1 && c.value.store.commit("insertColumn", u.value, i.value ? "columnConfig" in y && y.columnConfig.value : null, N);
+    }), jt(() => {
+      const y = u.value.getColumnIndex;
+      (y ? y() : -1) > -1 && c.value.store.commit("removeColumn", u.value, i.value ? "columnConfig" in f && f.columnConfig.value : null, N);
+    }), n.columnId = s.value, n.columnConfig = u;
+    const g = () => {
+      var y, C;
+      try {
+        const m = (y = l.default) == null ? void 0 : y.call(l, {
+          row: {},
+          column: {},
+          $index: -1
+        }), x = [];
+        if (ie(m))
+          for (const R of m)
+            ((C = R.type) == null ? void 0 : C.name) === "ElTableColumn" || R.shapeFlag & 2 ? x.push(R) : R.type === tt && ie(R.children) && R.children.forEach((k) => {
+              (k == null ? void 0 : k.patchFlag) !== 1024 && !we(k == null ? void 0 : k.children) && x.push(k);
+            });
+        return P("div", x);
+      } catch {
+        return P("div", []);
+      }
+    };
+    return (y, C) => (te(), Ke(g));
+  }
+}), $o = Ao, Io = $o, tn = Io;
+const Zo = Tn(Ro, { TableColumn: tn }), er = Fn(tn);
+export {
+  er as E,
+  Zo as a
+};