bp-aicc-editor 1.2.521 → 1.2.522

package/lib/atlas-BMjKIOwk.js

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