st-comp 0.0.93 → 0.0.94

package/es/el-table-column-675f51e6.js

@@ -0,0 +1,3795 @@
+import { inject as re, computed as T, getCurrentInstance as ee, watch as ie, nextTick as Ee, ref as E, toRaw as Bt, defineComponent as he, useSlots as al, openBlock as D, createBlock as Le, resolveDynamicComponent as il, unref as O, normalizeClass as I, withCtx as ye, createElementVNode as oe, withDirectives as xe, createElementBlock as G, isRef as Be, withModifiers as Qe, vModelCheckbox as Ze, renderSlot as Fe, Fragment as Je, createTextVNode as ot, toDisplayString as Se, createCommentVNode as Ce, normalizeStyle as ke, provide as ul, toRefs as dl, resolveComponent as fe, resolveDirective as cl, createVNode as we, renderList as It, onBeforeMount as fl, onMounted as Ke, onUpdated as wn, onUnmounted as Rt, h as H, watchEffect as He, vShow as zt, Comment as Sn, onBeforeUnmount as xn } from "vue";
+import { o as hl, p as Ve, q as vl, r as En, t as it, c as kn, v as Rn, U as Kt, k as Ln, h as Nn, w as On, S as Fn, l as Mn, x as An, i as Tn, y as Wn, z as Hn, b as pl, E as $n, C as Pn } from "./el-tag-f878b1f1.js";
+import { g as Bn } from "./_commonjsHelpers-10dfc225.js";
+import { A as De, O as ml, S as Vt, B as et, z as gl, P as In, Q as zn, R as Kn, T as Vn, U as Dn, V as jn, i as ut, k as dt, l as tt, E as lt, j as Lt, s as Me, e as ct, u as se, _ as je, b as Un, d as Gn, w as bl, f as Nt, W as Ie, t as Yn, J as Dt, o as ze, g as yl, a as Cl, x as qn, h as Ge, r as ft } from "./base-6e64c2e6.js";
+import { d as jt, c as wl, a as Xn, e as _n, g as Qn } from "./use-global-config-89daeba3.js";
+import { H as Zn, t as Ot, h as Jn, v as Ft, j as ht, w as Sl, E as Mt, a as eo, y as to, z as lo, b as xl, l as no } from "./use-form-item-bfc7dddf.js";
+import { d as nt, a as Ut, u as Gt } from "./el-scrollbar-a00aca2f.js";
+import { U as rt } from "./focus-trap-2677bd39.js";
+import { r as oo } from "./raf-32ed81f4.js";
+var Yt = Object.create, ro = function() {
+  function e() {
+  }
+  return function(t) {
+    if (!De(t))
+      return {};
+    if (Yt)
+      return Yt(t);
+    e.prototype = t;
+    var l = new e();
+    return e.prototype = void 0, l;
+  };
+}();
+const so = ro;
+function ao(e, t, l) {
+  switch (l.length) {
+    case 0:
+      return e.call(t);
+    case 1:
+      return e.call(t, l[0]);
+    case 2:
+      return e.call(t, l[0], l[1]);
+    case 3:
+      return e.call(t, l[0], l[1], l[2]);
+  }
+  return e.apply(t, l);
+}
+function io(e, t) {
+  var l = -1, n = e.length;
+  for (t || (t = Array(n)); ++l < n; )
+    t[l] = e[l];
+  return t;
+}
+var uo = 800, co = 16, fo = Date.now;
+function ho(e) {
+  var t = 0, l = 0;
+  return function() {
+    var n = fo(), r = co - (n - l);
+    if (l = n, r > 0) {
+      if (++t >= uo)
+        return arguments[0];
+    } else
+      t = 0;
+    return e.apply(void 0, arguments);
+  };
+}
+function vo(e) {
+  return function() {
+    return e;
+  };
+}
+var po = jt ? function(e, t) {
+  return jt(e, "toString", {
+    configurable: !0,
+    enumerable: !1,
+    value: vo(t),
+    writable: !0
+  });
+} : hl;
+const mo = po;
+var go = ho(mo);
+const El = go;
+function bo(e, t, l, n) {
+  var r = !l;
+  l || (l = {});
+  for (var a = -1, i = t.length; ++a < i; ) {
+    var o = t[a], s = n ? n(l[o], e[o], o, l, e) : void 0;
+    s === void 0 && (s = e[o]), r ? wl(l, o, s) : Xn(l, o, s);
+  }
+  return l;
+}
+var qt = Math.max;
+function kl(e, t, l) {
+  return t = qt(t === void 0 ? e.length - 1 : t, 0), function() {
+    for (var n = arguments, r = -1, a = qt(n.length - t, 0), i = Array(a); ++r < a; )
+      i[r] = n[t + r];
+    r = -1;
+    for (var o = Array(t + 1); ++r < t; )
+      o[r] = n[r];
+    return o[t] = l(i), ao(e, this, o);
+  };
+}
+function yo(e, t) {
+  return El(kl(e, t, hl), e + "");
+}
+function Co(e, t, l) {
+  if (!De(l))
+    return !1;
+  var n = typeof t;
+  return (n == "number" ? Ve(l) && Zn(t, l.length) : n == "string" && t in l) ? ml(l[t], e) : !1;
+}
+function wo(e) {
+  return yo(function(t, l) {
+    var n = -1, r = l.length, a = r > 1 ? l[r - 1] : void 0, i = r > 2 ? l[2] : void 0;
+    for (a = e.length > 3 && typeof a == "function" ? (r--, a) : void 0, i && Co(l[0], l[1], i) && (a = r < 3 ? void 0 : a, r = 1), t = Object(t); ++n < r; ) {
+      var o = l[n];
+      o && e(t, o, n, a);
+    }
+    return t;
+  });
+}
+function So(e) {
+  var t = [];
+  if (e != null)
+    for (var l in Object(e))
+      t.push(l);
+  return t;
+}
+var xo = Object.prototype, Eo = xo.hasOwnProperty;
+function ko(e) {
+  if (!De(e))
+    return So(e);
+  var t = vl(e), l = [];
+  for (var n in e)
+    n == "constructor" && (t || !Eo.call(e, n)) || l.push(n);
+  return l;
+}
+function Rl(e) {
+  return Ve(e) ? En(e, !0) : ko(e);
+}
+var Xt = Vt ? Vt.isConcatSpreadable : void 0;
+function Ro(e) {
+  return et(e) || it(e) || !!(Xt && e && e[Xt]);
+}
+function At(e, t, l, n, r) {
+  var a = -1, i = e.length;
+  for (l || (l = Ro), r || (r = []); ++a < i; ) {
+    var o = e[a];
+    t > 0 && l(o) ? t > 1 ? At(o, t - 1, l, n, r) : kn(r, o) : n || (r[r.length] = o);
+  }
+  return r;
+}
+function Lo(e) {
+  var t = e == null ? 0 : e.length;
+  return t ? At(e, 1) : [];
+}
+function No(e) {
+  return El(kl(e, void 0, Lo), e + "");
+}
+var Oo = Rn(Object.getPrototypeOf, Object);
+const Ll = Oo;
+var Fo = "[object Object]", Mo = Function.prototype, Ao = Object.prototype, Nl = Mo.toString, To = Ao.hasOwnProperty, Wo = Nl.call(Object);
+function Ho(e) {
+  if (!gl(e) || In(e) != Fo)
+    return !1;
+  var t = Ll(e);
+  if (t === null)
+    return !0;
+  var l = To.call(t, "constructor") && t.constructor;
+  return typeof l == "function" && l instanceof l && Nl.call(l) == Wo;
+}
+var Ol = typeof exports == "object" && exports && !exports.nodeType && exports, _t = Ol && typeof module == "object" && module && !module.nodeType && module, $o = _t && _t.exports === Ol, Qt = $o ? zn.Buffer : void 0, Zt = Qt ? Qt.allocUnsafe : void 0;
+function Po(e, t) {
+  if (t)
+    return e.slice();
+  var l = e.length, n = Zt ? Zt(l) : new e.constructor(l);
+  return e.copy(n), n;
+}
+function Bo(e) {
+  var t = new e.constructor(e.byteLength);
+  return new Kt(t).set(new Kt(e)), t;
+}
+function Io(e, t) {
+  var l = t ? Bo(e.buffer) : e.buffer;
+  return new e.constructor(l, e.byteOffset, e.length);
+}
+function zo(e) {
+  return typeof e.constructor == "function" && !vl(e) ? so(Ll(e)) : {};
+}
+function Ko(e) {
+  return function(t, l, n) {
+    for (var r = -1, a = Object(t), i = n(t), o = i.length; o--; ) {
+      var s = i[e ? o : ++r];
+      if (l(a[s], s, a) === !1)
+        break;
+    }
+    return t;
+  };
+}
+var Vo = Ko();
+const Fl = Vo;
+function Do(e, t) {
+  return e && Fl(e, t, Ln);
+}
+function jo(e, t) {
+  return function(l, n) {
+    if (l == null)
+      return l;
+    if (!Ve(l))
+      return e(l, n);
+    for (var r = l.length, a = t ? r : -1, i = Object(l); (t ? a-- : ++a < r) && n(i[a], a, i) !== !1; )
+      ;
+    return l;
+  };
+}
+var Uo = jo(Do);
+const Go = Uo;
+function vt(e, t, l) {
+  (l !== void 0 && !ml(e[t], l) || l === void 0 && !(t in e)) && wl(e, t, l);
+}
+function Yo(e) {
+  return gl(e) && Ve(e);
+}
+function pt(e, t) {
+  if (!(t === "constructor" && typeof e[t] == "function") && t != "__proto__")
+    return e[t];
+}
+function qo(e) {
+  return bo(e, Rl(e));
+}
+function Xo(e, t, l, n, r, a, i) {
+  var o = pt(e, l), s = pt(t, l), u = i.get(s);
+  if (u) {
+    vt(e, l, u);
+    return;
+  }
+  var d = a ? a(o, s, l + "", e, t, i) : void 0, h = d === void 0;
+  if (h) {
+    var p = et(s), m = !p && Nn(s), f = !p && !m && On(s);
+    d = s, p || m || f ? et(o) ? d = o : Yo(o) ? d = io(o) : m ? (h = !1, d = Po(s, !0)) : f ? (h = !1, d = Io(s, !0)) : d = [] : Ho(s) || it(s) ? (d = o, it(o) ? d = qo(o) : (!De(o) || Kn(o)) && (d = zo(s))) : h = !1;
+  }
+  h && (i.set(s, d), r(d, s, n, a, i), i.delete(s)), vt(e, l, d);
+}
+function Ml(e, t, l, n, r) {
+  e !== t && Fl(t, function(a, i) {
+    if (r || (r = new Fn()), De(a))
+      Xo(e, t, i, l, Ml, n, r);
+    else {
+      var o = n ? n(pt(e, i), a, i + "", e, t, r) : void 0;
+      o === void 0 && (o = a), vt(e, i, o);
+    }
+  }, Rl);
+}
+function _o(e, t) {
+  var l = -1, n = Ve(e) ? Array(e.length) : [];
+  return Go(e, function(r, a, i) {
+    n[++l] = t(r, a, i);
+  }), n;
+}
+function Qo(e, t) {
+  var l = et(e) ? Vn : _o;
+  return l(e, Mn(t));
+}
+function Zo(e, t) {
+  return At(Qo(e, t), 1);
+}
+var Jo = wo(function(e, t, l) {
+  Ml(e, t, l);
+});
+const Al = Jo;
+function er(e, t, l) {
+  for (var n = -1, r = t.length, a = {}; ++n < r; ) {
+    var i = t[n], o = Dn(e, i);
+    l(o, i) && _n(a, jn(i, e), o);
+  }
+  return a;
+}
+function tr(e, t) {
+  return er(e, t, function(l, n) {
+    return An(e, n);
+  });
+}
+var lr = No(function(e, t) {
+  return e == null ? {} : tr(e, t);
+});
+const nr = lr;
+var Jt = !1, Re, mt, gt, Ye, qe, Tl, Xe, bt, yt, Ct, Wl, wt, St, Hl, $l;
+function ne() {
+  if (!Jt) {
+    Jt = !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 (wt = /\b(iPhone|iP[ao]d)/.exec(e), St = /\b(iP[ao]d)/.exec(e), Ct = /Android/i.exec(e), Hl = /FBAN\/\w+;/i.exec(e), $l = /Mobile/i.exec(e), Wl = !!/Win64/.exec(e), t) {
+      Re = t[1] ? parseFloat(t[1]) : t[5] ? parseFloat(t[5]) : NaN, Re && document && document.documentMode && (Re = document.documentMode);
+      var n = /(?:Trident\/(\d+.\d+))/.exec(e);
+      Tl = n ? parseFloat(n[1]) + 4 : Re, mt = t[2] ? parseFloat(t[2]) : NaN, gt = t[3] ? parseFloat(t[3]) : NaN, Ye = t[4] ? parseFloat(t[4]) : NaN, Ye ? (t = /(?:Chrome\/(\d+\.\d+))/.exec(e), qe = t && t[1] ? parseFloat(t[1]) : NaN) : qe = NaN;
+    } else
+      Re = mt = gt = qe = Ye = NaN;
+    if (l) {
+      if (l[1]) {
+        var r = /(?:Mac OS X (\d+(?:[._]\d+)?))/.exec(e);
+        Xe = r ? parseFloat(r[1].replace("_", ".")) : !0;
+      } else
+        Xe = !1;
+      bt = !!l[2], yt = !!l[3];
+    } else
+      Xe = bt = yt = !1;
+  }
+}
+var xt = { ie: function() {
+  return ne() || Re;
+}, ieCompatibilityMode: function() {
+  return ne() || Tl > Re;
+}, ie64: function() {
+  return xt.ie() && Wl;
+}, firefox: function() {
+  return ne() || mt;
+}, opera: function() {
+  return ne() || gt;
+}, webkit: function() {
+  return ne() || Ye;
+}, safari: function() {
+  return xt.webkit();
+}, chrome: function() {
+  return ne() || qe;
+}, windows: function() {
+  return ne() || bt;
+}, osx: function() {
+  return ne() || Xe;
+}, linux: function() {
+  return ne() || yt;
+}, iphone: function() {
+  return ne() || wt;
+}, mobile: function() {
+  return ne() || wt || St || Ct || $l;
+}, nativeApp: function() {
+  return ne() || Hl;
+}, android: function() {
+  return ne() || Ct;
+}, ipad: function() {
+  return ne() || St;
+} }, or = xt, Ue = !!(typeof window < "u" && window.document && window.document.createElement), rr = { canUseDOM: Ue, canUseWorkers: typeof Worker < "u", canUseEventListeners: Ue && !!(window.addEventListener || window.attachEvent), canUseViewport: Ue && !!window.screen, isInWorker: !Ue }, Pl = rr, Bl;
+Pl.canUseDOM && (Bl = document.implementation && document.implementation.hasFeature && document.implementation.hasFeature("", "") !== !0);
+function sr(e, t) {
+  if (!Pl.canUseDOM || t && !("addEventListener" in document))
+    return !1;
+  var l = "on" + e, n = l in document;
+  if (!n) {
+    var r = document.createElement("div");
+    r.setAttribute(l, "return;"), n = typeof r[l] == "function";
+  }
+  return !n && Bl && e === "wheel" && (n = document.implementation.hasFeature("Events.wheel", "3.0")), n;
+}
+var ar = sr, el = 10, tl = 40, ll = 800;
+function Il(e) {
+  var t = 0, l = 0, n = 0, r = 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 * el, r = l * el, "deltaY" in e && (r = e.deltaY), "deltaX" in e && (n = e.deltaX), (n || r) && e.deltaMode && (e.deltaMode == 1 ? (n *= tl, r *= tl) : (n *= ll, r *= ll)), n && !t && (t = n < 1 ? -1 : 1), r && !l && (l = r < 1 ? -1 : 1), { spinX: t, spinY: l, pixelX: n, pixelY: r };
+}
+Il.getEventType = function() {
+  return or.firefox() ? "DOMMouseScroll" : ar("wheel") ? "wheel" : "mousewheel";
+};
+var ir = Il;
+/**
+* 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 ur = function(e, t) {
+  if (e && e.addEventListener) {
+    const l = function(n) {
+      const r = ir(n);
+      t && Reflect.apply(t, this, [n, r]);
+    };
+    e.addEventListener("wheel", l, { passive: !0 });
+  }
+}, dr = {
+  beforeMount(e, t) {
+    ur(e, t.value);
+  }
+}, zl = {
+  modelValue: {
+    type: [Number, String, Boolean],
+    default: void 0
+  },
+  label: {
+    type: [String, Boolean, Number, Object]
+  },
+  indeterminate: Boolean,
+  disabled: Boolean,
+  checked: Boolean,
+  name: {
+    type: String,
+    default: void 0
+  },
+  trueLabel: {
+    type: [String, Number],
+    default: void 0
+  },
+  falseLabel: {
+    type: [String, Number],
+    default: void 0
+  },
+  id: {
+    type: String,
+    default: void 0
+  },
+  controls: {
+    type: String,
+    default: void 0
+  },
+  border: Boolean,
+  size: Ot,
+  tabindex: [String, Number],
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  }
+}, Kl = {
+  [rt]: (e) => ut(e) || dt(e) || tt(e),
+  change: (e) => ut(e) || dt(e) || tt(e)
+}, We = Symbol("checkboxGroupContextKey"), cr = ({
+  model: e,
+  isChecked: t
+}) => {
+  const l = re(We, void 0), n = T(() => {
+    var a, i;
+    const o = (a = l == null ? void 0 : l.max) == null ? void 0 : a.value, s = (i = l == null ? void 0 : l.min) == null ? void 0 : i.value;
+    return !lt(o) && e.value.length >= o && !t.value || !lt(s) && e.value.length <= s && t.value;
+  });
+  return {
+    isDisabled: Jn(T(() => (l == null ? void 0 : l.disabled.value) || n.value)),
+    isLimitDisabled: n
+  };
+}, fr = (e, {
+  model: t,
+  isLimitExceeded: l,
+  hasOwnLabel: n,
+  isDisabled: r,
+  isLabeledByFormItem: a
+}) => {
+  const i = re(We, void 0), { formItem: o } = Ft(), { emit: s } = ee();
+  function u(f) {
+    var g, v;
+    return f === e.trueLabel || f === !0 ? (g = e.trueLabel) != null ? g : !0 : (v = e.falseLabel) != null ? v : !1;
+  }
+  function d(f, g) {
+    s("change", u(f), g);
+  }
+  function h(f) {
+    if (l.value)
+      return;
+    const g = f.target;
+    s("change", u(g.checked), f);
+  }
+  async function p(f) {
+    l.value || !n.value && !r.value && a.value && (f.composedPath().some((y) => y.tagName === "LABEL") || (t.value = u([!1, e.falseLabel].includes(t.value)), await Ee(), d(t.value, f)));
+  }
+  const m = T(() => (i == null ? void 0 : i.validateEvent) || e.validateEvent);
+  return ie(() => e.modelValue, () => {
+    m.value && (o == null || o.validate("change").catch((f) => Lt(f)));
+  }), {
+    handleChange: h,
+    onClickRoot: p
+  };
+}, hr = (e) => {
+  const t = E(!1), { emit: l } = ee(), n = re(We, void 0), r = T(() => lt(n) === !1), a = E(!1);
+  return {
+    model: T({
+      get() {
+        var o, s;
+        return r.value ? (o = n == null ? void 0 : n.modelValue) == null ? void 0 : o.value : (s = e.modelValue) != null ? s : t.value;
+      },
+      set(o) {
+        var s, u;
+        r.value && Me(o) ? (a.value = ((s = n == null ? void 0 : n.max) == null ? void 0 : s.value) !== void 0 && o.length > (n == null ? void 0 : n.max.value), a.value === !1 && ((u = n == null ? void 0 : n.changeEvent) == null || u.call(n, o))) : (l(rt, o), t.value = o);
+      }
+    }),
+    isGroup: r,
+    isLimitExceeded: a
+  };
+}, vr = (e, t, { model: l }) => {
+  const n = re(We, void 0), r = E(!1), a = T(() => {
+    const u = l.value;
+    return tt(u) ? u : Me(u) ? ct(e.label) ? u.map(Bt).some((d) => Tn(d, e.label)) : u.map(Bt).includes(e.label) : u != null ? u === e.trueLabel : !!u;
+  }), i = ht(T(() => {
+    var u;
+    return (u = n == null ? void 0 : n.size) == null ? void 0 : u.value;
+  }), {
+    prop: !0
+  }), o = ht(T(() => {
+    var u;
+    return (u = n == null ? void 0 : n.size) == null ? void 0 : u.value;
+  })), s = T(() => !!(t.default || e.label));
+  return {
+    checkboxButtonSize: i,
+    isChecked: a,
+    isFocused: r,
+    checkboxSize: o,
+    hasOwnLabel: s
+  };
+}, pr = (e, { model: t }) => {
+  function l() {
+    Me(t.value) && !t.value.includes(e.label) ? t.value.push(e.label) : t.value = e.trueLabel || !0;
+  }
+  e.checked && l();
+}, Vl = (e, t) => {
+  const { formItem: l } = Ft(), { model: n, isGroup: r, isLimitExceeded: a } = hr(e), {
+    isFocused: i,
+    isChecked: o,
+    checkboxButtonSize: s,
+    checkboxSize: u,
+    hasOwnLabel: d
+  } = vr(e, t, { model: n }), { isDisabled: h } = cr({ model: n, isChecked: o }), { inputId: p, isLabeledByFormItem: m } = Sl(e, {
+    formItemContext: l,
+    disableIdGeneration: d,
+    disableIdManagement: r
+  }), { handleChange: f, onClickRoot: g } = fr(e, {
+    model: n,
+    isLimitExceeded: a,
+    hasOwnLabel: d,
+    isDisabled: h,
+    isLabeledByFormItem: m
+  });
+  return pr(e, { model: n }), {
+    inputId: p,
+    isLabeledByFormItem: m,
+    isChecked: o,
+    isDisabled: h,
+    isFocused: i,
+    checkboxButtonSize: s,
+    checkboxSize: u,
+    hasOwnLabel: d,
+    model: n,
+    handleChange: f,
+    onClickRoot: g
+  };
+}, mr = ["tabindex", "role", "aria-checked"], gr = ["id", "aria-hidden", "name", "tabindex", "disabled", "true-value", "false-value"], br = ["id", "aria-hidden", "disabled", "value", "name", "tabindex"], yr = he({
+  name: "ElCheckbox"
+}), Cr = /* @__PURE__ */ he({
+  ...yr,
+  props: zl,
+  emits: Kl,
+  setup(e) {
+    const t = e, l = al(), {
+      inputId: n,
+      isLabeledByFormItem: r,
+      isChecked: a,
+      isDisabled: i,
+      isFocused: o,
+      checkboxSize: s,
+      hasOwnLabel: u,
+      model: d,
+      handleChange: h,
+      onClickRoot: p
+    } = Vl(t, l), m = se("checkbox"), f = T(() => [
+      m.b(),
+      m.m(s.value),
+      m.is("disabled", i.value),
+      m.is("bordered", t.border),
+      m.is("checked", a.value)
+    ]), g = T(() => [
+      m.e("input"),
+      m.is("disabled", i.value),
+      m.is("checked", a.value),
+      m.is("indeterminate", t.indeterminate),
+      m.is("focus", o.value)
+    ]);
+    return (v, y) => (D(), Le(il(!O(u) && O(r) ? "span" : "label"), {
+      class: I(O(f)),
+      "aria-controls": v.indeterminate ? v.controls : null,
+      onClick: O(p)
+    }, {
+      default: ye(() => [
+        oe("span", {
+          class: I(O(g)),
+          tabindex: v.indeterminate ? 0 : void 0,
+          role: v.indeterminate ? "checkbox" : void 0,
+          "aria-checked": v.indeterminate ? "mixed" : void 0
+        }, [
+          v.trueLabel || v.falseLabel ? xe((D(), G("input", {
+            key: 0,
+            id: O(n),
+            "onUpdate:modelValue": y[0] || (y[0] = (b) => Be(d) ? d.value = b : null),
+            class: I(O(m).e("original")),
+            type: "checkbox",
+            "aria-hidden": v.indeterminate ? "true" : "false",
+            name: v.name,
+            tabindex: v.tabindex,
+            disabled: O(i),
+            "true-value": v.trueLabel,
+            "false-value": v.falseLabel,
+            onChange: y[1] || (y[1] = (...b) => O(h) && O(h)(...b)),
+            onFocus: y[2] || (y[2] = (b) => o.value = !0),
+            onBlur: y[3] || (y[3] = (b) => o.value = !1),
+            onClick: y[4] || (y[4] = Qe(() => {
+            }, ["stop"]))
+          }, null, 42, gr)), [
+            [Ze, O(d)]
+          ]) : xe((D(), G("input", {
+            key: 1,
+            id: O(n),
+            "onUpdate:modelValue": y[5] || (y[5] = (b) => Be(d) ? d.value = b : null),
+            class: I(O(m).e("original")),
+            type: "checkbox",
+            "aria-hidden": v.indeterminate ? "true" : "false",
+            disabled: O(i),
+            value: v.label,
+            name: v.name,
+            tabindex: v.tabindex,
+            onChange: y[6] || (y[6] = (...b) => O(h) && O(h)(...b)),
+            onFocus: y[7] || (y[7] = (b) => o.value = !0),
+            onBlur: y[8] || (y[8] = (b) => o.value = !1),
+            onClick: y[9] || (y[9] = Qe(() => {
+            }, ["stop"]))
+          }, null, 42, br)), [
+            [Ze, O(d)]
+          ]),
+          oe("span", {
+            class: I(O(m).e("inner"))
+          }, null, 2)
+        ], 10, mr),
+        O(u) ? (D(), G("span", {
+          key: 0,
+          class: I(O(m).e("label"))
+        }, [
+          Fe(v.$slots, "default"),
+          v.$slots.default ? Ce("v-if", !0) : (D(), G(Je, { key: 0 }, [
+            ot(Se(v.label), 1)
+          ], 64))
+        ], 2)) : Ce("v-if", !0)
+      ]),
+      _: 3
+    }, 8, ["class", "aria-controls", "onClick"]));
+  }
+});
+var wr = /* @__PURE__ */ je(Cr, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/checkbox/src/checkbox.vue"]]);
+const Sr = ["name", "tabindex", "disabled", "true-value", "false-value"], xr = ["name", "tabindex", "disabled", "value"], Er = he({
+  name: "ElCheckboxButton"
+}), kr = /* @__PURE__ */ he({
+  ...Er,
+  props: zl,
+  emits: Kl,
+  setup(e) {
+    const t = e, l = al(), {
+      isFocused: n,
+      isChecked: r,
+      isDisabled: a,
+      checkboxButtonSize: i,
+      model: o,
+      handleChange: s
+    } = Vl(t, l), u = re(We, void 0), d = se("checkbox"), h = T(() => {
+      var m, f, g, v;
+      const y = (f = (m = u == null ? void 0 : u.fill) == null ? void 0 : m.value) != null ? f : "";
+      return {
+        backgroundColor: y,
+        borderColor: y,
+        color: (v = (g = u == null ? void 0 : u.textColor) == null ? void 0 : g.value) != null ? v : "",
+        boxShadow: y ? `-1px 0 0 0 ${y}` : void 0
+      };
+    }), p = T(() => [
+      d.b("button"),
+      d.bm("button", i.value),
+      d.is("disabled", a.value),
+      d.is("checked", r.value),
+      d.is("focus", n.value)
+    ]);
+    return (m, f) => (D(), G("label", {
+      class: I(O(p))
+    }, [
+      m.trueLabel || m.falseLabel ? xe((D(), G("input", {
+        key: 0,
+        "onUpdate:modelValue": f[0] || (f[0] = (g) => Be(o) ? o.value = g : null),
+        class: I(O(d).be("button", "original")),
+        type: "checkbox",
+        name: m.name,
+        tabindex: m.tabindex,
+        disabled: O(a),
+        "true-value": m.trueLabel,
+        "false-value": m.falseLabel,
+        onChange: f[1] || (f[1] = (...g) => O(s) && O(s)(...g)),
+        onFocus: f[2] || (f[2] = (g) => n.value = !0),
+        onBlur: f[3] || (f[3] = (g) => n.value = !1),
+        onClick: f[4] || (f[4] = Qe(() => {
+        }, ["stop"]))
+      }, null, 42, Sr)), [
+        [Ze, O(o)]
+      ]) : xe((D(), G("input", {
+        key: 1,
+        "onUpdate:modelValue": f[5] || (f[5] = (g) => Be(o) ? o.value = g : null),
+        class: I(O(d).be("button", "original")),
+        type: "checkbox",
+        name: m.name,
+        tabindex: m.tabindex,
+        disabled: O(a),
+        value: m.label,
+        onChange: f[6] || (f[6] = (...g) => O(s) && O(s)(...g)),
+        onFocus: f[7] || (f[7] = (g) => n.value = !0),
+        onBlur: f[8] || (f[8] = (g) => n.value = !1),
+        onClick: f[9] || (f[9] = Qe(() => {
+        }, ["stop"]))
+      }, null, 42, xr)), [
+        [Ze, O(o)]
+      ]),
+      m.$slots.default || m.label ? (D(), G("span", {
+        key: 2,
+        class: I(O(d).be("button", "inner")),
+        style: ke(O(r) ? O(h) : void 0)
+      }, [
+        Fe(m.$slots, "default", {}, () => [
+          ot(Se(m.label), 1)
+        ])
+      ], 6)) : Ce("v-if", !0)
+    ], 2));
+  }
+});
+var Dl = /* @__PURE__ */ je(kr, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/checkbox/src/checkbox-button.vue"]]);
+const Rr = Un({
+  modelValue: {
+    type: Gn(Array),
+    default: () => []
+  },
+  disabled: Boolean,
+  min: Number,
+  max: Number,
+  size: Ot,
+  label: String,
+  fill: String,
+  textColor: String,
+  tag: {
+    type: String,
+    default: "div"
+  },
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  }
+}), Lr = {
+  [rt]: (e) => Me(e),
+  change: (e) => Me(e)
+}, Nr = he({
+  name: "ElCheckboxGroup"
+}), Or = /* @__PURE__ */ he({
+  ...Nr,
+  props: Rr,
+  emits: Lr,
+  setup(e, { emit: t }) {
+    const l = e, n = se("checkbox"), { formItem: r } = Ft(), { inputId: a, isLabeledByFormItem: i } = Sl(l, {
+      formItemContext: r
+    }), o = async (u) => {
+      t(rt, u), await Ee(), t("change", u);
+    }, s = T({
+      get() {
+        return l.modelValue;
+      },
+      set(u) {
+        o(u);
+      }
+    });
+    return ul(We, {
+      ...nr(dl(l), [
+        "size",
+        "min",
+        "max",
+        "disabled",
+        "validateEvent",
+        "fill",
+        "textColor"
+      ]),
+      modelValue: s,
+      changeEvent: o
+    }), ie(() => l.modelValue, () => {
+      l.validateEvent && (r == null || r.validate("change").catch((u) => Lt(u)));
+    }), (u, d) => {
+      var h;
+      return D(), Le(il(u.tag), {
+        id: O(a),
+        class: I(O(n).b("group")),
+        role: "group",
+        "aria-label": O(i) ? void 0 : u.label || "checkbox-group",
+        "aria-labelledby": O(i) ? (h = O(r)) == null ? void 0 : h.labelId : void 0
+      }, {
+        default: ye(() => [
+          Fe(u.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["id", "class", "aria-label", "aria-labelledby"]);
+    };
+  }
+});
+var jl = /* @__PURE__ */ je(Or, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/checkbox/src/checkbox-group.vue"]]);
+const Ae = bl(wr, {
+  CheckboxButton: Dl,
+  CheckboxGroup: jl
+});
+Nt(Dl);
+const qs = Nt(jl);
+/*!
+ * escape-html
+ * Copyright(c) 2012-2013 TJ Holowaychuk
+ * Copyright(c) 2015 Andreas Lubbe
+ * Copyright(c) 2015 Tiancheng "Timothy" Gu
+ * MIT Licensed
+ */
+var Fr = /["'&<>]/, Mr = Ar;
+function Ar(e) {
+  var t = "" + e, l = Fr.exec(t);
+  if (!l)
+    return t;
+  var n, r = "", a = 0, i = 0;
+  for (a = l.index; a < t.length; a++) {
+    switch (t.charCodeAt(a)) {
+      case 34:
+        n = "&quot;";
+        break;
+      case 38:
+        n = "&amp;";
+        break;
+      case 39:
+        n = "&#39;";
+        break;
+      case 60:
+        n = "&lt;";
+        break;
+      case 62:
+        n = "&gt;";
+        break;
+      default:
+        continue;
+    }
+    i !== a && (r += t.substring(i, a)), i = a + 1, r += n;
+  }
+  return i !== a ? r + t.substring(i, a) : r;
+}
+const Tr = /* @__PURE__ */ Bn(Mr), at = function(e) {
+  var t;
+  return (t = e.target) == null ? void 0 : t.closest("td");
+}, Wr = function(e, t, l, n, r) {
+  if (!t && !n && (!r || Array.isArray(r) && !r.length))
+    return e;
+  typeof l == "string" ? l = l === "descending" ? -1 : 1 : l = l && l < 0 ? -1 : 1;
+  const a = n ? null : function(o, s) {
+    return r ? (Array.isArray(r) || (r = [r]), r.map((u) => typeof u == "string" ? Dt(o, u) : u(o, s, e))) : (t !== "$key" && ct(o) && "$value" in o && (o = o.$value), [ct(o) ? Dt(o, t) : o]);
+  }, i = function(o, s) {
+    if (n)
+      return n(o.value, s.value);
+    for (let u = 0, d = o.key.length; u < d; u++) {
+      if (o.key[u] < s.key[u])
+        return -1;
+      if (o.key[u] > s.key[u])
+        return 1;
+    }
+    return 0;
+  };
+  return e.map((o, s) => ({
+    value: o,
+    index: s,
+    key: a ? a(o, s) : null
+  })).sort((o, s) => {
+    let u = i(o, s);
+    return u || (u = o.index - s.index), u * +l;
+  }).map((o) => o.value);
+}, Ul = function(e, t) {
+  let l = null;
+  return e.columns.forEach((n) => {
+    n.id === t && (l = n);
+  }), l;
+}, Hr = function(e, t) {
+  let l = null;
+  for (let n = 0; n < e.columns.length; n++) {
+    const r = e.columns[n];
+    if (r.columnKey === t) {
+      l = r;
+      break;
+    }
+  }
+  return l || Yn("ElTable", `No column matching with column-key: ${t}`), l;
+}, nl = function(e, t, l) {
+  const n = (t.className || "").match(new RegExp(`${l}-table_[^\\s]+`, "gm"));
+  return n ? Ul(e, n[0]) : null;
+}, Z = (e, t) => {
+  if (!e)
+    throw new Error("Row is required when get row identity");
+  if (typeof t == "string") {
+    if (!t.includes("."))
+      return `${e[t]}`;
+    const l = t.split(".");
+    let n = e;
+    for (const r of l)
+      n = n[r];
+    return `${n}`;
+  } else if (typeof t == "function")
+    return t.call(null, e);
+}, Ne = function(e, t) {
+  const l = {};
+  return (e || []).forEach((n, r) => {
+    l[Z(n, t)] = { row: n, index: r };
+  }), l;
+};
+function $r(e, t) {
+  const l = {};
+  let n;
+  for (n in e)
+    l[n] = e[n];
+  for (n in t)
+    if (Ie(t, n)) {
+      const r = t[n];
+      typeof r < "u" && (l[n] = r);
+    }
+  return l;
+}
+function Tt(e) {
+  return e === "" || e !== void 0 && (e = Number.parseInt(e, 10), Number.isNaN(e) && (e = "")), e;
+}
+function Gl(e) {
+  return e === "" || e !== void 0 && (e = Tt(e), Number.isNaN(e) && (e = 80)), e;
+}
+function Pr(e) {
+  return typeof e == "number" ? e : typeof e == "string" ? /^\d+(?:px)?$/.test(e) ? Number.parseInt(e, 10) : e : null;
+}
+function Br(...e) {
+  return e.length === 0 ? (t) => t : e.length === 1 ? e[0] : e.reduce((t, l) => (...n) => t(l(...n)));
+}
+function $e(e, t, l) {
+  let n = !1;
+  const r = e.indexOf(t), a = r !== -1, i = (o) => {
+    o === "add" ? e.push(t) : e.splice(r, 1), n = !0, Me(t.children) && t.children.forEach((s) => {
+      $e(e, s, l ?? !a);
+    });
+  };
+  return tt(l) ? l && !a ? i("add") : !l && a && i("remove") : i(a ? "remove" : "add"), n;
+}
+function Ir(e, t, l = "children", n = "hasChildren") {
+  const r = (i) => !(Array.isArray(i) && i.length);
+  function a(i, o, s) {
+    t(i, o, s), o.forEach((u) => {
+      if (u[n]) {
+        t(u, null, s + 1);
+        return;
+      }
+      const d = u[l];
+      r(d) || a(u, d, s + 1);
+    });
+  }
+  e.forEach((i) => {
+    if (i[n]) {
+      t(i, null, 0);
+      return;
+    }
+    const o = i[l];
+    r(o) || a(i, o, 0);
+  });
+}
+let be;
+function zr(e, t, l, n, r) {
+  r = Al({
+    enterable: !0,
+    showArrow: !0
+  }, r);
+  const a = e == null ? void 0 : e.dataset.prefix, i = e == null ? void 0 : e.querySelector(`.${a}-scrollbar__wrap`);
+  function o() {
+    const v = r.effect === "light", y = document.createElement("div");
+    return y.className = [
+      `${a}-popper`,
+      v ? "is-light" : "is-dark",
+      r.popperClass || ""
+    ].join(" "), l = Tr(l), y.innerHTML = l, y.style.zIndex = String(n()), e == null || e.appendChild(y), y;
+  }
+  function s() {
+    const v = document.createElement("div");
+    return v.className = `${a}-popper__arrow`, v;
+  }
+  function u() {
+    d && d.update();
+  }
+  be == null || be(), be = () => {
+    try {
+      d && d.destroy(), m && (e == null || e.removeChild(m)), t.removeEventListener("mouseenter", h), t.removeEventListener("mouseleave", p), i == null || i.removeEventListener("scroll", be), be = void 0;
+    } catch {
+    }
+  };
+  let d = null, h = u, p = be;
+  r.enterable && ({ onOpen: h, onClose: p } = Wn({
+    showAfter: r.showAfter,
+    hideAfter: r.hideAfter,
+    open: u,
+    close: be
+  }));
+  const m = o();
+  m.onmouseenter = h, m.onmouseleave = p;
+  const f = [];
+  if (r.offset && f.push({
+    name: "offset",
+    options: {
+      offset: [0, r.offset]
+    }
+  }), r.showArrow) {
+    const v = m.appendChild(s());
+    f.push({
+      name: "arrow",
+      options: {
+        element: v,
+        padding: 10
+      }
+    });
+  }
+  const g = r.popperOptions || {};
+  return d = Hn(t, m, {
+    placement: r.placement || "top",
+    strategy: "fixed",
+    ...g,
+    modifiers: g.modifiers ? f.concat(g.modifiers) : f
+  }), t.addEventListener("mouseenter", h), t.addEventListener("mouseleave", p), i == null || i.addEventListener("scroll", be), d;
+}
+function Yl(e) {
+  return e.children ? Zo(e.children, Yl) : [e];
+}
+function ol(e, t) {
+  return e + t.colSpan;
+}
+const ql = (e, t, l, n) => {
+  let r = 0, a = e;
+  const i = l.states.columns.value;
+  if (n) {
+    const s = Yl(n[e]);
+    r = i.slice(0, i.indexOf(s[0])).reduce(ol, 0), a = r + s.reduce(ol, 0) - 1;
+  } else
+    r = e;
+  let o;
+  switch (t) {
+    case "left":
+      a < l.states.fixedLeafColumnsLength.value && (o = "left");
+      break;
+    case "right":
+      r >= i.length - l.states.rightFixedLeafColumnsLength.value && (o = "right");
+      break;
+    default:
+      a < l.states.fixedLeafColumnsLength.value ? o = "left" : r >= i.length - l.states.rightFixedLeafColumnsLength.value && (o = "right");
+  }
+  return o ? {
+    direction: o,
+    start: r,
+    after: a
+  } : {};
+}, Wt = (e, t, l, n, r, a = 0) => {
+  const i = [], { direction: o, start: s, after: u } = ql(t, l, n, r);
+  if (o) {
+    const d = o === "left";
+    i.push(`${e}-fixed-column--${o}`), d && u + a === n.states.fixedLeafColumnsLength.value - 1 ? i.push("is-last-column") : !d && s - a === n.states.columns.value.length - n.states.rightFixedLeafColumnsLength.value && i.push("is-first-column");
+  }
+  return i;
+};
+function rl(e, t) {
+  return e + (t.realWidth === null || Number.isNaN(t.realWidth) ? Number(t.width) : t.realWidth);
+}
+const Ht = (e, t, l, n) => {
+  const {
+    direction: r,
+    start: a = 0,
+    after: i = 0
+  } = ql(e, t, l, n);
+  if (!r)
+    return;
+  const o = {}, s = r === "left", u = l.states.columns.value;
+  return s ? o.left = u.slice(0, a).reduce(rl, 0) : o.right = u.slice(i + 1).reverse().reduce(rl, 0), o;
+}, Te = (e, t) => {
+  e && (Number.isNaN(e[t]) || (e[t] = `${e[t]}px`));
+};
+function Kr(e) {
+  const t = ee(), l = E(!1), n = E([]);
+  return {
+    updateExpandRows: () => {
+      const s = e.data.value || [], u = e.rowKey.value;
+      if (l.value)
+        n.value = s.slice();
+      else if (u) {
+        const d = Ne(n.value, u);
+        n.value = s.reduce((h, p) => {
+          const m = Z(p, u);
+          return d[m] && h.push(p), h;
+        }, []);
+      } else
+        n.value = [];
+    },
+    toggleRowExpansion: (s, u) => {
+      $e(n.value, s, u) && t.emit("expand-change", s, n.value.slice());
+    },
+    setExpandRowKeys: (s) => {
+      t.store.assertRowKey();
+      const u = e.data.value || [], d = e.rowKey.value, h = Ne(u, d);
+      n.value = s.reduce((p, m) => {
+        const f = h[m];
+        return f && p.push(f.row), p;
+      }, []);
+    },
+    isRowExpanded: (s) => {
+      const u = e.rowKey.value;
+      return u ? !!Ne(n.value, u)[Z(s, u)] : n.value.includes(s);
+    },
+    states: {
+      expandRows: n,
+      defaultExpandAll: l
+    }
+  };
+}
+function Vr(e) {
+  const t = ee(), l = E(null), n = E(null), r = (u) => {
+    t.store.assertRowKey(), l.value = u, i(u);
+  }, a = () => {
+    l.value = null;
+  }, i = (u) => {
+    const { data: d, rowKey: h } = e;
+    let p = null;
+    h.value && (p = (O(d) || []).find((m) => Z(m, h.value) === u)), n.value = p, t.emit("current-change", n.value, null);
+  };
+  return {
+    setCurrentRowKey: r,
+    restoreCurrentRowKey: a,
+    setCurrentRowByKey: i,
+    updateCurrentRow: (u) => {
+      const d = n.value;
+      if (u && u !== d) {
+        n.value = u, t.emit("current-change", n.value, d);
+        return;
+      }
+      !u && d && (n.value = null, t.emit("current-change", null, d));
+    },
+    updateCurrentRowData: () => {
+      const u = e.rowKey.value, d = e.data.value || [], h = n.value;
+      if (!d.includes(h) && h) {
+        if (u) {
+          const p = Z(h, u);
+          i(p);
+        } else
+          n.value = null;
+        n.value === null && t.emit("current-change", null, h);
+      } else
+        l.value && (i(l.value), a());
+    },
+    states: {
+      _currentRowKey: l,
+      currentRow: n
+    }
+  };
+}
+function Dr(e) {
+  const t = E([]), l = E({}), n = E(16), r = E(!1), a = E({}), i = E("hasChildren"), o = E("children"), s = ee(), u = T(() => {
+    if (!e.rowKey.value)
+      return {};
+    const y = e.data.value || [];
+    return h(y);
+  }), d = T(() => {
+    const y = e.rowKey.value, b = Object.keys(a.value), S = {};
+    return b.length && b.forEach((c) => {
+      if (a.value[c].length) {
+        const x = { children: [] };
+        a.value[c].forEach((k) => {
+          const w = Z(k, y);
+          x.children.push(w), k[i.value] && !S[w] && (S[w] = { children: [] });
+        }), S[c] = x;
+      }
+    }), S;
+  }), h = (y) => {
+    const b = e.rowKey.value, S = {};
+    return Ir(y, (c, x, k) => {
+      const w = Z(c, b);
+      Array.isArray(x) ? S[w] = {
+        children: x.map((R) => Z(R, b)),
+        level: k
+      } : r.value && (S[w] = {
+        children: [],
+        lazy: !0,
+        level: k
+      });
+    }, o.value, i.value), S;
+  }, p = (y = !1, b = ((S) => (S = s.store) == null ? void 0 : S.states.defaultExpandAll.value)()) => {
+    var S;
+    const c = u.value, x = d.value, k = Object.keys(c), w = {};
+    if (k.length) {
+      const R = O(l), F = [], K = (M, z) => {
+        if (y)
+          return t.value ? b || t.value.includes(z) : !!(b || M != null && M.expanded);
+        {
+          const j = b || t.value && t.value.includes(z);
+          return !!(M != null && M.expanded || j);
+        }
+      };
+      k.forEach((M) => {
+        const z = R[M], j = { ...c[M] };
+        if (j.expanded = K(z, M), j.lazy) {
+          const { loaded: X = !1, loading: _ = !1 } = z || {};
+          j.loaded = !!X, j.loading = !!_, F.push(M);
+        }
+        w[M] = j;
+      });
+      const B = Object.keys(x);
+      r.value && B.length && F.length && B.forEach((M) => {
+        const z = R[M], j = x[M].children;
+        if (F.includes(M)) {
+          if (w[M].children.length !== 0)
+            throw new Error("[ElTable]children must be an empty array.");
+          w[M].children = j;
+        } else {
+          const { loaded: X = !1, loading: _ = !1 } = z || {};
+          w[M] = {
+            lazy: !0,
+            loaded: !!X,
+            loading: !!_,
+            expanded: K(z, M),
+            children: j,
+            level: ""
+          };
+        }
+      });
+    }
+    l.value = w, (S = s.store) == null || S.updateTableScrollY();
+  };
+  ie(() => t.value, () => {
+    p(!0);
+  }), ie(() => u.value, () => {
+    p();
+  }), ie(() => d.value, () => {
+    p();
+  });
+  const m = (y) => {
+    t.value = y, p();
+  }, f = (y, b) => {
+    s.store.assertRowKey();
+    const S = e.rowKey.value, c = Z(y, S), x = c && l.value[c];
+    if (c && x && "expanded" in x) {
+      const k = x.expanded;
+      b = typeof b > "u" ? !x.expanded : b, l.value[c].expanded = b, k !== b && s.emit("expand-change", y, b), s.store.updateTableScrollY();
+    }
+  }, g = (y) => {
+    s.store.assertRowKey();
+    const b = e.rowKey.value, S = Z(y, b), c = l.value[S];
+    r.value && c && "loaded" in c && !c.loaded ? v(y, S, c) : f(y, void 0);
+  }, v = (y, b, S) => {
+    const { load: c } = s.props;
+    c && !l.value[b].loaded && (l.value[b].loading = !0, c(y, S, (x) => {
+      if (!Array.isArray(x))
+        throw new TypeError("[ElTable] data must be an array");
+      l.value[b].loading = !1, l.value[b].loaded = !0, l.value[b].expanded = !0, x.length && (a.value[b] = x), s.emit("expand-change", y, !0);
+    }));
+  };
+  return {
+    loadData: v,
+    loadOrToggle: g,
+    toggleTreeExpansion: f,
+    updateTreeExpandKeys: m,
+    updateTreeData: p,
+    normalize: h,
+    states: {
+      expandRowKeys: t,
+      treeData: l,
+      indent: n,
+      lazy: r,
+      lazyTreeNodeMap: a,
+      lazyColumnIdentifier: i,
+      childrenColumnName: o
+    }
+  };
+}
+const jr = (e, t) => {
+  const l = t.sortingColumn;
+  return !l || typeof l.sortable == "string" ? e : Wr(e, t.sortProp, t.sortOrder, l.sortMethod, l.sortBy);
+}, _e = (e) => {
+  const t = [];
+  return e.forEach((l) => {
+    l.children && l.children.length > 0 ? t.push.apply(t, _e(l.children)) : t.push(l);
+  }), t;
+};
+function Ur() {
+  var e;
+  const t = ee(), { size: l } = dl((e = t.proxy) == null ? void 0 : e.$props), n = E(null), r = E([]), a = E([]), i = E(!1), o = E([]), s = E([]), u = E([]), d = E([]), h = E([]), p = E([]), m = E([]), f = E([]), g = [], v = E(0), y = E(0), b = E(0), S = E(!1), c = E([]), x = E(!1), k = E(!1), w = E(null), R = E({}), F = E(null), K = E(null), B = E(null), M = E(null), z = E(null);
+  ie(r, () => t.state && ue(!1), {
+    deep: !0
+  });
+  const j = () => {
+    if (!n.value)
+      throw new Error("[ElTable] prop row-key is required");
+  }, X = (N) => {
+    var A;
+    (A = N.children) == null || A.forEach(($) => {
+      $.fixed = N.fixed, X($);
+    });
+  }, _ = () => {
+    o.value.forEach((V) => {
+      X(V);
+    }), d.value = o.value.filter((V) => V.fixed === !0 || V.fixed === "left"), h.value = o.value.filter((V) => V.fixed === "right"), d.value.length > 0 && o.value[0] && o.value[0].type === "selection" && !o.value[0].fixed && (o.value[0].fixed = !0, d.value.unshift(o.value[0]));
+    const N = o.value.filter((V) => !V.fixed);
+    s.value = [].concat(d.value).concat(N).concat(h.value);
+    const A = _e(N), $ = _e(d.value), W = _e(h.value);
+    v.value = A.length, y.value = $.length, b.value = W.length, u.value = [].concat($).concat(A).concat(W), i.value = d.value.length > 0 || h.value.length > 0;
+  }, ue = (N, A = !1) => {
+    N && _(), A ? t.state.doLayout() : t.state.debouncedUpdateLayout();
+  }, Q = (N) => c.value.includes(N), C = () => {
+    S.value = !1, c.value.length && (c.value = [], t.emit("selection-change", []));
+  }, L = () => {
+    let N;
+    if (n.value) {
+      N = [];
+      const A = Ne(c.value, n.value), $ = Ne(r.value, n.value);
+      for (const W in A)
+        Ie(A, W) && !$[W] && N.push(A[W].row);
+    } else
+      N = c.value.filter((A) => !r.value.includes(A));
+    if (N.length) {
+      const A = c.value.filter(($) => !N.includes($));
+      c.value = A, t.emit("selection-change", A.slice());
+    }
+  }, P = () => (c.value || []).slice(), U = (N, A = void 0, $ = !0) => {
+    if ($e(c.value, N, A)) {
+      const V = (c.value || []).slice();
+      $ && t.emit("select", V, N), t.emit("selection-change", V);
+    }
+  }, Y = () => {
+    var N, A;
+    const $ = k.value ? !S.value : !(S.value || c.value.length);
+    S.value = $;
+    let W = !1, V = 0;
+    const J = (A = (N = t == null ? void 0 : t.store) == null ? void 0 : N.states) == null ? void 0 : A.rowKey.value;
+    r.value.forEach((ce, Oe) => {
+      const ge = Oe + V;
+      w.value ? w.value.call(null, ce, ge) && $e(c.value, ce, $) && (W = !0) : $e(c.value, ce, $) && (W = !0), V += te(Z(ce, J));
+    }), W && t.emit("selection-change", c.value ? c.value.slice() : []), t.emit("select-all", c.value);
+  }, q = () => {
+    const N = Ne(c.value, n.value);
+    r.value.forEach((A) => {
+      const $ = Z(A, n.value), W = N[$];
+      W && (c.value[W.index] = A);
+    });
+  }, ae = () => {
+    var N, A, $;
+    if (((N = r.value) == null ? void 0 : N.length) === 0) {
+      S.value = !1;
+      return;
+    }
+    let W;
+    n.value && (W = Ne(c.value, n.value));
+    const V = function(ge) {
+      return W ? !!W[Z(ge, n.value)] : c.value.includes(ge);
+    };
+    let J = !0, ce = 0, Oe = 0;
+    for (let ge = 0, gn = (r.value || []).length; ge < gn; ge++) {
+      const bn = ($ = (A = t == null ? void 0 : t.store) == null ? void 0 : A.states) == null ? void 0 : $.rowKey.value, yn = ge + Oe, st = r.value[ge], Cn = w.value && w.value.call(null, st, yn);
+      if (V(st))
+        ce++;
+      else if (!w.value || Cn) {
+        J = !1;
+        break;
+      }
+      Oe += te(Z(st, bn));
+    }
+    ce === 0 && (J = !1), S.value = J;
+  }, te = (N) => {
+    var A;
+    if (!t || !t.store)
+      return 0;
+    const { treeData: $ } = t.store.states;
+    let W = 0;
+    const V = (A = $.value[N]) == null ? void 0 : A.children;
+    return V && (W += V.length, V.forEach((J) => {
+      W += te(J);
+    })), W;
+  }, me = (N, A) => {
+    Array.isArray(N) || (N = [N]);
+    const $ = {};
+    return N.forEach((W) => {
+      R.value[W.id] = A, $[W.columnKey || W.id] = A;
+    }), $;
+  }, le = (N, A, $) => {
+    K.value && K.value !== N && (K.value.order = null), K.value = N, B.value = A, M.value = $;
+  }, de = () => {
+    let N = O(a);
+    Object.keys(R.value).forEach((A) => {
+      const $ = R.value[A];
+      if (!$ || $.length === 0)
+        return;
+      const W = Ul({
+        columns: u.value
+      }, A);
+      W && W.filterMethod && (N = N.filter((V) => $.some((J) => W.filterMethod.call(null, J, V, W))));
+    }), F.value = N;
+  }, ve = () => {
+    r.value = jr(F.value, {
+      sortingColumn: K.value,
+      sortProp: B.value,
+      sortOrder: M.value
+    });
+  }, en = (N = void 0) => {
+    N && N.filter || de(), ve();
+  }, tn = (N) => {
+    const { tableHeaderRef: A } = t.refs;
+    if (!A)
+      return;
+    const $ = Object.assign({}, A.filterPanels), W = Object.keys($);
+    if (W.length)
+      if (typeof N == "string" && (N = [N]), Array.isArray(N)) {
+        const V = N.map((J) => Hr({
+          columns: u.value
+        }, J));
+        W.forEach((J) => {
+          const ce = V.find((Oe) => Oe.id === J);
+          ce && (ce.filteredValue = []);
+        }), t.store.commit("filterChange", {
+          column: V,
+          values: [],
+          silent: !0,
+          multi: !0
+        });
+      } else
+        W.forEach((V) => {
+          const J = u.value.find((ce) => ce.id === V);
+          J && (J.filteredValue = []);
+        }), R.value = {}, t.store.commit("filterChange", {
+          column: {},
+          values: [],
+          silent: !0
+        });
+  }, ln = () => {
+    K.value && (le(null, null, null), t.store.commit("changeSortCondition", {
+      silent: !0
+    }));
+  }, {
+    setExpandRowKeys: nn,
+    toggleRowExpansion: Pt,
+    updateExpandRows: on,
+    states: rn,
+    isRowExpanded: sn
+  } = Kr({
+    data: r,
+    rowKey: n
+  }), {
+    updateTreeExpandKeys: an,
+    toggleTreeExpansion: un,
+    updateTreeData: dn,
+    loadOrToggle: cn,
+    states: fn
+  } = Dr({
+    data: r,
+    rowKey: n
+  }), {
+    updateCurrentRowData: hn,
+    updateCurrentRow: vn,
+    setCurrentRowKey: pn,
+    states: mn
+  } = Vr({
+    data: r,
+    rowKey: n
+  });
+  return {
+    assertRowKey: j,
+    updateColumns: _,
+    scheduleLayout: ue,
+    isSelected: Q,
+    clearSelection: C,
+    cleanSelection: L,
+    getSelectionRows: P,
+    toggleRowSelection: U,
+    _toggleAllSelection: Y,
+    toggleAllSelection: null,
+    updateSelectionByRowKey: q,
+    updateAllSelected: ae,
+    updateFilters: me,
+    updateCurrentRow: vn,
+    updateSort: le,
+    execFilter: de,
+    execSort: ve,
+    execQuery: en,
+    clearFilter: tn,
+    clearSort: ln,
+    toggleRowExpansion: Pt,
+    setExpandRowKeysAdapter: (N) => {
+      nn(N), an(N);
+    },
+    setCurrentRowKey: pn,
+    toggleRowExpansionAdapter: (N, A) => {
+      u.value.some(({ type: W }) => W === "expand") ? Pt(N, A) : un(N, A);
+    },
+    isRowExpanded: sn,
+    updateExpandRows: on,
+    updateCurrentRowData: hn,
+    loadOrToggle: cn,
+    updateTreeData: dn,
+    states: {
+      tableSize: l,
+      rowKey: n,
+      data: r,
+      _data: a,
+      isComplex: i,
+      _columns: o,
+      originColumns: s,
+      columns: u,
+      fixedColumns: d,
+      rightFixedColumns: h,
+      leafColumns: p,
+      fixedLeafColumns: m,
+      rightFixedLeafColumns: f,
+      updateOrderFns: g,
+      leafColumnsLength: v,
+      fixedLeafColumnsLength: y,
+      rightFixedLeafColumnsLength: b,
+      isAllSelected: S,
+      selection: c,
+      reserveSelection: x,
+      selectOnIndeterminate: k,
+      selectable: w,
+      filters: R,
+      filteredData: F,
+      sortingColumn: K,
+      sortProp: B,
+      sortOrder: M,
+      hoverRow: z,
+      ...rn,
+      ...fn,
+      ...mn
+    }
+  };
+}
+function Et(e, t) {
+  return e.map((l) => {
+    var n;
+    return l.id === t.id ? t : ((n = l.children) != null && n.length && (l.children = Et(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 Gr() {
+  const e = ee(), t = Ur();
+  return {
+    ns: se("table"),
+    ...t,
+    mutations: {
+      setData(i, o) {
+        const s = O(i._data) !== o;
+        i.data.value = o, i._data.value = o, e.store.execQuery(), e.store.updateCurrentRowData(), e.store.updateExpandRows(), e.store.updateTreeData(e.store.states.defaultExpandAll.value), O(i.reserveSelection) ? (e.store.assertRowKey(), e.store.updateSelectionByRowKey()) : s ? e.store.clearSelection() : e.store.cleanSelection(), e.store.updateAllSelected(), e.$ready && e.store.scheduleLayout();
+      },
+      insertColumn(i, o, s, u) {
+        const d = O(i._columns);
+        let h = [];
+        s ? (s && !s.children && (s.children = []), s.children.push(o), h = Et(d, s)) : (d.push(o), h = d), kt(h), i._columns.value = h, i.updateOrderFns.push(u), o.type === "selection" && (i.selectable.value = o.selectable, i.reserveSelection.value = o.reserveSelection), e.$ready && (e.store.updateColumns(), e.store.scheduleLayout());
+      },
+      updateColumnOrder(i, o) {
+        var s;
+        ((s = o.getColumnIndex) == null ? void 0 : s.call(o)) !== o.no && (kt(i._columns.value), e.$ready && e.store.updateColumns());
+      },
+      removeColumn(i, o, s, u) {
+        const d = O(i._columns) || [];
+        if (s)
+          s.children.splice(s.children.findIndex((p) => p.id === o.id), 1), Ee(() => {
+            var p;
+            ((p = s.children) == null ? void 0 : p.length) === 0 && delete s.children;
+          }), i._columns.value = Et(d, s);
+        else {
+          const p = d.indexOf(o);
+          p > -1 && (d.splice(p, 1), i._columns.value = d);
+        }
+        const h = i.updateOrderFns.indexOf(u);
+        h > -1 && i.updateOrderFns.splice(h, 1), e.$ready && (e.store.updateColumns(), e.store.scheduleLayout());
+      },
+      sort(i, o) {
+        const { prop: s, order: u, init: d } = o;
+        if (s) {
+          const h = O(i.columns).find((p) => p.property === s);
+          h && (h.order = u, e.store.updateSort(h, s, u), e.store.commit("changeSortCondition", { init: d }));
+        }
+      },
+      changeSortCondition(i, o) {
+        const { sortingColumn: s, sortProp: u, sortOrder: d } = i, h = O(s), p = O(u), m = O(d);
+        m === null && (i.sortingColumn.value = null, i.sortProp.value = null);
+        const f = { filter: !0 };
+        e.store.execQuery(f), (!o || !(o.silent || o.init)) && e.emit("sort-change", {
+          column: h,
+          prop: p,
+          order: m
+        }), e.store.updateTableScrollY();
+      },
+      filterChange(i, o) {
+        const { column: s, values: u, silent: d } = o, h = e.store.updateFilters(s, u);
+        e.store.execQuery(), d || e.emit("filter-change", h), e.store.updateTableScrollY();
+      },
+      toggleAllSelection() {
+        e.store.toggleAllSelection();
+      },
+      rowSelectedChanged(i, o) {
+        e.store.toggleRowSelection(o), e.store.updateAllSelected();
+      },
+      setHoverRow(i, o) {
+        i.hoverRow.value = o;
+      },
+      setCurrentRow(i, o) {
+        e.store.updateCurrentRow(o);
+      }
+    },
+    commit: function(i, ...o) {
+      const s = e.store.mutations;
+      if (s[i])
+        s[i].apply(e, [e.store.states].concat(o));
+      else
+        throw new Error(`Action not found: ${i}`);
+    },
+    updateTableScrollY: function() {
+      Ee(() => e.layout.updateScrollY.apply(e.layout));
+    }
+  };
+}
+const Pe = {
+  rowKey: "rowKey",
+  defaultExpandAll: "defaultExpandAll",
+  selectOnIndeterminate: "selectOnIndeterminate",
+  indent: "indent",
+  lazy: "lazy",
+  data: "data",
+  "treeProps.hasChildren": {
+    key: "lazyColumnIdentifier",
+    default: "hasChildren"
+  },
+  "treeProps.children": {
+    key: "childrenColumnName",
+    default: "children"
+  }
+};
+function Yr(e, t) {
+  if (!e)
+    throw new Error("Table is required.");
+  const l = Gr();
+  return l.toggleAllSelection = nt(l._toggleAllSelection, 10), Object.keys(Pe).forEach((n) => {
+    Xl(_l(t, n), n, l);
+  }), qr(l, t), l;
+}
+function qr(e, t) {
+  Object.keys(Pe).forEach((l) => {
+    ie(() => _l(t, l), (n) => {
+      Xl(n, l, e);
+    });
+  });
+}
+function Xl(e, t, l) {
+  let n = e, r = Pe[t];
+  typeof Pe[t] == "object" && (r = r.key, n = n || Pe[t].default), l.states[r].value = n;
+}
+function _l(e, t) {
+  if (t.includes(".")) {
+    const l = t.split(".");
+    let n = e;
+    return l.forEach((r) => {
+      n = n[r];
+    }), n;
+  } else
+    return e[t];
+}
+class Xr {
+  constructor(t) {
+    this.observers = [], this.table = null, this.store = null, this.columns = [], this.fit = !0, this.showHeader = !0, this.height = E(null), this.scrollX = E(!1), this.scrollY = E(!1), this.bodyWidth = E(null), this.fixedWidth = E(null), this.rightFixedWidth = E(null), this.gutterWidth = 0;
+    for (const l in t)
+      Ie(t, l) && (Be(this[l]) ? this[l].value = t[l] : this[l] = t[l]);
+    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() {
+    if (this.height.value === null)
+      return !1;
+    const l = this.table.refs.scrollBarRef;
+    if (this.table.vnode.el && (l != null && l.wrapRef)) {
+      let n = !0;
+      const r = this.scrollY.value;
+      return n = l.wrapRef.scrollHeight > l.wrapRef.clientHeight, this.scrollY.value = n, r !== n;
+    }
+    return !1;
+  }
+  setHeight(t, l = "height") {
+    if (!ze)
+      return;
+    const n = this.table.vnode.el;
+    if (t = Pr(t), this.height.value = Number(t), !n && (t || t === 0))
+      return Ee(() => this.setHeight(t, l));
+    typeof t == "number" ? (n.style[l] = `${t}px`, this.updateElsHeight()) : typeof t == "string" && (n.style[l] = t, this.updateElsHeight());
+  }
+  setMaxHeight(t) {
+    this.setHeight(t, "max-height");
+  }
+  getFlattenColumns() {
+    const t = [];
+    return this.table.store.states.columns.value.forEach((n) => {
+      n.isColumnGroup ? t.push.apply(t, n.columns) : t.push(n);
+    }), t;
+  }
+  updateElsHeight() {
+    this.updateScrollY(), this.notifyObservers("scrollable");
+  }
+  headerDisplayNone(t) {
+    if (!t)
+      return !0;
+    let l = t;
+    for (; l.tagName !== "DIV"; ) {
+      if (getComputedStyle(l).display === "none")
+        return !0;
+      l = l.parentElement;
+    }
+    return !1;
+  }
+  updateColumnsWidth() {
+    if (!ze)
+      return;
+    const t = this.fit, l = this.table.vnode.el.clientWidth;
+    let n = 0;
+    const r = this.getFlattenColumns(), a = r.filter((s) => typeof s.width != "number");
+    if (r.forEach((s) => {
+      typeof s.width == "number" && s.realWidth && (s.realWidth = null);
+    }), a.length > 0 && t) {
+      if (r.forEach((s) => {
+        n += Number(s.width || s.minWidth || 80);
+      }), n <= l) {
+        this.scrollX.value = !1;
+        const s = l - n;
+        if (a.length === 1)
+          a[0].realWidth = Number(a[0].minWidth || 80) + s;
+        else {
+          const u = a.reduce((p, m) => p + Number(m.minWidth || 80), 0), d = s / u;
+          let h = 0;
+          a.forEach((p, m) => {
+            if (m === 0)
+              return;
+            const f = Math.floor(Number(p.minWidth || 80) * d);
+            h += f, p.realWidth = Number(p.minWidth || 80) + f;
+          }), a[0].realWidth = Number(a[0].minWidth || 80) + s - h;
+        }
+      } else
+        this.scrollX.value = !0, a.forEach((s) => {
+          s.realWidth = Number(s.minWidth);
+        });
+      this.bodyWidth.value = Math.max(n, l), this.table.state.resizeState.value.width = this.bodyWidth.value;
+    } else
+      r.forEach((s) => {
+        !s.width && !s.minWidth ? s.realWidth = 80 : s.realWidth = Number(s.width || s.minWidth), n += s.realWidth;
+      }), this.scrollX.value = n > l, this.bodyWidth.value = n;
+    const i = this.store.states.fixedColumns.value;
+    if (i.length > 0) {
+      let s = 0;
+      i.forEach((u) => {
+        s += Number(u.realWidth || u.width);
+      }), this.fixedWidth.value = s;
+    }
+    const o = this.store.states.rightFixedColumns.value;
+    if (o.length > 0) {
+      let s = 0;
+      o.forEach((u) => {
+        s += Number(u.realWidth || u.width);
+      }), this.rightFixedWidth.value = s;
+    }
+    this.notifyObservers("columns");
+  }
+  addObserver(t) {
+    this.observers.push(t);
+  }
+  removeObserver(t) {
+    const l = this.observers.indexOf(t);
+    l !== -1 && this.observers.splice(l, 1);
+  }
+  notifyObservers(t) {
+    this.observers.forEach((n) => {
+      var r, a;
+      switch (t) {
+        case "columns":
+          (r = n.state) == null || r.onColumnsChange(this);
+          break;
+        case "scrollable":
+          (a = n.state) == null || a.onScrollableChange(this);
+          break;
+        default:
+          throw new Error(`Table Layout don't have event ${t}.`);
+      }
+    });
+  }
+}
+const { CheckboxGroup: _r } = Ae, Qr = he({
+  name: "ElTableFilterPanel",
+  components: {
+    ElCheckbox: Ae,
+    ElCheckboxGroup: _r,
+    ElScrollbar: pl,
+    ElTooltip: $n,
+    ElIcon: Mt,
+    ArrowDown: eo,
+    ArrowUp: to
+  },
+  directives: { ClickOutside: Pn },
+  props: {
+    placement: {
+      type: String,
+      default: "bottom-start"
+    },
+    store: {
+      type: Object
+    },
+    column: {
+      type: Object
+    },
+    upDataColumn: {
+      type: Function
+    }
+  },
+  setup(e) {
+    const t = ee(), { t: l } = yl(), n = se("table-filter"), r = t == null ? void 0 : t.parent;
+    r.filterPanels.value[e.column.id] || (r.filterPanels.value[e.column.id] = t);
+    const a = E(!1), i = E(null), o = T(() => e.column && e.column.filters), s = T({
+      get: () => {
+        var c;
+        return (((c = e.column) == null ? void 0 : c.filteredValue) || [])[0];
+      },
+      set: (c) => {
+        u.value && (typeof c < "u" && c !== null ? u.value.splice(0, 1, c) : u.value.splice(0, 1));
+      }
+    }), u = T({
+      get() {
+        return e.column ? e.column.filteredValue || [] : [];
+      },
+      set(c) {
+        e.column && e.upDataColumn("filteredValue", c);
+      }
+    }), d = T(() => e.column ? e.column.filterMultiple : !0), h = (c) => c.value === s.value, p = () => {
+      a.value = !1;
+    }, m = (c) => {
+      c.stopPropagation(), a.value = !a.value;
+    }, f = () => {
+      a.value = !1;
+    }, g = () => {
+      b(u.value), p();
+    }, v = () => {
+      u.value = [], b(u.value), p();
+    }, y = (c) => {
+      s.value = c, b(typeof c < "u" && c !== null ? u.value : []), p();
+    }, b = (c) => {
+      e.store.commit("filterChange", {
+        column: e.column,
+        values: c
+      }), e.store.updateAllSelected();
+    };
+    ie(a, (c) => {
+      e.column && e.upDataColumn("filterOpened", c);
+    }, {
+      immediate: !0
+    });
+    const S = T(() => {
+      var c, x;
+      return (x = (c = i.value) == null ? void 0 : c.popperRef) == null ? void 0 : x.contentRef;
+    });
+    return {
+      tooltipVisible: a,
+      multiple: d,
+      filteredValue: u,
+      filterValue: s,
+      filters: o,
+      handleConfirm: g,
+      handleReset: v,
+      handleSelect: y,
+      isActive: h,
+      t: l,
+      ns: n,
+      showFilterPanel: m,
+      hideFilterPanel: f,
+      popperPaneRef: S,
+      tooltip: i
+    };
+  }
+}), Zr = { key: 0 }, Jr = ["disabled"], es = ["label", "onClick"];
+function ts(e, t, l, n, r, a) {
+  const i = fe("el-checkbox"), o = fe("el-checkbox-group"), s = fe("el-scrollbar"), u = fe("arrow-up"), d = fe("arrow-down"), h = fe("el-icon"), p = fe("el-tooltip"), m = cl("click-outside");
+  return D(), Le(p, {
+    ref: "tooltip",
+    visible: e.tooltipVisible,
+    offset: 0,
+    placement: e.placement,
+    "show-arrow": !1,
+    "stop-popper-mouse-event": !1,
+    teleported: "",
+    effect: "light",
+    pure: "",
+    "popper-class": e.ns.b(),
+    persistent: ""
+  }, {
+    content: ye(() => [
+      e.multiple ? (D(), G("div", Zr, [
+        oe("div", {
+          class: I(e.ns.e("content"))
+        }, [
+          we(s, {
+            "wrap-class": e.ns.e("wrap")
+          }, {
+            default: ye(() => [
+              we(o, {
+                modelValue: e.filteredValue,
+                "onUpdate:modelValue": t[0] || (t[0] = (f) => e.filteredValue = f),
+                class: I(e.ns.e("checkbox-group"))
+              }, {
+                default: ye(() => [
+                  (D(!0), G(Je, null, It(e.filters, (f) => (D(), Le(i, {
+                    key: f.value,
+                    label: f.value
+                  }, {
+                    default: ye(() => [
+                      ot(Se(f.text), 1)
+                    ]),
+                    _: 2
+                  }, 1032, ["label"]))), 128))
+                ]),
+                _: 1
+              }, 8, ["modelValue", "class"])
+            ]),
+            _: 1
+          }, 8, ["wrap-class"])
+        ], 2),
+        oe("div", {
+          class: I(e.ns.e("bottom"))
+        }, [
+          oe("button", {
+            class: I({ [e.ns.is("disabled")]: e.filteredValue.length === 0 }),
+            disabled: e.filteredValue.length === 0,
+            type: "button",
+            onClick: t[1] || (t[1] = (...f) => e.handleConfirm && e.handleConfirm(...f))
+          }, Se(e.t("el.table.confirmFilter")), 11, Jr),
+          oe("button", {
+            type: "button",
+            onClick: t[2] || (t[2] = (...f) => e.handleReset && e.handleReset(...f))
+          }, Se(e.t("el.table.resetFilter")), 1)
+        ], 2)
+      ])) : (D(), G("ul", {
+        key: 1,
+        class: I(e.ns.e("list"))
+      }, [
+        oe("li", {
+          class: I([
+            e.ns.e("list-item"),
+            {
+              [e.ns.is("active")]: e.filterValue === void 0 || e.filterValue === null
+            }
+          ]),
+          onClick: t[3] || (t[3] = (f) => e.handleSelect(null))
+        }, Se(e.t("el.table.clearFilter")), 3),
+        (D(!0), G(Je, null, It(e.filters, (f) => (D(), G("li", {
+          key: f.value,
+          class: I([e.ns.e("list-item"), e.ns.is("active", e.isActive(f))]),
+          label: f.value,
+          onClick: (g) => e.handleSelect(f.value)
+        }, Se(f.text), 11, es))), 128))
+      ], 2))
+    ]),
+    default: ye(() => [
+      xe((D(), G("span", {
+        class: I([
+          `${e.ns.namespace.value}-table__column-filter-trigger`,
+          `${e.ns.namespace.value}-none-outline`
+        ]),
+        onClick: t[4] || (t[4] = (...f) => e.showFilterPanel && e.showFilterPanel(...f))
+      }, [
+        we(h, null, {
+          default: ye(() => [
+            e.column.filterOpened ? (D(), Le(u, { key: 0 })) : (D(), Le(d, { key: 1 }))
+          ]),
+          _: 1
+        })
+      ], 2)), [
+        [m, e.hideFilterPanel, e.popperPaneRef]
+      ])
+    ]),
+    _: 1
+  }, 8, ["visible", "placement", "popper-class"]);
+}
+var ls = /* @__PURE__ */ je(Qr, [["render", ts], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/table/src/filter-panel.vue"]]);
+function Ql(e) {
+  const t = ee();
+  fl(() => {
+    l.value.addObserver(t);
+  }), Ke(() => {
+    n(l.value), r(l.value);
+  }), wn(() => {
+    n(l.value), r(l.value);
+  }), Rt(() => {
+    l.value.removeObserver(t);
+  });
+  const l = T(() => {
+    const a = e.layout;
+    if (!a)
+      throw new Error("Can not find table layout.");
+    return a;
+  }), n = (a) => {
+    var i;
+    const o = ((i = e.vnode.el) == null ? void 0 : i.querySelectorAll("colgroup > col")) || [];
+    if (!o.length)
+      return;
+    const s = a.getFlattenColumns(), u = {};
+    s.forEach((d) => {
+      u[d.id] = d;
+    });
+    for (let d = 0, h = o.length; d < h; d++) {
+      const p = o[d], m = p.getAttribute("name"), f = u[m];
+      f && p.setAttribute("width", f.realWidth || f.width);
+    }
+  }, r = (a) => {
+    var i, o;
+    const s = ((i = e.vnode.el) == null ? void 0 : i.querySelectorAll("colgroup > col[name=gutter]")) || [];
+    for (let d = 0, h = s.length; d < h; d++)
+      s[d].setAttribute("width", a.scrollY.value ? a.gutterWidth : "0");
+    const u = ((o = e.vnode.el) == null ? void 0 : o.querySelectorAll("th.gutter")) || [];
+    for (let d = 0, h = u.length; d < h; d++) {
+      const p = u[d];
+      p.style.width = a.scrollY.value ? `${a.gutterWidth}px` : "0", p.style.display = a.scrollY.value ? "" : "none";
+    }
+  };
+  return {
+    tableLayout: l.value,
+    onColumnsChange: n,
+    onScrollableChange: r
+  };
+}
+const pe = Symbol("ElTable");
+function ns(e, t) {
+  const l = ee(), n = re(pe), r = (g) => {
+    g.stopPropagation();
+  }, a = (g, v) => {
+    !v.filters && v.sortable ? f(g, v, !1) : v.filterable && !v.sortable && r(g), n == null || n.emit("header-click", v, g);
+  }, i = (g, v) => {
+    n == null || n.emit("header-contextmenu", v, g);
+  }, o = E(null), s = E(!1), u = E({}), d = (g, v) => {
+    if (ze && !(v.children && v.children.length > 0) && o.value && e.border) {
+      s.value = !0;
+      const y = n;
+      t("set-drag-visible", !0);
+      const S = (y == null ? void 0 : y.vnode.el).getBoundingClientRect().left, c = l.vnode.el.querySelector(`th.${v.id}`), x = c.getBoundingClientRect(), k = x.left - S + 30;
+      Cl(c, "noclick"), u.value = {
+        startMouseLeft: g.clientX,
+        startLeft: x.right - S,
+        startColumnLeft: x.left - S,
+        tableLeft: S
+      };
+      const w = y == null ? void 0 : y.refs.resizeProxy;
+      w.style.left = `${u.value.startLeft}px`, document.onselectstart = function() {
+        return !1;
+      }, document.ondragstart = function() {
+        return !1;
+      };
+      const R = (K) => {
+        const B = K.clientX - u.value.startMouseLeft, M = u.value.startLeft + B;
+        w.style.left = `${Math.max(k, M)}px`;
+      }, F = () => {
+        if (s.value) {
+          const { startColumnLeft: K, startLeft: B } = u.value, z = Number.parseInt(w.style.left, 10) - K;
+          v.width = v.realWidth = z, y == null || y.emit("header-dragend", v.width, B - K, v, g), requestAnimationFrame(() => {
+            e.store.scheduleLayout(!1, !0);
+          }), document.body.style.cursor = "", s.value = !1, o.value = null, u.value = {}, t("set-drag-visible", !1);
+        }
+        document.removeEventListener("mousemove", R), document.removeEventListener("mouseup", F), document.onselectstart = null, document.ondragstart = null, setTimeout(() => {
+          ft(c, "noclick");
+        }, 0);
+      };
+      document.addEventListener("mousemove", R), document.addEventListener("mouseup", F);
+    }
+  }, h = (g, v) => {
+    if (v.children && v.children.length > 0)
+      return;
+    const y = g.target;
+    if (!qn(y))
+      return;
+    const b = y == null ? void 0 : y.closest("th");
+    if (!(!v || !v.resizable) && !s.value && e.border) {
+      const S = b.getBoundingClientRect(), c = document.body.style;
+      S.width > 12 && S.right - g.pageX < 8 ? (c.cursor = "col-resize", Ge(b, "is-sortable") && (b.style.cursor = "col-resize"), o.value = v) : s.value || (c.cursor = "", Ge(b, "is-sortable") && (b.style.cursor = "pointer"), o.value = null);
+    }
+  }, p = () => {
+    ze && (document.body.style.cursor = "");
+  }, m = ({ order: g, sortOrders: v }) => {
+    if (g === "")
+      return v[0];
+    const y = v.indexOf(g || null);
+    return v[y > v.length - 2 ? 0 : y + 1];
+  }, f = (g, v, y) => {
+    var b;
+    g.stopPropagation();
+    const S = v.order === y ? null : y || m(v), c = (b = g.target) == null ? void 0 : b.closest("th");
+    if (c && Ge(c, "noclick")) {
+      ft(c, "noclick");
+      return;
+    }
+    if (!v.sortable)
+      return;
+    const x = e.store.states;
+    let k = x.sortProp.value, w;
+    const R = x.sortingColumn.value;
+    (R !== v || R === v && R.order === null) && (R && (R.order = null), x.sortingColumn.value = v, k = v.property), S ? w = v.order = S : w = v.order = null, x.sortProp.value = k, x.sortOrder.value = w, n == null || n.store.commit("changeSortCondition");
+  };
+  return {
+    handleHeaderClick: a,
+    handleHeaderContextMenu: i,
+    handleMouseDown: d,
+    handleMouseMove: h,
+    handleMouseOut: p,
+    handleSortClick: f,
+    handleFilterClick: r
+  };
+}
+function os(e) {
+  const t = re(pe), l = se("table");
+  return {
+    getHeaderRowStyle: (o) => {
+      const s = t == null ? void 0 : t.props.headerRowStyle;
+      return typeof s == "function" ? s.call(null, { rowIndex: o }) : s;
+    },
+    getHeaderRowClass: (o) => {
+      const s = [], u = t == null ? void 0 : t.props.headerRowClassName;
+      return typeof u == "string" ? s.push(u) : typeof u == "function" && s.push(u.call(null, { rowIndex: o })), s.join(" ");
+    },
+    getHeaderCellStyle: (o, s, u, d) => {
+      var h;
+      let p = (h = t == null ? void 0 : t.props.headerCellStyle) != null ? h : {};
+      typeof p == "function" && (p = p.call(null, {
+        rowIndex: o,
+        columnIndex: s,
+        row: u,
+        column: d
+      }));
+      const m = Ht(s, d.fixed, e.store, u);
+      return Te(m, "left"), Te(m, "right"), Object.assign({}, p, m);
+    },
+    getHeaderCellClass: (o, s, u, d) => {
+      const h = Wt(l.b(), s, d.fixed, e.store, u), p = [
+        d.id,
+        d.order,
+        d.headerAlign,
+        d.className,
+        d.labelClassName,
+        ...h
+      ];
+      d.children || p.push("is-leaf"), d.sortable && p.push("is-sortable");
+      const m = t == null ? void 0 : t.props.headerCellClassName;
+      return typeof m == "string" ? p.push(m) : typeof m == "function" && p.push(m.call(null, {
+        rowIndex: o,
+        columnIndex: s,
+        row: u,
+        column: d
+      })), p.push(l.e("cell")), p.filter((f) => !!f).join(" ");
+    }
+  };
+}
+const Zl = (e) => {
+  const t = [];
+  return e.forEach((l) => {
+    l.children ? (t.push(l), t.push.apply(t, Zl(l.children))) : t.push(l);
+  }), t;
+}, rs = (e) => {
+  let t = 1;
+  const l = (a, i) => {
+    if (i && (a.level = i.level + 1, t < a.level && (t = a.level)), a.children) {
+      let o = 0;
+      a.children.forEach((s) => {
+        l(s, a), o += s.colSpan;
+      }), a.colSpan = o;
+    } 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((i) => i.isSubColumn = !0)) : a.rowSpan = t - a.level + 1, n[a.level - 1].push(a);
+  }), n;
+};
+function ss(e) {
+  const t = re(pe), l = T(() => rs(e.store.states.originColumns.value));
+  return {
+    isGroup: T(() => {
+      const a = l.value.length > 1;
+      return a && t && (t.state.isGroup.value = !0), a;
+    }),
+    toggleAllSelection: (a) => {
+      a.stopPropagation(), t == null || t.store.commit("toggleAllSelection");
+    },
+    columnRows: l
+  };
+}
+var as = he({
+  name: "ElTableHeader",
+  components: {
+    ElCheckbox: Ae
+  },
+  props: {
+    fixed: {
+      type: String,
+      default: ""
+    },
+    store: {
+      required: !0,
+      type: Object
+    },
+    border: Boolean,
+    defaultSort: {
+      type: Object,
+      default: () => ({
+        prop: "",
+        order: ""
+      })
+    }
+  },
+  setup(e, { emit: t }) {
+    const l = ee(), n = re(pe), r = se("table"), a = E({}), { onColumnsChange: i, onScrollableChange: o } = Ql(n);
+    Ke(async () => {
+      await Ee(), await Ee();
+      const { prop: k, order: w } = e.defaultSort;
+      n == null || n.store.commit("sort", { prop: k, order: w, init: !0 });
+    });
+    const {
+      handleHeaderClick: s,
+      handleHeaderContextMenu: u,
+      handleMouseDown: d,
+      handleMouseMove: h,
+      handleMouseOut: p,
+      handleSortClick: m,
+      handleFilterClick: f
+    } = ns(e, t), {
+      getHeaderRowStyle: g,
+      getHeaderRowClass: v,
+      getHeaderCellStyle: y,
+      getHeaderCellClass: b
+    } = os(e), { isGroup: S, toggleAllSelection: c, columnRows: x } = ss(e);
+    return l.state = {
+      onColumnsChange: i,
+      onScrollableChange: o
+    }, l.filterPanels = a, {
+      ns: r,
+      filterPanels: a,
+      onColumnsChange: i,
+      onScrollableChange: o,
+      columnRows: x,
+      getHeaderRowClass: v,
+      getHeaderRowStyle: g,
+      getHeaderCellClass: b,
+      getHeaderCellStyle: y,
+      handleHeaderClick: s,
+      handleHeaderContextMenu: u,
+      handleMouseDown: d,
+      handleMouseMove: h,
+      handleMouseOut: p,
+      handleSortClick: m,
+      handleFilterClick: f,
+      isGroup: S,
+      toggleAllSelection: c
+    };
+  },
+  render() {
+    const {
+      ns: e,
+      isGroup: t,
+      columnRows: l,
+      getHeaderCellStyle: n,
+      getHeaderCellClass: r,
+      getHeaderRowClass: a,
+      getHeaderRowStyle: i,
+      handleHeaderClick: o,
+      handleHeaderContextMenu: s,
+      handleMouseDown: u,
+      handleMouseMove: d,
+      handleSortClick: h,
+      handleMouseOut: p,
+      store: m,
+      $parent: f
+    } = this;
+    let g = 1;
+    return H("thead", {
+      class: { [e.is("group")]: t }
+    }, l.map((v, y) => H("tr", {
+      class: a(y),
+      key: y,
+      style: i(y)
+    }, v.map((b, S) => (b.rowSpan > g && (g = b.rowSpan), H("th", {
+      class: r(y, S, v, b),
+      colspan: b.colSpan,
+      key: `${b.id}-thead`,
+      rowspan: b.rowSpan,
+      style: n(y, S, v, b),
+      onClick: (c) => o(c, b),
+      onContextmenu: (c) => s(c, b),
+      onMousedown: (c) => u(c, b),
+      onMousemove: (c) => d(c, b),
+      onMouseout: p
+    }, [
+      H("div", {
+        class: [
+          "cell",
+          b.filteredValue && b.filteredValue.length > 0 ? "highlight" : ""
+        ]
+      }, [
+        b.renderHeader ? b.renderHeader({
+          column: b,
+          $index: S,
+          store: m,
+          _self: f
+        }) : b.label,
+        b.sortable && H("span", {
+          onClick: (c) => h(c, b),
+          class: "caret-wrapper"
+        }, [
+          H("i", {
+            onClick: (c) => h(c, b, "ascending"),
+            class: "sort-caret ascending"
+          }),
+          H("i", {
+            onClick: (c) => h(c, b, "descending"),
+            class: "sort-caret descending"
+          })
+        ]),
+        b.filterable && H(ls, {
+          store: m,
+          placement: b.filterPlacement || "bottom-start",
+          column: b,
+          upDataColumn: (c, x) => {
+            b[c] = x;
+          }
+        })
+      ])
+    ]))))));
+  }
+});
+function is(e) {
+  const t = re(pe), l = E(""), n = E(H("div")), { nextZIndex: r } = lo(), a = (f, g, v) => {
+    var y;
+    const b = t, S = at(f);
+    let c;
+    const x = (y = b == null ? void 0 : b.vnode.el) == null ? void 0 : y.dataset.prefix;
+    S && (c = nl({
+      columns: e.store.states.columns.value
+    }, S, x), c && (b == null || b.emit(`cell-${v}`, g, c, S, f))), b == null || b.emit(`row-${v}`, g, c, f);
+  }, i = (f, g) => {
+    a(f, g, "dblclick");
+  }, o = (f, g) => {
+    e.store.commit("setCurrentRow", g), a(f, g, "click");
+  }, s = (f, g) => {
+    a(f, g, "contextmenu");
+  }, u = nt((f) => {
+    e.store.commit("setHoverRow", f);
+  }, 30), d = nt(() => {
+    e.store.commit("setHoverRow", null);
+  }, 30), h = (f) => {
+    const g = window.getComputedStyle(f, null), v = Number.parseInt(g.paddingLeft, 10) || 0, y = Number.parseInt(g.paddingRight, 10) || 0, b = Number.parseInt(g.paddingTop, 10) || 0, S = Number.parseInt(g.paddingBottom, 10) || 0;
+    return {
+      left: v,
+      right: y,
+      top: b,
+      bottom: S
+    };
+  };
+  return {
+    handleDoubleClick: i,
+    handleClick: o,
+    handleContextMenu: s,
+    handleMouseEnter: u,
+    handleMouseLeave: d,
+    handleCellMouseEnter: (f, g, v) => {
+      var y;
+      const b = t, S = at(f), c = (y = b == null ? void 0 : b.vnode.el) == null ? void 0 : y.dataset.prefix;
+      if (S) {
+        const ue = nl({
+          columns: e.store.states.columns.value
+        }, S, c), Q = b.hoverState = { cell: S, column: ue, row: g };
+        b == null || b.emit("cell-mouse-enter", Q.row, Q.column, Q.cell, f);
+      }
+      if (!v)
+        return;
+      const x = f.target.querySelector(".cell");
+      if (!(Ge(x, `${c}-tooltip`) && x.childNodes.length))
+        return;
+      const k = document.createRange();
+      k.setStart(x, 0), k.setEnd(x, x.childNodes.length);
+      let w = k.getBoundingClientRect().width, R = k.getBoundingClientRect().height;
+      w - Math.floor(w) < 1e-3 && (w = Math.floor(w)), R - Math.floor(R) < 1e-3 && (R = Math.floor(R));
+      const { top: B, left: M, right: z, bottom: j } = h(x), X = M + z, _ = B + j;
+      (w + X > x.offsetWidth || R + _ > x.offsetHeight || x.scrollWidth > x.offsetWidth) && zr(t == null ? void 0 : t.refs.tableWrapper, S, S.innerText || S.textContent, r, v);
+    },
+    handleCellMouseLeave: (f) => {
+      if (!at(f))
+        return;
+      const v = t == null ? void 0 : t.hoverState;
+      t == null || t.emit("cell-mouse-leave", v == null ? void 0 : v.row, v == null ? void 0 : v.column, v == null ? void 0 : v.cell, f);
+    },
+    tooltipContent: l,
+    tooltipTrigger: n
+  };
+}
+function us(e) {
+  const t = re(pe), l = se("table");
+  return {
+    getRowStyle: (u, d) => {
+      const h = t == null ? void 0 : t.props.rowStyle;
+      return typeof h == "function" ? h.call(null, {
+        row: u,
+        rowIndex: d
+      }) : h || null;
+    },
+    getRowClass: (u, d) => {
+      const h = [l.e("row")];
+      t != null && t.props.highlightCurrentRow && u === e.store.states.currentRow.value && h.push("current-row"), e.stripe && d % 2 === 1 && h.push(l.em("row", "striped"));
+      const p = t == null ? void 0 : t.props.rowClassName;
+      return typeof p == "string" ? h.push(p) : typeof p == "function" && h.push(p.call(null, {
+        row: u,
+        rowIndex: d
+      })), h;
+    },
+    getCellStyle: (u, d, h, p) => {
+      const m = t == null ? void 0 : t.props.cellStyle;
+      let f = m ?? {};
+      typeof m == "function" && (f = m.call(null, {
+        rowIndex: u,
+        columnIndex: d,
+        row: h,
+        column: p
+      }));
+      const g = Ht(d, e == null ? void 0 : e.fixed, e.store);
+      return Te(g, "left"), Te(g, "right"), Object.assign({}, f, g);
+    },
+    getCellClass: (u, d, h, p, m) => {
+      const f = Wt(l.b(), d, e == null ? void 0 : e.fixed, e.store, void 0, m), g = [p.id, p.align, p.className, ...f], v = t == null ? void 0 : t.props.cellClassName;
+      return typeof v == "string" ? g.push(v) : typeof v == "function" && g.push(v.call(null, {
+        rowIndex: u,
+        columnIndex: d,
+        row: h,
+        column: p
+      })), g.push(l.e("cell")), g.filter((y) => !!y).join(" ");
+    },
+    getSpan: (u, d, h, p) => {
+      let m = 1, f = 1;
+      const g = t == null ? void 0 : t.props.spanMethod;
+      if (typeof g == "function") {
+        const v = g({
+          row: u,
+          column: d,
+          rowIndex: h,
+          columnIndex: p
+        });
+        Array.isArray(v) ? (m = v[0], f = v[1]) : typeof v == "object" && (m = v.rowspan, f = v.colspan);
+      }
+      return { rowspan: m, colspan: f };
+    },
+    getColspanRealWidth: (u, d, h) => {
+      if (d < 1)
+        return u[h].realWidth;
+      const p = u.map(({ realWidth: m, width: f }) => m || f).slice(h, h + d);
+      return Number(p.reduce((m, f) => Number(m) + Number(f), -1));
+    }
+  };
+}
+function ds(e) {
+  const t = re(pe), l = se("table"), {
+    handleDoubleClick: n,
+    handleClick: r,
+    handleContextMenu: a,
+    handleMouseEnter: i,
+    handleMouseLeave: o,
+    handleCellMouseEnter: s,
+    handleCellMouseLeave: u,
+    tooltipContent: d,
+    tooltipTrigger: h
+  } = is(e), {
+    getRowStyle: p,
+    getRowClass: m,
+    getCellStyle: f,
+    getCellClass: g,
+    getSpan: v,
+    getColspanRealWidth: y
+  } = us(e), b = T(() => e.store.states.columns.value.findIndex(({ type: w }) => w === "default")), S = (w, R) => {
+    const F = t.props.rowKey;
+    return F ? Z(w, F) : R;
+  }, c = (w, R, F, K = !1) => {
+    const { tooltipEffect: B, tooltipOptions: M, store: z } = e, { indent: j, columns: X } = z.states, _ = m(w, R);
+    let ue = !0;
+    return F && (_.push(l.em("row", `level-${F.level}`)), ue = F.display), H("tr", {
+      style: [ue ? null : {
+        display: "none"
+      }, p(w, R)],
+      class: _,
+      key: S(w, R),
+      onDblclick: (C) => n(C, w),
+      onClick: (C) => r(C, w),
+      onContextmenu: (C) => a(C, w),
+      onMouseenter: () => i(R),
+      onMouseleave: o
+    }, X.value.map((C, L) => {
+      const { rowspan: P, colspan: U } = v(w, C, R, L);
+      if (!P || !U)
+        return null;
+      const Y = Object.assign({}, C);
+      Y.realWidth = y(X.value, U, L);
+      const q = {
+        store: e.store,
+        _self: e.context || t,
+        column: Y,
+        row: w,
+        $index: R,
+        cellIndex: L,
+        expanded: K
+      };
+      L === b.value && F && (q.treeNode = {
+        indent: F.level * j.value,
+        level: F.level
+      }, typeof F.expanded == "boolean" && (q.treeNode.expanded = F.expanded, "loading" in F && (q.treeNode.loading = F.loading), "noLazyChildren" in F && (q.treeNode.noLazyChildren = F.noLazyChildren)));
+      const ae = `${R},${L}`, te = Y.columnKey || Y.rawColumnKey || "", me = x(L, C, q), le = C.showOverflowTooltip && Al({
+        effect: B
+      }, M, C.showOverflowTooltip);
+      return H("td", {
+        style: f(R, L, w, C),
+        class: g(R, L, w, C, U - 1),
+        key: `${te}${ae}`,
+        rowspan: P,
+        colspan: U,
+        onMouseenter: (de) => s(de, w, le),
+        onMouseleave: u
+      }, [me]);
+    }));
+  }, x = (w, R, F) => R.renderCell(F);
+  return {
+    wrappedRowRender: (w, R) => {
+      const F = e.store, { isRowExpanded: K, assertRowKey: B } = F, { treeData: M, lazyTreeNodeMap: z, childrenColumnName: j, rowKey: X } = F.states, _ = F.states.columns.value;
+      if (_.some(({ type: Q }) => Q === "expand")) {
+        const Q = K(w), C = c(w, R, void 0, Q), L = t.renderExpanded;
+        return Q ? L ? [
+          [
+            C,
+            H("tr", {
+              key: `expanded-row__${C.key}`
+            }, [
+              H("td", {
+                colspan: _.length,
+                class: `${l.e("cell")} ${l.e("expanded-cell")}`
+              }, [L({ row: w, $index: R, store: F, expanded: Q })])
+            ])
+          ]
+        ] : (console.error("[Element Error]renderExpanded is required."), C) : [[C]];
+      } else if (Object.keys(M.value).length) {
+        B();
+        const Q = Z(w, X.value);
+        let C = M.value[Q], L = null;
+        C && (L = {
+          expanded: C.expanded,
+          level: C.level,
+          display: !0
+        }, typeof C.lazy == "boolean" && (typeof C.loaded == "boolean" && C.loaded && (L.noLazyChildren = !(C.children && C.children.length)), L.loading = C.loading));
+        const P = [c(w, R, L)];
+        if (C) {
+          let U = 0;
+          const Y = (ae, te) => {
+            ae && ae.length && te && ae.forEach((me) => {
+              const le = {
+                display: te.display && te.expanded,
+                level: te.level + 1,
+                expanded: !1,
+                noLazyChildren: !1,
+                loading: !1
+              }, de = Z(me, X.value);
+              if (de == null)
+                throw new Error("For nested data item, row-key is required.");
+              if (C = { ...M.value[de] }, C && (le.expanded = C.expanded, C.level = C.level || le.level, C.display = !!(C.expanded && le.display), typeof C.lazy == "boolean" && (typeof C.loaded == "boolean" && C.loaded && (le.noLazyChildren = !(C.children && C.children.length)), le.loading = C.loading)), U++, P.push(c(me, R + U, le)), C) {
+                const ve = z.value[de] || me[j.value];
+                Y(ve, C);
+              }
+            });
+          };
+          C.display = !0;
+          const q = z.value[Q] || w[j.value];
+          Y(q, C);
+        }
+        return P;
+      } else
+        return c(w, R, void 0);
+    },
+    tooltipContent: d,
+    tooltipTrigger: h
+  };
+}
+const cs = {
+  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 fs = he({
+  name: "ElTableBody",
+  props: cs,
+  setup(e) {
+    const t = ee(), l = re(pe), n = se("table"), { wrappedRowRender: r, tooltipContent: a, tooltipTrigger: i } = ds(e), { onColumnsChange: o, onScrollableChange: s } = Ql(l);
+    return ie(e.store.states.hoverRow, (u, d) => {
+      !e.store.states.isComplex.value || !ze || oo(() => {
+        const h = t == null ? void 0 : t.vnode.el, p = Array.from((h == null ? void 0 : h.children) || []).filter((g) => g == null ? void 0 : g.classList.contains(`${n.e("row")}`)), m = p[d], f = p[u];
+        m && ft(m, "hover-row"), f && Cl(f, "hover-row");
+      });
+    }), Rt(() => {
+      var u;
+      (u = be) == null || u();
+    }), {
+      ns: n,
+      onColumnsChange: o,
+      onScrollableChange: s,
+      wrappedRowRender: r,
+      tooltipContent: a,
+      tooltipTrigger: i
+    };
+  },
+  render() {
+    const { wrappedRowRender: e, store: t } = this, l = t.states.data.value || [];
+    return H("tbody", { tabIndex: -1 }, [
+      l.reduce((n, r) => n.concat(e(r, n.length)), [])
+    ]);
+  }
+});
+function $t(e) {
+  const t = e.tableLayout === "auto";
+  let l = e.columns || [];
+  t && l.every((r) => r.width === void 0) && (l = []);
+  const n = (r) => {
+    const a = {
+      key: `${e.tableLayout}_${r.id}`,
+      style: {},
+      name: void 0
+    };
+    return t ? a.style = {
+      width: `${r.width}px`
+    } : a.name = r.id, a;
+  };
+  return H("colgroup", {}, l.map((r) => H("col", n(r))));
+}
+$t.props = ["columns", "tableLayout"];
+function hs() {
+  const e = re(pe), t = e == null ? void 0 : e.store, l = T(() => t.states.fixedLeafColumnsLength.value), n = T(() => t.states.rightFixedColumns.value.length), r = T(() => t.states.columns.value.length), a = T(() => t.states.fixedColumns.value.length), i = T(() => t.states.rightFixedColumns.value.length);
+  return {
+    leftFixedLeafCount: l,
+    rightFixedLeafCount: n,
+    columnsCount: r,
+    leftFixedCount: a,
+    rightFixedCount: i,
+    columns: t.states.columns
+  };
+}
+function vs(e) {
+  const { columns: t } = hs(), l = se("table");
+  return {
+    getCellClasses: (a, i) => {
+      const o = a[i], s = [
+        l.e("cell"),
+        o.id,
+        o.align,
+        o.labelClassName,
+        ...Wt(l.b(), i, o.fixed, e.store)
+      ];
+      return o.className && s.push(o.className), o.children || s.push(l.is("leaf")), s;
+    },
+    getCellStyles: (a, i) => {
+      const o = Ht(i, a.fixed, e.store);
+      return Te(o, "left"), Te(o, "right"), o;
+    },
+    columns: t
+  };
+}
+var ps = he({
+  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 { getCellClasses: t, getCellStyles: l, columns: n } = vs(e);
+    return {
+      ns: se("table"),
+      getCellClasses: t,
+      getCellStyles: l,
+      columns: n
+    };
+  },
+  render() {
+    const {
+      columns: e,
+      getCellStyles: t,
+      getCellClasses: l,
+      summaryMethod: n,
+      sumText: r,
+      ns: a
+    } = this, i = this.store.states.data.value;
+    let o = [];
+    return n ? o = n({
+      columns: e,
+      data: i
+    }) : e.forEach((s, u) => {
+      if (u === 0) {
+        o[u] = r;
+        return;
+      }
+      const d = i.map((f) => Number(f[s.property])), h = [];
+      let p = !0;
+      d.forEach((f) => {
+        if (!Number.isNaN(+f)) {
+          p = !1;
+          const g = `${f}`.split(".")[1];
+          h.push(g ? g.length : 0);
+        }
+      });
+      const m = Math.max.apply(null, h);
+      p ? o[u] = "" : o[u] = d.reduce((f, g) => {
+        const v = Number(g);
+        return Number.isNaN(+v) ? f : Number.parseFloat((f + g).toFixed(Math.min(m, 20)));
+      }, 0);
+    }), H("table", {
+      class: a.e("footer"),
+      cellspacing: "0",
+      cellpadding: "0",
+      border: "0"
+    }, [
+      $t({
+        columns: e
+      }),
+      H("tbody", [
+        H("tr", {}, [
+          ...e.map((s, u) => H("td", {
+            key: u,
+            colspan: s.colSpan,
+            rowspan: s.rowSpan,
+            class: l(e, u),
+            style: t(s, u)
+          }, [
+            H("div", {
+              class: ["cell", s.labelClassName]
+            }, [o[u]])
+          ]))
+        ])
+      ])
+    ]);
+  }
+});
+function ms(e) {
+  return {
+    setCurrentRow: (d) => {
+      e.commit("setCurrentRow", d);
+    },
+    getSelectionRows: () => e.getSelectionRows(),
+    toggleRowSelection: (d, h) => {
+      e.toggleRowSelection(d, h, !1), e.updateAllSelected();
+    },
+    clearSelection: () => {
+      e.clearSelection();
+    },
+    clearFilter: (d) => {
+      e.clearFilter(d);
+    },
+    toggleAllSelection: () => {
+      e.commit("toggleAllSelection");
+    },
+    toggleRowExpansion: (d, h) => {
+      e.toggleRowExpansionAdapter(d, h);
+    },
+    clearSort: () => {
+      e.clearSort();
+    },
+    sort: (d, h) => {
+      e.commit("sort", { prop: d, order: h });
+    }
+  };
+}
+function gs(e, t, l, n) {
+  const r = E(!1), a = E(null), i = E(!1), o = (C) => {
+    i.value = C;
+  }, s = E({
+    width: null,
+    height: null,
+    headerHeight: null
+  }), u = E(!1), d = {
+    display: "inline-block",
+    verticalAlign: "middle"
+  }, h = E(), p = E(0), m = E(0), f = E(0), g = E(0), v = E(0);
+  He(() => {
+    t.setHeight(e.height);
+  }), He(() => {
+    t.setMaxHeight(e.maxHeight);
+  }), ie(() => [e.currentRowKey, l.states.rowKey], ([C, L]) => {
+    !O(L) || !O(C) || l.setCurrentRowKey(`${C}`);
+  }, {
+    immediate: !0
+  }), ie(() => e.data, (C) => {
+    n.store.commit("setData", C);
+  }, {
+    immediate: !0,
+    deep: !0
+  }), He(() => {
+    e.expandRowKeys && l.setExpandRowKeysAdapter(e.expandRowKeys);
+  });
+  const y = () => {
+    n.store.commit("setHoverRow", null), n.hoverState && (n.hoverState = null);
+  }, b = (C, L) => {
+    const { pixelX: P, pixelY: U } = L;
+    Math.abs(P) >= Math.abs(U) && (n.refs.bodyWrapper.scrollLeft += L.pixelX / 5);
+  }, S = T(() => e.height || e.maxHeight || l.states.fixedColumns.value.length > 0 || l.states.rightFixedColumns.value.length > 0), c = T(() => ({
+    width: t.bodyWidth.value ? `${t.bodyWidth.value}px` : ""
+  })), x = () => {
+    S.value && t.updateElsHeight(), t.updateColumnsWidth(), requestAnimationFrame(F);
+  };
+  Ke(async () => {
+    await Ee(), l.updateColumns(), K(), requestAnimationFrame(x);
+    const C = n.vnode.el, L = n.refs.headerWrapper;
+    e.flexible && C && C.parentElement && (C.parentElement.style.minWidth = "0"), s.value = {
+      width: h.value = C.offsetWidth,
+      height: C.offsetHeight,
+      headerHeight: e.showHeader && L ? L.offsetHeight : null
+    }, l.states.columns.value.forEach((P) => {
+      P.filteredValue && P.filteredValue.length && n.store.commit("filterChange", {
+        column: P,
+        values: P.filteredValue,
+        silent: !0
+      });
+    }), n.$ready = !0;
+  });
+  const k = (C, L) => {
+    if (!C)
+      return;
+    const P = Array.from(C.classList).filter((U) => !U.startsWith("is-scrolling-"));
+    P.push(t.scrollX.value ? L : "is-scrolling-none"), C.className = P.join(" ");
+  }, w = (C) => {
+    const { tableWrapper: L } = n.refs;
+    k(L, C);
+  }, R = (C) => {
+    const { tableWrapper: L } = n.refs;
+    return !!(L && L.classList.contains(C));
+  }, F = function() {
+    if (!n.refs.scrollBarRef)
+      return;
+    if (!t.scrollX.value) {
+      const te = "is-scrolling-none";
+      R(te) || w(te);
+      return;
+    }
+    const C = n.refs.scrollBarRef.wrapRef;
+    if (!C)
+      return;
+    const { scrollLeft: L, offsetWidth: P, scrollWidth: U } = C, { headerWrapper: Y, footerWrapper: q } = n.refs;
+    Y && (Y.scrollLeft = L), q && (q.scrollLeft = L);
+    const ae = U - P - 1;
+    L >= ae ? w("is-scrolling-right") : w(L === 0 ? "is-scrolling-left" : "is-scrolling-middle");
+  }, K = () => {
+    n.refs.scrollBarRef && (n.refs.scrollBarRef.wrapRef && Ut(n.refs.scrollBarRef.wrapRef, "scroll", F, {
+      passive: !0
+    }), e.fit ? Gt(n.vnode.el, B) : Ut(window, "resize", B), Gt(n.refs.bodyWrapper, () => {
+      var C, L;
+      B(), (L = (C = n.refs) == null ? void 0 : C.scrollBarRef) == null || L.update();
+    }));
+  }, B = () => {
+    var C, L, P, U;
+    const Y = n.vnode.el;
+    if (!n.$ready || !Y)
+      return;
+    let q = !1;
+    const {
+      width: ae,
+      height: te,
+      headerHeight: me
+    } = s.value, le = h.value = Y.offsetWidth;
+    ae !== le && (q = !0);
+    const de = Y.offsetHeight;
+    (e.height || S.value) && te !== de && (q = !0);
+    const ve = e.tableLayout === "fixed" ? n.refs.headerWrapper : (C = n.refs.tableHeaderRef) == null ? void 0 : C.$el;
+    e.showHeader && (ve == null ? void 0 : ve.offsetHeight) !== me && (q = !0), p.value = ((L = n.refs.tableWrapper) == null ? void 0 : L.scrollHeight) || 0, f.value = (ve == null ? void 0 : ve.scrollHeight) || 0, g.value = ((P = n.refs.footerWrapper) == null ? void 0 : P.offsetHeight) || 0, v.value = ((U = n.refs.appendWrapper) == null ? void 0 : U.offsetHeight) || 0, m.value = p.value - f.value - g.value - v.value, q && (s.value = {
+      width: le,
+      height: de,
+      headerHeight: e.showHeader && (ve == null ? void 0 : ve.offsetHeight) || 0
+    }, x());
+  }, M = ht(), z = T(() => {
+    const { bodyWidth: C, scrollY: L, gutterWidth: P } = t;
+    return C.value ? `${C.value - (L.value ? P : 0)}px` : "";
+  }), j = T(() => e.maxHeight ? "fixed" : e.tableLayout), X = T(() => {
+    if (e.data && e.data.length)
+      return null;
+    let C = "100%";
+    e.height && m.value && (C = `${m.value}px`);
+    const L = h.value;
+    return {
+      width: L ? `${L}px` : "",
+      height: C
+    };
+  }), _ = T(() => e.height ? {
+    height: Number.isNaN(Number(e.height)) ? e.height : `${e.height}px`
+  } : e.maxHeight ? {
+    maxHeight: Number.isNaN(Number(e.maxHeight)) ? e.maxHeight : `${e.maxHeight}px`
+  } : {}), ue = T(() => e.height ? {
+    height: "100%"
+  } : e.maxHeight ? Number.isNaN(Number(e.maxHeight)) ? {
+    maxHeight: `calc(${e.maxHeight} - ${f.value + g.value}px)`
+  } : {
+    maxHeight: `${e.maxHeight - f.value - g.value}px`
+  } : {});
+  return {
+    isHidden: r,
+    renderExpanded: a,
+    setDragVisible: o,
+    isGroup: u,
+    handleMouseLeave: y,
+    handleHeaderFooterMousewheel: b,
+    tableSize: M,
+    emptyBlockStyle: X,
+    handleFixedMousewheel: (C, L) => {
+      const P = n.refs.bodyWrapper;
+      if (Math.abs(L.spinY) > 0) {
+        const U = P.scrollTop;
+        L.pixelY < 0 && U !== 0 && C.preventDefault(), L.pixelY > 0 && P.scrollHeight - P.clientHeight > U && C.preventDefault(), P.scrollTop += Math.ceil(L.pixelY / 5);
+      } else
+        P.scrollLeft += Math.ceil(L.pixelX / 5);
+    },
+    resizeProxyVisible: i,
+    bodyWidth: z,
+    resizeState: s,
+    doLayout: x,
+    tableBodyStyles: c,
+    tableLayout: j,
+    scrollbarViewStyle: d,
+    tableInnerStyle: _,
+    scrollbarStyle: ue
+  };
+}
+function bs(e) {
+  const t = E(), l = () => {
+    const r = e.vnode.el.querySelector(".hidden-columns"), a = { childList: !0, subtree: !0 }, i = e.store.states.updateOrderFns;
+    t.value = new MutationObserver(() => {
+      i.forEach((o) => o());
+    }), t.value.observe(r, a);
+  };
+  Ke(() => {
+    l();
+  }), Rt(() => {
+    var n;
+    (n = t.value) == null || n.disconnect();
+  });
+}
+var ys = {
+  data: {
+    type: Array,
+    default: () => []
+  },
+  size: Ot,
+  width: [String, Number],
+  height: [String, Number],
+  maxHeight: [String, Number],
+  fit: {
+    type: Boolean,
+    default: !0
+  },
+  stripe: Boolean,
+  border: Boolean,
+  rowKey: [String, Function],
+  showHeader: {
+    type: Boolean,
+    default: !0
+  },
+  showSummary: Boolean,
+  sumText: String,
+  summaryMethod: Function,
+  rowClassName: [String, Function],
+  rowStyle: [Object, Function],
+  cellClassName: [String, Function],
+  cellStyle: [Object, Function],
+  headerRowClassName: [String, Function],
+  headerRowStyle: [Object, Function],
+  headerCellClassName: [String, Function],
+  headerCellStyle: [Object, Function],
+  highlightCurrentRow: Boolean,
+  currentRowKey: [String, Number],
+  emptyText: String,
+  expandRowKeys: Array,
+  defaultExpandAll: Boolean,
+  defaultSort: Object,
+  tooltipEffect: String,
+  tooltipOptions: Object,
+  spanMethod: Function,
+  selectOnIndeterminate: {
+    type: Boolean,
+    default: !0
+  },
+  indent: {
+    type: Number,
+    default: 16
+  },
+  treeProps: {
+    type: Object,
+    default: () => ({
+      hasChildren: "hasChildren",
+      children: "children"
+    })
+  },
+  lazy: Boolean,
+  load: Function,
+  style: {
+    type: Object,
+    default: () => ({})
+  },
+  className: {
+    type: String,
+    default: ""
+  },
+  tableLayout: {
+    type: String,
+    default: "fixed"
+  },
+  scrollbarAlwaysOn: {
+    type: Boolean,
+    default: !1
+  },
+  flexible: Boolean,
+  showOverflowTooltip: [Boolean, Object]
+};
+const Cs = () => {
+  const e = E(), t = (a, i) => {
+    const o = e.value;
+    o && o.scrollTo(a, i);
+  }, l = (a, i) => {
+    const o = e.value;
+    o && dt(i) && ["Top", "Left"].includes(a) && o[`setScroll${a}`](i);
+  };
+  return {
+    scrollBarRef: e,
+    scrollTo: t,
+    setScrollTop: (a) => l("Top", a),
+    setScrollLeft: (a) => l("Left", a)
+  };
+};
+let ws = 1;
+const Ss = he({
+  name: "ElTable",
+  directives: {
+    Mousewheel: dr
+  },
+  components: {
+    TableHeader: as,
+    TableBody: fs,
+    TableFooter: ps,
+    ElScrollbar: pl,
+    hColgroup: $t
+  },
+  props: ys,
+  emits: [
+    "select",
+    "select-all",
+    "selection-change",
+    "cell-mouse-enter",
+    "cell-mouse-leave",
+    "cell-contextmenu",
+    "cell-click",
+    "cell-dblclick",
+    "row-click",
+    "row-contextmenu",
+    "row-dblclick",
+    "header-click",
+    "header-contextmenu",
+    "sort-change",
+    "filter-change",
+    "current-change",
+    "header-dragend",
+    "expand-change"
+  ],
+  setup(e) {
+    const { t } = yl(), l = se("table"), n = ee();
+    ul(pe, n);
+    const r = Yr(n, e);
+    n.store = r;
+    const a = new Xr({
+      store: n.store,
+      table: n,
+      fit: e.fit,
+      showHeader: e.showHeader
+    });
+    n.layout = a;
+    const i = T(() => (r.states.data.value || []).length === 0), {
+      setCurrentRow: o,
+      getSelectionRows: s,
+      toggleRowSelection: u,
+      clearSelection: d,
+      clearFilter: h,
+      toggleAllSelection: p,
+      toggleRowExpansion: m,
+      clearSort: f,
+      sort: g
+    } = ms(r), {
+      isHidden: v,
+      renderExpanded: y,
+      setDragVisible: b,
+      isGroup: S,
+      handleMouseLeave: c,
+      handleHeaderFooterMousewheel: x,
+      tableSize: k,
+      emptyBlockStyle: w,
+      handleFixedMousewheel: R,
+      resizeProxyVisible: F,
+      bodyWidth: K,
+      resizeState: B,
+      doLayout: M,
+      tableBodyStyles: z,
+      tableLayout: j,
+      scrollbarViewStyle: X,
+      tableInnerStyle: _,
+      scrollbarStyle: ue
+    } = gs(e, a, r, n), { scrollBarRef: Q, scrollTo: C, setScrollLeft: L, setScrollTop: P } = Cs(), U = nt(M, 50), Y = `${l.namespace.value}-table_${ws++}`;
+    n.tableId = Y, n.state = {
+      isGroup: S,
+      resizeState: B,
+      doLayout: M,
+      debouncedUpdateLayout: U
+    };
+    const q = T(() => e.sumText || t("el.table.sumText")), ae = T(() => e.emptyText || t("el.table.emptyText"));
+    return bs(n), {
+      ns: l,
+      layout: a,
+      store: r,
+      handleHeaderFooterMousewheel: x,
+      handleMouseLeave: c,
+      tableId: Y,
+      tableSize: k,
+      isHidden: v,
+      isEmpty: i,
+      renderExpanded: y,
+      resizeProxyVisible: F,
+      resizeState: B,
+      isGroup: S,
+      bodyWidth: K,
+      tableBodyStyles: z,
+      emptyBlockStyle: w,
+      debouncedUpdateLayout: U,
+      handleFixedMousewheel: R,
+      setCurrentRow: o,
+      getSelectionRows: s,
+      toggleRowSelection: u,
+      clearSelection: d,
+      clearFilter: h,
+      toggleAllSelection: p,
+      toggleRowExpansion: m,
+      clearSort: f,
+      doLayout: M,
+      sort: g,
+      t,
+      setDragVisible: b,
+      context: n,
+      computedSumText: q,
+      computedEmptyText: ae,
+      tableLayout: j,
+      scrollbarViewStyle: X,
+      tableInnerStyle: _,
+      scrollbarStyle: ue,
+      scrollBarRef: Q,
+      scrollTo: C,
+      setScrollLeft: L,
+      setScrollTop: P
+    };
+  }
+}), xs = ["data-prefix"], Es = {
+  ref: "hiddenColumns",
+  class: "hidden-columns"
+};
+function ks(e, t, l, n, r, a) {
+  const i = fe("hColgroup"), o = fe("table-header"), s = fe("table-body"), u = fe("el-scrollbar"), d = fe("table-footer"), h = cl("mousewheel");
+  return D(), G("div", {
+    ref: "tableWrapper",
+    class: I([
+      {
+        [e.ns.m("fit")]: e.fit,
+        [e.ns.m("striped")]: e.stripe,
+        [e.ns.m("border")]: e.border || e.isGroup,
+        [e.ns.m("hidden")]: e.isHidden,
+        [e.ns.m("group")]: e.isGroup,
+        [e.ns.m("fluid-height")]: e.maxHeight,
+        [e.ns.m("scrollable-x")]: e.layout.scrollX.value,
+        [e.ns.m("scrollable-y")]: e.layout.scrollY.value,
+        [e.ns.m("enable-row-hover")]: !e.store.states.isComplex.value,
+        [e.ns.m("enable-row-transition")]: (e.store.states.data.value || []).length !== 0 && (e.store.states.data.value || []).length < 100,
+        "has-footer": e.showSummary
+      },
+      e.ns.m(e.tableSize),
+      e.className,
+      e.ns.b(),
+      e.ns.m(`layout-${e.tableLayout}`)
+    ]),
+    style: ke(e.style),
+    "data-prefix": e.ns.namespace.value,
+    onMouseleave: t[0] || (t[0] = (...p) => e.handleMouseLeave && e.handleMouseLeave(...p))
+  }, [
+    oe("div", {
+      class: I(e.ns.e("inner-wrapper")),
+      style: ke(e.tableInnerStyle)
+    }, [
+      oe("div", Es, [
+        Fe(e.$slots, "default")
+      ], 512),
+      e.showHeader && e.tableLayout === "fixed" ? xe((D(), G("div", {
+        key: 0,
+        ref: "headerWrapper",
+        class: I(e.ns.e("header-wrapper"))
+      }, [
+        oe("table", {
+          ref: "tableHeader",
+          class: I(e.ns.e("header")),
+          style: ke(e.tableBodyStyles),
+          border: "0",
+          cellpadding: "0",
+          cellspacing: "0"
+        }, [
+          we(i, {
+            columns: e.store.states.columns.value,
+            "table-layout": e.tableLayout
+          }, null, 8, ["columns", "table-layout"]),
+          we(o, {
+            ref: "tableHeaderRef",
+            border: e.border,
+            "default-sort": e.defaultSort,
+            store: e.store,
+            onSetDragVisible: e.setDragVisible
+          }, null, 8, ["border", "default-sort", "store", "onSetDragVisible"])
+        ], 6)
+      ], 2)), [
+        [h, e.handleHeaderFooterMousewheel]
+      ]) : Ce("v-if", !0),
+      oe("div", {
+        ref: "bodyWrapper",
+        class: I(e.ns.e("body-wrapper"))
+      }, [
+        we(u, {
+          ref: "scrollBarRef",
+          "view-style": e.scrollbarViewStyle,
+          "wrap-style": e.scrollbarStyle,
+          always: e.scrollbarAlwaysOn
+        }, {
+          default: ye(() => [
+            oe("table", {
+              ref: "tableBody",
+              class: I(e.ns.e("body")),
+              cellspacing: "0",
+              cellpadding: "0",
+              border: "0",
+              style: ke({
+                width: e.bodyWidth,
+                tableLayout: e.tableLayout
+              })
+            }, [
+              we(i, {
+                columns: e.store.states.columns.value,
+                "table-layout": e.tableLayout
+              }, null, 8, ["columns", "table-layout"]),
+              e.showHeader && e.tableLayout === "auto" ? (D(), Le(o, {
+                key: 0,
+                ref: "tableHeaderRef",
+                border: e.border,
+                "default-sort": e.defaultSort,
+                store: e.store,
+                onSetDragVisible: e.setDragVisible
+              }, null, 8, ["border", "default-sort", "store", "onSetDragVisible"])) : Ce("v-if", !0),
+              we(s, {
+                context: e.context,
+                highlight: e.highlightCurrentRow,
+                "row-class-name": e.rowClassName,
+                "tooltip-effect": e.tooltipEffect,
+                "tooltip-options": e.tooltipOptions,
+                "row-style": e.rowStyle,
+                store: e.store,
+                stripe: e.stripe
+              }, null, 8, ["context", "highlight", "row-class-name", "tooltip-effect", "tooltip-options", "row-style", "store", "stripe"])
+            ], 6),
+            e.isEmpty ? (D(), G("div", {
+              key: 0,
+              ref: "emptyBlock",
+              style: ke(e.emptyBlockStyle),
+              class: I(e.ns.e("empty-block"))
+            }, [
+              oe("span", {
+                class: I(e.ns.e("empty-text"))
+              }, [
+                Fe(e.$slots, "empty", {}, () => [
+                  ot(Se(e.computedEmptyText), 1)
+                ])
+              ], 2)
+            ], 6)) : Ce("v-if", !0),
+            e.$slots.append ? (D(), G("div", {
+              key: 1,
+              ref: "appendWrapper",
+              class: I(e.ns.e("append-wrapper"))
+            }, [
+              Fe(e.$slots, "append")
+            ], 2)) : Ce("v-if", !0)
+          ]),
+          _: 3
+        }, 8, ["view-style", "wrap-style", "always"])
+      ], 2),
+      e.showSummary ? xe((D(), G("div", {
+        key: 1,
+        ref: "footerWrapper",
+        class: I(e.ns.e("footer-wrapper"))
+      }, [
+        we(d, {
+          border: e.border,
+          "default-sort": e.defaultSort,
+          store: e.store,
+          style: ke(e.tableBodyStyles),
+          "sum-text": e.computedSumText,
+          "summary-method": e.summaryMethod
+        }, null, 8, ["border", "default-sort", "store", "style", "sum-text", "summary-method"])
+      ], 2)), [
+        [zt, !e.isEmpty],
+        [h, e.handleHeaderFooterMousewheel]
+      ]) : Ce("v-if", !0),
+      e.border || e.isGroup ? (D(), G("div", {
+        key: 2,
+        class: I(e.ns.e("border-left-patch"))
+      }, null, 2)) : Ce("v-if", !0)
+    ], 6),
+    xe(oe("div", {
+      ref: "resizeProxy",
+      class: I(e.ns.e("column-resize-proxy"))
+    }, null, 2), [
+      [zt, e.resizeProxyVisible]
+    ])
+  ], 46, xs);
+}
+var Rs = /* @__PURE__ */ je(Ss, [["render", ks], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/table/src/table.vue"]]);
+const Ls = {
+  selection: "table-column--selection",
+  expand: "table__expand-column"
+}, Ns = {
+  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: ""
+  }
+}, Os = (e) => Ls[e] || "", Fs = {
+  selection: {
+    renderHeader({ store: e, column: t }) {
+      function l() {
+        return e.states.data.value && e.states.data.value.length === 0;
+      }
+      return H(Ae, {
+        disabled: l(),
+        size: e.states.tableSize.value,
+        indeterminate: e.states.selection.value.length > 0 && !e.states.isAllSelected.value,
+        "onUpdate:modelValue": e.toggleAllSelection,
+        modelValue: e.states.isAllSelected.value,
+        ariaLabel: t.label
+      });
+    },
+    renderCell({
+      row: e,
+      column: t,
+      store: l,
+      $index: n
+    }) {
+      return H(Ae, {
+        disabled: t.selectable ? !t.selectable.call(null, e, n) : !1,
+        size: l.states.tableSize.value,
+        onChange: () => {
+          l.commit("rowSelectedChanged", e);
+        },
+        onClick: (r) => r.stopPropagation(),
+        modelValue: l.isSelected(e),
+        ariaLabel: t.label
+      });
+    },
+    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 typeof n == "number" ? l = t + n : typeof n == "function" && (l = n(t)), H("div", {}, [l]);
+    },
+    sortable: !1
+  },
+  expand: {
+    renderHeader({ column: e }) {
+      return e.label || "";
+    },
+    renderCell({
+      row: e,
+      store: t,
+      expanded: l
+    }) {
+      const { ns: n } = t, r = [n.e("expand-icon")];
+      return l && r.push(n.em("expand-icon", "expanded")), H("div", {
+        class: r,
+        onClick: function(i) {
+          i.stopPropagation(), t.toggleRowExpansion(e);
+        }
+      }, {
+        default: () => [
+          H(Mt, null, {
+            default: () => [H(xl)]
+          })
+        ]
+      });
+    },
+    sortable: !1,
+    resizable: !1
+  }
+};
+function Ms({
+  row: e,
+  column: t,
+  $index: l
+}) {
+  var n;
+  const r = t.property, a = r && Qn(e, r).value;
+  return t && t.formatter ? t.formatter(e, t, a, l) : ((n = a == null ? void 0 : a.toString) == null ? void 0 : n.call(a)) || "";
+}
+function As({
+  row: e,
+  treeNode: t,
+  store: l
+}, n = !1) {
+  const { ns: r } = l;
+  if (!t)
+    return n ? [
+      H("span", {
+        class: r.e("placeholder")
+      })
+    ] : null;
+  const a = [], i = function(o) {
+    o.stopPropagation(), !t.loading && l.loadOrToggle(e);
+  };
+  if (t.indent && a.push(H("span", {
+    class: r.e("indent"),
+    style: { "padding-left": `${t.indent}px` }
+  })), typeof t.expanded == "boolean" && !t.noLazyChildren) {
+    const o = [
+      r.e("expand-icon"),
+      t.expanded ? r.em("expand-icon", "expanded") : ""
+    ];
+    let s = xl;
+    t.loading && (s = no), a.push(H("div", {
+      class: o,
+      onClick: i
+    }, {
+      default: () => [
+        H(Mt, { class: { [r.is("loading")]: t.loading } }, {
+          default: () => [H(s)]
+        })
+      ]
+    }));
+  } else
+    a.push(H("span", {
+      class: r.e("placeholder")
+    }));
+  return a;
+}
+function sl(e, t) {
+  return e.reduce((l, n) => (l[n] = n, l), t);
+}
+function Ts(e, t) {
+  const l = ee();
+  return {
+    registerComplexWatchers: () => {
+      const a = ["fixed"], i = {
+        realWidth: "width",
+        realMinWidth: "minWidth"
+      }, o = sl(a, i);
+      Object.keys(o).forEach((s) => {
+        const u = i[s];
+        Ie(t, u) && ie(() => t[u], (d) => {
+          let h = d;
+          u === "width" && s === "realWidth" && (h = Tt(d)), u === "minWidth" && s === "realMinWidth" && (h = Gl(d)), l.columnConfig.value[u] = h, l.columnConfig.value[s] = h;
+          const p = u === "fixed";
+          e.value.store.scheduleLayout(p);
+        });
+      });
+    },
+    registerNormalWatchers: () => {
+      const a = [
+        "label",
+        "filters",
+        "filterMultiple",
+        "filteredValue",
+        "sortable",
+        "index",
+        "formatter",
+        "className",
+        "labelClassName",
+        "showOverflowTooltip"
+      ], i = {
+        property: "prop",
+        align: "realAlign",
+        headerAlign: "realHeaderAlign"
+      }, o = sl(a, i);
+      Object.keys(o).forEach((s) => {
+        const u = i[s];
+        Ie(t, u) && ie(() => t[u], (d) => {
+          l.columnConfig.value[s] = d;
+        });
+      });
+    }
+  };
+}
+function Ws(e, t, l) {
+  const n = ee(), r = E(""), a = E(!1), i = E(), o = E(), s = se("table");
+  He(() => {
+    i.value = e.align ? `is-${e.align}` : null, i.value;
+  }), He(() => {
+    o.value = e.headerAlign ? `is-${e.headerAlign}` : i.value, o.value;
+  });
+  const u = T(() => {
+    let c = n.vnode.vParent || n.parent;
+    for (; c && !c.tableId && !c.columnId; )
+      c = c.vnode.vParent || c.parent;
+    return c;
+  }), d = T(() => {
+    const { store: c } = n.parent;
+    if (!c)
+      return !1;
+    const { treeData: x } = c.states, k = x.value;
+    return k && Object.keys(k).length > 0;
+  }), h = E(Tt(e.width)), p = E(Gl(e.minWidth)), m = (c) => (h.value && (c.width = h.value), p.value && (c.minWidth = p.value), !h.value && p.value && (c.width = void 0), c.minWidth || (c.minWidth = 80), c.realWidth = Number(c.width === void 0 ? c.minWidth : c.width), c), f = (c) => {
+    const x = c.type, k = Fs[x] || {};
+    Object.keys(k).forEach((R) => {
+      const F = k[R];
+      R !== "className" && F !== void 0 && (c[R] = F);
+    });
+    const w = Os(x);
+    if (w) {
+      const R = `${O(s.namespace)}-${w}`;
+      c.className = c.className ? `${c.className} ${R}` : R;
+    }
+    return c;
+  }, g = (c) => {
+    Array.isArray(c) ? c.forEach((k) => x(k)) : x(c);
+    function x(k) {
+      var w;
+      ((w = k == null ? void 0 : k.type) == null ? void 0 : w.name) === "ElTableColumn" && (k.vParent = n);
+    }
+  };
+  return {
+    columnId: r,
+    realAlign: i,
+    isSubColumn: a,
+    realHeaderAlign: o,
+    columnOrTableParent: u,
+    setColumnWidth: m,
+    setColumnForcedProps: f,
+    setColumnRenders: (c) => {
+      e.renderHeader ? Lt("TableColumn", "Comparing to render-header, scoped-slot header is easier to use. We recommend users to use scoped-slot header.") : c.type !== "selection" && (c.renderHeader = (k) => {
+        n.columnConfig.value.label;
+        const w = t.header;
+        return w ? w(k) : c.label;
+      });
+      let x = c.renderCell;
+      return c.type === "expand" ? (c.renderCell = (k) => H("div", {
+        class: "cell"
+      }, [x(k)]), l.value.renderExpanded = (k) => t.default ? t.default(k) : t.default) : (x = x || Ms, c.renderCell = (k) => {
+        let w = null;
+        if (t.default) {
+          const z = t.default(k);
+          w = z.some((j) => j.type !== Sn) ? z : x(k);
+        } else
+          w = x(k);
+        const { columns: R } = l.value.store.states, F = R.value.findIndex((z) => z.type === "default"), K = d.value && k.cellIndex === F, B = As(k, K), M = {
+          class: "cell",
+          style: {}
+        };
+        return c.showOverflowTooltip && (M.class = `${M.class} ${O(s.namespace)}-tooltip`, M.style = {
+          width: `${(k.column.realWidth || Number(k.column.width)) - 1}px`
+        }), g(w), H("div", M, [B, w]);
+      }), c;
+    },
+    getPropsData: (...c) => c.reduce((x, k) => (Array.isArray(k) && k.forEach((w) => {
+      x[w] = e[w];
+    }), x), {}),
+    getColumnElIndex: (c, x) => Array.prototype.indexOf.call(c, x),
+    updateColumnOrder: () => {
+      l.value.store.commit("updateColumnOrder", n.columnConfig.value);
+    }
+  };
+}
+var Hs = {
+  type: {
+    type: String,
+    default: "default"
+  },
+  label: String,
+  className: String,
+  labelClassName: String,
+  property: String,
+  prop: String,
+  width: {
+    type: [String, Number],
+    default: ""
+  },
+  minWidth: {
+    type: [String, Number],
+    default: ""
+  },
+  renderHeader: Function,
+  sortable: {
+    type: [Boolean, String],
+    default: !1
+  },
+  sortMethod: Function,
+  sortBy: [String, Function, Array],
+  resizable: {
+    type: Boolean,
+    default: !0
+  },
+  columnKey: String,
+  align: String,
+  headerAlign: String,
+  showOverflowTooltip: {
+    type: [Boolean, Object],
+    default: void 0
+  },
+  fixed: [Boolean, String],
+  formatter: Function,
+  selectable: Function,
+  reserveSelection: Boolean,
+  filterMethod: Function,
+  filteredValue: Array,
+  filters: Array,
+  filterPlacement: String,
+  filterMultiple: {
+    type: Boolean,
+    default: !0
+  },
+  index: [Number, Function],
+  sortOrders: {
+    type: Array,
+    default: () => ["ascending", "descending", null],
+    validator: (e) => e.every((t) => ["ascending", "descending", null].includes(t))
+  }
+};
+let $s = 1;
+var Jl = he({
+  name: "ElTableColumn",
+  components: {
+    ElCheckbox: Ae
+  },
+  props: Hs,
+  setup(e, { slots: t }) {
+    const l = ee(), n = E({}), r = T(() => {
+      let S = l.parent;
+      for (; S && !S.tableId; )
+        S = S.parent;
+      return S;
+    }), { registerNormalWatchers: a, registerComplexWatchers: i } = Ts(r, e), {
+      columnId: o,
+      isSubColumn: s,
+      realHeaderAlign: u,
+      columnOrTableParent: d,
+      setColumnWidth: h,
+      setColumnForcedProps: p,
+      setColumnRenders: m,
+      getPropsData: f,
+      getColumnElIndex: g,
+      realAlign: v,
+      updateColumnOrder: y
+    } = Ws(e, t, r), b = d.value;
+    o.value = `${b.tableId || b.columnId}_column_${$s++}`, fl(() => {
+      s.value = r.value !== b;
+      const S = e.type || "default", c = e.sortable === "" ? !0 : e.sortable, x = lt(e.showOverflowTooltip) ? b.props.showOverflowTooltip : e.showOverflowTooltip, k = {
+        ...Ns[S],
+        id: o.value,
+        type: S,
+        property: e.prop || e.property,
+        align: v,
+        headerAlign: u,
+        showOverflowTooltip: x,
+        filterable: e.filters || e.filterMethod,
+        filteredValue: [],
+        filterPlacement: "",
+        isColumnGroup: !1,
+        isSubColumn: !1,
+        filterOpened: !1,
+        sortable: c,
+        index: e.index,
+        rawColumnKey: l.vnode.key
+      };
+      let B = f([
+        "columnKey",
+        "label",
+        "className",
+        "labelClassName",
+        "type",
+        "renderHeader",
+        "formatter",
+        "fixed",
+        "resizable"
+      ], ["sortMethod", "sortBy", "sortOrders"], ["selectable", "reserveSelection"], [
+        "filterMethod",
+        "filters",
+        "filterMultiple",
+        "filterOpened",
+        "filteredValue",
+        "filterPlacement"
+      ]);
+      B = $r(k, B), B = Br(m, h, p)(B), n.value = B, a(), i();
+    }), Ke(() => {
+      var S;
+      const c = d.value, x = s.value ? c.vnode.el.children : (S = c.refs.hiddenColumns) == null ? void 0 : S.children, k = () => g(x || [], l.vnode.el);
+      n.value.getColumnIndex = k, k() > -1 && r.value.store.commit("insertColumn", n.value, s.value ? c.columnConfig.value : null, y);
+    }), xn(() => {
+      r.value.store.commit("removeColumn", n.value, s.value ? b.columnConfig.value : null, y);
+    }), l.columnId = o.value, l.columnConfig = n;
+  },
+  render() {
+    var e, t, l;
+    try {
+      const n = (t = (e = this.$slots).default) == null ? void 0 : t.call(e, {
+        row: {},
+        column: {},
+        $index: -1
+      }), r = [];
+      if (Array.isArray(n))
+        for (const i of n)
+          ((l = i.type) == null ? void 0 : l.name) === "ElTableColumn" || i.shapeFlag & 2 ? r.push(i) : i.type === Je && Array.isArray(i.children) && i.children.forEach((o) => {
+            (o == null ? void 0 : o.patchFlag) !== 1024 && !ut(o == null ? void 0 : o.children) && r.push(o);
+          });
+      return H("div", r);
+    } catch {
+      return H("div", []);
+    }
+  }
+});
+const Xs = bl(Rs, {
+  TableColumn: Jl
+}), _s = Nt(Jl);
+export {
+  Ae as E,
+  qs as a,
+  _s as b,
+  Xs as c,
+  bo as d,
+  Bo as e,
+  Io as f,
+  Ll as g,
+  io as h,
+  Po as i,
+  zo as j,
+  Rl as k
+};