st-comp 0.0.69 → 0.0.71

package/lib/Table.es.js

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