st-comp 0.0.201 → 0.0.203

package/es/el-table-column-376cd907.js

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