jmash-core 0.0.3 → 0.0.5

package/dist/el-table-c9Sup56w.mjs

@@ -0,0 +1,3168 @@
+import { createVNode as fe, render as yt, getCurrentInstance as le, ref as x, unref as Z, computed as P, watch as he, toRefs as Fl, nextTick as Le, isRef as Al, defineComponent as Fe, resolveComponent as ue, resolveDirective as Tt, openBlock as G, createBlock as Ne, withCtx as Ce, createElementBlock as de, createElementVNode as oe, normalizeClass as V, Fragment as Qe, renderList as bt, createTextVNode as kt, toDisplayString as Re, withDirectives as Ke, onBeforeMount as $t, onMounted as Pe, onUpdated as Hl, onUnmounted as ct, inject as ye, h as H, watchEffect as Ae, provide as Tl, normalizeStyle as xe, renderSlot as ze, createCommentVNode as be, vShow as Ct, Comment as kl, onBeforeUnmount as $l } from "vue";
+import { a as Pl, b as Bl, E as Pt, C as Kl } from "./el-scrollbar-B8QteGV0.mjs";
+import { E as Bt } from "./el-popper-C13p_dqu.mjs";
+import { k as ft, bi as zl, bD as Kt, bf as zt, bg as Dl, bc as Il, bj as Je, be as Vl, cg as jl, j as Oe, c2 as ke, a4 as Yl, aL as ql, b8 as Ul, bu as wt, aa as St, x as pe, z as ht, a5 as Xl, b$ as Gl, w as Dt, _ as It, a0 as qe, N as _l, a2 as De, a1 as $e, I as Et, a7 as xt, aO as Ql, aJ as Jl, p as Zl, bt as en, C as Vt, bK as tn, aU as ln, by as nn, O as on, L as rn, Z as sn } from "./index-B6wY38lY.mjs";
+import { s as an, o as un, b as dn, E as We } from "./el-checkbox-B44P9jFr.mjs";
+import { l as Xe, m as cn, k as fn, n as hn, o as jt, i as pn, c as vn, p as gn, q as mn, r as yn, e as Rt, s as bn, S as Cn } from "./el-form-item-f-baJSfe.mjs";
+import { d as Ue } from "./debounce-XYByYe_I.mjs";
+function wn(e, t) {
+  return an(un(e, t, Pl), e + "");
+}
+function Sn(e, t, l) {
+  if (!ft(l))
+    return !1;
+  var n = typeof t;
+  return (n == "number" ? Xe(l) && zl(t, l.length) : n == "string" && t in l) ? Kt(l[t], e) : !1;
+}
+function En(e) {
+  return wn(function(t, l) {
+    var n = -1, s = l.length, a = s > 1 ? l[s - 1] : void 0, i = s > 2 ? l[2] : void 0;
+    for (a = e.length > 3 && typeof a == "function" ? (s--, a) : void 0, i && Sn(l[0], l[1], i) && (a = s < 3 ? void 0 : a, s = 1), t = Object(t); ++n < s; ) {
+      var o = l[n];
+      o && e(t, o, n, a);
+    }
+    return t;
+  });
+}
+var xn = "[object Object]", Rn = Function.prototype, Nn = Object.prototype, Yt = Rn.toString, Ln = Nn.hasOwnProperty, On = Yt.call(Object);
+function Wn(e) {
+  if (!zt(e) || Dl(e) != xn)
+    return !1;
+  var t = cn(e);
+  if (t === null)
+    return !0;
+  var l = Ln.call(t, "constructor") && t.constructor;
+  return typeof l == "function" && l instanceof l && Yt.call(l) == On;
+}
+function Mn(e) {
+  return function(t, l, n) {
+    for (var s = -1, a = Object(t), i = n(t), o = i.length; o--; ) {
+      var r = i[e ? o : ++s];
+      if (l(a[r], r, a) === !1)
+        break;
+    }
+    return t;
+  };
+}
+var qt = Mn();
+function Fn(e, t) {
+  return e && qt(e, t, fn);
+}
+function An(e, t) {
+  return function(l, n) {
+    if (l == null)
+      return l;
+    if (!Xe(l))
+      return e(l, n);
+    for (var s = l.length, a = t ? s : -1, i = Object(l); (t ? a-- : ++a < s) && n(i[a], a, i) !== !1; )
+      ;
+    return l;
+  };
+}
+var Hn = An(Fn);
+function Ze(e, t, l) {
+  (l !== void 0 && !Kt(e[t], l) || l === void 0 && !(t in e)) && Il(e, t, l);
+}
+function Tn(e) {
+  return zt(e) && Xe(e);
+}
+function et(e, t) {
+  if (!(t === "constructor" && typeof e[t] == "function") && t != "__proto__")
+    return e[t];
+}
+function kn(e) {
+  return hn(e, jt(e));
+}
+function $n(e, t, l, n, s, a, i) {
+  var o = et(e, l), r = et(t, l), u = i.get(r);
+  if (u) {
+    Ze(e, l, u);
+    return;
+  }
+  var d = a ? a(o, r, l + "", e, t, i) : void 0, f = d === void 0;
+  if (f) {
+    var p = Je(r), E = !p && pn(r), h = !p && !E && vn(r);
+    d = r, p || E || h ? Je(o) ? d = o : Tn(o) ? d = gn(o) : E ? (f = !1, d = mn(r, !0)) : h ? (f = !1, d = yn(r, !0)) : d = [] : Wn(r) || Rt(r) ? (d = o, Rt(o) ? d = kn(o) : (!ft(o) || Vl(o)) && (d = bn(r))) : f = !1;
+  }
+  f && (i.set(r, d), s(d, r, n, a, i), i.delete(r)), Ze(e, l, d);
+}
+function Ut(e, t, l, n, s) {
+  e !== t && qt(t, function(a, i) {
+    if (s || (s = new Cn()), ft(a))
+      $n(e, t, i, l, Ut, n, s);
+    else {
+      var o = n ? n(et(e, i), a, i + "", e, t, s) : void 0;
+      o === void 0 && (o = a), Ze(e, i, o);
+    }
+  }, jt);
+}
+function Pn(e, t) {
+  var l = -1, n = Xe(e) ? Array(e.length) : [];
+  return Hn(e, function(s, a, i) {
+    n[++l] = t(s, a, i);
+  }), n;
+}
+function Bn(e, t) {
+  var l = Je(e) ? jl : Pn;
+  return l(e, Bl(t));
+}
+function Kn(e, t) {
+  return dn(Bn(e, t), 1);
+}
+var zn = En(function(e, t, l) {
+  Ut(e, t, l);
+});
+const Dn = zn, In = (e) => Oe ? window.requestAnimationFrame(e) : setTimeout(e, 16);
+var Nt = !1, we, tt, lt, Ie, Ve, Xt, je, nt, ot, rt, Gt, st, at, _t, Qt;
+function te() {
+  if (!Nt) {
+    Nt = !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 (st = /\b(iPhone|iP[ao]d)/.exec(e), at = /\b(iP[ao]d)/.exec(e), rt = /Android/i.exec(e), _t = /FBAN\/\w+;/i.exec(e), Qt = /Mobile/i.exec(e), Gt = !!/Win64/.exec(e), t) {
+      we = t[1] ? parseFloat(t[1]) : t[5] ? parseFloat(t[5]) : NaN, we && document && document.documentMode && (we = document.documentMode);
+      var n = /(?:Trident\/(\d+.\d+))/.exec(e);
+      Xt = n ? parseFloat(n[1]) + 4 : we, tt = t[2] ? parseFloat(t[2]) : NaN, lt = t[3] ? parseFloat(t[3]) : NaN, Ie = t[4] ? parseFloat(t[4]) : NaN, Ie ? (t = /(?:Chrome\/(\d+\.\d+))/.exec(e), Ve = t && t[1] ? parseFloat(t[1]) : NaN) : Ve = NaN;
+    } else
+      we = tt = lt = Ve = Ie = NaN;
+    if (l) {
+      if (l[1]) {
+        var s = /(?:Mac OS X (\d+(?:[._]\d+)?))/.exec(e);
+        je = s ? parseFloat(s[1].replace("_", ".")) : !0;
+      } else
+        je = !1;
+      nt = !!l[2], ot = !!l[3];
+    } else
+      je = nt = ot = !1;
+  }
+}
+var it = { ie: function() {
+  return te() || we;
+}, ieCompatibilityMode: function() {
+  return te() || Xt > we;
+}, ie64: function() {
+  return it.ie() && Gt;
+}, firefox: function() {
+  return te() || tt;
+}, opera: function() {
+  return te() || lt;
+}, webkit: function() {
+  return te() || Ie;
+}, safari: function() {
+  return it.webkit();
+}, chrome: function() {
+  return te() || Ve;
+}, windows: function() {
+  return te() || nt;
+}, osx: function() {
+  return te() || je;
+}, linux: function() {
+  return te() || ot;
+}, iphone: function() {
+  return te() || st;
+}, mobile: function() {
+  return te() || st || at || rt || Qt;
+}, nativeApp: function() {
+  return te() || _t;
+}, android: function() {
+  return te() || rt;
+}, ipad: function() {
+  return te() || at;
+} }, Vn = it, Be = !!(typeof window < "u" && window.document && window.document.createElement), jn = { canUseDOM: Be, canUseWorkers: typeof Worker < "u", canUseEventListeners: Be && !!(window.addEventListener || window.attachEvent), canUseViewport: Be && !!window.screen, isInWorker: !Be }, Jt = jn, Zt;
+Jt.canUseDOM && (Zt = document.implementation && document.implementation.hasFeature && document.implementation.hasFeature("", "") !== !0);
+function Yn(e, t) {
+  if (!Jt.canUseDOM || t && !("addEventListener" in document))
+    return !1;
+  var l = "on" + e, n = l in document;
+  if (!n) {
+    var s = document.createElement("div");
+    s.setAttribute(l, "return;"), n = typeof s[l] == "function";
+  }
+  return !n && Zt && e === "wheel" && (n = document.implementation.hasFeature("Events.wheel", "3.0")), n;
+}
+var qn = Yn, Lt = 10, Ot = 40, Wt = 800;
+function el(e) {
+  var t = 0, l = 0, n = 0, s = 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 * Lt, s = l * Lt, "deltaY" in e && (s = e.deltaY), "deltaX" in e && (n = e.deltaX), (n || s) && e.deltaMode && (e.deltaMode == 1 ? (n *= Ot, s *= Ot) : (n *= Wt, s *= Wt)), n && !t && (t = n < 1 ? -1 : 1), s && !l && (l = s < 1 ? -1 : 1), { spinX: t, spinY: l, pixelX: n, pixelY: s };
+}
+el.getEventType = function() {
+  return Vn.firefox() ? "DOMMouseScroll" : qn("wheel") ? "wheel" : "mousewheel";
+};
+var Un = el;
+/**
+* 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 Xn = function(e, t) {
+  if (e && e.addEventListener) {
+    const l = function(n) {
+      const s = Un(n);
+      t && Reflect.apply(t, this, [n, s]);
+    };
+    e.addEventListener("wheel", l, { passive: !0 });
+  }
+}, Gn = {
+  beforeMount(e, t) {
+    Xn(e, t.value);
+  }
+}, _e = function(e) {
+  var t;
+  return (t = e.target) == null ? void 0 : t.closest("td");
+}, _n = function(e, t, l, n, s) {
+  if (!t && !n && (!s || Array.isArray(s) && !s.length))
+    return e;
+  typeof l == "string" ? l = l === "descending" ? -1 : 1 : l = l && l < 0 ? -1 : 1;
+  const a = n ? null : function(o, r) {
+    return s ? (Array.isArray(s) || (s = [s]), s.map((u) => typeof u == "string" ? wt(o, u) : u(o, r, e))) : (t !== "$key" && St(o) && "$value" in o && (o = o.$value), [St(o) ? wt(o, t) : o]);
+  }, i = function(o, r) {
+    if (n)
+      return n(o.value, r.value);
+    for (let u = 0, d = o.key.length; u < d; u++) {
+      if (o.key[u] < r.key[u])
+        return -1;
+      if (o.key[u] > r.key[u])
+        return 1;
+    }
+    return 0;
+  };
+  return e.map((o, r) => ({
+    value: o,
+    index: r,
+    key: a ? a(o, r) : null
+  })).sort((o, r) => {
+    let u = i(o, r);
+    return u || (u = o.index - r.index), u * +l;
+  }).map((o) => o.value);
+}, tl = function(e, t) {
+  let l = null;
+  return e.columns.forEach((n) => {
+    n.id === t && (l = n);
+  }), l;
+}, Qn = function(e, t) {
+  let l = null;
+  for (let n = 0; n < e.columns.length; n++) {
+    const s = e.columns[n];
+    if (s.columnKey === t) {
+      l = s;
+      break;
+    }
+  }
+  return l || Yl("ElTable", `No column matching with column-key: ${t}`), l;
+}, Mt = function(e, t, l) {
+  const n = (t.className || "").match(new RegExp(`${l}-table_[^\\s]+`, "gm"));
+  return n ? tl(e, n[0]) : null;
+}, _ = (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 s of l)
+      n = n[s];
+    return `${n}`;
+  } else if (typeof t == "function")
+    return t.call(null, e);
+}, Se = function(e, t) {
+  const l = {};
+  return (e || []).forEach((n, s) => {
+    l[_(n, t)] = { row: n, index: s };
+  }), l;
+};
+function Jn(e, t) {
+  const l = {};
+  let n;
+  for (n in e)
+    l[n] = e[n];
+  for (n in t)
+    if (ke(t, n)) {
+      const s = t[n];
+      typeof s < "u" && (l[n] = s);
+    }
+  return l;
+}
+function pt(e) {
+  return e === "" || e !== void 0 && (e = Number.parseInt(e, 10), Number.isNaN(e) && (e = "")), e;
+}
+function ll(e) {
+  return e === "" || e !== void 0 && (e = pt(e), Number.isNaN(e) && (e = 80)), e;
+}
+function Zn(e) {
+  return typeof e == "number" ? e : typeof e == "string" ? /^\d+(?:px)?$/.test(e) ? Number.parseInt(e, 10) : e : null;
+}
+function eo(...e) {
+  return e.length === 0 ? (t) => t : e.length === 1 ? e[0] : e.reduce((t, l) => (...n) => t(l(...n)));
+}
+function He(e, t, l) {
+  let n = !1;
+  const s = e.indexOf(t), a = s !== -1, i = (o) => {
+    o === "add" ? e.push(t) : e.splice(s, 1), n = !0, Ul(t.children) && t.children.forEach((r) => {
+      He(e, r, l ?? !a);
+    });
+  };
+  return ql(l) ? l && !a ? i("add") : !l && a && i("remove") : i(a ? "remove" : "add"), n;
+}
+function to(e, t, l = "children", n = "hasChildren") {
+  const s = (i) => !(Array.isArray(i) && i.length);
+  function a(i, o, r) {
+    t(i, o, r), o.forEach((u) => {
+      if (u[n]) {
+        t(u, null, r + 1);
+        return;
+      }
+      const d = u[l];
+      s(d) || a(u, d, r + 1);
+    });
+  }
+  e.forEach((i) => {
+    if (i[n]) {
+      t(i, null, 0);
+      return;
+    }
+    const o = i[l];
+    s(o) || a(i, o, 0);
+  });
+}
+let ie = null;
+function lo(e, t, l, n) {
+  if ((ie == null ? void 0 : ie.trigger) === l)
+    return;
+  ie == null || ie();
+  const s = n == null ? void 0 : n.refs.tableWrapper, a = s == null ? void 0 : s.dataset.prefix, i = {
+    strategy: "fixed",
+    ...e.popperOptions
+  }, o = fe(Bt, {
+    content: t,
+    virtualTriggering: !0,
+    virtualRef: l,
+    appendTo: s,
+    placement: "top",
+    transition: "none",
+    offset: 0,
+    hideAfter: 0,
+    ...e,
+    popperOptions: i,
+    onHide: () => {
+      ie == null || ie();
+    }
+  });
+  o.appContext = { ...n.appContext, ...n };
+  const r = document.createElement("div");
+  yt(o, r), o.component.exposed.onOpen();
+  const u = s == null ? void 0 : s.querySelector(`.${a}-scrollbar__wrap`);
+  ie = () => {
+    yt(null, r), u == null || u.removeEventListener("scroll", ie), ie = null;
+  }, ie.trigger = l, u == null || u.addEventListener("scroll", ie);
+}
+function nl(e) {
+  return e.children ? Kn(e.children, nl) : [e];
+}
+function Ft(e, t) {
+  return e + t.colSpan;
+}
+const ol = (e, t, l, n) => {
+  let s = 0, a = e;
+  const i = l.states.columns.value;
+  if (n) {
+    const r = nl(n[e]);
+    s = i.slice(0, i.indexOf(r[0])).reduce(Ft, 0), a = s + r.reduce(Ft, 0) - 1;
+  } else
+    s = e;
+  let o;
+  switch (t) {
+    case "left":
+      a < l.states.fixedLeafColumnsLength.value && (o = "left");
+      break;
+    case "right":
+      s >= i.length - l.states.rightFixedLeafColumnsLength.value && (o = "right");
+      break;
+    default:
+      a < l.states.fixedLeafColumnsLength.value ? o = "left" : s >= i.length - l.states.rightFixedLeafColumnsLength.value && (o = "right");
+  }
+  return o ? {
+    direction: o,
+    start: s,
+    after: a
+  } : {};
+}, vt = (e, t, l, n, s, a = 0) => {
+  const i = [], { direction: o, start: r, after: u } = ol(t, l, n, s);
+  if (o) {
+    const d = o === "left";
+    i.push(`${e}-fixed-column--${o}`), d && u + a === n.states.fixedLeafColumnsLength.value - 1 ? i.push("is-last-column") : !d && r - a === n.states.columns.value.length - n.states.rightFixedLeafColumnsLength.value && i.push("is-first-column");
+  }
+  return i;
+};
+function At(e, t) {
+  return e + (t.realWidth === null || Number.isNaN(t.realWidth) ? Number(t.width) : t.realWidth);
+}
+const gt = (e, t, l, n) => {
+  const {
+    direction: s,
+    start: a = 0,
+    after: i = 0
+  } = ol(e, t, l, n);
+  if (!s)
+    return;
+  const o = {}, r = s === "left", u = l.states.columns.value;
+  return r ? o.left = u.slice(0, a).reduce(At, 0) : o.right = u.slice(i + 1).reverse().reduce(At, 0), o;
+}, Me = (e, t) => {
+  e && (Number.isNaN(e[t]) || (e[t] = `${e[t]}px`));
+};
+function no(e) {
+  const t = le(), l = x(!1), n = x([]);
+  return {
+    updateExpandRows: () => {
+      const r = e.data.value || [], u = e.rowKey.value;
+      if (l.value)
+        n.value = r.slice();
+      else if (u) {
+        const d = Se(n.value, u);
+        n.value = r.reduce((f, p) => {
+          const E = _(p, u);
+          return d[E] && f.push(p), f;
+        }, []);
+      } else
+        n.value = [];
+    },
+    toggleRowExpansion: (r, u) => {
+      He(n.value, r, u) && t.emit("expand-change", r, n.value.slice());
+    },
+    setExpandRowKeys: (r) => {
+      t.store.assertRowKey();
+      const u = e.data.value || [], d = e.rowKey.value, f = Se(u, d);
+      n.value = r.reduce((p, E) => {
+        const h = f[E];
+        return h && p.push(h.row), p;
+      }, []);
+    },
+    isRowExpanded: (r) => {
+      const u = e.rowKey.value;
+      return u ? !!Se(n.value, u)[_(r, u)] : n.value.includes(r);
+    },
+    states: {
+      expandRows: n,
+      defaultExpandAll: l
+    }
+  };
+}
+function oo(e) {
+  const t = le(), l = x(null), n = x(null), s = (u) => {
+    t.store.assertRowKey(), l.value = u, i(u);
+  }, a = () => {
+    l.value = null;
+  }, i = (u) => {
+    const { data: d, rowKey: f } = e;
+    let p = null;
+    f.value && (p = (Z(d) || []).find((E) => _(E, f.value) === u)), n.value = p, t.emit("current-change", n.value, null);
+  };
+  return {
+    setCurrentRowKey: s,
+    restoreCurrentRowKey: a,
+    setCurrentRowByKey: i,
+    updateCurrentRow: (u) => {
+      const d = n.value;
+      if (u && u !== d) {
+        n.value = u, t.emit("current-change", n.value, d);
+        return;
+      }
+      !u && d && (n.value = null, t.emit("current-change", null, d));
+    },
+    updateCurrentRowData: () => {
+      const u = e.rowKey.value, d = e.data.value || [], f = n.value;
+      if (!d.includes(f) && f) {
+        if (u) {
+          const p = _(f, u);
+          i(p);
+        } else
+          n.value = null;
+        n.value === null && t.emit("current-change", null, f);
+      } else
+        l.value && (i(l.value), a());
+    },
+    states: {
+      _currentRowKey: l,
+      currentRow: n
+    }
+  };
+}
+function ro(e) {
+  const t = x([]), l = x({}), n = x(16), s = x(!1), a = x({}), i = x("hasChildren"), o = x("children"), r = le(), u = P(() => {
+    if (!e.rowKey.value)
+      return {};
+    const w = e.data.value || [];
+    return f(w);
+  }), d = P(() => {
+    const w = e.rowKey.value, v = Object.keys(a.value), y = {};
+    return v.length && v.forEach((c) => {
+      if (a.value[c].length) {
+        const g = { children: [] };
+        a.value[c].forEach((R) => {
+          const S = _(R, w);
+          g.children.push(S), R[i.value] && !y[S] && (y[S] = { children: [] });
+        }), y[c] = g;
+      }
+    }), y;
+  }), f = (w) => {
+    const v = e.rowKey.value, y = {};
+    return to(w, (c, g, R) => {
+      const S = _(c, v);
+      Array.isArray(g) ? y[S] = {
+        children: g.map((N) => _(N, v)),
+        level: R
+      } : s.value && (y[S] = {
+        children: [],
+        lazy: !0,
+        level: R
+      });
+    }, o.value, i.value), y;
+  }, p = (w = !1, v = ((y) => (y = r.store) == null ? void 0 : y.states.defaultExpandAll.value)()) => {
+    var y;
+    const c = u.value, g = d.value, R = Object.keys(c), S = {};
+    if (R.length) {
+      const N = Z(l), W = [], K = (M, B) => {
+        if (w)
+          return t.value ? v || t.value.includes(B) : !!(v || M != null && M.expanded);
+        {
+          const D = v || t.value && t.value.includes(B);
+          return !!(M != null && M.expanded || D);
+        }
+      };
+      R.forEach((M) => {
+        const B = N[M], D = { ...c[M] };
+        if (D.expanded = K(B, M), D.lazy) {
+          const { loaded: q = !1, loading: U = !1 } = B || {};
+          D.loaded = !!q, D.loading = !!U, W.push(M);
+        }
+        S[M] = D;
+      });
+      const $ = Object.keys(g);
+      s.value && $.length && W.length && $.forEach((M) => {
+        const B = N[M], D = g[M].children;
+        if (W.includes(M)) {
+          if (S[M].children.length !== 0)
+            throw new Error("[ElTable]children must be an empty array.");
+          S[M].children = D;
+        } else {
+          const { loaded: q = !1, loading: U = !1 } = B || {};
+          S[M] = {
+            lazy: !0,
+            loaded: !!q,
+            loading: !!U,
+            expanded: K(B, M),
+            children: D,
+            level: ""
+          };
+        }
+      });
+    }
+    l.value = S, (y = r.store) == null || y.updateTableScrollY();
+  };
+  he(() => t.value, () => {
+    p(!0);
+  }), he(() => u.value, () => {
+    p();
+  }), he(() => d.value, () => {
+    p();
+  });
+  const E = (w) => {
+    t.value = w, p();
+  }, h = (w, v) => {
+    r.store.assertRowKey();
+    const y = e.rowKey.value, c = _(w, y), g = c && l.value[c];
+    if (c && g && "expanded" in g) {
+      const R = g.expanded;
+      v = typeof v > "u" ? !g.expanded : v, l.value[c].expanded = v, R !== v && r.emit("expand-change", w, v), r.store.updateTableScrollY();
+    }
+  }, C = (w) => {
+    r.store.assertRowKey();
+    const v = e.rowKey.value, y = _(w, v), c = l.value[y];
+    s.value && c && "loaded" in c && !c.loaded ? m(w, y, c) : h(w, void 0);
+  }, m = (w, v, y) => {
+    const { load: c } = r.props;
+    c && !l.value[v].loaded && (l.value[v].loading = !0, c(w, y, (g) => {
+      if (!Array.isArray(g))
+        throw new TypeError("[ElTable] data must be an array");
+      l.value[v].loading = !1, l.value[v].loaded = !0, l.value[v].expanded = !0, g.length && (a.value[v] = g), r.emit("expand-change", w, !0);
+    }));
+  };
+  return {
+    loadData: m,
+    loadOrToggle: C,
+    toggleTreeExpansion: h,
+    updateTreeExpandKeys: E,
+    updateTreeData: p,
+    normalize: f,
+    states: {
+      expandRowKeys: t,
+      treeData: l,
+      indent: n,
+      lazy: s,
+      lazyTreeNodeMap: a,
+      lazyColumnIdentifier: i,
+      childrenColumnName: o
+    }
+  };
+}
+const so = (e, t) => {
+  const l = t.sortingColumn;
+  return !l || typeof l.sortable == "string" ? e : _n(e, t.sortProp, t.sortOrder, l.sortMethod, l.sortBy);
+}, Ye = (e) => {
+  const t = [];
+  return e.forEach((l) => {
+    l.children && l.children.length > 0 ? t.push.apply(t, Ye(l.children)) : t.push(l);
+  }), t;
+};
+function ao() {
+  var e;
+  const t = le(), { size: l } = Fl((e = t.proxy) == null ? void 0 : e.$props), n = x(null), s = x([]), a = x([]), i = x(!1), o = x([]), r = x([]), u = x([]), d = x([]), f = x([]), p = x([]), E = x([]), h = x([]), C = [], m = x(0), w = x(0), v = x(0), y = x(!1), c = x([]), g = x(!1), R = x(!1), S = x(null), N = x({}), W = x(null), K = x(null), $ = x(null), M = x(null), B = x(null);
+  he(s, () => t.state && re(!1), {
+    deep: !0
+  });
+  const D = () => {
+    if (!n.value)
+      throw new Error("[ElTable] prop row-key is required");
+  }, q = (O) => {
+    var F;
+    (F = O.children) == null || F.forEach((T) => {
+      T.fixed = O.fixed, q(T);
+    });
+  }, U = () => {
+    o.value.forEach((z) => {
+      q(z);
+    }), d.value = o.value.filter((z) => z.fixed === !0 || z.fixed === "left"), f.value = o.value.filter((z) => z.fixed === "right"), d.value.length > 0 && o.value[0] && o.value[0].type === "selection" && !o.value[0].fixed && (o.value[0].fixed = !0, d.value.unshift(o.value[0]));
+    const O = o.value.filter((z) => !z.fixed);
+    r.value = [].concat(d.value).concat(O).concat(f.value);
+    const F = Ye(O), T = Ye(d.value), A = Ye(f.value);
+    m.value = F.length, w.value = T.length, v.value = A.length, u.value = [].concat(T).concat(F).concat(A), i.value = d.value.length > 0 || f.value.length > 0;
+  }, re = (O, F = !1) => {
+    O && U(), F ? t.state.doLayout() : t.state.debouncedUpdateLayout();
+  }, X = (O) => c.value.includes(O), b = () => {
+    y.value = !1, c.value.length && (c.value = [], t.emit("selection-change", []));
+  }, L = () => {
+    let O;
+    if (n.value) {
+      O = [];
+      const F = Se(c.value, n.value), T = Se(s.value, n.value);
+      for (const A in F)
+        ke(F, A) && !T[A] && O.push(F[A].row);
+    } else
+      O = c.value.filter((F) => !s.value.includes(F));
+    if (O.length) {
+      const F = c.value.filter((T) => !O.includes(T));
+      c.value = F, t.emit("selection-change", F.slice());
+    }
+  }, k = () => (c.value || []).slice(), I = (O, F = void 0, T = !0) => {
+    if (He(c.value, O, F)) {
+      const z = (c.value || []).slice();
+      T && t.emit("select", z, O), t.emit("selection-change", z);
+    }
+  }, j = () => {
+    var O, F;
+    const T = R.value ? !y.value : !(y.value || c.value.length);
+    y.value = T;
+    let A = !1, z = 0;
+    const Q = (F = (O = t == null ? void 0 : t.store) == null ? void 0 : O.states) == null ? void 0 : F.rowKey.value;
+    s.value.forEach((ae, Ee) => {
+      const me = Ee + z;
+      S.value ? S.value.call(null, ae, me) && He(c.value, ae, T) && (A = !0) : He(c.value, ae, T) && (A = !0), z += J(_(ae, Q));
+    }), A && t.emit("selection-change", c.value ? c.value.slice() : []), t.emit("select-all", c.value);
+  }, Y = () => {
+    const O = Se(c.value, n.value);
+    s.value.forEach((F) => {
+      const T = _(F, n.value), A = O[T];
+      A && (c.value[A.index] = F);
+    });
+  }, ne = () => {
+    var O, F, T;
+    if (((O = s.value) == null ? void 0 : O.length) === 0) {
+      y.value = !1;
+      return;
+    }
+    let A;
+    n.value && (A = Se(c.value, n.value));
+    const z = function(me) {
+      return A ? !!A[_(me, n.value)] : c.value.includes(me);
+    };
+    let Q = !0, ae = 0, Ee = 0;
+    for (let me = 0, Ll = (s.value || []).length; me < Ll; me++) {
+      const Ol = (T = (F = t == null ? void 0 : t.store) == null ? void 0 : F.states) == null ? void 0 : T.rowKey.value, Wl = me + Ee, Ge = s.value[me], Ml = S.value && S.value.call(null, Ge, Wl);
+      if (z(Ge))
+        ae++;
+      else if (!S.value || Ml) {
+        Q = !1;
+        break;
+      }
+      Ee += J(_(Ge, Ol));
+    }
+    ae === 0 && (Q = !1), y.value = Q;
+  }, J = (O) => {
+    var F;
+    if (!t || !t.store)
+      return 0;
+    const { treeData: T } = t.store.states;
+    let A = 0;
+    const z = (F = T.value[O]) == null ? void 0 : F.children;
+    return z && (A += z.length, z.forEach((Q) => {
+      A += J(Q);
+    })), A;
+  }, ge = (O, F) => {
+    Array.isArray(O) || (O = [O]);
+    const T = {};
+    return O.forEach((A) => {
+      N.value[A.id] = F, T[A.columnKey || A.id] = F;
+    }), T;
+  }, ee = (O, F, T) => {
+    K.value && K.value !== O && (K.value.order = null), K.value = O, $.value = F, M.value = T;
+  }, se = () => {
+    let O = Z(a);
+    Object.keys(N.value).forEach((F) => {
+      const T = N.value[F];
+      if (!T || T.length === 0)
+        return;
+      const A = tl({
+        columns: u.value
+      }, F);
+      A && A.filterMethod && (O = O.filter((z) => T.some((Q) => A.filterMethod.call(null, Q, z, A))));
+    }), W.value = O;
+  }, ce = () => {
+    s.value = so(W.value, {
+      sortingColumn: K.value,
+      sortProp: $.value,
+      sortOrder: M.value
+    });
+  }, cl = (O = void 0) => {
+    O && O.filter || se(), ce();
+  }, fl = (O) => {
+    const { tableHeaderRef: F } = t.refs;
+    if (!F)
+      return;
+    const T = Object.assign({}, F.filterPanels), A = Object.keys(T);
+    if (A.length)
+      if (typeof O == "string" && (O = [O]), Array.isArray(O)) {
+        const z = O.map((Q) => Qn({
+          columns: u.value
+        }, Q));
+        A.forEach((Q) => {
+          const ae = z.find((Ee) => Ee.id === Q);
+          ae && (ae.filteredValue = []);
+        }), t.store.commit("filterChange", {
+          column: z,
+          values: [],
+          silent: !0,
+          multi: !0
+        });
+      } else
+        A.forEach((z) => {
+          const Q = u.value.find((ae) => ae.id === z);
+          Q && (Q.filteredValue = []);
+        }), N.value = {}, t.store.commit("filterChange", {
+          column: {},
+          values: [],
+          silent: !0
+        });
+  }, hl = () => {
+    K.value && (ee(null, null, null), t.store.commit("changeSortCondition", {
+      silent: !0
+    }));
+  }, {
+    setExpandRowKeys: pl,
+    toggleRowExpansion: mt,
+    updateExpandRows: vl,
+    states: gl,
+    isRowExpanded: ml
+  } = no({
+    data: s,
+    rowKey: n
+  }), {
+    updateTreeExpandKeys: yl,
+    toggleTreeExpansion: bl,
+    updateTreeData: Cl,
+    loadOrToggle: wl,
+    states: Sl
+  } = ro({
+    data: s,
+    rowKey: n
+  }), {
+    updateCurrentRowData: El,
+    updateCurrentRow: xl,
+    setCurrentRowKey: Rl,
+    states: Nl
+  } = oo({
+    data: s,
+    rowKey: n
+  });
+  return {
+    assertRowKey: D,
+    updateColumns: U,
+    scheduleLayout: re,
+    isSelected: X,
+    clearSelection: b,
+    cleanSelection: L,
+    getSelectionRows: k,
+    toggleRowSelection: I,
+    _toggleAllSelection: j,
+    toggleAllSelection: null,
+    updateSelectionByRowKey: Y,
+    updateAllSelected: ne,
+    updateFilters: ge,
+    updateCurrentRow: xl,
+    updateSort: ee,
+    execFilter: se,
+    execSort: ce,
+    execQuery: cl,
+    clearFilter: fl,
+    clearSort: hl,
+    toggleRowExpansion: mt,
+    setExpandRowKeysAdapter: (O) => {
+      pl(O), yl(O);
+    },
+    setCurrentRowKey: Rl,
+    toggleRowExpansionAdapter: (O, F) => {
+      u.value.some(({ type: A }) => A === "expand") ? mt(O, F) : bl(O, F);
+    },
+    isRowExpanded: ml,
+    updateExpandRows: vl,
+    updateCurrentRowData: El,
+    loadOrToggle: wl,
+    updateTreeData: Cl,
+    states: {
+      tableSize: l,
+      rowKey: n,
+      data: s,
+      _data: a,
+      isComplex: i,
+      _columns: o,
+      originColumns: r,
+      columns: u,
+      fixedColumns: d,
+      rightFixedColumns: f,
+      leafColumns: p,
+      fixedLeafColumns: E,
+      rightFixedLeafColumns: h,
+      updateOrderFns: C,
+      leafColumnsLength: m,
+      fixedLeafColumnsLength: w,
+      rightFixedLeafColumnsLength: v,
+      isAllSelected: y,
+      selection: c,
+      reserveSelection: g,
+      selectOnIndeterminate: R,
+      selectable: S,
+      filters: N,
+      filteredData: W,
+      sortingColumn: K,
+      sortProp: $,
+      sortOrder: M,
+      hoverRow: B,
+      ...gl,
+      ...Sl,
+      ...Nl
+    }
+  };
+}
+function ut(e, t) {
+  return e.map((l) => {
+    var n;
+    return l.id === t.id ? t : ((n = l.children) != null && n.length && (l.children = ut(l.children, t)), l);
+  });
+}
+function dt(e) {
+  e.forEach((t) => {
+    var l, n;
+    t.no = (l = t.getColumnIndex) == null ? void 0 : l.call(t), (n = t.children) != null && n.length && dt(t.children);
+  }), e.sort((t, l) => t.no - l.no);
+}
+function io() {
+  const e = le(), t = ao();
+  return {
+    ns: pe("table"),
+    ...t,
+    mutations: {
+      setData(i, o) {
+        const r = Z(i._data) !== o;
+        i.data.value = o, i._data.value = o, e.store.execQuery(), e.store.updateCurrentRowData(), e.store.updateExpandRows(), e.store.updateTreeData(e.store.states.defaultExpandAll.value), Z(i.reserveSelection) ? (e.store.assertRowKey(), e.store.updateSelectionByRowKey()) : r ? e.store.clearSelection() : e.store.cleanSelection(), e.store.updateAllSelected(), e.$ready && e.store.scheduleLayout();
+      },
+      insertColumn(i, o, r, u) {
+        const d = Z(i._columns);
+        let f = [];
+        r ? (r && !r.children && (r.children = []), r.children.push(o), f = ut(d, r)) : (d.push(o), f = d), dt(f), i._columns.value = f, i.updateOrderFns.push(u), o.type === "selection" && (i.selectable.value = o.selectable, i.reserveSelection.value = o.reserveSelection), e.$ready && (e.store.updateColumns(), e.store.scheduleLayout());
+      },
+      updateColumnOrder(i, o) {
+        var r;
+        ((r = o.getColumnIndex) == null ? void 0 : r.call(o)) !== o.no && (dt(i._columns.value), e.$ready && e.store.updateColumns());
+      },
+      removeColumn(i, o, r, u) {
+        const d = Z(i._columns) || [];
+        if (r)
+          r.children.splice(r.children.findIndex((p) => p.id === o.id), 1), Le(() => {
+            var p;
+            ((p = r.children) == null ? void 0 : p.length) === 0 && delete r.children;
+          }), i._columns.value = ut(d, r);
+        else {
+          const p = d.indexOf(o);
+          p > -1 && (d.splice(p, 1), i._columns.value = d);
+        }
+        const f = i.updateOrderFns.indexOf(u);
+        f > -1 && i.updateOrderFns.splice(f, 1), e.$ready && (e.store.updateColumns(), e.store.scheduleLayout());
+      },
+      sort(i, o) {
+        const { prop: r, order: u, init: d } = o;
+        if (r) {
+          const f = Z(i.columns).find((p) => p.property === r);
+          f && (f.order = u, e.store.updateSort(f, r, u), e.store.commit("changeSortCondition", { init: d }));
+        }
+      },
+      changeSortCondition(i, o) {
+        const { sortingColumn: r, sortProp: u, sortOrder: d } = i, f = Z(r), p = Z(u), E = Z(d);
+        E === null && (i.sortingColumn.value = null, i.sortProp.value = null);
+        const h = { filter: !0 };
+        e.store.execQuery(h), (!o || !(o.silent || o.init)) && e.emit("sort-change", {
+          column: f,
+          prop: p,
+          order: E
+        }), e.store.updateTableScrollY();
+      },
+      filterChange(i, o) {
+        const { column: r, values: u, silent: d } = o, f = e.store.updateFilters(r, u);
+        e.store.execQuery(), d || e.emit("filter-change", f), e.store.updateTableScrollY();
+      },
+      toggleAllSelection() {
+        e.store.toggleAllSelection();
+      },
+      rowSelectedChanged(i, o) {
+        e.store.toggleRowSelection(o), e.store.updateAllSelected();
+      },
+      setHoverRow(i, o) {
+        i.hoverRow.value = o;
+      },
+      setCurrentRow(i, o) {
+        e.store.updateCurrentRow(o);
+      }
+    },
+    commit: function(i, ...o) {
+      const r = e.store.mutations;
+      if (r[i])
+        r[i].apply(e, [e.store.states].concat(o));
+      else
+        throw new Error(`Action not found: ${i}`);
+    },
+    updateTableScrollY: function() {
+      Le(() => e.layout.updateScrollY.apply(e.layout));
+    }
+  };
+}
+const Te = {
+  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 uo(e, t) {
+  if (!e)
+    throw new Error("Table is required.");
+  const l = io();
+  return l.toggleAllSelection = Ue(l._toggleAllSelection, 10), Object.keys(Te).forEach((n) => {
+    rl(sl(t, n), n, l);
+  }), co(l, t), l;
+}
+function co(e, t) {
+  Object.keys(Te).forEach((l) => {
+    he(() => sl(t, l), (n) => {
+      rl(n, l, e);
+    });
+  });
+}
+function rl(e, t, l) {
+  let n = e, s = Te[t];
+  typeof Te[t] == "object" && (s = s.key, n = n || Te[t].default), l.states[s].value = n;
+}
+function sl(e, t) {
+  if (t.includes(".")) {
+    const l = t.split(".");
+    let n = e;
+    return l.forEach((s) => {
+      n = n[s];
+    }), n;
+  } else
+    return e[t];
+}
+class fo {
+  constructor(t) {
+    this.observers = [], this.table = null, this.store = null, this.columns = [], this.fit = !0, this.showHeader = !0, this.height = x(null), this.scrollX = x(!1), this.scrollY = x(!1), this.bodyWidth = x(null), this.fixedWidth = x(null), this.rightFixedWidth = x(null), this.gutterWidth = 0;
+    for (const l in t)
+      ke(t, l) && (Al(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 s = this.scrollY.value;
+      return n = l.wrapRef.scrollHeight > l.wrapRef.clientHeight, this.scrollY.value = n, s !== n;
+    }
+    return !1;
+  }
+  setHeight(t, l = "height") {
+    if (!Oe)
+      return;
+    const n = this.table.vnode.el;
+    if (t = Zn(t), this.height.value = Number(t), !n && (t || t === 0))
+      return Le(() => 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 (!Oe)
+      return;
+    const t = this.fit, l = this.table.vnode.el.clientWidth;
+    let n = 0;
+    const s = this.getFlattenColumns(), a = s.filter((r) => typeof r.width != "number");
+    if (s.forEach((r) => {
+      typeof r.width == "number" && r.realWidth && (r.realWidth = null);
+    }), a.length > 0 && t) {
+      if (s.forEach((r) => {
+        n += Number(r.width || r.minWidth || 80);
+      }), n <= l) {
+        this.scrollX.value = !1;
+        const r = l - n;
+        if (a.length === 1)
+          a[0].realWidth = Number(a[0].minWidth || 80) + r;
+        else {
+          const u = a.reduce((p, E) => p + Number(E.minWidth || 80), 0), d = r / u;
+          let f = 0;
+          a.forEach((p, E) => {
+            if (E === 0)
+              return;
+            const h = Math.floor(Number(p.minWidth || 80) * d);
+            f += h, p.realWidth = Number(p.minWidth || 80) + h;
+          }), a[0].realWidth = Number(a[0].minWidth || 80) + r - f;
+        }
+      } else
+        this.scrollX.value = !0, a.forEach((r) => {
+          r.realWidth = Number(r.minWidth);
+        });
+      this.bodyWidth.value = Math.max(n, l), this.table.state.resizeState.value.width = this.bodyWidth.value;
+    } else
+      s.forEach((r) => {
+        !r.width && !r.minWidth ? r.realWidth = 80 : r.realWidth = Number(r.width || r.minWidth), n += r.realWidth;
+      }), this.scrollX.value = n > l, this.bodyWidth.value = n;
+    const i = this.store.states.fixedColumns.value;
+    if (i.length > 0) {
+      let r = 0;
+      i.forEach((u) => {
+        r += Number(u.realWidth || u.width);
+      }), this.fixedWidth.value = r;
+    }
+    const o = this.store.states.rightFixedColumns.value;
+    if (o.length > 0) {
+      let r = 0;
+      o.forEach((u) => {
+        r += Number(u.realWidth || u.width);
+      }), this.rightFixedWidth.value = r;
+    }
+    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 s, a;
+      switch (t) {
+        case "columns":
+          (s = n.state) == null || s.onColumnsChange(this);
+          break;
+        case "scrollable":
+          (a = n.state) == null || a.onScrollableChange(this);
+          break;
+        default:
+          throw new Error(`Table Layout don't have event ${t}.`);
+      }
+    });
+  }
+}
+const { CheckboxGroup: ho } = We, po = Fe({
+  name: "ElTableFilterPanel",
+  components: {
+    ElCheckbox: We,
+    ElCheckboxGroup: ho,
+    ElScrollbar: Pt,
+    ElTooltip: Bt,
+    ElIcon: ht,
+    ArrowDown: Xl,
+    ArrowUp: Gl
+  },
+  directives: { ClickOutside: Kl },
+  props: {
+    placement: {
+      type: String,
+      default: "bottom-start"
+    },
+    store: {
+      type: Object
+    },
+    column: {
+      type: Object
+    },
+    upDataColumn: {
+      type: Function
+    }
+  },
+  setup(e) {
+    const t = le(), { t: l } = Dt(), n = pe("table-filter"), s = t == null ? void 0 : t.parent;
+    s.filterPanels.value[e.column.id] || (s.filterPanels.value[e.column.id] = t);
+    const a = x(!1), i = x(null), o = P(() => e.column && e.column.filters), r = P(() => e.column.filterClassName ? `${n.b()} ${e.column.filterClassName}` : n.b()), u = P({
+      get: () => {
+        var g;
+        return (((g = e.column) == null ? void 0 : g.filteredValue) || [])[0];
+      },
+      set: (g) => {
+        d.value && (typeof g < "u" && g !== null ? d.value.splice(0, 1, g) : d.value.splice(0, 1));
+      }
+    }), d = P({
+      get() {
+        return e.column ? e.column.filteredValue || [] : [];
+      },
+      set(g) {
+        e.column && e.upDataColumn("filteredValue", g);
+      }
+    }), f = P(() => e.column ? e.column.filterMultiple : !0), p = (g) => g.value === u.value, E = () => {
+      a.value = !1;
+    }, h = (g) => {
+      g.stopPropagation(), a.value = !a.value;
+    }, C = () => {
+      a.value = !1;
+    }, m = () => {
+      y(d.value), E();
+    }, w = () => {
+      d.value = [], y(d.value), E();
+    }, v = (g) => {
+      u.value = g, y(typeof g < "u" && g !== null ? d.value : []), E();
+    }, y = (g) => {
+      e.store.commit("filterChange", {
+        column: e.column,
+        values: g
+      }), e.store.updateAllSelected();
+    };
+    he(a, (g) => {
+      e.column && e.upDataColumn("filterOpened", g);
+    }, {
+      immediate: !0
+    });
+    const c = P(() => {
+      var g, R;
+      return (R = (g = i.value) == null ? void 0 : g.popperRef) == null ? void 0 : R.contentRef;
+    });
+    return {
+      tooltipVisible: a,
+      multiple: f,
+      filterClassName: r,
+      filteredValue: d,
+      filterValue: u,
+      filters: o,
+      handleConfirm: m,
+      handleReset: w,
+      handleSelect: v,
+      isActive: p,
+      t: l,
+      ns: n,
+      showFilterPanel: h,
+      hideFilterPanel: C,
+      popperPaneRef: c,
+      tooltip: i
+    };
+  }
+}), vo = { key: 0 }, go = ["disabled"], mo = ["label", "onClick"];
+function yo(e, t, l, n, s, a) {
+  const i = ue("el-checkbox"), o = ue("el-checkbox-group"), r = ue("el-scrollbar"), u = ue("arrow-up"), d = ue("arrow-down"), f = ue("el-icon"), p = ue("el-tooltip"), E = Tt("click-outside");
+  return G(), Ne(p, {
+    ref: "tooltip",
+    visible: e.tooltipVisible,
+    offset: 0,
+    placement: e.placement,
+    "show-arrow": !1,
+    "stop-popper-mouse-event": !1,
+    teleported: "",
+    effect: "light",
+    pure: "",
+    "popper-class": e.filterClassName,
+    persistent: ""
+  }, {
+    content: Ce(() => [
+      e.multiple ? (G(), de("div", vo, [
+        oe("div", {
+          class: V(e.ns.e("content"))
+        }, [
+          fe(r, {
+            "wrap-class": e.ns.e("wrap")
+          }, {
+            default: Ce(() => [
+              fe(o, {
+                modelValue: e.filteredValue,
+                "onUpdate:modelValue": t[0] || (t[0] = (h) => e.filteredValue = h),
+                class: V(e.ns.e("checkbox-group"))
+              }, {
+                default: Ce(() => [
+                  (G(!0), de(Qe, null, bt(e.filters, (h) => (G(), Ne(i, {
+                    key: h.value,
+                    label: h.value
+                  }, {
+                    default: Ce(() => [
+                      kt(Re(h.text), 1)
+                    ]),
+                    _: 2
+                  }, 1032, ["label"]))), 128))
+                ]),
+                _: 1
+              }, 8, ["modelValue", "class"])
+            ]),
+            _: 1
+          }, 8, ["wrap-class"])
+        ], 2),
+        oe("div", {
+          class: V(e.ns.e("bottom"))
+        }, [
+          oe("button", {
+            class: V({ [e.ns.is("disabled")]: e.filteredValue.length === 0 }),
+            disabled: e.filteredValue.length === 0,
+            type: "button",
+            onClick: t[1] || (t[1] = (...h) => e.handleConfirm && e.handleConfirm(...h))
+          }, Re(e.t("el.table.confirmFilter")), 11, go),
+          oe("button", {
+            type: "button",
+            onClick: t[2] || (t[2] = (...h) => e.handleReset && e.handleReset(...h))
+          }, Re(e.t("el.table.resetFilter")), 1)
+        ], 2)
+      ])) : (G(), de("ul", {
+        key: 1,
+        class: V(e.ns.e("list"))
+      }, [
+        oe("li", {
+          class: V([
+            e.ns.e("list-item"),
+            {
+              [e.ns.is("active")]: e.filterValue === void 0 || e.filterValue === null
+            }
+          ]),
+          onClick: t[3] || (t[3] = (h) => e.handleSelect(null))
+        }, Re(e.t("el.table.clearFilter")), 3),
+        (G(!0), de(Qe, null, bt(e.filters, (h) => (G(), de("li", {
+          key: h.value,
+          class: V([e.ns.e("list-item"), e.ns.is("active", e.isActive(h))]),
+          label: h.value,
+          onClick: (C) => e.handleSelect(h.value)
+        }, Re(h.text), 11, mo))), 128))
+      ], 2))
+    ]),
+    default: Ce(() => [
+      Ke((G(), de("span", {
+        class: V([
+          `${e.ns.namespace.value}-table__column-filter-trigger`,
+          `${e.ns.namespace.value}-none-outline`
+        ]),
+        onClick: t[4] || (t[4] = (...h) => e.showFilterPanel && e.showFilterPanel(...h))
+      }, [
+        fe(f, null, {
+          default: Ce(() => [
+            e.column.filterOpened ? (G(), Ne(u, { key: 0 })) : (G(), Ne(d, { key: 1 }))
+          ]),
+          _: 1
+        })
+      ], 2)), [
+        [E, e.hideFilterPanel, e.popperPaneRef]
+      ])
+    ]),
+    _: 1
+  }, 8, ["visible", "placement", "popper-class"]);
+}
+var bo = /* @__PURE__ */ It(po, [["render", yo], ["__file", "filter-panel.vue"]]);
+function al(e) {
+  const t = le();
+  $t(() => {
+    l.value.addObserver(t);
+  }), Pe(() => {
+    n(l.value), s(l.value);
+  }), Hl(() => {
+    n(l.value), s(l.value);
+  }), ct(() => {
+    l.value.removeObserver(t);
+  });
+  const l = P(() => {
+    const a = e.layout;
+    if (!a)
+      throw new Error("Can not find table layout.");
+    return a;
+  }), n = (a) => {
+    var i;
+    const o = ((i = e.vnode.el) == null ? void 0 : i.querySelectorAll("colgroup > col")) || [];
+    if (!o.length)
+      return;
+    const r = a.getFlattenColumns(), u = {};
+    r.forEach((d) => {
+      u[d.id] = d;
+    });
+    for (let d = 0, f = o.length; d < f; d++) {
+      const p = o[d], E = p.getAttribute("name"), h = u[E];
+      h && p.setAttribute("width", h.realWidth || h.width);
+    }
+  }, s = (a) => {
+    var i, o;
+    const r = ((i = e.vnode.el) == null ? void 0 : i.querySelectorAll("colgroup > col[name=gutter]")) || [];
+    for (let d = 0, f = r.length; d < f; d++)
+      r[d].setAttribute("width", a.scrollY.value ? a.gutterWidth : "0");
+    const u = ((o = e.vnode.el) == null ? void 0 : o.querySelectorAll("th.gutter")) || [];
+    for (let d = 0, f = u.length; d < f; d++) {
+      const p = u[d];
+      p.style.width = a.scrollY.value ? `${a.gutterWidth}px` : "0", p.style.display = a.scrollY.value ? "" : "none";
+    }
+  };
+  return {
+    tableLayout: l.value,
+    onColumnsChange: n,
+    onScrollableChange: s
+  };
+}
+const ve = Symbol("ElTable");
+function Co(e, t) {
+  const l = le(), n = ye(ve), s = (C) => {
+    C.stopPropagation();
+  }, a = (C, m) => {
+    !m.filters && m.sortable ? h(C, m, !1) : m.filterable && !m.sortable && s(C), n == null || n.emit("header-click", m, C);
+  }, i = (C, m) => {
+    n == null || n.emit("header-contextmenu", m, C);
+  }, o = x(null), r = x(!1), u = x({}), d = (C, m) => {
+    if (Oe && !(m.children && m.children.length > 0) && o.value && e.border) {
+      r.value = !0;
+      const w = n;
+      t("set-drag-visible", !0);
+      const y = (w == null ? void 0 : w.vnode.el).getBoundingClientRect().left, c = l.vnode.el.querySelector(`th.${m.id}`), g = c.getBoundingClientRect(), R = g.left - y + 30;
+      qe(c, "noclick"), u.value = {
+        startMouseLeft: C.clientX,
+        startLeft: g.right - y,
+        startColumnLeft: g.left - y,
+        tableLeft: y
+      };
+      const S = w == null ? void 0 : w.refs.resizeProxy;
+      S.style.left = `${u.value.startLeft}px`, document.onselectstart = function() {
+        return !1;
+      }, document.ondragstart = function() {
+        return !1;
+      };
+      const N = (K) => {
+        const $ = K.clientX - u.value.startMouseLeft, M = u.value.startLeft + $;
+        S.style.left = `${Math.max(R, M)}px`;
+      }, W = () => {
+        if (r.value) {
+          const { startColumnLeft: K, startLeft: $ } = u.value, B = Number.parseInt(S.style.left, 10) - K;
+          m.width = m.realWidth = B, w == null || w.emit("header-dragend", m.width, $ - K, m, C), requestAnimationFrame(() => {
+            e.store.scheduleLayout(!1, !0);
+          }), document.body.style.cursor = "", r.value = !1, o.value = null, u.value = {}, t("set-drag-visible", !1);
+        }
+        document.removeEventListener("mousemove", N), document.removeEventListener("mouseup", W), document.onselectstart = null, document.ondragstart = null, setTimeout(() => {
+          $e(c, "noclick");
+        }, 0);
+      };
+      document.addEventListener("mousemove", N), document.addEventListener("mouseup", W);
+    }
+  }, f = (C, m) => {
+    if (m.children && m.children.length > 0)
+      return;
+    const w = C.target;
+    if (!_l(w))
+      return;
+    const v = w == null ? void 0 : w.closest("th");
+    if (!(!m || !m.resizable) && !r.value && e.border) {
+      const y = v.getBoundingClientRect(), c = document.body.style;
+      y.width > 12 && y.right - C.pageX < 8 ? (c.cursor = "col-resize", De(v, "is-sortable") && (v.style.cursor = "col-resize"), o.value = m) : r.value || (c.cursor = "", De(v, "is-sortable") && (v.style.cursor = "pointer"), o.value = null);
+    }
+  }, p = () => {
+    Oe && (document.body.style.cursor = "");
+  }, E = ({ order: C, sortOrders: m }) => {
+    if (C === "")
+      return m[0];
+    const w = m.indexOf(C || null);
+    return m[w > m.length - 2 ? 0 : w + 1];
+  }, h = (C, m, w) => {
+    var v;
+    C.stopPropagation();
+    const y = m.order === w ? null : w || E(m), c = (v = C.target) == null ? void 0 : v.closest("th");
+    if (c && De(c, "noclick")) {
+      $e(c, "noclick");
+      return;
+    }
+    if (!m.sortable)
+      return;
+    const g = e.store.states;
+    let R = g.sortProp.value, S;
+    const N = g.sortingColumn.value;
+    (N !== m || N === m && N.order === null) && (N && (N.order = null), g.sortingColumn.value = m, R = m.property), y ? S = m.order = y : S = m.order = null, g.sortProp.value = R, g.sortOrder.value = S, n == null || n.store.commit("changeSortCondition");
+  };
+  return {
+    handleHeaderClick: a,
+    handleHeaderContextMenu: i,
+    handleMouseDown: d,
+    handleMouseMove: f,
+    handleMouseOut: p,
+    handleSortClick: h,
+    handleFilterClick: s
+  };
+}
+function wo(e) {
+  const t = ye(ve), l = pe("table");
+  return {
+    getHeaderRowStyle: (o) => {
+      const r = t == null ? void 0 : t.props.headerRowStyle;
+      return typeof r == "function" ? r.call(null, { rowIndex: o }) : r;
+    },
+    getHeaderRowClass: (o) => {
+      const r = [], u = t == null ? void 0 : t.props.headerRowClassName;
+      return typeof u == "string" ? r.push(u) : typeof u == "function" && r.push(u.call(null, { rowIndex: o })), r.join(" ");
+    },
+    getHeaderCellStyle: (o, r, u, d) => {
+      var f;
+      let p = (f = t == null ? void 0 : t.props.headerCellStyle) != null ? f : {};
+      typeof p == "function" && (p = p.call(null, {
+        rowIndex: o,
+        columnIndex: r,
+        row: u,
+        column: d
+      }));
+      const E = gt(r, d.fixed, e.store, u);
+      return Me(E, "left"), Me(E, "right"), Object.assign({}, p, E);
+    },
+    getHeaderCellClass: (o, r, u, d) => {
+      const f = vt(l.b(), r, d.fixed, e.store, u), p = [
+        d.id,
+        d.order,
+        d.headerAlign,
+        d.className,
+        d.labelClassName,
+        ...f
+      ];
+      d.children || p.push("is-leaf"), d.sortable && p.push("is-sortable");
+      const E = t == null ? void 0 : t.props.headerCellClassName;
+      return typeof E == "string" ? p.push(E) : typeof E == "function" && p.push(E.call(null, {
+        rowIndex: o,
+        columnIndex: r,
+        row: u,
+        column: d
+      })), p.push(l.e("cell")), p.filter((h) => !!h).join(" ");
+    }
+  };
+}
+const il = (e) => {
+  const t = [];
+  return e.forEach((l) => {
+    l.children ? (t.push(l), t.push.apply(t, il(l.children))) : t.push(l);
+  }), t;
+}, So = (e) => {
+  let t = 1;
+  const l = (a, i) => {
+    if (i && (a.level = i.level + 1, t < a.level && (t = a.level)), a.children) {
+      let o = 0;
+      a.children.forEach((r) => {
+        l(r, a), o += r.colSpan;
+      }), a.colSpan = o;
+    } else
+      a.colSpan = 1;
+  };
+  e.forEach((a) => {
+    a.level = 1, l(a, void 0);
+  });
+  const n = [];
+  for (let a = 0; a < t; a++)
+    n.push([]);
+  return il(e).forEach((a) => {
+    a.children ? (a.rowSpan = 1, a.children.forEach((i) => i.isSubColumn = !0)) : a.rowSpan = t - a.level + 1, n[a.level - 1].push(a);
+  }), n;
+};
+function Eo(e) {
+  const t = ye(ve), l = P(() => So(e.store.states.originColumns.value));
+  return {
+    isGroup: P(() => {
+      const a = l.value.length > 1;
+      return a && t && (t.state.isGroup.value = !0), a;
+    }),
+    toggleAllSelection: (a) => {
+      a.stopPropagation(), t == null || t.store.commit("toggleAllSelection");
+    },
+    columnRows: l
+  };
+}
+var xo = Fe({
+  name: "ElTableHeader",
+  components: {
+    ElCheckbox: We
+  },
+  props: {
+    fixed: {
+      type: String,
+      default: ""
+    },
+    store: {
+      required: !0,
+      type: Object
+    },
+    border: Boolean,
+    defaultSort: {
+      type: Object,
+      default: () => ({
+        prop: "",
+        order: ""
+      })
+    }
+  },
+  setup(e, { emit: t }) {
+    const l = le(), n = ye(ve), s = pe("table"), a = x({}), { onColumnsChange: i, onScrollableChange: o } = al(n);
+    Pe(async () => {
+      await Le(), await Le();
+      const { prop: R, order: S } = e.defaultSort;
+      n == null || n.store.commit("sort", { prop: R, order: S, init: !0 });
+    });
+    const {
+      handleHeaderClick: r,
+      handleHeaderContextMenu: u,
+      handleMouseDown: d,
+      handleMouseMove: f,
+      handleMouseOut: p,
+      handleSortClick: E,
+      handleFilterClick: h
+    } = Co(e, t), {
+      getHeaderRowStyle: C,
+      getHeaderRowClass: m,
+      getHeaderCellStyle: w,
+      getHeaderCellClass: v
+    } = wo(e), { isGroup: y, toggleAllSelection: c, columnRows: g } = Eo(e);
+    return l.state = {
+      onColumnsChange: i,
+      onScrollableChange: o
+    }, l.filterPanels = a, {
+      ns: s,
+      filterPanels: a,
+      onColumnsChange: i,
+      onScrollableChange: o,
+      columnRows: g,
+      getHeaderRowClass: m,
+      getHeaderRowStyle: C,
+      getHeaderCellClass: v,
+      getHeaderCellStyle: w,
+      handleHeaderClick: r,
+      handleHeaderContextMenu: u,
+      handleMouseDown: d,
+      handleMouseMove: f,
+      handleMouseOut: p,
+      handleSortClick: E,
+      handleFilterClick: h,
+      isGroup: y,
+      toggleAllSelection: c
+    };
+  },
+  render() {
+    const {
+      ns: e,
+      isGroup: t,
+      columnRows: l,
+      getHeaderCellStyle: n,
+      getHeaderCellClass: s,
+      getHeaderRowClass: a,
+      getHeaderRowStyle: i,
+      handleHeaderClick: o,
+      handleHeaderContextMenu: r,
+      handleMouseDown: u,
+      handleMouseMove: d,
+      handleSortClick: f,
+      handleMouseOut: p,
+      store: E,
+      $parent: h
+    } = this;
+    let C = 1;
+    return H("thead", {
+      class: { [e.is("group")]: t }
+    }, l.map((m, w) => H("tr", {
+      class: a(w),
+      key: w,
+      style: i(w)
+    }, m.map((v, y) => (v.rowSpan > C && (C = v.rowSpan), H("th", {
+      class: s(w, y, m, v),
+      colspan: v.colSpan,
+      key: `${v.id}-thead`,
+      rowspan: v.rowSpan,
+      style: n(w, y, m, v),
+      onClick: (c) => o(c, v),
+      onContextmenu: (c) => r(c, v),
+      onMousedown: (c) => u(c, v),
+      onMousemove: (c) => d(c, v),
+      onMouseout: p
+    }, [
+      H("div", {
+        class: [
+          "cell",
+          v.filteredValue && v.filteredValue.length > 0 ? "highlight" : ""
+        ]
+      }, [
+        v.renderHeader ? v.renderHeader({
+          column: v,
+          $index: y,
+          store: E,
+          _self: h
+        }) : v.label,
+        v.sortable && H("span", {
+          onClick: (c) => f(c, v),
+          class: "caret-wrapper"
+        }, [
+          H("i", {
+            onClick: (c) => f(c, v, "ascending"),
+            class: "sort-caret ascending"
+          }),
+          H("i", {
+            onClick: (c) => f(c, v, "descending"),
+            class: "sort-caret descending"
+          })
+        ]),
+        v.filterable && H(bo, {
+          store: E,
+          placement: v.filterPlacement || "bottom-start",
+          column: v,
+          upDataColumn: (c, g) => {
+            v[c] = g;
+          }
+        })
+      ])
+    ]))))));
+  }
+});
+function Ro(e) {
+  const t = ye(ve), l = x(""), n = x(H("div")), s = (h, C, m) => {
+    var w;
+    const v = t, y = _e(h);
+    let c;
+    const g = (w = v == null ? void 0 : v.vnode.el) == null ? void 0 : w.dataset.prefix;
+    y && (c = Mt({
+      columns: e.store.states.columns.value
+    }, y, g), c && (v == null || v.emit(`cell-${m}`, C, c, y, h))), v == null || v.emit(`row-${m}`, C, c, h);
+  }, a = (h, C) => {
+    s(h, C, "dblclick");
+  }, i = (h, C) => {
+    e.store.commit("setCurrentRow", C), s(h, C, "click");
+  }, o = (h, C) => {
+    s(h, C, "contextmenu");
+  }, r = Ue((h) => {
+    e.store.commit("setHoverRow", h);
+  }, 30), u = Ue(() => {
+    e.store.commit("setHoverRow", null);
+  }, 30), d = (h) => {
+    const C = window.getComputedStyle(h, null), m = Number.parseInt(C.paddingLeft, 10) || 0, w = Number.parseInt(C.paddingRight, 10) || 0, v = Number.parseInt(C.paddingTop, 10) || 0, y = Number.parseInt(C.paddingBottom, 10) || 0;
+    return {
+      left: m,
+      right: w,
+      top: v,
+      bottom: y
+    };
+  }, f = (h, C, m) => {
+    let w = C.target.parentNode;
+    for (; h > 1 && (w = w == null ? void 0 : w.nextSibling, !(!w || w.nodeName !== "TR")); )
+      m(w, "hover-row hover-fixed-row"), h--;
+  };
+  return {
+    handleDoubleClick: a,
+    handleClick: i,
+    handleContextMenu: o,
+    handleMouseEnter: r,
+    handleMouseLeave: u,
+    handleCellMouseEnter: (h, C, m) => {
+      var w;
+      const v = t, y = _e(h), c = (w = v == null ? void 0 : v.vnode.el) == null ? void 0 : w.dataset.prefix;
+      if (y) {
+        const re = Mt({
+          columns: e.store.states.columns.value
+        }, y, c);
+        y.rowSpan > 1 && f(y.rowSpan, h, qe);
+        const X = v.hoverState = { cell: y, column: re, row: C };
+        v == null || v.emit("cell-mouse-enter", X.row, X.column, X.cell, h);
+      }
+      if (!m)
+        return;
+      const g = h.target.querySelector(".cell");
+      if (!(De(g, `${c}-tooltip`) && g.childNodes.length))
+        return;
+      const R = document.createRange();
+      R.setStart(g, 0), R.setEnd(g, g.childNodes.length);
+      let S = R.getBoundingClientRect().width, N = R.getBoundingClientRect().height;
+      S - Math.floor(S) < 1e-3 && (S = Math.floor(S)), N - Math.floor(N) < 1e-3 && (N = Math.floor(N));
+      const { top: $, left: M, right: B, bottom: D } = d(g), q = M + B, U = $ + D;
+      (S + q > g.offsetWidth || N + U > g.offsetHeight || g.scrollWidth > g.offsetWidth) && lo(m, y.innerText || y.textContent, y, v);
+    },
+    handleCellMouseLeave: (h) => {
+      const C = _e(h);
+      if (!C)
+        return;
+      C.rowSpan > 1 && f(C.rowSpan, h, $e);
+      const m = t == null ? void 0 : t.hoverState;
+      t == null || t.emit("cell-mouse-leave", m == null ? void 0 : m.row, m == null ? void 0 : m.column, m == null ? void 0 : m.cell, h);
+    },
+    tooltipContent: l,
+    tooltipTrigger: n
+  };
+}
+function No(e) {
+  const t = ye(ve), l = pe("table");
+  return {
+    getRowStyle: (u, d) => {
+      const f = t == null ? void 0 : t.props.rowStyle;
+      return typeof f == "function" ? f.call(null, {
+        row: u,
+        rowIndex: d
+      }) : f || null;
+    },
+    getRowClass: (u, d) => {
+      const f = [l.e("row")];
+      t != null && t.props.highlightCurrentRow && u === e.store.states.currentRow.value && f.push("current-row"), e.stripe && d % 2 === 1 && f.push(l.em("row", "striped"));
+      const p = t == null ? void 0 : t.props.rowClassName;
+      return typeof p == "string" ? f.push(p) : typeof p == "function" && f.push(p.call(null, {
+        row: u,
+        rowIndex: d
+      })), f;
+    },
+    getCellStyle: (u, d, f, p) => {
+      const E = t == null ? void 0 : t.props.cellStyle;
+      let h = E ?? {};
+      typeof E == "function" && (h = E.call(null, {
+        rowIndex: u,
+        columnIndex: d,
+        row: f,
+        column: p
+      }));
+      const C = gt(d, e == null ? void 0 : e.fixed, e.store);
+      return Me(C, "left"), Me(C, "right"), Object.assign({}, h, C);
+    },
+    getCellClass: (u, d, f, p, E) => {
+      const h = vt(l.b(), d, e == null ? void 0 : e.fixed, e.store, void 0, E), C = [p.id, p.align, p.className, ...h], m = t == null ? void 0 : t.props.cellClassName;
+      return typeof m == "string" ? C.push(m) : typeof m == "function" && C.push(m.call(null, {
+        rowIndex: u,
+        columnIndex: d,
+        row: f,
+        column: p
+      })), C.push(l.e("cell")), C.filter((w) => !!w).join(" ");
+    },
+    getSpan: (u, d, f, p) => {
+      let E = 1, h = 1;
+      const C = t == null ? void 0 : t.props.spanMethod;
+      if (typeof C == "function") {
+        const m = C({
+          row: u,
+          column: d,
+          rowIndex: f,
+          columnIndex: p
+        });
+        Array.isArray(m) ? (E = m[0], h = m[1]) : typeof m == "object" && (E = m.rowspan, h = m.colspan);
+      }
+      return { rowspan: E, colspan: h };
+    },
+    getColspanRealWidth: (u, d, f) => {
+      if (d < 1)
+        return u[f].realWidth;
+      const p = u.map(({ realWidth: E, width: h }) => E || h).slice(f, f + d);
+      return Number(p.reduce((E, h) => Number(E) + Number(h), -1));
+    }
+  };
+}
+function Lo(e) {
+  const t = ye(ve), l = pe("table"), {
+    handleDoubleClick: n,
+    handleClick: s,
+    handleContextMenu: a,
+    handleMouseEnter: i,
+    handleMouseLeave: o,
+    handleCellMouseEnter: r,
+    handleCellMouseLeave: u,
+    tooltipContent: d,
+    tooltipTrigger: f
+  } = Ro(e), {
+    getRowStyle: p,
+    getRowClass: E,
+    getCellStyle: h,
+    getCellClass: C,
+    getSpan: m,
+    getColspanRealWidth: w
+  } = No(e), v = P(() => e.store.states.columns.value.findIndex(({ type: S }) => S === "default")), y = (S, N) => {
+    const W = t.props.rowKey;
+    return W ? _(S, W) : N;
+  }, c = (S, N, W, K = !1) => {
+    const { tooltipEffect: $, tooltipOptions: M, store: B } = e, { indent: D, columns: q } = B.states, U = E(S, N);
+    let re = !0;
+    return W && (U.push(l.em("row", `level-${W.level}`)), re = W.display), H("tr", {
+      style: [re ? null : {
+        display: "none"
+      }, p(S, N)],
+      class: U,
+      key: y(S, N),
+      onDblclick: (b) => n(b, S),
+      onClick: (b) => s(b, S),
+      onContextmenu: (b) => a(b, S),
+      onMouseenter: () => i(N),
+      onMouseleave: o
+    }, q.value.map((b, L) => {
+      const { rowspan: k, colspan: I } = m(S, b, N, L);
+      if (!k || !I)
+        return null;
+      const j = Object.assign({}, b);
+      j.realWidth = w(q.value, I, L);
+      const Y = {
+        store: e.store,
+        _self: e.context || t,
+        column: j,
+        row: S,
+        $index: N,
+        cellIndex: L,
+        expanded: K
+      };
+      L === v.value && W && (Y.treeNode = {
+        indent: W.level * D.value,
+        level: W.level
+      }, typeof W.expanded == "boolean" && (Y.treeNode.expanded = W.expanded, "loading" in W && (Y.treeNode.loading = W.loading), "noLazyChildren" in W && (Y.treeNode.noLazyChildren = W.noLazyChildren)));
+      const ne = `${N},${L}`, J = j.columnKey || j.rawColumnKey || "", ge = g(L, b, Y), ee = b.showOverflowTooltip && Dn({
+        effect: $
+      }, M, b.showOverflowTooltip);
+      return H("td", {
+        style: h(N, L, S, b),
+        class: C(N, L, S, b, I - 1),
+        key: `${J}${ne}`,
+        rowspan: k,
+        colspan: I,
+        onMouseenter: (se) => r(se, S, ee),
+        onMouseleave: u
+      }, [ge]);
+    }));
+  }, g = (S, N, W) => N.renderCell(W);
+  return {
+    wrappedRowRender: (S, N) => {
+      const W = e.store, { isRowExpanded: K, assertRowKey: $ } = W, { treeData: M, lazyTreeNodeMap: B, childrenColumnName: D, rowKey: q } = W.states, U = W.states.columns.value;
+      if (U.some(({ type: X }) => X === "expand")) {
+        const X = K(S), b = c(S, N, void 0, X), L = t.renderExpanded;
+        return X ? L ? [
+          [
+            b,
+            H("tr", {
+              key: `expanded-row__${b.key}`
+            }, [
+              H("td", {
+                colspan: U.length,
+                class: `${l.e("cell")} ${l.e("expanded-cell")}`
+              }, [L({ row: S, $index: N, store: W, expanded: X })])
+            ])
+          ]
+        ] : (console.error("[Element Error]renderExpanded is required."), b) : [[b]];
+      } else if (Object.keys(M.value).length) {
+        $();
+        const X = _(S, q.value);
+        let b = M.value[X], L = null;
+        b && (L = {
+          expanded: b.expanded,
+          level: b.level,
+          display: !0
+        }, typeof b.lazy == "boolean" && (typeof b.loaded == "boolean" && b.loaded && (L.noLazyChildren = !(b.children && b.children.length)), L.loading = b.loading));
+        const k = [c(S, N, L)];
+        if (b) {
+          let I = 0;
+          const j = (ne, J) => {
+            ne && ne.length && J && ne.forEach((ge) => {
+              const ee = {
+                display: J.display && J.expanded,
+                level: J.level + 1,
+                expanded: !1,
+                noLazyChildren: !1,
+                loading: !1
+              }, se = _(ge, q.value);
+              if (se == null)
+                throw new Error("For nested data item, row-key is required.");
+              if (b = { ...M.value[se] }, b && (ee.expanded = b.expanded, b.level = b.level || ee.level, b.display = !!(b.expanded && ee.display), typeof b.lazy == "boolean" && (typeof b.loaded == "boolean" && b.loaded && (ee.noLazyChildren = !(b.children && b.children.length)), ee.loading = b.loading)), I++, k.push(c(ge, N + I, ee)), b) {
+                const ce = B.value[se] || ge[D.value];
+                j(ce, b);
+              }
+            });
+          };
+          b.display = !0;
+          const Y = B.value[X] || S[D.value];
+          j(Y, b);
+        }
+        return k;
+      } else
+        return c(S, N, void 0);
+    },
+    tooltipContent: d,
+    tooltipTrigger: f
+  };
+}
+const Oo = {
+  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 Wo = Fe({
+  name: "ElTableBody",
+  props: Oo,
+  setup(e) {
+    const t = le(), l = ye(ve), n = pe("table"), { wrappedRowRender: s, tooltipContent: a, tooltipTrigger: i } = Lo(e), { onColumnsChange: o, onScrollableChange: r } = al(l), u = [];
+    return he(e.store.states.hoverRow, (d, f) => {
+      var p;
+      const E = t == null ? void 0 : t.vnode.el, h = Array.from((E == null ? void 0 : E.children) || []).filter((w) => w == null ? void 0 : w.classList.contains(`${n.e("row")}`));
+      let C = d;
+      const m = (p = h[C]) == null ? void 0 : p.childNodes;
+      m != null && m.length ? Array.from(m).reduce((v, y, c) => {
+        var g, R;
+        const S = ((g = m[c - 1]) == null ? void 0 : g.colSpan) > 1, N = ((R = m[c + 1]) == null ? void 0 : R.colSpan) > 1;
+        return y.nodeName !== "TD" && !S && !N && v.push(c), v;
+      }, []).forEach((v) => {
+        for (var y; C > 0; ) {
+          const c = (y = h[C - 1]) == null ? void 0 : y.childNodes;
+          if (c[v] && c[v].nodeName === "TD") {
+            qe(c[v], "hover-cell"), u.push(c[v]);
+            break;
+          }
+          C--;
+        }
+      }) : (u.forEach((w) => $e(w, "hover-cell")), u.length = 0), !(!e.store.states.isComplex.value || !Oe) && In(() => {
+        const w = h[f], v = h[d];
+        w && !w.classList.contains("hover-fixed-row") && $e(w, "hover-row"), v && qe(v, "hover-row");
+      });
+    }), ct(() => {
+      var d;
+      (d = ie) == null || d();
+    }), {
+      ns: n,
+      onColumnsChange: o,
+      onScrollableChange: r,
+      wrappedRowRender: s,
+      tooltipContent: a,
+      tooltipTrigger: i
+    };
+  },
+  render() {
+    const { wrappedRowRender: e, store: t } = this, l = t.states.data.value || [];
+    return H("tbody", { tabIndex: -1 }, [
+      l.reduce((n, s) => n.concat(e(s, n.length)), [])
+    ]);
+  }
+});
+function Mo() {
+  const e = ye(ve), t = e == null ? void 0 : e.store, l = P(() => t.states.fixedLeafColumnsLength.value), n = P(() => t.states.rightFixedColumns.value.length), s = P(() => t.states.columns.value.length), a = P(() => t.states.fixedColumns.value.length), i = P(() => t.states.rightFixedColumns.value.length);
+  return {
+    leftFixedLeafCount: l,
+    rightFixedLeafCount: n,
+    columnsCount: s,
+    leftFixedCount: a,
+    rightFixedCount: i,
+    columns: t.states.columns
+  };
+}
+function Fo(e) {
+  const { columns: t } = Mo(), l = pe("table");
+  return {
+    getCellClasses: (a, i) => {
+      const o = a[i], r = [
+        l.e("cell"),
+        o.id,
+        o.align,
+        o.labelClassName,
+        ...vt(l.b(), i, o.fixed, e.store)
+      ];
+      return o.className && r.push(o.className), o.children || r.push(l.is("leaf")), r;
+    },
+    getCellStyles: (a, i) => {
+      const o = gt(i, a.fixed, e.store);
+      return Me(o, "left"), Me(o, "right"), o;
+    },
+    columns: t
+  };
+}
+var Ao = Fe({
+  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 } = Fo(e);
+    return {
+      ns: pe("table"),
+      getCellClasses: t,
+      getCellStyles: l,
+      columns: n
+    };
+  },
+  render() {
+    const { columns: e, getCellStyles: t, getCellClasses: l, summaryMethod: n, sumText: s } = this, a = this.store.states.data.value;
+    let i = [];
+    return n ? i = n({
+      columns: e,
+      data: a
+    }) : e.forEach((o, r) => {
+      if (r === 0) {
+        i[r] = s;
+        return;
+      }
+      const u = a.map((E) => Number(E[o.property])), d = [];
+      let f = !0;
+      u.forEach((E) => {
+        if (!Number.isNaN(+E)) {
+          f = !1;
+          const h = `${E}`.split(".")[1];
+          d.push(h ? h.length : 0);
+        }
+      });
+      const p = Math.max.apply(null, d);
+      f ? i[r] = "" : i[r] = u.reduce((E, h) => {
+        const C = Number(h);
+        return Number.isNaN(+C) ? E : Number.parseFloat((E + h).toFixed(Math.min(p, 20)));
+      }, 0);
+    }), H(H("tfoot", [
+      H("tr", {}, [
+        ...e.map((o, r) => H("td", {
+          key: r,
+          colspan: o.colSpan,
+          rowspan: o.rowSpan,
+          class: l(e, r),
+          style: t(o, r)
+        }, [
+          H("div", {
+            class: ["cell", o.labelClassName]
+          }, [i[r]])
+        ]))
+      ])
+    ]));
+  }
+});
+function Ho(e) {
+  return {
+    setCurrentRow: (d) => {
+      e.commit("setCurrentRow", d);
+    },
+    getSelectionRows: () => e.getSelectionRows(),
+    toggleRowSelection: (d, f) => {
+      e.toggleRowSelection(d, f, !1), e.updateAllSelected();
+    },
+    clearSelection: () => {
+      e.clearSelection();
+    },
+    clearFilter: (d) => {
+      e.clearFilter(d);
+    },
+    toggleAllSelection: () => {
+      e.commit("toggleAllSelection");
+    },
+    toggleRowExpansion: (d, f) => {
+      e.toggleRowExpansionAdapter(d, f);
+    },
+    clearSort: () => {
+      e.clearSort();
+    },
+    sort: (d, f) => {
+      e.commit("sort", { prop: d, order: f });
+    }
+  };
+}
+function To(e, t, l, n) {
+  const s = x(!1), a = x(null), i = x(!1), o = (b) => {
+    i.value = b;
+  }, r = x({
+    width: null,
+    height: null,
+    headerHeight: null
+  }), u = x(!1), d = {
+    display: "inline-block",
+    verticalAlign: "middle"
+  }, f = x(), p = x(0), E = x(0), h = x(0), C = x(0), m = x(0);
+  Ae(() => {
+    t.setHeight(e.height);
+  }), Ae(() => {
+    t.setMaxHeight(e.maxHeight);
+  }), he(() => [e.currentRowKey, l.states.rowKey], ([b, L]) => {
+    !Z(L) || !Z(b) || l.setCurrentRowKey(`${b}`);
+  }, {
+    immediate: !0
+  }), he(() => e.data, (b) => {
+    n.store.commit("setData", b);
+  }, {
+    immediate: !0,
+    deep: !0
+  }), Ae(() => {
+    e.expandRowKeys && l.setExpandRowKeysAdapter(e.expandRowKeys);
+  });
+  const w = () => {
+    n.store.commit("setHoverRow", null), n.hoverState && (n.hoverState = null);
+  }, v = (b, L) => {
+    const { pixelX: k, pixelY: I } = L;
+    Math.abs(k) >= Math.abs(I) && (n.refs.bodyWrapper.scrollLeft += L.pixelX / 5);
+  }, y = P(() => e.height || e.maxHeight || l.states.fixedColumns.value.length > 0 || l.states.rightFixedColumns.value.length > 0), c = P(() => ({
+    width: t.bodyWidth.value ? `${t.bodyWidth.value}px` : ""
+  })), g = () => {
+    y.value && t.updateElsHeight(), t.updateColumnsWidth(), requestAnimationFrame(W);
+  };
+  Pe(async () => {
+    await Le(), l.updateColumns(), K(), requestAnimationFrame(g);
+    const b = n.vnode.el, L = n.refs.headerWrapper;
+    e.flexible && b && b.parentElement && (b.parentElement.style.minWidth = "0"), r.value = {
+      width: f.value = b.offsetWidth,
+      height: b.offsetHeight,
+      headerHeight: e.showHeader && L ? L.offsetHeight : null
+    }, l.states.columns.value.forEach((k) => {
+      k.filteredValue && k.filteredValue.length && n.store.commit("filterChange", {
+        column: k,
+        values: k.filteredValue,
+        silent: !0
+      });
+    }), n.$ready = !0;
+  });
+  const R = (b, L) => {
+    if (!b)
+      return;
+    const k = Array.from(b.classList).filter((I) => !I.startsWith("is-scrolling-"));
+    k.push(t.scrollX.value ? L : "is-scrolling-none"), b.className = k.join(" ");
+  }, S = (b) => {
+    const { tableWrapper: L } = n.refs;
+    R(L, b);
+  }, N = (b) => {
+    const { tableWrapper: L } = n.refs;
+    return !!(L && L.classList.contains(b));
+  }, W = function() {
+    if (!n.refs.scrollBarRef)
+      return;
+    if (!t.scrollX.value) {
+      const J = "is-scrolling-none";
+      N(J) || S(J);
+      return;
+    }
+    const b = n.refs.scrollBarRef.wrapRef;
+    if (!b)
+      return;
+    const { scrollLeft: L, offsetWidth: k, scrollWidth: I } = b, { headerWrapper: j, footerWrapper: Y } = n.refs;
+    j && (j.scrollLeft = L), Y && (Y.scrollLeft = L);
+    const ne = I - k - 1;
+    L >= ne ? S("is-scrolling-right") : S(L === 0 ? "is-scrolling-left" : "is-scrolling-middle");
+  }, K = () => {
+    n.refs.scrollBarRef && (n.refs.scrollBarRef.wrapRef && Et(n.refs.scrollBarRef.wrapRef, "scroll", W, {
+      passive: !0
+    }), e.fit ? xt(n.vnode.el, $) : Et(window, "resize", $), xt(n.refs.bodyWrapper, () => {
+      var b, L;
+      $(), (L = (b = n.refs) == null ? void 0 : b.scrollBarRef) == null || L.update();
+    }));
+  }, $ = () => {
+    var b, L, k, I;
+    const j = n.vnode.el;
+    if (!n.$ready || !j)
+      return;
+    let Y = !1;
+    const {
+      width: ne,
+      height: J,
+      headerHeight: ge
+    } = r.value, ee = f.value = j.offsetWidth;
+    ne !== ee && (Y = !0);
+    const se = j.offsetHeight;
+    (e.height || y.value) && J !== se && (Y = !0);
+    const ce = e.tableLayout === "fixed" ? n.refs.headerWrapper : (b = n.refs.tableHeaderRef) == null ? void 0 : b.$el;
+    e.showHeader && (ce == null ? void 0 : ce.offsetHeight) !== ge && (Y = !0), p.value = ((L = n.refs.tableWrapper) == null ? void 0 : L.scrollHeight) || 0, h.value = (ce == null ? void 0 : ce.scrollHeight) || 0, C.value = ((k = n.refs.footerWrapper) == null ? void 0 : k.offsetHeight) || 0, m.value = ((I = n.refs.appendWrapper) == null ? void 0 : I.offsetHeight) || 0, E.value = p.value - h.value - C.value - m.value, Y && (r.value = {
+      width: ee,
+      height: se,
+      headerHeight: e.showHeader && (ce == null ? void 0 : ce.offsetHeight) || 0
+    }, g());
+  }, M = Ql(), B = P(() => {
+    const { bodyWidth: b, scrollY: L, gutterWidth: k } = t;
+    return b.value ? `${b.value - (L.value ? k : 0)}px` : "";
+  }), D = P(() => e.maxHeight ? "fixed" : e.tableLayout), q = P(() => {
+    if (e.data && e.data.length)
+      return null;
+    let b = "100%";
+    e.height && E.value && (b = `${E.value}px`);
+    const L = f.value;
+    return {
+      width: L ? `${L}px` : "",
+      height: b
+    };
+  }), U = P(() => 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`
+  } : {}), re = P(() => e.height ? {
+    height: "100%"
+  } : e.maxHeight ? Number.isNaN(Number(e.maxHeight)) ? {
+    maxHeight: `calc(${e.maxHeight} - ${h.value + C.value}px)`
+  } : {
+    maxHeight: `${e.maxHeight - h.value - C.value}px`
+  } : {});
+  return {
+    isHidden: s,
+    renderExpanded: a,
+    setDragVisible: o,
+    isGroup: u,
+    handleMouseLeave: w,
+    handleHeaderFooterMousewheel: v,
+    tableSize: M,
+    emptyBlockStyle: q,
+    handleFixedMousewheel: (b, L) => {
+      const k = n.refs.bodyWrapper;
+      if (Math.abs(L.spinY) > 0) {
+        const I = k.scrollTop;
+        L.pixelY < 0 && I !== 0 && b.preventDefault(), L.pixelY > 0 && k.scrollHeight - k.clientHeight > I && b.preventDefault(), k.scrollTop += Math.ceil(L.pixelY / 5);
+      } else
+        k.scrollLeft += Math.ceil(L.pixelX / 5);
+    },
+    resizeProxyVisible: i,
+    bodyWidth: B,
+    resizeState: r,
+    doLayout: g,
+    tableBodyStyles: c,
+    tableLayout: D,
+    scrollbarViewStyle: d,
+    tableInnerStyle: U,
+    scrollbarStyle: re
+  };
+}
+function ko(e) {
+  const t = x(), l = () => {
+    const s = e.vnode.el.querySelector(".hidden-columns"), a = { childList: !0, subtree: !0 }, i = e.store.states.updateOrderFns;
+    t.value = new MutationObserver(() => {
+      i.forEach((o) => o());
+    }), t.value.observe(s, a);
+  };
+  Pe(() => {
+    l();
+  }), ct(() => {
+    var n;
+    (n = t.value) == null || n.disconnect();
+  });
+}
+var $o = {
+  data: {
+    type: Array,
+    default: () => []
+  },
+  size: Jl,
+  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: Boolean,
+  flexible: Boolean,
+  showOverflowTooltip: [Boolean, Object]
+};
+function ul(e) {
+  const t = e.tableLayout === "auto";
+  let l = e.columns || [];
+  t && l.every((s) => s.width === void 0) && (l = []);
+  const n = (s) => {
+    const a = {
+      key: `${e.tableLayout}_${s.id}`,
+      style: {},
+      name: void 0
+    };
+    return t ? a.style = {
+      width: `${s.width}px`
+    } : a.name = s.id, a;
+  };
+  return H("colgroup", {}, l.map((s) => H("col", n(s))));
+}
+ul.props = ["columns", "tableLayout"];
+const Po = () => {
+  const e = x(), t = (a, i) => {
+    const o = e.value;
+    o && o.scrollTo(a, i);
+  }, l = (a, i) => {
+    const o = e.value;
+    o && Zl(i) && ["Top", "Left"].includes(a) && o[`setScroll${a}`](i);
+  };
+  return {
+    scrollBarRef: e,
+    scrollTo: t,
+    setScrollTop: (a) => l("Top", a),
+    setScrollLeft: (a) => l("Left", a)
+  };
+};
+let Bo = 1;
+const Ko = Fe({
+  name: "ElTable",
+  directives: {
+    Mousewheel: Gn
+  },
+  components: {
+    TableHeader: xo,
+    TableBody: Wo,
+    TableFooter: Ao,
+    ElScrollbar: Pt,
+    hColgroup: ul
+  },
+  props: $o,
+  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 } = Dt(), l = pe("table"), n = le();
+    Tl(ve, n);
+    const s = uo(n, e);
+    n.store = s;
+    const a = new fo({
+      store: n.store,
+      table: n,
+      fit: e.fit,
+      showHeader: e.showHeader
+    });
+    n.layout = a;
+    const i = P(() => (s.states.data.value || []).length === 0), {
+      setCurrentRow: o,
+      getSelectionRows: r,
+      toggleRowSelection: u,
+      clearSelection: d,
+      clearFilter: f,
+      toggleAllSelection: p,
+      toggleRowExpansion: E,
+      clearSort: h,
+      sort: C
+    } = Ho(s), {
+      isHidden: m,
+      renderExpanded: w,
+      setDragVisible: v,
+      isGroup: y,
+      handleMouseLeave: c,
+      handleHeaderFooterMousewheel: g,
+      tableSize: R,
+      emptyBlockStyle: S,
+      handleFixedMousewheel: N,
+      resizeProxyVisible: W,
+      bodyWidth: K,
+      resizeState: $,
+      doLayout: M,
+      tableBodyStyles: B,
+      tableLayout: D,
+      scrollbarViewStyle: q,
+      tableInnerStyle: U,
+      scrollbarStyle: re
+    } = To(e, a, s, n), { scrollBarRef: X, scrollTo: b, setScrollLeft: L, setScrollTop: k } = Po(), I = Ue(M, 50), j = `${l.namespace.value}-table_${Bo++}`;
+    n.tableId = j, n.state = {
+      isGroup: y,
+      resizeState: $,
+      doLayout: M,
+      debouncedUpdateLayout: I
+    };
+    const Y = P(() => e.sumText || t("el.table.sumText")), ne = P(() => e.emptyText || t("el.table.emptyText"));
+    return ko(n), {
+      ns: l,
+      layout: a,
+      store: s,
+      handleHeaderFooterMousewheel: g,
+      handleMouseLeave: c,
+      tableId: j,
+      tableSize: R,
+      isHidden: m,
+      isEmpty: i,
+      renderExpanded: w,
+      resizeProxyVisible: W,
+      resizeState: $,
+      isGroup: y,
+      bodyWidth: K,
+      tableBodyStyles: B,
+      emptyBlockStyle: S,
+      debouncedUpdateLayout: I,
+      handleFixedMousewheel: N,
+      setCurrentRow: o,
+      getSelectionRows: r,
+      toggleRowSelection: u,
+      clearSelection: d,
+      clearFilter: f,
+      toggleAllSelection: p,
+      toggleRowExpansion: E,
+      clearSort: h,
+      doLayout: M,
+      sort: C,
+      t,
+      setDragVisible: v,
+      context: n,
+      computedSumText: Y,
+      computedEmptyText: ne,
+      tableLayout: D,
+      scrollbarViewStyle: q,
+      tableInnerStyle: U,
+      scrollbarStyle: re,
+      scrollBarRef: X,
+      scrollTo: b,
+      setScrollLeft: L,
+      setScrollTop: k
+    };
+  }
+}), zo = ["data-prefix"], Do = {
+  ref: "hiddenColumns",
+  class: "hidden-columns"
+};
+function Io(e, t, l, n, s, a) {
+  const i = ue("hColgroup"), o = ue("table-header"), r = ue("table-body"), u = ue("table-footer"), d = ue("el-scrollbar"), f = Tt("mousewheel");
+  return G(), de("div", {
+    ref: "tableWrapper",
+    class: V([
+      {
+        [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: xe(e.style),
+    "data-prefix": e.ns.namespace.value,
+    onMouseleave: t[0] || (t[0] = (...p) => e.handleMouseLeave && e.handleMouseLeave(...p))
+  }, [
+    oe("div", {
+      class: V(e.ns.e("inner-wrapper")),
+      style: xe(e.tableInnerStyle)
+    }, [
+      oe("div", Do, [
+        ze(e.$slots, "default")
+      ], 512),
+      e.showHeader && e.tableLayout === "fixed" ? Ke((G(), de("div", {
+        key: 0,
+        ref: "headerWrapper",
+        class: V(e.ns.e("header-wrapper"))
+      }, [
+        oe("table", {
+          ref: "tableHeader",
+          class: V(e.ns.e("header")),
+          style: xe(e.tableBodyStyles),
+          border: "0",
+          cellpadding: "0",
+          cellspacing: "0"
+        }, [
+          fe(i, {
+            columns: e.store.states.columns.value,
+            "table-layout": e.tableLayout
+          }, null, 8, ["columns", "table-layout"]),
+          fe(o, {
+            ref: "tableHeaderRef",
+            border: e.border,
+            "default-sort": e.defaultSort,
+            store: e.store,
+            onSetDragVisible: e.setDragVisible
+          }, null, 8, ["border", "default-sort", "store", "onSetDragVisible"])
+        ], 6)
+      ], 2)), [
+        [f, e.handleHeaderFooterMousewheel]
+      ]) : be("v-if", !0),
+      oe("div", {
+        ref: "bodyWrapper",
+        class: V(e.ns.e("body-wrapper"))
+      }, [
+        fe(d, {
+          ref: "scrollBarRef",
+          "view-style": e.scrollbarViewStyle,
+          "wrap-style": e.scrollbarStyle,
+          always: e.scrollbarAlwaysOn
+        }, {
+          default: Ce(() => [
+            oe("table", {
+              ref: "tableBody",
+              class: V(e.ns.e("body")),
+              cellspacing: "0",
+              cellpadding: "0",
+              border: "0",
+              style: xe({
+                width: e.bodyWidth,
+                tableLayout: e.tableLayout
+              })
+            }, [
+              fe(i, {
+                columns: e.store.states.columns.value,
+                "table-layout": e.tableLayout
+              }, null, 8, ["columns", "table-layout"]),
+              e.showHeader && e.tableLayout === "auto" ? (G(), Ne(o, {
+                key: 0,
+                ref: "tableHeaderRef",
+                class: V(e.ns.e("body-header")),
+                border: e.border,
+                "default-sort": e.defaultSort,
+                store: e.store,
+                onSetDragVisible: e.setDragVisible
+              }, null, 8, ["class", "border", "default-sort", "store", "onSetDragVisible"])) : be("v-if", !0),
+              fe(r, {
+                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"]),
+              e.showSummary && e.tableLayout === "auto" ? (G(), Ne(u, {
+                key: 1,
+                class: V(e.ns.e("body-footer")),
+                border: e.border,
+                "default-sort": e.defaultSort,
+                store: e.store,
+                "sum-text": e.computedSumText,
+                "summary-method": e.summaryMethod
+              }, null, 8, ["class", "border", "default-sort", "store", "sum-text", "summary-method"])) : be("v-if", !0)
+            ], 6),
+            e.isEmpty ? (G(), de("div", {
+              key: 0,
+              ref: "emptyBlock",
+              style: xe(e.emptyBlockStyle),
+              class: V(e.ns.e("empty-block"))
+            }, [
+              oe("span", {
+                class: V(e.ns.e("empty-text"))
+              }, [
+                ze(e.$slots, "empty", {}, () => [
+                  kt(Re(e.computedEmptyText), 1)
+                ])
+              ], 2)
+            ], 6)) : be("v-if", !0),
+            e.$slots.append ? (G(), de("div", {
+              key: 1,
+              ref: "appendWrapper",
+              class: V(e.ns.e("append-wrapper"))
+            }, [
+              ze(e.$slots, "append")
+            ], 2)) : be("v-if", !0)
+          ]),
+          _: 3
+        }, 8, ["view-style", "wrap-style", "always"])
+      ], 2),
+      e.showSummary && e.tableLayout === "fixed" ? Ke((G(), de("div", {
+        key: 1,
+        ref: "footerWrapper",
+        class: V(e.ns.e("footer-wrapper"))
+      }, [
+        oe("table", {
+          class: V(e.ns.e("footer")),
+          cellspacing: "0",
+          cellpadding: "0",
+          border: "0",
+          style: xe(e.tableBodyStyles)
+        }, [
+          fe(i, {
+            columns: e.store.states.columns.value,
+            "table-layout": e.tableLayout
+          }, null, 8, ["columns", "table-layout"]),
+          fe(u, {
+            border: e.border,
+            "default-sort": e.defaultSort,
+            store: e.store,
+            "sum-text": e.computedSumText,
+            "summary-method": e.summaryMethod
+          }, null, 8, ["border", "default-sort", "store", "sum-text", "summary-method"])
+        ], 6)
+      ], 2)), [
+        [Ct, !e.isEmpty],
+        [f, e.handleHeaderFooterMousewheel]
+      ]) : be("v-if", !0),
+      e.border || e.isGroup ? (G(), de("div", {
+        key: 2,
+        class: V(e.ns.e("border-left-patch"))
+      }, null, 2)) : be("v-if", !0)
+    ], 6),
+    Ke(oe("div", {
+      ref: "resizeProxy",
+      class: V(e.ns.e("column-resize-proxy"))
+    }, null, 2), [
+      [Ct, e.resizeProxyVisible]
+    ])
+  ], 46, zo);
+}
+var Vo = /* @__PURE__ */ It(Ko, [["render", Io], ["__file", "table.vue"]]);
+const jo = {
+  selection: "table-column--selection",
+  expand: "table__expand-column"
+}, Yo = {
+  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: ""
+  }
+}, qo = (e) => jo[e] || "", Uo = {
+  selection: {
+    renderHeader({ store: e, column: t }) {
+      function l() {
+        return e.states.data.value && e.states.data.value.length === 0;
+      }
+      return H(We, {
+        disabled: l(),
+        size: e.states.tableSize.value,
+        indeterminate: e.states.selection.value.length > 0 && !e.states.isAllSelected.value,
+        "onUpdate:modelValue": e.toggleAllSelection,
+        modelValue: e.states.isAllSelected.value,
+        ariaLabel: t.label
+      });
+    },
+    renderCell({
+      row: e,
+      column: t,
+      store: l,
+      $index: n
+    }) {
+      return H(We, {
+        disabled: t.selectable ? !t.selectable.call(null, e, n) : !1,
+        size: l.states.tableSize.value,
+        onChange: () => {
+          l.commit("rowSelectedChanged", e);
+        },
+        onClick: (s) => s.stopPropagation(),
+        modelValue: l.isSelected(e),
+        ariaLabel: t.label
+      });
+    },
+    sortable: !1,
+    resizable: !1
+  },
+  index: {
+    renderHeader({ column: e }) {
+      return e.label || "#";
+    },
+    renderCell({
+      column: e,
+      $index: t
+    }) {
+      let l = t + 1;
+      const n = e.index;
+      return typeof n == "number" ? l = t + n : typeof n == "function" && (l = n(t)), H("div", {}, [l]);
+    },
+    sortable: !1
+  },
+  expand: {
+    renderHeader({ column: e }) {
+      return e.label || "";
+    },
+    renderCell({
+      row: e,
+      store: t,
+      expanded: l
+    }) {
+      const { ns: n } = t, s = [n.e("expand-icon")];
+      return l && s.push(n.em("expand-icon", "expanded")), H("div", {
+        class: s,
+        onClick: function(i) {
+          i.stopPropagation(), t.toggleRowExpansion(e);
+        }
+      }, {
+        default: () => [
+          H(ht, null, {
+            default: () => [H(Vt)]
+          })
+        ]
+      });
+    },
+    sortable: !1,
+    resizable: !1
+  }
+};
+function Xo({
+  row: e,
+  column: t,
+  $index: l
+}) {
+  var n;
+  const s = t.property, a = s && en(e, s).value;
+  return t && t.formatter ? t.formatter(e, t, a, l) : ((n = a == null ? void 0 : a.toString) == null ? void 0 : n.call(a)) || "";
+}
+function Go({
+  row: e,
+  treeNode: t,
+  store: l
+}, n = !1) {
+  const { ns: s } = l;
+  if (!t)
+    return n ? [
+      H("span", {
+        class: s.e("placeholder")
+      })
+    ] : null;
+  const a = [], i = function(o) {
+    o.stopPropagation(), !t.loading && l.loadOrToggle(e);
+  };
+  if (t.indent && a.push(H("span", {
+    class: s.e("indent"),
+    style: { "padding-left": `${t.indent}px` }
+  })), typeof t.expanded == "boolean" && !t.noLazyChildren) {
+    const o = [
+      s.e("expand-icon"),
+      t.expanded ? s.em("expand-icon", "expanded") : ""
+    ];
+    let r = Vt;
+    t.loading && (r = tn), a.push(H("div", {
+      class: o,
+      onClick: i
+    }, {
+      default: () => [
+        H(ht, { class: { [s.is("loading")]: t.loading } }, {
+          default: () => [H(r)]
+        })
+      ]
+    }));
+  } else
+    a.push(H("span", {
+      class: s.e("placeholder")
+    }));
+  return a;
+}
+function Ht(e, t) {
+  return e.reduce((l, n) => (l[n] = n, l), t);
+}
+function _o(e, t) {
+  const l = le();
+  return {
+    registerComplexWatchers: () => {
+      const a = ["fixed"], i = {
+        realWidth: "width",
+        realMinWidth: "minWidth"
+      }, o = Ht(a, i);
+      Object.keys(o).forEach((r) => {
+        const u = i[r];
+        ke(t, u) && he(() => t[u], (d) => {
+          let f = d;
+          u === "width" && r === "realWidth" && (f = pt(d)), u === "minWidth" && r === "realMinWidth" && (f = ll(d)), l.columnConfig.value[u] = f, l.columnConfig.value[r] = f;
+          const p = u === "fixed";
+          e.value.store.scheduleLayout(p);
+        });
+      });
+    },
+    registerNormalWatchers: () => {
+      const a = [
+        "label",
+        "filters",
+        "filterMultiple",
+        "filteredValue",
+        "sortable",
+        "index",
+        "formatter",
+        "className",
+        "labelClassName",
+        "filterClassName",
+        "showOverflowTooltip"
+      ], i = {
+        property: "prop",
+        align: "realAlign",
+        headerAlign: "realHeaderAlign"
+      }, o = Ht(a, i);
+      Object.keys(o).forEach((r) => {
+        const u = i[r];
+        ke(t, u) && he(() => t[u], (d) => {
+          l.columnConfig.value[r] = d;
+        });
+      });
+    }
+  };
+}
+function Qo(e, t, l) {
+  const n = le(), s = x(""), a = x(!1), i = x(), o = x(), r = pe("table");
+  Ae(() => {
+    i.value = e.align ? `is-${e.align}` : null, i.value;
+  }), Ae(() => {
+    o.value = e.headerAlign ? `is-${e.headerAlign}` : i.value, o.value;
+  });
+  const u = P(() => {
+    let c = n.vnode.vParent || n.parent;
+    for (; c && !c.tableId && !c.columnId; )
+      c = c.vnode.vParent || c.parent;
+    return c;
+  }), d = P(() => {
+    const { store: c } = n.parent;
+    if (!c)
+      return !1;
+    const { treeData: g } = c.states, R = g.value;
+    return R && Object.keys(R).length > 0;
+  }), f = x(pt(e.width)), p = x(ll(e.minWidth)), E = (c) => (f.value && (c.width = f.value), p.value && (c.minWidth = p.value), !f.value && p.value && (c.width = void 0), c.minWidth || (c.minWidth = 80), c.realWidth = Number(c.width === void 0 ? c.minWidth : c.width), c), h = (c) => {
+    const g = c.type, R = Uo[g] || {};
+    Object.keys(R).forEach((N) => {
+      const W = R[N];
+      N !== "className" && W !== void 0 && (c[N] = W);
+    });
+    const S = qo(g);
+    if (S) {
+      const N = `${Z(r.namespace)}-${S}`;
+      c.className = c.className ? `${c.className} ${N}` : N;
+    }
+    return c;
+  }, C = (c) => {
+    Array.isArray(c) ? c.forEach((R) => g(R)) : g(c);
+    function g(R) {
+      var S;
+      ((S = R == null ? void 0 : R.type) == null ? void 0 : S.name) === "ElTableColumn" && (R.vParent = n);
+    }
+  };
+  return {
+    columnId: s,
+    realAlign: i,
+    isSubColumn: a,
+    realHeaderAlign: o,
+    columnOrTableParent: u,
+    setColumnWidth: E,
+    setColumnForcedProps: h,
+    setColumnRenders: (c) => {
+      e.renderHeader ? ln("TableColumn", "Comparing to render-header, scoped-slot header is easier to use. We recommend users to use scoped-slot header.") : c.type !== "selection" && (c.renderHeader = (R) => (n.columnConfig.value.label, ze(t, "header", R, () => [c.label])));
+      let g = c.renderCell;
+      return c.type === "expand" ? (c.renderCell = (R) => H("div", {
+        class: "cell"
+      }, [g(R)]), l.value.renderExpanded = (R) => t.default ? t.default(R) : t.default) : (g = g || Xo, c.renderCell = (R) => {
+        let S = null;
+        if (t.default) {
+          const B = t.default(R);
+          S = B.some((D) => D.type !== kl) ? B : g(R);
+        } else
+          S = g(R);
+        const { columns: N } = l.value.store.states, W = N.value.findIndex((B) => B.type === "default"), K = d.value && R.cellIndex === W, $ = Go(R, K), M = {
+          class: "cell",
+          style: {}
+        };
+        return c.showOverflowTooltip && (M.class = `${M.class} ${Z(r.namespace)}-tooltip`, M.style = {
+          width: `${(R.column.realWidth || Number(R.column.width)) - 1}px`
+        }), C(S), H("div", M, [$, S]);
+      }), c;
+    },
+    getPropsData: (...c) => c.reduce((g, R) => (Array.isArray(R) && R.forEach((S) => {
+      g[S] = e[S];
+    }), g), {}),
+    getColumnElIndex: (c, g) => Array.prototype.indexOf.call(c, g),
+    updateColumnOrder: () => {
+      l.value.store.commit("updateColumnOrder", n.columnConfig.value);
+    }
+  };
+}
+var Jo = {
+  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
+  },
+  filterClassName: String,
+  index: [Number, Function],
+  sortOrders: {
+    type: Array,
+    default: () => ["ascending", "descending", null],
+    validator: (e) => e.every((t) => ["ascending", "descending", null].includes(t))
+  }
+};
+let Zo = 1;
+var dl = Fe({
+  name: "ElTableColumn",
+  components: {
+    ElCheckbox: We
+  },
+  props: Jo,
+  setup(e, { slots: t }) {
+    const l = le(), n = x({}), s = P(() => {
+      let y = l.parent;
+      for (; y && !y.tableId; )
+        y = y.parent;
+      return y;
+    }), { registerNormalWatchers: a, registerComplexWatchers: i } = _o(s, e), {
+      columnId: o,
+      isSubColumn: r,
+      realHeaderAlign: u,
+      columnOrTableParent: d,
+      setColumnWidth: f,
+      setColumnForcedProps: p,
+      setColumnRenders: E,
+      getPropsData: h,
+      getColumnElIndex: C,
+      realAlign: m,
+      updateColumnOrder: w
+    } = Qo(e, t, s), v = d.value;
+    o.value = `${v.tableId || v.columnId}_column_${Zo++}`, $t(() => {
+      r.value = s.value !== v;
+      const y = e.type || "default", c = e.sortable === "" ? !0 : e.sortable, g = nn(e.showOverflowTooltip) ? v.props.showOverflowTooltip : e.showOverflowTooltip, R = {
+        ...Yo[y],
+        id: o.value,
+        type: y,
+        property: e.prop || e.property,
+        align: m,
+        headerAlign: u,
+        showOverflowTooltip: g,
+        filterable: e.filters || e.filterMethod,
+        filteredValue: [],
+        filterPlacement: "",
+        filterClassName: "",
+        isColumnGroup: !1,
+        isSubColumn: !1,
+        filterOpened: !1,
+        sortable: c,
+        index: e.index,
+        rawColumnKey: l.vnode.key
+      };
+      let $ = h([
+        "columnKey",
+        "label",
+        "className",
+        "labelClassName",
+        "type",
+        "renderHeader",
+        "formatter",
+        "fixed",
+        "resizable"
+      ], ["sortMethod", "sortBy", "sortOrders"], ["selectable", "reserveSelection"], [
+        "filterMethod",
+        "filters",
+        "filterMultiple",
+        "filterOpened",
+        "filteredValue",
+        "filterPlacement",
+        "filterClassName"
+      ]);
+      $ = Jn(R, $), $ = eo(E, f, p)($), n.value = $, a(), i();
+    }), Pe(() => {
+      var y;
+      const c = d.value, g = r.value ? c.vnode.el.children : (y = c.refs.hiddenColumns) == null ? void 0 : y.children, R = () => C(g || [], l.vnode.el);
+      n.value.getColumnIndex = R, R() > -1 && s.value.store.commit("insertColumn", n.value, r.value ? c.columnConfig.value : null, w);
+    }), $l(() => {
+      s.value.store.commit("removeColumn", n.value, r.value ? v.columnConfig.value : null, w);
+    }), l.columnId = o.value, l.columnConfig = n;
+  },
+  render() {
+    var e, t, l;
+    try {
+      const n = (t = (e = this.$slots).default) == null ? void 0 : t.call(e, {
+        row: {},
+        column: {},
+        $index: -1
+      }), s = [];
+      if (Array.isArray(n))
+        for (const i of n)
+          ((l = i.type) == null ? void 0 : l.name) === "ElTableColumn" || i.shapeFlag & 2 ? s.push(i) : i.type === Qe && Array.isArray(i.children) && i.children.forEach((o) => {
+            (o == null ? void 0 : o.patchFlag) !== 1024 && !on(o == null ? void 0 : o.children) && s.push(o);
+          });
+      return H("div", s);
+    } catch {
+      return H("div", []);
+    }
+  }
+});
+const ur = rn(Vo, {
+  TableColumn: dl
+}), dr = sn(dl);
+export {
+  dr as E,
+  ur as a
+};