@unicom-cloud/ui 0.8.108 → 0.8.110

package/chunk/COsRZOz1.js

@@ -0,0 +1,1813 @@
+import { jsx as r, jsxs as ce, Fragment as xt } from "react/jsx-runtime";
+import Dn from "lodash/debounce";
+import Kn from "lodash/throttle";
+import Ye, { useMemo as ie, useCallback as Ze, useState as ge, useRef as he, useContext as Ke, useEffect as et, forwardRef as Ot, createElement as tt, createContext as _n, useImperativeHandle as Bn } from "react";
+import { a as nt } from "./BcEZk8pT.js";
+import { u as Hn } from "./CylJZkp8.js";
+import { u as qt } from "./FgWHhRFz.js";
+import { u as Pt } from "./DfChiMIE.js";
+import Xt from "../pagination/Pagination.js";
+import Ln from "../spin/index.js";
+import Q from "@unicom-cloud/utils/class-name";
+import { b as mt, o as ht } from "./d1c9z8T1.js";
+import "./DsaQZE4X.js";
+import { p as An, a as Mn } from "./ClqoGc3r.js";
+import { r as Wn } from "./B8W1N4er.js";
+import yt from "../table/ColGroup.js";
+import { TableContext as Dt } from "../table/context.js";
+import Re from "lodash/isArray";
+import { defaultComponent as Gt, INTERNAL_EXPAND_KEY as Ct, INTERNAL_SELECTION_KEY as wt } from "../table/constant.js";
+import Ne from "lodash/isPlainObject";
+import zn from "lodash/merge";
+import { getOriginData as J, isChildrenNotEmpty as Et, getSelectedKeysByData as Vn, getSelectedKeys as jn, getSorterPriority as Ft, getSorterFn as It, px2Number as Tt, deepCloneData as Un, getScrollBarHeight as Yn, getScrollBarWidth as qn } from "../table/util.js";
+import gt from "lodash/isNumber";
+import Xn from "../virtual-list/VirtualList.js";
+import Gn from "@unicom-cloud/icons/IconUiMinus";
+import Jn from "@unicom-cloud/icons/IconUiPlus";
+import Ue from "lodash/isString";
+import { C as Kt } from "./qsVvkBLU.js";
+import { R as on } from "./BUNoUPLs.js";
+import Jt from "lodash/get";
+import Qe from "lodash/isFunction";
+import { u as Qn } from "./BJeTDXdz.js";
+import rn from "../tooltip/index.js";
+import { m as Zn } from "./B5RFT17G.js";
+import eo from "@unicom-cloud/icons/IconUiCaretDown";
+import to from "@unicom-cloud/icons/IconUiCaretUp";
+import no from "@unicom-cloud/icons/IconUiFilter";
+import Qt from "../button/index.js";
+import { u as oo } from "./2vdCeheu.js";
+import ro from "../space/index.js";
+import so from "../trigger/index.js";
+import { isArray as je, isPlainObject as ye, isFunction as De, isNumber as Zt } from "@unicom-cloud/utils/is";
+function _e(i) {
+  const c = ie(
+    () => Ne(i) ? zn({}, Gt, i) : Gt,
+    [i]
+  );
+  return {
+    getHeaderComponentOperations: c.header.operations,
+    getBodyComponentOperations: c.body.operations,
+    ComponentTable: c.table,
+    ComponentHeaderWrapper: c.header.wrapper,
+    ComponentThead: c.header.thead,
+    ComponentHeaderRow: c.header.row,
+    ComponentTh: c.header.th,
+    ComponentHeaderCell: c.header.cell,
+    ComponentBodyWrapper: c.body.wrapper,
+    ComponentTbody: c.body.tbody,
+    ComponentBodyRow: c.body.row,
+    ComponentTd: c.body.td,
+    ComponentBodyCell: c.body.cell
+  };
+}
+function en(i, c) {
+  const f = [];
+  function w(t) {
+    t && t.length > 0 && t.forEach((P) => {
+      P[c] ? w(P[c]) : f.push({ ...P, key: P.dataIndex || P.key });
+    });
+  }
+  return w(i), f;
+}
+function sn(i, c) {
+  let f = 0;
+  return i && i.length > 0 && i.forEach((w) => {
+    const t = sn(w[c], c) + 1;
+    f = Math.max(t, f);
+  }), f;
+}
+function io(i) {
+  const {
+    component: c,
+    rowSelection: f,
+    expandedRowRender: w,
+    expandProps: t = {},
+    columns: P = [],
+    childrenColumnName: s
+  } = i, S = ie(() => P || [], [P]), d = ie(
+    () => en(S, s),
+    [S, s]
+  ), $ = f && f.type === "checkbox" || f && !("type" in f), E = f && f.type === "radio", { width: p } = t, y = !!w, h = $ || E, { getHeaderComponentOperations: v, getBodyComponentOperations: O } = _e(c), g = ie(
+    () => v({
+      selectionNode: h ? "holder_node" : "",
+      expandNode: y ? "holder_node" : ""
+    }),
+    [
+      h,
+      y,
+      v
+    ]
+  ), m = ie(
+    () => O({
+      selectionNode: h ? "holder_node" : "",
+      expandNode: y ? "holder_node" : ""
+    }),
+    [
+      h,
+      y,
+      O
+    ]
+  ), u = f && f.fixed, _ = f && f.columnWidth, M = Ze(
+    (j, I, N) => {
+      const K = {}, W = [];
+      j.forEach((l, x) => {
+        const b = { ...l };
+        (!("key" in l) || typeof l.key > "u") && (b.key = b.dataIndex || x), x === 0 ? (b.$$isFirstColumn = !0, b.fixed === "left" && (K.fixed = b.fixed)) : b.$$isFirstColumn = !1, W.push(b);
+      });
+      const H = y && {
+        key: Ct,
+        title: Ct,
+        width: p,
+        $$isOperation: !0
+      }, U = h && {
+        key: wt,
+        title: wt,
+        width: _,
+        $$isOperation: !0
+      };
+      return u && (K.fixed = "left"), (typeof N != "number" || N === 0) && [...I].reverse().forEach((l, x) => {
+        if (l.node) {
+          const b = g.filter((L) => L.node).length - x - 1;
+          l.name === "expandNode" ? W.unshift({
+            ...H,
+            ...K,
+            $$columnIndex: b
+          }) : l.name === "selectionNode" ? W.unshift({
+            ...U,
+            ...K,
+            $$columnIndex: b
+          }) : W.unshift({
+            ...l,
+            ...K,
+            title: l.name,
+            key: l.name,
+            $$isOperation: !0,
+            width: l.width || 40,
+            $$columnIndex: b
+          });
+        }
+      }), W;
+    },
+    [
+      p,
+      y,
+      h,
+      _,
+      u,
+      g
+    ]
+  ), F = ie(
+    () => M(d, m),
+    [d, M, m]
+  ), Z = ie(
+    () => sn(S, s),
+    [S, s]
+  );
+  return [ie(() => {
+    const j = Re(g) ? g.filter((W) => W.node).length : 0;
+    if (Z === 1) {
+      const W = S.map((H, U) => ({
+        ...H,
+        $$columnIndex: U + j
+      }));
+      return [M(W, g, 0)];
+    }
+    let I = j;
+    const N = [], K = (W, H = 0) => {
+      N[H] = N[H] || [], W.forEach((U) => {
+        const l = { ...U };
+        l[s] ? (l.colSpan = en(
+          U[s],
+          s
+        ).length, l.$$columnIndex = [I], N[H].push(l), K(l[s], H + 1), l.$$columnIndex.push(I - 1)) : (l.rowSpan = Z - H, l.$$columnIndex = I++, N[H].push(l));
+      }), N[H] = M(
+        N[H],
+        g,
+        H
+      );
+    };
+    return K(S), N;
+  }, [
+    S,
+    s,
+    Z,
+    M,
+    g
+  ]), F];
+}
+function lo(i, c, f) {
+  const {
+    defaultExpandedRowKeys: w,
+    defaultExpandAllRows: t,
+    expandedRowRender: P,
+    onExpand: s,
+    onExpandedRowsChange: S,
+    childrenColumnName: d = "children",
+    expandProps: $
+  } = i, [E, p] = ge(
+    h()
+  ), y = i.expandedRowKeys || E;
+  function h() {
+    let g = [];
+    return i.expandedRowKeys ? g = i.expandedRowKeys : w ? g = w : t && (g = c.map((m, u) => {
+      const _ = J(m);
+      return $ && "rowExpandable" in $ && typeof $.rowExpandable == "function" ? $.rowExpandable(_) && f(m) : typeof P == "function" ? P(_, u) && f(m) : Et(m, d) && f(m);
+    }).filter((m) => m)), g;
+  }
+  function v(g) {
+    const m = y.indexOf(g) === -1, u = m ? y.concat(g) : y.filter((M) => g !== M), _ = c.filter((M) => u.indexOf(f(M)) !== -1).map((M) => f(M));
+    p(_), O(g, m), S?.(_);
+  }
+  function O(g, m) {
+    s?.(
+      J(c.find((u) => f(u) === g)),
+      m
+    );
+  }
+  return [y, v];
+}
+function tn(i) {
+  return [...new Set(i)];
+}
+function ao(i, c, f, w) {
+  const { rowSelection: t, childrenColumnName: P } = i, s = t?.selectedRowKeys, S = t?.onSelectAll, d = t?.onSelect, $ = t?.onChange, E = t?.pureKeys, p = typeof t?.checkStrictly == "boolean" ? !t.checkStrictly : !1, y = t?.preserveSelectedRowKeys;
+  function h() {
+    const l = [], x = [], b = (D) => {
+      Re(D) && D.length && D.forEach((C) => {
+        const R = w(C);
+        (t && typeof t.checkboxProps == "function" ? t.checkboxProps(J(C)) : {}).disabled || l.push(R), Et(C, i.childrenColumnName) && b(C[i.childrenColumnName]);
+      });
+    };
+    b(c);
+    const L = (D, C) => {
+      Re(D) && D.length && D.forEach((R) => {
+        if (C && p && (R.__INTERNAL_PARENT = C), x.push(R), Et(R, i.childrenColumnName)) {
+          const a = { ...R };
+          L(R[i.childrenColumnName], a);
+        }
+      });
+    };
+    return L(f, void 0), {
+      allSelectedRowKeys: l,
+      flattenData: x
+    };
+  }
+  const { allSelectedRowKeys: v, flattenData: O } = h(), [g, m] = ge([]), [u, _] = ge([]), M = Vn(
+    O,
+    tn(s || g),
+    w,
+    P,
+    p
+  ), F = p && !s ? g : M.selectedRowKeys, Z = p && !s ? u : M.indeterminateKeys, [Y, j] = ge(
+    E ? [] : I(F)
+  );
+  function I(l, x) {
+    const b = x ? Y.concat(O) : O, L = new Map(
+      b.map((D, C, R) => [w(D), D])
+    );
+    return l.map((D) => L.get(D)).filter((D) => D);
+  }
+  const N = new Set(O.map((l) => w(l)));
+  function K(l) {
+    return y ? l : l.filter((x) => N.has(x));
+  }
+  function W(l) {
+    let x = [], b = [];
+    if (l)
+      x = K(
+        tn(F.concat(v))
+      );
+    else {
+      const D = new Set(v);
+      x = K(
+        F.filter((C) => !D.has(C))
+      );
+    }
+    E || (b = I(x, !0));
+    const L = J(b);
+    m(x), j(b), _([]), $?.(x, L), S?.(l, L);
+  }
+  function H(l, x) {
+    const { selectedRowKeys: b, indeterminateKeys: L } = jn(
+      x,
+      l,
+      F,
+      u,
+      w,
+      P,
+      p
+    ), D = K(b), C = I(D, !0), R = J(C);
+    m(D), j(C), _(L), d?.(l, J(x), R), $?.(D, R);
+  }
+  function U(l, x) {
+    const b = [O.find((D) => w(D) === l)], L = J(b);
+    m([l]), d?.(!0, J(x), L), $?.([l], L);
+  }
+  return {
+    selectedRowKeys: F,
+    indeterminateKeys: Z,
+    onCheckAll: W,
+    onCheck: H,
+    onCheckRadio: U,
+    setSelectedRowKeys: m,
+    allSelectedRowKeys: v,
+    flattenData: O
+  };
+}
+function co(i, c) {
+  const [f, w] = ge(c), [t, P] = ge({}), s = he(i), S = Ze(
+    (E) => {
+      const { field: p, direction: y } = E;
+      return f.find((h) => h.field === p) ? y ? f.map(
+        (h) => h.field === p ? E : h
+      ) : f.filter((h) => h.field !== p) : y ? !gt(E.priority) || f.find((h) => !gt(h.priority)) ? [E] : [...f, E] : [...f];
+    },
+    [f]
+  ), d = Ze((E) => {
+    const p = E.filter((h) => "sortOrder" in h);
+    let y = [];
+    return p.forEach((h) => {
+      const v = Ft(h.sorter), O = h.sortOrder, g = {
+        field: h.dataIndex || h.key,
+        direction: O,
+        sorterFn: It(h.sorter),
+        priority: v
+      };
+      O ? gt(v) ? y.every((m) => gt(m.priority) || !m.direction) && y.push(g) : y.every((m) => !m.direction) ? y.push(g) : y = [g] : y.push(g);
+    }), y;
+  }, []), $ = Ze(
+    (E, p) => {
+      d(i).length || (w(p), P(E));
+    },
+    [i, d, w, P]
+  );
+  return Pt(() => {
+    const E = s.current, p = d(E), y = d(i), h = p.map(
+      (O) => O.field
+    ), v = y.filter((O) => p.find(
+      ({ field: m, direction: u }) => O.field === m && O.direction !== u
+    ) ? !0 : !h.includes(O.field));
+    v && v.length && (w(y), P({})), s.current = i;
+  }, [
+    i,
+    d,
+    S,
+    P,
+    w
+  ]), {
+    currentSorter: t,
+    activeSorters: f,
+    getNextActiveSorters: S,
+    updateStateSorters: $
+  };
+}
+function fo(i, c, f) {
+  const w = c.map((S) => S.fixed);
+  function t(S, d) {
+    return Q({
+      [`${f}-col-fixed-left`]: S.fixed === "left",
+      [`${f}-col-fixed-right`]: S.fixed === "right",
+      [`${f}-col-fixed-left-last`]: S.fixed === "left" && (Ne(c[d + 1]) ? c[d + 1].fixed !== "left" : !0),
+      [`${f}-col-fixed-right-first`]: S.fixed === "right" && (Ne(c[d - 1]) ? c[d - 1].fixed !== "right" : !0)
+    });
+  }
+  const P = ie(() => c.map(
+    (S, d) => t(S, d)
+  ), [w.join("-")]);
+  return [ie(
+    () => i.map((S) => S.map((d, $) => {
+      let E = $;
+      const p = d.$$columnIndex;
+      return Re(p) && p.length === 2 ? E = d.fixed === "right" ? p[0] : p[1] : typeof p == "number" && (E = p), t(d, E);
+    })),
+    [
+      i.map((S) => `|${S.map((d) => d.fixed || "undefined").join("-")}|`).join("_")
+    ]
+  ), P];
+}
+function po(i) {
+  const c = i.map((t) => Tt(t.width)), f = i.map((t) => t.fixed);
+  return ie(() => i.map((t) => {
+    let P = 0;
+    return t.fixed === "left" && i.some((s) => {
+      if (s.fixed === "left") {
+        if (s.key === t.key)
+          return !0;
+        const S = Tt(s.width), d = s.$$isOperation ? S || 40 : S;
+        return P += d, !1;
+      }
+      return !1;
+    }), t.fixed === "right" && [...i].reverse().some((s) => {
+      if (s.fixed === "right") {
+        if (s.key === t.key)
+          return !0;
+        const S = Tt(s.width), d = s.$$isOperation ? S || 40 : S;
+        return P += d, !1;
+      }
+      return !1;
+    }), P;
+  }), [c.join("-"), f.join("-")]);
+}
+function uo(i) {
+  return i && !Ye.isValidElement(i) && Ne(i);
+}
+function mo(i) {
+  const c = Qn(), {
+    component: f,
+    InnerComponentTd: w,
+    column: t,
+    columnIndex: P,
+    prefixCls: s,
+    stickyClassName: S,
+    stickyOffset: d,
+    currentSorter: $,
+    virtualized: E,
+    record: p,
+    trIndex: y,
+    level: h,
+    placeholder: v = "-",
+    indentSize: O,
+    renderExpandIcon: g,
+    rowKey: m,
+    recordHaveChildren: u,
+    haveTreeData: _
+  } = i, { rtl: M } = Ke(nt), F = Ke(Dt), { ComponentBodyCell: Z } = _e(f), Y = he(null), j = he(null), I = he(null), N = he(null), K = t?.tooltip?.show !== !1 && t?.ellipsis, W = Q(
+    `${s}-td`,
+    S,
+    {
+      [`${s}-col-sorted`]: $ && $.direction && $.field === t?.dataIndex
+    },
+    t?.className,
+    Qe(t?.bodyClassName) ? t.bodyClassName(p, y) : t?.bodyClassName
+  );
+  let H = {}, U, l, x = {};
+  t?.fixed === "left" && (x[M ? "right" : "left"] = d), t?.fixed === "right" && (x[M ? "left" : "right"] = d), Ne(t?.cellStyle) && (x = {
+    ...x,
+    ...t?.cellStyle
+  }), Ne(t?.bodyCellStyle) && (x = {
+    ...x,
+    ...t?.bodyCellStyle
+  }), Qe(t?.bodyCellStyle) && (x = {
+    ...x,
+    ...t?.bodyCellStyle?.(p, y) ?? {}
+  }), t?.align && (x.textAlign = t?.align), E && t.width && (x.width = t.width, x.minWidth = t.width, x.maxWidth = t.width);
+  const { onHandleSave: b, ...L } = t?.onCell ? t?.onCell(
+    p,
+    y,
+    t,
+    { rowKey: m }
+    // 潘启宝添加
+  ) ?? {} : { onHandleSave: () => {
+  } }, D = t?.render;
+  let C = ie(() => D?.(
+    Jt(p, t?.dataIndex ?? ""),
+    J(p),
+    y,
+    t,
+    // 潘启宝添加
+    { rowKey: m }
+    // 潘启宝添加
+  ), [p, t, y]);
+  if (Qe(D) || (C = Jt(p, t?.dataIndex ?? "")), uo(C) && (H = C?.props, U = H?.rowSpan, l = H?.colSpan, C = C?.children), et(() => (c(), () => {
+  }), [Y.current, j.current]), U === 0 || l === 0)
+    return null;
+  Ue(C) && (C = C.trim()), !C && C !== 0 && (C = t?.placeholder ?? v ?? "-");
+  const R = t?.ellipsis && Ue(C) && !K ? {
+    title: C
+  } : {}, a = _ && t?.$$isFirstColumn, X = a && u;
+  let q = a && h > 0 ? O * h : 0;
+  a && !u && (q += 20);
+  function ne(te) {
+    c();
+  }
+  const de = `${P}-${y}-${q}-${X}`, ee = /* @__PURE__ */ r(
+    "div",
+    {
+      ref: Y,
+      className: Q(`${s}-cell`, {
+        [`${s}-cell-text-ellipsis`]: t?.ellipsis
+      }),
+      ...R,
+      onMouseEnter: K ? ne : void 0,
+      children: /* @__PURE__ */ ce(
+        Z,
+        {
+          ref: j,
+          className: `${s}-cell-wrap-value`,
+          ...Ue(Z) ? {} : {
+            rowData: J(p),
+            column: t,
+            onHandleSave: b,
+            ...L
+          },
+          children: [
+            !!q && /* @__PURE__ */ r(
+              "span",
+              {
+                ref: I,
+                className: `${s}-cell-indent`,
+                style: { paddingLeft: q }
+              }
+            ),
+            !!X && /* @__PURE__ */ r(
+              "span",
+              {
+                ref: N,
+                className: `${s}-cell-expand-icon`,
+                children: g(p, m)
+              }
+            ),
+            i.___dangerouslySetInnerHTML___ && Ue(C) ? /* @__PURE__ */ r(
+              "span",
+              {
+                dangerouslySetInnerHTML: {
+                  __html: C
+                }
+              }
+            ) : C
+          ]
+        },
+        de
+      )
+    },
+    de
+  );
+  let oe = /* @__PURE__ */ r(
+    w,
+    {
+      className: W,
+      style: x,
+      ...An(L, [
+        "onClick",
+        "onDoubleClick",
+        "onContextMenu",
+        "onMouseOver",
+        "onMouseEnter",
+        "onMouseLeave",
+        "onMouseMove",
+        "onMouseDown",
+        "onMouseUp"
+      ]),
+      ...H,
+      children: ee
+    },
+    t?.key || t?.dataIndex || P
+  );
+  if (K) {
+    let te = 0, le = 0, se = 0, pe = 0;
+    if (Y.current instanceof Element && (te = Y.current.getBoundingClientRect().width), j.current instanceof Element && (le = j.current.getBoundingClientRect().width), I.current instanceof Element && (se = I.current.getBoundingClientRect().width), N.current instanceof Element && (pe = N.current.getBoundingClientRect().width), te < le + se + pe) {
+      const Ce = t?.tooltip?.render, G = Qe(Ce) ? Ce(p, y, t) : t?.tooltip?.content ?? Zn(oe);
+      oe = /* @__PURE__ */ r(
+        rn,
+        {
+          ...t?.tooltip,
+          className: Q(
+            `${s}-cell-tooltip`,
+            t?.tooltip?.className
+          ),
+          content: G,
+          triggerProps: F.triggerProps,
+          children: oe
+        }
+      );
+    }
+  }
+  return oe;
+}
+const ho = Ye.memo(mo);
+function yo(i, c) {
+  const {
+    expandedRowRender: f,
+    onClickExpandBtn: w,
+    columns: t,
+    component: P,
+    onCheck: s,
+    onCheckRadio: S,
+    prefixCls: d,
+    selectedRowKeys: $,
+    indeterminateKeys: E,
+    rowClassName: p,
+    onRow: y,
+    rowSelection: h,
+    indentSize: v = 16,
+    activeSorters: O,
+    virtualized: g,
+    stickyOffsets: m,
+    stickyClassNames: u,
+    getRowKey: _,
+    placeholder: M,
+    expandProps: F = { strictTreeData: !0 },
+    data: Z,
+    expandedRowKeys: Y,
+    childrenColumnName: j,
+    record: I,
+    index: N,
+    type: K,
+    shouldRowExpand: W,
+    level: H
+  } = i, { rtl: U } = Ke(nt), l = J(I), { ...x } = y?.(l, N) || {}, b = _(I), L = K === "radio" ? $.slice(0, 1) : $, D = b || N, C = L.indexOf(b) > -1, R = Y.indexOf(b) > -1, a = E.indexOf(b) > -1, X = Q(
+    `${d}-tr`,
+    {
+      [`${d}-row-checked`]: C,
+      [`${d}-row-expanded`]: R
+    },
+    p?.(l, N)
+  ), q = h && typeof h.checkboxProps == "function" ? h.checkboxProps(l) : {}, ne = Q(`${d}-td`, `${d}-operation`), de = (T) => Q(ne, `${d}-${T}`, {
+    [`${d}-selection-col`]: g && K === "checkbox" || K === "radio",
+    [`${d}-expand-icon-col`]: g && f
+  });
+  function ee(T) {
+    return F.strictTreeData ? Re(T[j]) && T[j].length : T[j] !== void 0;
+  }
+  function oe() {
+    return Z.find((T) => ee(T));
+  }
+  const te = W(I, N), le = ee(I), se = oe() && !f, pe = se && le, G = F.expandRowByClick && (te || pe) ? {
+    onClick: (T) => {
+      w(b), x?.onClick?.(T);
+    }
+  } : {}, { ComponentBodyRow: Be, ComponentTd: qe, getBodyComponentOperations: we } = _e(P), ve = g ? "div" : Be, fe = g ? "div" : qe, Se = {
+    className: X,
+    key: D,
+    ...x,
+    ...G
+  }, Te = Ue(Be) ? Se : { ...Se, record: I, index: N };
+  function ke(T, ae) {
+    const { icon: re } = F, Ee = !!~Y.indexOf(ae), Fe = {
+      onClick: (me) => {
+        me.stopPropagation(), w(ae);
+      }
+    };
+    return typeof re == "function" ? re({ expanded: Ee, record: T, ...Fe }) : /* @__PURE__ */ r("button", { ...Fe, type: "button", children: Ee ? /* @__PURE__ */ r(Gn, {}) : /* @__PURE__ */ r(Jn, {}) });
+  }
+  const He = f && /* @__PURE__ */ r(fe, { className: de("expand-icon-cell"), children: te && ke(I, b) }), be = h && h.renderCell;
+  let Pe;
+  const Le = /* @__PURE__ */ r(
+    Kt,
+    {
+      value: b,
+      onChange: (T) => s(T, I),
+      checked: C,
+      indeterminate: a,
+      ...q
+    }
+  ), A = /* @__PURE__ */ r(
+    on,
+    {
+      onChange: () => S(b, I),
+      value: b,
+      checked: C,
+      ...q
+    }
+  );
+  K === "checkbox" && (Pe = /* @__PURE__ */ r(fe, { className: de("checkbox"), children: be ? be(Le, C, l) : Le })), K === "radio" && (Pe = /* @__PURE__ */ r(fe, { className: de("radio"), children: be ? be(A, C, l) : A }));
+  const ue = we({
+    selectionNode: Pe,
+    expandNode: He
+  });
+  return /* @__PURE__ */ tt(ve, { ...Te, key: Te.key, ref: c }, t.map((T, ae) => {
+    const re = `${T.key}-${T.dataIndex}-${T.title}-${ae}`, Ee = m[ae], Fe = u[ae];
+    if (T.$$isOperation) {
+      let me = T.node, Xe = !0;
+      T.title === wt && (me = ue.find((Ie) => Ie.name === "selectionNode")?.node, Xe = !1), T.title === Ct && (me = ue.find((Ie) => Ie.name === "expandNode")?.node, Xe = !1);
+      const Ae = typeof me == "function" ? me(I) : me;
+      return Ye.cloneElement(Ae, {
+        key: re || ae,
+        ...Ae.props,
+        className: Q(
+          Xe ? ne : "",
+          Ae?.props?.className,
+          Fe
+        ),
+        style: {
+          ...Ae?.props?.style,
+          ...T.fixed === "left" ? {
+            [U ? "right" : "left"]: Ee
+          } : {},
+          width: T.width,
+          minWidth: T.width
+        }
+      });
+    }
+    return /* @__PURE__ */ r(
+      ho,
+      {
+        prefixCls: d,
+        virtualized: g,
+        component: P,
+        currentSorter: O.find(
+          (me) => me.field === (T.dataIndex || T.key)
+        ),
+        placeholder: M,
+        indentSize: v,
+        stickyClassName: Fe,
+        stickyOffset: Ee,
+        InnerComponentTd: fe,
+        column: T,
+        columnIndex: ae,
+        record: I,
+        trIndex: N,
+        level: H,
+        haveTreeData: se,
+        recordHaveChildren: le,
+        rowKey: b,
+        renderExpandIcon: ke,
+        ___dangerouslySetInnerHTML___: i.___dangerouslySetInnerHTML___
+      },
+      re
+    );
+  }));
+}
+const nn = Ot(yo), go = Ot(function({
+  record: c,
+  index: f,
+  virtualized: w,
+  tbodyProps: t
+}, P) {
+  const {
+    prefixCls: s,
+    columns: S,
+    indentSize: d = 16,
+    childrenColumnName: $ = "children",
+    expandProps: E = {},
+    rowSelection: p,
+    hasFixedColumn: y,
+    tableViewWidth: h,
+    getRowKey: v,
+    expandedRowKeys: O,
+    expandedRowRender: g
+  } = t;
+  let m;
+  p && "type" in p ? m = p.type : p && !("type" in p) && (m = "checkbox");
+  const u = g && ((N, K) => g(J(N), K)), _ = (N) => Re(N[$]) && N[$].length, M = (N, K) => "rowExpandable" in E && typeof E.rowExpandable == "function" ? E.rowExpandable(N) : u?.(N, K) !== null, F = (N, K) => {
+    const W = [], H = {
+      ...t,
+      type: m,
+      shouldRowExpand: M
+    };
+    W.push(
+      /* @__PURE__ */ r(
+        nn,
+        {
+          ref: P,
+          ...H,
+          record: N,
+          level: 0,
+          index: K
+        },
+        v(N)
+      )
+    );
+    const U = (l, x, b = 0) => {
+      Re(l) && l.length && l.forEach((L, D) => {
+        O.indexOf(x) !== -1 && (W.push(
+          /* @__PURE__ */ tt(
+            nn,
+            {
+              ...H,
+              key: v(L),
+              record: L,
+              level: b + 1,
+              index: D
+            }
+          )
+        ), _(L) && U(L[$], v(L), b + 1));
+      });
+    };
+    return u || U(N[$], v(N)), W;
+  }, Z = v(c), Y = M(c, f) && O.indexOf(Z) !== -1, j = w ? "div" : "tr", I = w ? "div" : "td";
+  return /* @__PURE__ */ ce(Ye.Fragment, { children: [
+    F(c, f),
+    Y && /* @__PURE__ */ r(
+      j,
+      {
+        className: Q(`${s}-tr`, `${s}-expand-content`),
+        children: /* @__PURE__ */ r(
+          I,
+          {
+            className: Q(`${s}-td`),
+            style: { paddingLeft: d },
+            colSpan: S.length,
+            children: y ? /* @__PURE__ */ r(
+              "div",
+              {
+                className: `${s}-expand-fixed-row`,
+                style: { width: h },
+                children: u?.(c, f)
+              }
+            ) : u?.(c, f)
+          }
+        )
+      },
+      `${Z}-expanded`
+    )
+  ] }, Z);
+});
+function xo(i) {
+  const {
+    data: c,
+    columns: f,
+    prefixCls: w,
+    component: t,
+    noDataElement: P,
+    scroll: s,
+    tableViewWidth: S,
+    virtualized: d,
+    virtualListProps: $,
+    getRowKey: E,
+    saveVirtualListRef: p
+  } = i, y = (_) => {
+    i.saveRef?.(_);
+  }, { ComponentTbody: h } = _e(t);
+  let v = {}, O = {};
+  s && (s.x && (typeof s.x == "number" || typeof s.x == "string") && (v = {
+    width: s.x
+  }), s.y && (typeof s.y == "number" || typeof s.y == "string") && (O = {
+    maxHeight: s.y
+  }));
+  const g = {
+    className: `${w}-no-data`
+  };
+  S && (g.className = `${w}-no-data ${w}-expand-fixed-row`, g.style = { width: S });
+  const m = /* @__PURE__ */ r("tr", { className: Q(`${w}-tr`, `${w}-empty-row`), children: /* @__PURE__ */ r("td", { className: `${w}-td`, colSpan: f.length, children: /* @__PURE__ */ r("div", { ...g, children: P }) }) }), u = (_, M) => {
+    const F = E(_) ?? M;
+    return /* @__PURE__ */ r(
+      go,
+      {
+        record: _,
+        index: M,
+        virtualized: d,
+        tbodyProps: i
+      },
+      F
+    );
+  };
+  return d ? c.length > 0 ? /* @__PURE__ */ r(
+    Xn,
+    {
+      data: c,
+      height: O.maxHeight,
+      isStaticItemHeight: !1,
+      outerStyle: { ...v, minWidth: "100%", overflow: "visible" },
+      innerStyle: { right: "auto", minWidth: "100%" },
+      className: `${w}-body`,
+      ref: (_) => {
+        p(_), y(_?.dom);
+      },
+      itemKey: E,
+      ...$,
+      children: u
+    }
+  ) : /* @__PURE__ */ r("div", { className: `${w}-body`, ref: y, children: /* @__PURE__ */ r("table", { children: /* @__PURE__ */ r("tbody", { children: m }) }) }) : /* @__PURE__ */ r(h, { ref: y, children: c.length > 0 ? c.map(u) : m });
+}
+const Co = _n({});
+function wo(i) {
+  const { summary: c, data: f, prefixCls: w, columns: t, stickyOffsets: P, stickyClassNames: s } = i;
+  return /* @__PURE__ */ r("tfoot", { className: `${w}-tfoot`, children: /* @__PURE__ */ r(
+    Co.Provider,
+    {
+      value: { columns: t, stickyOffsets: P, stickyClassNames: s, prefixCls: w },
+      children: c(J(f))
+    }
+  ) });
+}
+function So(i, c) {
+  return i === "ascend" ? c?.Table.sortAscend : i === "descend" ? c?.Table.sortDescend : c?.Table.cancelSort;
+}
+const bo = { bottom: 0 };
+function $o(i) {
+  const {
+    onSort: c,
+    onFilter: f,
+    onHandleFilter: w,
+    onHandleFilterReset: t,
+    currentFilters: P = {},
+    currentSorter: s,
+    _key: S,
+    dataIndex: d,
+    title: $,
+    sorter: E,
+    sortDirections: p = ["ascend", "descend"],
+    filters: y = [],
+    columnFixedStyle: h,
+    className: v,
+    headerClassName: O,
+    cellStyle: g,
+    headerCellStyle: m,
+    rowSpan: u,
+    colSpan: _,
+    headerCellProps: M,
+    prefixCls: F,
+    align: Z = "left",
+    component: Y,
+    filterIcon: j,
+    filterDropdown: I,
+    filterMultiple: N = !0,
+    ellipsis: K,
+    filterDropdownProps: W,
+    onFilterDropdownVisibleChange: H,
+    column: U,
+    showSorterTooltip: l,
+    index: x
+  } = i, { locale: b, rtl: L } = Ke(nt), D = Ke(Dt), C = S || d || x, [R, a, X] = oo([], {
+    value: P[C] || []
+  }), [q, ne] = ge(!1), [de, ee] = ge(!1), oe = E && Re(p) && p.length, te = oe ? le() : void 0;
+  et(() => {
+    a(P[C] || []);
+  }, [P, C]), et(() => {
+    R && R !== X && a(R);
+  }, [q]);
+  function le() {
+    const A = s && s.direction;
+    if (!A || s && s.field !== C)
+      return p[0];
+    const ue = p.indexOf(A);
+    if (ue < p.length)
+      return p[ue + 1];
+  }
+  function se() {
+    R && (w?.(
+      { onFilter: f, filters: y, dataIndex: C },
+      X
+    ), Ce(!1));
+  }
+  function pe() {
+    t({ dataIndex: C }), Ce(!1);
+  }
+  function Ce(A) {
+    ne(A), H?.(A);
+  }
+  function G(A, ue) {
+    let T = [...X];
+    if (N)
+      ue ? T = T.concat(A) : T.splice(
+        T.findIndex((ae) => ae === A),
+        1
+      );
+    else if (T.length > 0)
+      if (T[0] !== A)
+        T = [A];
+      else
+        return;
+    else
+      T = [A];
+    a(T);
+  }
+  function Be(A) {
+    a(A || X), ne(!1), w?.(
+      { filters: y, onFilter: f, dataIndex: C },
+      A || X
+    );
+  }
+  function qe() {
+    return typeof I == "function" ? I({
+      filterKeys: X,
+      setFilterKeys: (A, ue) => {
+        a(A), ue?.();
+      },
+      confirm: Be
+    }) : /* @__PURE__ */ ce("div", { className: `${F}-filters-popup`, children: [
+      /* @__PURE__ */ r("div", { className: `${F}-filters-list`, children: y.map((A) => {
+        const ue = X.findIndex((T) => T === A.value) !== -1;
+        return /* @__PURE__ */ r("div", { className: `${F}-filters-item`, children: N ? /* @__PURE__ */ r(
+          Kt,
+          {
+            checked: ue,
+            onChange: (T) => G(A.value, T),
+            children: A.text
+          }
+        ) : /* @__PURE__ */ r(
+          on,
+          {
+            checked: ue,
+            onChange: (T) => G(A.value, T),
+            children: A.text
+          }
+        ) }, A.value);
+      }) }),
+      /* @__PURE__ */ ce(ro, { className: `${F}-filters-btn`, children: [
+        /* @__PURE__ */ r(Qt, { onClick: pe, size: "mini", children: b?.Table.resetText }),
+        /* @__PURE__ */ r(Qt, { onClick: se, type: "primary", size: "mini", children: b?.Table.okText })
+      ] })
+    ] });
+  }
+  const we = (A) => Q(`${F}-sorter-icon`, {
+    [`${F}-sorter-icon-active`]: s && s.direction === A && s.field === C
+  }), ve = Q(`${F}-filters`, {
+    [`${F}-filters-open`]: q,
+    [`${F}-filters-active`]: R && R.length
+  });
+  let fe = {
+    ...h
+  };
+  Ne(g) && (fe = {
+    ...fe,
+    ...g
+  }), Ne(m) && (fe = {
+    ...fe,
+    ...m
+  }), Qe(m) && (fe = {
+    ...fe,
+    ...m()
+  }), Z && Z !== "left" && (fe.textAlign = Z);
+  const Se = {
+    style: fe,
+    key: S || C
+  };
+  _ && _ > 1 && (Se.colSpan = _), u && u > 1 && (Se.rowSpan = u);
+  const { ComponentTh: Te, ComponentHeaderCell: ke } = _e(Y), He = Re(y) && y.length > 0 || typeof I == "function", be = K && typeof $ == "string" ? { title: $ } : {}, Pe = /* @__PURE__ */ ce(xt, { children: [
+    oe ? /* @__PURE__ */ r(
+      rn,
+      {
+        content: So(te, b),
+        disabled: !l,
+        triggerProps: D.triggerProps,
+        ...Ne(l) ? l : {},
+        children: /* @__PURE__ */ ce(
+          "div",
+          {
+            className: `${F}-cell-with-sorter`,
+            onMouseEnter: () => {
+              ee(!0);
+            },
+            onMouseLeave: () => {
+              ee(!1);
+            },
+            onClick: () => c(te, C),
+            children: [
+              /* @__PURE__ */ r("span", { className: `${F}-th-item-title`, ...be, children: $ }),
+              oe && /* @__PURE__ */ ce(
+                "div",
+                {
+                  className: Q(`${F}-sorter`, {
+                    [`${F}-sorter-direction-one`]: p.length === 1
+                  }),
+                  children: [
+                    p.indexOf("ascend") !== -1 && /* @__PURE__ */ r("div", { className: we("ascend"), children: /* @__PURE__ */ r(to, {}) }),
+                    p.indexOf("descend") !== -1 && /* @__PURE__ */ r("div", { className: we("descend"), children: /* @__PURE__ */ r(eo, {}) })
+                  ]
+                }
+              )
+            ]
+          }
+        )
+      }
+    ) : /* @__PURE__ */ r("span", { className: `${F}-th-item-title`, ...be, children: $ }),
+    He && /* @__PURE__ */ r(
+      so,
+      {
+        popup: qe,
+        trigger: "click",
+        classNames: "slideDynamicOrigin",
+        position: L ? "bl" : "br",
+        popupAlign: bo,
+        popupVisible: q,
+        onVisibleChange: Ce,
+        ...D.triggerProps,
+        ...W?.triggerProps,
+        children: /* @__PURE__ */ r("div", { className: ve, children: j || /* @__PURE__ */ r(no, {}) })
+      }
+    )
+  ] }), Le = Q(`${F}-th-item`, {
+    [`${F}-cell-text-ellipsis`]: K,
+    [`${F}-cell-mouseenter`]: de,
+    [`${F}-cell-next-${te}`]: de && te,
+    [`${F}-col-has-sorter`]: oe,
+    [`${F}-col-has-filter`]: He
+  });
+  return _ !== 0 && /* @__PURE__ */ tt(
+    Te,
+    {
+      className: Q(
+        `${F}-th`,
+        {
+          [`${F}-col-sorted`]: s?.direction && s.field === C
+        },
+        v,
+        O
+      ),
+      index: x,
+      ...Se,
+      key: Se.key,
+      ...M
+    },
+    /* @__PURE__ */ r(
+      ke,
+      {
+        className: Le,
+        column: Ue(ke) ? void 0 : U,
+        children: Pe
+      }
+    )
+  );
+}
+function No(i) {
+  const {
+    activeSorters: c,
+    expandedRowRender: f,
+    expandProps: w = {},
+    onSort: t,
+    onHandleFilter: P,
+    onHandleFilterReset: s,
+    onHeaderRow: S,
+    prefixCls: d,
+    currentFilters: $,
+    component: E,
+    data: p,
+    selectedRowKeys: y,
+    rowSelection: h,
+    allSelectedRowKeys: v = [],
+    groupColumns: O,
+    stickyOffsets: g,
+    groupStickyClassNames: m,
+    showSorterTooltip: u
+  } = i, { rtl: _ } = Ke(nt), { ComponentThead: M, ComponentHeaderRow: F, getHeaderComponentOperations: Z } = _e(E), Y = h && (h.type === "checkbox" || !("type" in h)), j = h && "checkAll" in h ? h.checkAll : !0, I = h && h.type === "radio", { columnTitle: N } = w, K = ie(() => {
+    const U = new Set(v);
+    return y.filter((l, x, b) => U.has(l));
+  }, [y, v]), W = O.length > 1 ? { rowSpan: O.length } : {}, H = Q(`${d}-th`, `${d}-operation`);
+  return /* @__PURE__ */ r(M, { children: O.map((U, l) => {
+    const x = S?.(U, l), b = (Y || I) && l === 0 && /* @__PURE__ */ r(
+      "th",
+      {
+        className: Q(
+          H,
+          `${d}-${I ? "radio" : "checkbox"}`
+        ),
+        children: /* @__PURE__ */ ce("div", { className: `${d}-th-item`, children: [
+          j && !I ? /* @__PURE__ */ r(
+            Kt,
+            {
+              indeterminate: p && K.length > 0 && K.length !== v.length,
+              checked: p && K.length !== 0 && K.length === v.length,
+              disabled: !v.length,
+              onChange: i.onCheckAll
+            }
+          ) : null,
+          h && h.columnTitle
+        ] })
+      }
+    ), L = f && /* @__PURE__ */ r("th", { className: Q(H, `${d}-expand`), children: N && /* @__PURE__ */ r("div", { className: `${d}-th-item`, children: N }) }), D = m[l], C = Z({
+      selectionNode: b,
+      expandNode: L
+    });
+    return /* @__PURE__ */ tt(
+      F,
+      {
+        ...x,
+        key: l,
+        className: `${d}-tr`
+      },
+      U.map((R, a) => {
+        const X = R.$$columnIndex;
+        let q = 0;
+        je(X) && X.length === 2 ? q = R.fixed === "right" ? g[X[1]] : g[X[0]] : typeof X == "number" && (q = g[X] || 0);
+        const ne = D[a];
+        if (R.$$isOperation) {
+          let te = R.node, le = !0;
+          R.title === wt && (te = C.find(
+            (pe) => pe.name === "selectionNode"
+          )?.node, le = !1), R.title === Ct && (te = C.find(
+            (pe) => pe.name === "expandNode"
+          )?.node, le = !1);
+          const se = te;
+          return Ye.cloneElement(se, {
+            key: R.key || a,
+            ...se.props,
+            ...W,
+            className: Q(
+              le ? H : "",
+              se?.props?.className,
+              ne
+            ),
+            style: {
+              ...se?.props?.style,
+              ...R.fixed === "left" ? {
+                [_ ? "right" : "left"]: q
+              } : {},
+              width: R.width,
+              minWidth: R.width
+            }
+          });
+        }
+        const de = R?.onHeaderCell?.(R, a), ee = Q(ne, R.className), oe = {};
+        return R.fixed === "left" && (oe[_ ? "right" : "left"] = q), R.fixed === "right" && (oe[_ ? "left" : "right"] = q), /* @__PURE__ */ tt(
+          $o,
+          {
+            index: a,
+            onSort: t,
+            onHandleFilter: P,
+            onHandleFilterReset: s,
+            currentSorter: c.find(
+              (te) => te.field === (R.dataIndex || R.key)
+            ),
+            currentFilters: $,
+            _key: R.key || R.dataIndex || a,
+            ...R,
+            key: R.key,
+            column: R,
+            headerCellProps: de,
+            prefixCls: d,
+            component: E,
+            className: ee,
+            columnFixedStyle: oe,
+            showSorterTooltip: u
+          }
+        );
+      })
+    );
+  }) });
+}
+const Ro = [], ko = [], vo = {
+  showHeader: !0,
+  border: !0,
+  hover: !0,
+  rowKey: "key",
+  pagePosition: "br",
+  childrenColumnName: "children",
+  indentSize: 15,
+  showSorterTooltip: !0
+};
+function To(i, c) {
+  const {
+    getPrefixCls: f,
+    loadingElement: w,
+    size: t,
+    tablePagination: P,
+    renderEmpty: s,
+    componentConfig: S,
+    rtl: d
+  } = Ke(nt), $ = qt(
+    i,
+    vo,
+    S?.Table
+  ), E = qt(
+    ye(i?.pagination) ? i?.pagination : {},
+    ye(S?.Table?.pagination) ? S?.Table?.pagination : {},
+    P || {}
+  ), {
+    style: p,
+    className: y,
+    component: h,
+    border: v,
+    borderCell: O,
+    columns: g = ko,
+    data: m = Ro,
+    scroll: u,
+    noDataElement: _,
+    showHeader: M,
+    stripe: F,
+    hover: Z,
+    pagination: Y,
+    onChange: j,
+    pagePosition: I,
+    childrenColumnName: N,
+    indentSize: K,
+    rowSelection: W,
+    tableLayoutFixed: H,
+    header: U,
+    // 潘启宝添加
+    footer: l,
+    virtualized: x,
+    renderPagination: b,
+    summary: L,
+    rowKey: D,
+    triggerProps: C
+  } = $, R = ie(
+    () => Un(m, N),
+    [m, N]
+  ), a = f?.("table"), X = $.size || (["default", "middle", "small", "mini"].indexOf(t) > -1 ? t : "default"), q = he(null), ne = he(null), de = he(null), ee = he(null), oe = he(null), te = he(null), le = he(null), se = he(0), pe = he(!1), [Ce, G] = io($), { currentFilters: Be, defaultSorters: qe } = ln(), [we, ve] = ge(1), [fe, Se] = ge(
+    E.pageSize || E.defaultPageSize || 10
+  ), [Te, ke] = ge(Be), [He, be] = ge(0), [Pe, Le] = ge([]), A = po(G), [ue, T] = fo(
+    Ce,
+    G,
+    a
+  ), {
+    currentSorter: ae,
+    activeSorters: re,
+    getNextActiveSorters: Ee,
+    updateStateSorters: Fe
+  } = co(G, qe), { ComponentTable: me, ComponentBodyWrapper: Xe, ComponentHeaderWrapper: Ae } = _e(h), Ie = ie(() => De(D) ? (e) => D(J(e)) : (e) => e[D], [D]);
+  function ln() {
+    const e = {};
+    let n = [];
+    return G.forEach((o) => {
+      const k = o.dataIndex || o.key;
+      if (o.defaultFilters && (e[k] = o.defaultFilters), o.filteredValue && (e[k] = o.filteredValue), "defaultSortOrder" in o || "sortOrder" in o) {
+        const B = Ft(o.sorter), V = "sortOrder" in o ? o.sortOrder : o.defaultSortOrder, z = {
+          field: k,
+          direction: V,
+          sorterFn: It(o.sorter),
+          priority: B
+        };
+        V ? Zt(B) ? n.every(
+          (xe) => Zt(xe.priority) || !xe.direction
+        ) && n.push(z) : n.every((xe) => !xe.direction) ? n.push(z) : n = [z] : n.push(z);
+      }
+    }), { currentFilters: e, defaultSorters: n };
+  }
+  const ot = ie(() => {
+    const e = G.filter(
+      (o) => "filteredValue" in o
+    ), n = {};
+    return e.length && e.forEach((o, k) => {
+      const B = o.key || o.dataIndex || k;
+      B !== void 0 && (n[B] = o.filteredValue);
+    }), n;
+  }, [G]), Oe = ie(() => Object.keys(ot).length ? ot : Te, [Te, ot]);
+  function an(e, n) {
+    const o = Mt(n);
+    if (!o) return;
+    const k = {
+      direction: e,
+      field: n,
+      sorterFn: It(o.sorter),
+      priority: Ft(o.sorter)
+    }, B = Ee(k);
+    Fe(k, B);
+    const V = lt(
+      k,
+      B,
+      Oe
+    ), z = Ge(V);
+    j?.(We(V), k, Oe, {
+      currentData: J(z),
+      currentAllData: J(V),
+      action: "sort"
+    });
+  }
+  function cn(e) {
+    const n = function(k, B) {
+      return (V, z) => {
+        const xe = k(V, z);
+        return B === "descend" ? -xe : xe;
+      };
+    }, o = [...e];
+    return o.sort((k, B) => B.priority - k.priority), (k, B) => {
+      for (let V = 0, z = o.length; V < z; V++) {
+        const { sorterFn: xe, direction: vt } = o[V];
+        if (!De(xe)) continue;
+        const ut = n(xe, vt)(k, B);
+        if (ut !== 0)
+          return ut;
+      }
+      return 0;
+    };
+  }
+  function dn(e, n) {
+    const o = {
+      ...Oe,
+      [e.dataIndex]: n
+    }, k = {
+      ...o,
+      ...ot
+    };
+    if (je(n) && n.length) {
+      ke(k);
+      const B = lt(
+        ae,
+        re,
+        o
+      ), V = Ge(B);
+      j?.(
+        We(B),
+        re.length === 1 ? re[0] : re,
+        o,
+        {
+          currentData: J(V),
+          currentAllData: J(B),
+          action: "filter"
+        }
+      );
+    } else je(n) && !n.length && _t(e);
+  }
+  function _t({ dataIndex: e }) {
+    const n = {
+      ...Oe
+    };
+    delete n[e], ke(n);
+    const o = lt(
+      ae,
+      re,
+      n
+    ), k = Ge(o);
+    j?.(
+      We(o),
+      re.length === 1 ? re[0] : re,
+      n,
+      {
+        currentData: J(k),
+        currentAllData: J(o),
+        action: "filter"
+      }
+    );
+  }
+  const rt = !!G.find((e) => e.fixed === "left"), st = !!G.find((e) => e.fixed === "right"), it = rt || st;
+  function lt(e, n, o) {
+    let k = (R || []).slice();
+    Object.keys(o).forEach((V) => {
+      if (o[V] && o[V].length) {
+        const z = Mt(V);
+        z && De(z.onFilter) && (k = k.filter((xe) => o[V].reduce(
+          (vt, ut) => vt || z.onFilter(ut, xe),
+          !1
+        )));
+      }
+    });
+    const B = (V) => V.slice().sort(cn(n)).map((z) => je(z[N]) ? {
+      ...z,
+      [N]: B(z[N])
+    } : z);
+    return e.direction && De(e.sorterFn) || n.length ? B(k) : k;
+  }
+  const Me = lt(
+    ae,
+    re,
+    Oe
+  );
+  function We(e = Me) {
+    const n = E.pageSize || fe || 10, o = X === "middle" ? "default" : X;
+    let k = "top";
+    I === "tl" || I === "bl" ? k = "bottom" : k = "top";
+    const B = je(e) ? e.length : 0, V = Math.ceil(B / n) < we ? 1 : we;
+    V !== we && ve(V);
+    let z = {
+      size: o,
+      total: B,
+      pageSize: n,
+      current: V,
+      selectProps: {
+        triggerProps: {
+          ...C,
+          position: k
+        }
+      }
+    };
+    return typeof Y == "object" && Y.selectProps && (z.selectProps = {
+      ...z.selectProps,
+      ...Y.selectProps
+    }), ye(Y) && (z = {
+      ...z,
+      ...Y
+    }), ye(E) && (z = {
+      ...z,
+      ...E
+    }), z.onChange = wn, z;
+  }
+  const at = We(), ze = Ge();
+  function Ge(e = Me, n = at) {
+    const { current: o = 0, pageSize: k = 10 } = n;
+    return Y === !1 || ye(Y) && m.length <= k ? e : e.slice((o - 1) * k, o * k);
+  }
+  const Bt = Dn(Ht, 100), $e = !!(u && u.y), Je = L?.(J(Me)), St = L && Ye.isValidElement(Je) && Je.props.fixed, fn = $e && St;
+  Hn(() => {
+    Ht(), mt(window, "resize", Bt);
+    const e = q.current, n = ne.current, o = ee.current;
+    n && mt(n, "scroll", Ve);
+    const k = e && e.parentNode;
+    return e && k && mt(k, "scroll", Ve), o && mt(o, "scroll", Ve), () => {
+      ht(window, "resize", Bt), n && ht(n, "scroll", Ve), k && ht(k, "scroll", Ve), o && ht(o, "scroll", Ve);
+    };
+  }, [
+    rt,
+    st,
+    u?.x,
+    u?.y,
+    G.length,
+    m
+  ]), Pt(() => {
+    const { total: e, pageSize: n } = We(m);
+    Math.ceil(e / n) < we && ve(1);
+  }, [m?.length]), Pt(() => {
+    ct();
+  }, [m, rt, st, d]), Bn(c, () => ({
+    getRootDomElement: bt,
+    scrollIntoView: (e) => {
+      te.current && te.current.scrollTo({ key: e });
+    },
+    getRootDOMNode: bt
+  }));
+  function bt() {
+    return oe.current;
+  }
+  function Ht() {
+    ct();
+    const e = bt();
+    if (e && (it || u && u.x)) {
+      const o = (e.querySelector(`.${a}-body`) || e.querySelector(`.${a}-content-inner`))?.getBoundingClientRect?.()?.width;
+      be(o);
+    }
+  }
+  const pn = Ze(
+    Kn(() => {
+      const e = oe.current, n = $e ? ne.current : le.current && le.current.parentNode;
+      if (n) {
+        const o = d ? -n.scrollLeft : n.scrollLeft, k = o === 0, B = o + 1 >= n.children[0].getBoundingClientRect().width - n.getBoundingClientRect().width;
+        k && B ? dt(
+          e.classList,
+          `${a}-scroll-position-both`
+        ) : k ? dt(
+          e.classList,
+          `${a}-scroll-position-${d ? "right" : "left"}`
+        ) : B ? dt(
+          e.classList,
+          `${a}-scroll-position-${d ? "left" : "right"}`
+        ) : dt(
+          e.classList,
+          `${a}-scroll-position-middle`
+        );
+      } else
+        e && At(e.classList);
+    }, 100),
+    [oe.current, ne.current, $e, d]
+  );
+  function ct() {
+    if (it || u && ye(u) && u.x) {
+      const e = oe.current;
+      e && (rt && Lt(
+        e.classList,
+        `${a}-has-fixed-col-left`
+      ), st && Lt(
+        e.classList,
+        `${a}-has-fixed-col-right`
+      )), pn();
+    }
+  }
+  function Lt(e, n) {
+    e.contains(n) || e.add(n);
+  }
+  function At(e) {
+    e.remove(`${a}-scroll-position-both`), e.remove(`${a}-scroll-position-left`), e.remove(`${a}-scroll-position-right`), e.remove(`${a}-scroll-position-middle`);
+  }
+  function dt(e, n) {
+    e.contains(n) || (At(e), e.add(n));
+  }
+  const {
+    selectedRowKeys: $t,
+    indeterminateKeys: un,
+    onCheckAll: mn,
+    onCheck: hn,
+    onCheckRadio: yn,
+    setSelectedRowKeys: gn,
+    allSelectedRowKeys: xn,
+    flattenData: Cn
+  } = ao($, ze, R, Ie);
+  function Mt(e) {
+    return G.find((n, o) => typeof n.key < "u" ? typeof n.key == "number" && typeof e == "string" ? n.key.toString() === e : n.key === e : typeof n.dataIndex < "u" ? n.dataIndex === e : typeof e == "number" ? o === e : !1);
+  }
+  function wn(e, n) {
+    ve(e), Se(n), e !== we && Sn(), W && !W.checkCrossPage && $t.length && (gn([]), W.onChange?.([], []));
+    const o = { ...We(), current: e, pageSize: n };
+    j?.(
+      o,
+      re.length === 1 ? re[0] : re,
+      Oe,
+      {
+        currentData: J(
+          Ge(Me, o)
+        ),
+        currentAllData: J(Me),
+        action: "paginate"
+      }
+    ), E.onChange?.(e, n);
+  }
+  function Sn() {
+    const e = ne.current;
+    e && e.scrollTo({ top: 0, behavior: "smooth" });
+  }
+  function Ve(e) {
+    const { target: n } = e, o = ne.current, k = q.current && q.current.parentNode, B = ee.current;
+    n.scrollLeft !== se.current && (k && (k.scrollLeft = n.scrollLeft), o && (o.scrollLeft = n.scrollLeft), B && (B.scrollLeft = n.scrollLeft), ct()), se.current = e.target.scrollLeft;
+  }
+  function bn(e) {
+    const { target: n } = e, o = le.current;
+    n.scrollLeft !== se.current && (o.scrollLeft = n.scrollLeft, ct()), se.current = e.target.scrollLeft;
+  }
+  const [Wt, $n] = lo(
+    $,
+    Cn,
+    Ie
+  );
+  let zt = {}, Nt = {};
+  u && (u.x && (typeof u.x == "number" || typeof u.x == "string") && (Nt = {
+    width: u.x
+  }), u.y && (typeof u.y == "number" || typeof u.y == "string") && (zt = {
+    maxHeight: u.y
+  }));
+  function Nn() {
+    requestAnimationFrame((e) => {
+      const n = q.current && q.current.parentNode, o = Yn(n);
+      o && o > 0 && (n.style.marginBottom = `-${o}px`, n.style.paddingBottom = "0px", ee.current && (ee.current.style.marginBottom = `-${o}px`, ee.current.style.paddingBottom = "0px")), setTimeout(() => {
+        const k = ne.current;
+        qn(k) ? (pe.current = !0, n && (n.style.overflowY = "scroll", n.style.scrollSnapType = "y mandatory"), ee.current && (ee.current.style.overflowY = "scroll", ee.current.style.overflowY = "y mandatory")) : n && pe.current && (pe.current = !1, n.style.overflowY = "auto", n.style.overflowY = "y mandatory", ee.current && (ee.current.style.overflowY = "auto", ee.current.style.overflowY = "y mandatory"));
+      }, 0);
+    });
+  }
+  const Vt = /* @__PURE__ */ r(
+    No,
+    {
+      ...$,
+      activeSorters: re,
+      currentSorter: ae,
+      selectedRowKeys: $t,
+      currentFilters: Oe,
+      onCheckAll: mn,
+      onSort: an,
+      data: ze,
+      onHandleFilter: dn,
+      onHandleFilterReset: _t,
+      prefixCls: a,
+      allSelectedRowKeys: xn,
+      groupColumns: Ce,
+      stickyOffsets: A,
+      groupStickyClassNames: ue
+    }
+  );
+  function Rn() {
+    const e = ye(u) && u.x === "max-content";
+    return $e || x ? /* @__PURE__ */ r(Ae, { className: `${a}-header`, children: /* @__PURE__ */ ce(
+      me,
+      {
+        ref: q,
+        style: e ? {} : Nt,
+        children: [
+          /* @__PURE__ */ r(
+            yt,
+            {
+              columns: G,
+              prefixCls: a,
+              producer: !1,
+              columnWidths: e && u.y ? Pe : null
+            }
+          ),
+          Vt
+        ]
+      }
+    ) }) : Vt;
+  }
+  const jt = Je && /* @__PURE__ */ r(
+    wo,
+    {
+      prefixCls: a,
+      summary: L,
+      data: ze,
+      columns: G,
+      stickyOffsets: A,
+      stickyClassNames: T
+    }
+  ), Ut = /* @__PURE__ */ r(
+    xo,
+    {
+      ...$,
+      saveRef: (e) => de.current = e,
+      selectedRowKeys: $t,
+      indeterminateKeys: un,
+      expandedRowKeys: Wt,
+      onCheck: hn,
+      onCheckRadio: yn,
+      onClickExpandBtn: $n,
+      columns: G,
+      data: ze,
+      prefixCls: a,
+      hasFixedColumn: it,
+      tableViewWidth: He,
+      indentSize: K,
+      noDataElement: _ || s("Table"),
+      activeSorters: re,
+      currentSorter: ae,
+      stickyOffsets: A,
+      stickyClassNames: T,
+      getRowKey: Ie,
+      saveVirtualListRef: (e) => {
+        x && (te.current = e, ne.current = e?.dom);
+      },
+      ___dangerouslySetInnerHTML___: $.___dangerouslySetInnerHTML___
+    }
+  ), Yt = !x && !fn ? /* @__PURE__ */ ce(xt, { children: [
+    Ut,
+    jt
+  ] }) : Ut;
+  if (et(() => {
+    const e = ne.current || de.current, n = Wn([e], Nn);
+    return () => {
+      n();
+    };
+  }, [ne.current, de.current]), et(() => ($.consoleTable && console.table(m), () => {
+  }), [m, $.consoleTable]), !g.length) return null;
+  function kn() {
+    const e = ye(u) && u.x === "max-content" && !!u.y && je(m) && m.length > 0;
+    return $e && !x ? /* @__PURE__ */ r(
+      Xe,
+      {
+        ref: ne,
+        className: `${a}-body`,
+        style: zt,
+        children: /* @__PURE__ */ ce(me, { style: Nt, children: [
+          /* @__PURE__ */ r(
+            yt,
+            {
+              columns: G,
+              prefixCls: a,
+              producer: e,
+              onSetColumnWidths: Le,
+              expandedRowKeys: Wt,
+              data: m
+            }
+          ),
+          Yt
+        ] })
+      }
+    ) : Yt;
+  }
+  function vn() {
+    let e = {};
+    u && ye(u) && u.x && (e = {
+      width: u.x
+    });
+    const n = /* @__PURE__ */ r("div", { className: `${a}-tfoot`, ref: ee, children: /* @__PURE__ */ ce(me, { style: e, children: [
+      /* @__PURE__ */ r(yt, { columns: G, prefixCls: a }),
+      jt
+    ] }) }), o = Je && $e && St === "top", k = Je && $e && St === "bottom", B = /* @__PURE__ */ ce(xt, { children: [
+      M ? Rn() : null,
+      o && n,
+      kn(),
+      k && n
+    ] }), V = De(U) && U(ze), z = De(l) && l(ze);
+    return /* @__PURE__ */ ce(xt, { children: [
+      !!V && /* @__PURE__ */ r("div", { className: `${a}-header-`, children: V }),
+      /* @__PURE__ */ r("div", { className: `${a}-container`, children: /* @__PURE__ */ r("div", { className: `${a}-content-scroll`, children: /* @__PURE__ */ r(
+        "div",
+        {
+          className: `${a}-content-inner`,
+          onScroll: $e ? void 0 : bn,
+          children: $e || x ? B : /* @__PURE__ */ ce(me, { ref: le, style: e, children: [
+            /* @__PURE__ */ r(yt, { prefixCls: a, columns: G }),
+            B
+          ] })
+        }
+      ) }) }),
+      !!z && /* @__PURE__ */ r("div", { className: `${a}-footer`, children: z })
+    ] });
+  }
+  const Tn = ye(v) ? v.wrapper : v, Rt = ye(v) ? v.cell : O, Pn = ye(v) ? v.cell || v.headerCell : O, En = ye(v) ? v.cell || v.bodyCell : O, Fn = Q(
+    a,
+    `${a}-size-${X}`,
+    {
+      [`${a}-border`]: Tn,
+      [`${a}-border-cell`]: Rt,
+      [`${a}-border-header-cell`]: !Rt && Pn,
+      [`${a}-border-body-cell`]: !Rt && En,
+      [`${a}-stripe`]: F,
+      [`${a}-hover`]: Z,
+      [`${a}-type-radio`]: W && W.type === "radio",
+      [`${a}-layout-fixed`]: H || u && (u.x || u.y) || g.find((e) => e.ellipsis),
+      [`${a}-fixed-column`]: it,
+      [`${a}-virtualized`]: x,
+      [`${a}-rtl`]: d
+    },
+    y
+  ), kt = I === "tl" || I === "tr" || I === "topCenter", In = Q(`${a}-pagination`, {
+    [`${a}-pagination-left`]: I === "tl" || I === "bl",
+    [`${a}-pagination-center`]: I === "topCenter" || I === "bottomCenter",
+    [`${a}-pagination-top`]: kt
+  });
+  let ft = $.loading;
+  typeof ft == "boolean" && (ft = { loading: ft });
+  const On = Y !== !1 && (Me.length !== 0 || at?.total > 0);
+  let pt;
+  return On && (De(b) ? pt = b(/* @__PURE__ */ r(Xt, { ...at })) : pt = /* @__PURE__ */ r("div", { className: In, children: /* @__PURE__ */ r(Xt, { ...at }) })), /* @__PURE__ */ r(Dt.Provider, { value: $, children: /* @__PURE__ */ r(
+    "div",
+    {
+      ref: oe,
+      style: p,
+      className: Fn,
+      ...Mn($),
+      children: /* @__PURE__ */ ce(
+        Ln,
+        {
+          className: `${a}-spin`,
+          element: w,
+          ...ft,
+          children: [
+            kt && pt,
+            vn(),
+            !kt && pt
+          ]
+        }
+      )
+    }
+  ) });
+}
+const Po = Ot(To);
+Po.displayName = "Table";
+export {
+  Co as S,
+  Po as T,
+  _e as a,
+  lo as b,
+  ao as c,
+  co as d,
+  fo as e,
+  po as f,
+  io as u
+};