@unicom-cloud/ui 0.8.111 → 0.8.113

package/chunk/D0dVE1v1.js

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