add all frontend files

node_modules/antd/es/table/Column.d.ts

@@ -0,0 +1,8 @@
+import type { AnyObject } from '../_util/type';
+import type { ColumnType } from './interface';
+export interface ColumnProps<RecordType = AnyObject> extends ColumnType<RecordType> {
+    children?: null;
+}
+/** This is a syntactic sugar for `columns` prop. So HOC will not work on this. */
+declare const Column: <RecordType extends AnyObject>(_: ColumnProps<RecordType>) => null;
+export default Column;

node_modules/antd/es/table/Column.js

@@ -0,0 +1,4 @@
+/* istanbul ignore next */
+/** This is a syntactic sugar for `columns` prop. So HOC will not work on this. */
+const Column = _ => null;
+export default Column;

node_modules/antd/es/table/ColumnGroup.d.ts

@@ -0,0 +1,10 @@
+import type * as React from 'react';
+import type { AnyObject } from '../_util/type';
+import type { ColumnProps } from './Column';
+import type { ColumnType } from './interface';
+export interface ColumnGroupProps<RecordType = AnyObject> extends Omit<ColumnType<RecordType>, 'children'> {
+    children: React.ReactElement<ColumnProps<RecordType>> | React.ReactElement<ColumnProps<RecordType>>[];
+}
+/** This is a syntactic sugar for `columns` prop. So HOC will not work on this. */
+declare const ColumnGroup: <RecordType extends AnyObject>(_: ColumnGroupProps<RecordType>) => null;
+export default ColumnGroup;

node_modules/antd/es/table/ColumnGroup.js

@@ -0,0 +1,4 @@
+/* istanbul ignore next */
+/** This is a syntactic sugar for `columns` prop. So HOC will not work on this. */
+const ColumnGroup = _ => null;
+export default ColumnGroup;

node_modules/antd/es/table/ExpandIcon.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import type { AnyObject } from '../_util/type';
+import type { TableLocale } from './interface';
+interface DefaultExpandIconProps<RecordType = AnyObject> {
+    prefixCls: string;
+    record: RecordType;
+    expanded: boolean;
+    expandable: boolean;
+    onExpand: (record: RecordType, e: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+}
+declare function renderExpandIcon(locale: TableLocale): <RecordType extends AnyObject = AnyObject>(props: DefaultExpandIconProps<RecordType>) => React.JSX.Element;
+export default renderExpandIcon;

node_modules/antd/es/table/ExpandIcon.js

@@ -0,0 +1,31 @@
+"use client";
+
+import * as React from 'react';
+import classNames from 'classnames';
+function renderExpandIcon(locale) {
+  return props => {
+    const {
+      prefixCls,
+      onExpand,
+      record,
+      expanded,
+      expandable
+    } = props;
+    const iconPrefix = `${prefixCls}-row-expand-icon`;
+    return /*#__PURE__*/React.createElement("button", {
+      type: "button",
+      onClick: e => {
+        onExpand(record, e);
+        e.stopPropagation();
+      },
+      className: classNames(iconPrefix, {
+        [`${iconPrefix}-spaced`]: !expandable,
+        [`${iconPrefix}-expanded`]: expandable && expanded,
+        [`${iconPrefix}-collapsed`]: expandable && !expanded
+      }),
+      "aria-label": expanded ? locale.collapse : locale.expand,
+      "aria-expanded": expanded
+    });
+  };
+}
+export default renderExpandIcon;

node_modules/antd/es/table/InternalTable.d.ts

@@ -0,0 +1,32 @@
+import type { TableProps as RcTableProps } from 'rc-table';
+import type { AnyObject } from '../_util/type';
+import type { SizeType } from '../config-provider/SizeContext';
+import type { SpinProps } from '../spin';
+import type { ColumnsType, FilterValue, GetPopupContainer, RefInternalTable, SorterResult, SorterTooltipProps, SortOrder, TableCurrentDataSource, TableLocale, TablePaginationConfig, TableRowSelection } from './interface';
+export type { ColumnsType, TablePaginationConfig };
+export interface TableProps<RecordType = AnyObject> extends Omit<RcTableProps<RecordType>, 'transformColumns' | 'internalHooks' | 'internalRefs' | 'data' | 'columns' | 'scroll' | 'emptyText'> {
+    dropdownPrefixCls?: string;
+    dataSource?: RcTableProps<RecordType>['data'];
+    columns?: ColumnsType<RecordType>;
+    pagination?: false | TablePaginationConfig;
+    loading?: boolean | SpinProps;
+    size?: SizeType;
+    bordered?: boolean;
+    locale?: TableLocale;
+    rootClassName?: string;
+    onChange?: (pagination: TablePaginationConfig, filters: Record<string, FilterValue | null>, sorter: SorterResult<RecordType> | SorterResult<RecordType>[], extra: TableCurrentDataSource<RecordType>) => void;
+    rowSelection?: TableRowSelection<RecordType>;
+    getPopupContainer?: GetPopupContainer;
+    scroll?: RcTableProps<RecordType>['scroll'] & {
+        scrollToFirstRowOnChange?: boolean;
+    };
+    sortDirections?: SortOrder[];
+    showSorterTooltip?: boolean | SorterTooltipProps;
+    virtual?: boolean;
+}
+/** Same as `TableProps` but we need record parent render times */
+export interface InternalTableProps<RecordType = AnyObject> extends TableProps<RecordType> {
+    _renderTimes: number;
+}
+declare const _default: RefInternalTable;
+export default _default;

node_modules/antd/es/table/InternalTable.js

@@ -0,0 +1,424 @@
+"use client";
+
+import * as React from 'react';
+import classNames from 'classnames';
+import { INTERNAL_HOOKS } from 'rc-table';
+import { convertChildrenToColumns } from "rc-table/es/hooks/useColumns";
+import omit from "rc-util/es/omit";
+import { useProxyImperativeHandle } from '../_util/hooks';
+import scrollTo from '../_util/scrollTo';
+import { devUseWarning } from '../_util/warning';
+import ConfigProvider from '../config-provider';
+import { ConfigContext } from '../config-provider/context';
+import DefaultRenderEmpty from '../config-provider/defaultRenderEmpty';
+import useCSSVarCls from '../config-provider/hooks/useCSSVarCls';
+import useSize from '../config-provider/hooks/useSize';
+import useBreakpoint from '../grid/hooks/useBreakpoint';
+import defaultLocale from '../locale/en_US';
+import Pagination from '../pagination';
+import Spin from '../spin';
+import { useToken } from '../theme/internal';
+import renderExpandIcon from './ExpandIcon';
+import useContainerWidth from './hooks/useContainerWidth';
+import useFilter, { getFilterData } from './hooks/useFilter';
+import useLazyKVMap from './hooks/useLazyKVMap';
+import usePagination, { DEFAULT_PAGE_SIZE, getPaginationParam } from './hooks/usePagination';
+import useSelection from './hooks/useSelection';
+import useSorter, { getSortData } from './hooks/useSorter';
+import useTitleColumns from './hooks/useTitleColumns';
+import RcTable from './RcTable';
+import RcVirtualTable from './RcTable/VirtualTable';
+import useStyle from './style';
+const EMPTY_LIST = [];
+const InternalTable = (props, ref) => {
+  var _a, _b;
+  const {
+    prefixCls: customizePrefixCls,
+    className,
+    rootClassName,
+    style,
+    size: customizeSize,
+    bordered,
+    dropdownPrefixCls: customizeDropdownPrefixCls,
+    dataSource,
+    pagination,
+    rowSelection,
+    rowKey = 'key',
+    rowClassName,
+    columns,
+    children,
+    childrenColumnName: legacyChildrenColumnName,
+    onChange,
+    getPopupContainer,
+    loading,
+    expandIcon,
+    expandable,
+    expandedRowRender,
+    expandIconColumnIndex,
+    indentSize,
+    scroll,
+    sortDirections,
+    locale,
+    showSorterTooltip = {
+      target: 'full-header'
+    },
+    virtual
+  } = props;
+  const warning = devUseWarning('Table');
+  if (process.env.NODE_ENV !== 'production') {
+    process.env.NODE_ENV !== "production" ? warning(!(typeof rowKey === 'function' && rowKey.length > 1), 'usage', '`index` parameter of `rowKey` function is deprecated. There is no guarantee that it will work as expected.') : void 0;
+  }
+  const baseColumns = React.useMemo(() => columns || convertChildrenToColumns(children), [columns, children]);
+  const needResponsive = React.useMemo(() => baseColumns.some(col => col.responsive), [baseColumns]);
+  const screens = useBreakpoint(needResponsive);
+  const mergedColumns = React.useMemo(() => {
+    const matched = new Set(Object.keys(screens).filter(m => screens[m]));
+    return baseColumns.filter(c => !c.responsive || c.responsive.some(r => matched.has(r)));
+  }, [baseColumns, screens]);
+  const tableProps = omit(props, ['className', 'style', 'columns']);
+  const {
+    locale: contextLocale = defaultLocale,
+    direction,
+    table,
+    renderEmpty,
+    getPrefixCls,
+    getPopupContainer: getContextPopupContainer
+  } = React.useContext(ConfigContext);
+  const mergedSize = useSize(customizeSize);
+  const tableLocale = Object.assign(Object.assign({}, contextLocale.Table), locale);
+  const rawData = dataSource || EMPTY_LIST;
+  const prefixCls = getPrefixCls('table', customizePrefixCls);
+  const dropdownPrefixCls = getPrefixCls('dropdown', customizeDropdownPrefixCls);
+  const [, token] = useToken();
+  const rootCls = useCSSVarCls(prefixCls);
+  const [wrapCSSVar, hashId, cssVarCls] = useStyle(prefixCls, rootCls);
+  const mergedExpandable = Object.assign(Object.assign({
+    childrenColumnName: legacyChildrenColumnName,
+    expandIconColumnIndex
+  }, expandable), {
+    expandIcon: (_a = expandable === null || expandable === void 0 ? void 0 : expandable.expandIcon) !== null && _a !== void 0 ? _a : (_b = table === null || table === void 0 ? void 0 : table.expandable) === null || _b === void 0 ? void 0 : _b.expandIcon
+  });
+  const {
+    childrenColumnName = 'children'
+  } = mergedExpandable;
+  const expandType = React.useMemo(() => {
+    if (rawData.some(item => item === null || item === void 0 ? void 0 : item[childrenColumnName])) {
+      return 'nest';
+    }
+    if (expandedRowRender || (expandable === null || expandable === void 0 ? void 0 : expandable.expandedRowRender)) {
+      return 'row';
+    }
+    return null;
+  }, [rawData]);
+  const internalRefs = {
+    body: React.useRef(null)
+  };
+  // ============================ Width =============================
+  const getContainerWidth = useContainerWidth(prefixCls);
+  // ============================= Refs =============================
+  const rootRef = React.useRef(null);
+  const tblRef = React.useRef(null);
+  useProxyImperativeHandle(ref, () => Object.assign(Object.assign({}, tblRef.current), {
+    nativeElement: rootRef.current
+  }));
+  // ============================ RowKey ============================
+  const getRowKey = React.useMemo(() => {
+    if (typeof rowKey === 'function') {
+      return rowKey;
+    }
+    return record => record === null || record === void 0 ? void 0 : record[rowKey];
+  }, [rowKey]);
+  const [getRecordByKey] = useLazyKVMap(rawData, childrenColumnName, getRowKey);
+  // ============================ Events =============================
+  const changeEventInfo = {};
+  const triggerOnChange = (info, action, reset = false) => {
+    var _a, _b, _c, _d;
+    const changeInfo = Object.assign(Object.assign({}, changeEventInfo), info);
+    if (reset) {
+      (_a = changeEventInfo.resetPagination) === null || _a === void 0 ? void 0 : _a.call(changeEventInfo);
+      // Reset event param
+      if ((_b = changeInfo.pagination) === null || _b === void 0 ? void 0 : _b.current) {
+        changeInfo.pagination.current = 1;
+      }
+      // Trigger pagination events
+      if (pagination) {
+        (_c = pagination.onChange) === null || _c === void 0 ? void 0 : _c.call(pagination, 1, (_d = changeInfo.pagination) === null || _d === void 0 ? void 0 : _d.pageSize);
+      }
+    }
+    if (scroll && scroll.scrollToFirstRowOnChange !== false && internalRefs.body.current) {
+      scrollTo(0, {
+        getContainer: () => internalRefs.body.current
+      });
+    }
+    onChange === null || onChange === void 0 ? void 0 : onChange(changeInfo.pagination, changeInfo.filters, changeInfo.sorter, {
+      currentDataSource: getFilterData(getSortData(rawData, changeInfo.sorterStates, childrenColumnName), changeInfo.filterStates, childrenColumnName),
+      action
+    });
+  };
+  /**
+   * Controlled state in `columns` is not a good idea that makes too many code (1000+ line?) to read
+   * state out and then put it back to title render. Move these code into `hooks` but still too
+   * complex. We should provides Table props like `sorter` & `filter` to handle control in next big
+   * version.
+   */
+  // ============================ Sorter =============================
+  const onSorterChange = (sorter, sorterStates) => {
+    triggerOnChange({
+      sorter,
+      sorterStates
+    }, 'sort', false);
+  };
+  const [transformSorterColumns, sortStates, sorterTitleProps, getSorters] = useSorter({
+    prefixCls,
+    mergedColumns,
+    onSorterChange,
+    sortDirections: sortDirections || ['ascend', 'descend'],
+    tableLocale,
+    showSorterTooltip
+  });
+  const sortedData = React.useMemo(() => getSortData(rawData, sortStates, childrenColumnName), [rawData, sortStates]);
+  changeEventInfo.sorter = getSorters();
+  changeEventInfo.sorterStates = sortStates;
+  // ============================ Filter ============================
+  const onFilterChange = (filters, filterStates) => {
+    triggerOnChange({
+      filters,
+      filterStates
+    }, 'filter', true);
+  };
+  const [transformFilterColumns, filterStates, filters] = useFilter({
+    prefixCls,
+    locale: tableLocale,
+    dropdownPrefixCls,
+    mergedColumns,
+    onFilterChange,
+    getPopupContainer: getPopupContainer || getContextPopupContainer,
+    rootClassName: classNames(rootClassName, rootCls)
+  });
+  const mergedData = getFilterData(sortedData, filterStates, childrenColumnName);
+  changeEventInfo.filters = filters;
+  changeEventInfo.filterStates = filterStates;
+  // ============================ Column ============================
+  const columnTitleProps = React.useMemo(() => {
+    const mergedFilters = {};
+    Object.keys(filters).forEach(filterKey => {
+      if (filters[filterKey] !== null) {
+        mergedFilters[filterKey] = filters[filterKey];
+      }
+    });
+    return Object.assign(Object.assign({}, sorterTitleProps), {
+      filters: mergedFilters
+    });
+  }, [sorterTitleProps, filters]);
+  const [transformTitleColumns] = useTitleColumns(columnTitleProps);
+  // ========================== Pagination ==========================
+  const onPaginationChange = (current, pageSize) => {
+    triggerOnChange({
+      pagination: Object.assign(Object.assign({}, changeEventInfo.pagination), {
+        current,
+        pageSize
+      })
+    }, 'paginate');
+  };
+  const [mergedPagination, resetPagination] = usePagination(mergedData.length, onPaginationChange, pagination);
+  changeEventInfo.pagination = pagination === false ? {} : getPaginationParam(mergedPagination, pagination);
+  changeEventInfo.resetPagination = resetPagination;
+  // ============================= Data =============================
+  const pageData = React.useMemo(() => {
+    if (pagination === false || !mergedPagination.pageSize) {
+      return mergedData;
+    }
+    const {
+      current = 1,
+      total,
+      pageSize = DEFAULT_PAGE_SIZE
+    } = mergedPagination;
+    process.env.NODE_ENV !== "production" ? warning(current > 0, 'usage', '`current` should be positive number.') : void 0;
+    // Dynamic table data
+    if (mergedData.length < total) {
+      if (mergedData.length > pageSize) {
+        process.env.NODE_ENV !== "production" ? warning(false, 'usage', '`dataSource` length is less than `pagination.total` but large than `pagination.pageSize`. Please make sure your config correct data with async mode.') : void 0;
+        return mergedData.slice((current - 1) * pageSize, current * pageSize);
+      }
+      return mergedData;
+    }
+    return mergedData.slice((current - 1) * pageSize, current * pageSize);
+  }, [!!pagination, mergedData, mergedPagination === null || mergedPagination === void 0 ? void 0 : mergedPagination.current, mergedPagination === null || mergedPagination === void 0 ? void 0 : mergedPagination.pageSize, mergedPagination === null || mergedPagination === void 0 ? void 0 : mergedPagination.total]);
+  // ========================== Selections ==========================
+  const [transformSelectionColumns, selectedKeySet] = useSelection({
+    prefixCls,
+    data: mergedData,
+    pageData,
+    getRowKey,
+    getRecordByKey,
+    expandType,
+    childrenColumnName,
+    locale: tableLocale,
+    getPopupContainer: getPopupContainer || getContextPopupContainer
+  }, rowSelection);
+  const internalRowClassName = (record, index, indent) => {
+    let mergedRowClassName;
+    if (typeof rowClassName === 'function') {
+      mergedRowClassName = classNames(rowClassName(record, index, indent));
+    } else {
+      mergedRowClassName = classNames(rowClassName);
+    }
+    return classNames({
+      [`${prefixCls}-row-selected`]: selectedKeySet.has(getRowKey(record, index))
+    }, mergedRowClassName);
+  };
+  // ========================== Expandable ==========================
+  // Pass origin render status into `rc-table`, this can be removed when refactor with `rc-table`
+  mergedExpandable.__PARENT_RENDER_ICON__ = mergedExpandable.expandIcon;
+  // Customize expandable icon
+  mergedExpandable.expandIcon = mergedExpandable.expandIcon || expandIcon || renderExpandIcon(tableLocale);
+  // Adjust expand icon index, no overwrite expandIconColumnIndex if set.
+  if (expandType === 'nest' && mergedExpandable.expandIconColumnIndex === undefined) {
+    mergedExpandable.expandIconColumnIndex = rowSelection ? 1 : 0;
+  } else if (mergedExpandable.expandIconColumnIndex > 0 && rowSelection) {
+    mergedExpandable.expandIconColumnIndex -= 1;
+  }
+  // Indent size
+  if (typeof mergedExpandable.indentSize !== 'number') {
+    mergedExpandable.indentSize = typeof indentSize === 'number' ? indentSize : 15;
+  }
+  // ============================ Render ============================
+  const transformColumns = React.useCallback(innerColumns => transformTitleColumns(transformSelectionColumns(transformFilterColumns(transformSorterColumns(innerColumns)))), [transformSorterColumns, transformFilterColumns, transformSelectionColumns]);
+  const getPaginationNodes = () => {
+    if (pagination === false || !(mergedPagination === null || mergedPagination === void 0 ? void 0 : mergedPagination.total)) {
+      return {};
+    }
+    const getPaginationSize = () => mergedPagination.size || (mergedSize === 'small' || mergedSize === 'middle' ? 'small' : undefined);
+    const renderPagination = position => {
+      const align = position === 'left' ? 'start' : position === 'right' ? 'end' : position;
+      return /*#__PURE__*/React.createElement(Pagination, Object.assign({}, mergedPagination, {
+        align: mergedPagination.align || align,
+        className: classNames(`${prefixCls}-pagination`, mergedPagination.className),
+        size: getPaginationSize()
+      }));
+    };
+    const defaultPosition = direction === 'rtl' ? 'left' : 'right';
+    const positions = mergedPagination.position;
+    if (positions === null || !Array.isArray(positions)) {
+      return {
+        bottom: renderPagination(defaultPosition)
+      };
+    }
+    const topPosition = positions.find(pos => typeof pos === 'string' && pos.toLowerCase().includes('top'));
+    const bottomPosition = positions.find(pos => typeof pos === 'string' && pos.toLowerCase().includes('bottom'));
+    const isNone = positions.every(pos => `${pos}` === 'none');
+    const topAlign = topPosition ? topPosition.toLowerCase().replace('top', '') : '';
+    const bottomAlign = bottomPosition ? bottomPosition.toLowerCase().replace('bottom', '') : '';
+    const shouldDefaultBottom = !topPosition && !bottomPosition && !isNone;
+    const renderTop = () => topAlign ? renderPagination(topAlign) : undefined;
+    const renderBottom = () => {
+      if (bottomAlign) {
+        return renderPagination(bottomAlign);
+      }
+      if (shouldDefaultBottom) {
+        return renderPagination(defaultPosition);
+      }
+      return undefined;
+    };
+    return {
+      top: renderTop(),
+      bottom: renderBottom()
+    };
+  };
+  // >>>>>>>>> Spinning
+  const spinProps = React.useMemo(() => {
+    if (typeof loading === 'boolean') {
+      return {
+        spinning: loading
+      };
+    } else if (typeof loading === 'object' && loading !== null) {
+      return Object.assign({
+        spinning: true
+      }, loading);
+    } else {
+      return undefined;
+    }
+  }, [loading]);
+  const wrapperClassNames = classNames(cssVarCls, rootCls, `${prefixCls}-wrapper`, table === null || table === void 0 ? void 0 : table.className, {
+    [`${prefixCls}-wrapper-rtl`]: direction === 'rtl'
+  }, className, rootClassName, hashId);
+  const mergedStyle = Object.assign(Object.assign({}, table === null || table === void 0 ? void 0 : table.style), style);
+  // ========== empty ==========
+  const mergedEmptyNode = React.useMemo(() => {
+    // When dataSource is null/undefined (detected by reference equality with EMPTY_LIST),
+    // and the table is in a loading state, we only show the loading spinner without the empty placeholder.
+    // For empty arrays (datasource={[]}), both loading and empty states would normally be shown.
+    // discussion https://github.com/ant-design/ant-design/issues/54601#issuecomment-3158091383
+    if ((spinProps === null || spinProps === void 0 ? void 0 : spinProps.spinning) && rawData === EMPTY_LIST) {
+      return null;
+    }
+    if (typeof (locale === null || locale === void 0 ? void 0 : locale.emptyText) !== 'undefined') {
+      return locale.emptyText;
+    }
+    return (renderEmpty === null || renderEmpty === void 0 ? void 0 : renderEmpty('Table')) || /*#__PURE__*/React.createElement(DefaultRenderEmpty, {
+      componentName: "Table"
+    });
+  }, [spinProps === null || spinProps === void 0 ? void 0 : spinProps.spinning, rawData, locale === null || locale === void 0 ? void 0 : locale.emptyText, renderEmpty]);
+  // ========================== Render ==========================
+  const TableComponent = virtual ? RcVirtualTable : RcTable;
+  // >>> Virtual Table props. We set height here since it will affect height collection
+  const virtualProps = {};
+  const listItemHeight = React.useMemo(() => {
+    const {
+      fontSize,
+      lineHeight,
+      lineWidth,
+      padding,
+      paddingXS,
+      paddingSM
+    } = token;
+    const fontHeight = Math.floor(fontSize * lineHeight);
+    switch (mergedSize) {
+      case 'middle':
+        return paddingSM * 2 + fontHeight + lineWidth;
+      case 'small':
+        return paddingXS * 2 + fontHeight + lineWidth;
+      default:
+        return padding * 2 + fontHeight + lineWidth;
+    }
+  }, [token, mergedSize]);
+  if (virtual) {
+    virtualProps.listItemHeight = listItemHeight;
+  }
+  const {
+    top: topPaginationNode,
+    bottom: bottomPaginationNode
+  } = getPaginationNodes();
+  return wrapCSSVar(/*#__PURE__*/React.createElement("div", {
+    ref: rootRef,
+    className: wrapperClassNames,
+    style: mergedStyle
+  }, /*#__PURE__*/React.createElement(Spin, Object.assign({
+    spinning: false
+  }, spinProps), topPaginationNode, /*#__PURE__*/React.createElement(TableComponent, Object.assign({}, virtualProps, tableProps, {
+    ref: tblRef,
+    columns: mergedColumns,
+    direction: direction,
+    expandable: mergedExpandable,
+    prefixCls: prefixCls,
+    className: classNames({
+      [`${prefixCls}-middle`]: mergedSize === 'middle',
+      [`${prefixCls}-small`]: mergedSize === 'small',
+      [`${prefixCls}-bordered`]: bordered,
+      [`${prefixCls}-empty`]: rawData.length === 0
+    }, cssVarCls, rootCls, hashId),
+    data: pageData,
+    rowKey: getRowKey,
+    rowClassName: internalRowClassName,
+    emptyText: mergedEmptyNode,
+    // Internal
+    internalHooks: INTERNAL_HOOKS,
+    internalRefs: internalRefs,
+    transformColumns: transformColumns,
+    getContainerWidth: getContainerWidth,
+    measureRowRender: measureRow => (/*#__PURE__*/React.createElement(ConfigProvider, {
+      getPopupContainer: node => node
+    }, measureRow))
+  })), bottomPaginationNode)));
+};
+export default /*#__PURE__*/React.forwardRef(InternalTable);

node_modules/antd/es/table/RcTable/VirtualTable.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Same as `rc-table` but we modify trigger children update logic instead.
+ */
+declare const RcVirtualTable: import("rc-table/lib/VirtualTable").ForwardGenericVirtualTable;
+export default RcVirtualTable;

node_modules/antd/es/table/RcTable/VirtualTable.js

@@ -0,0 +1,16 @@
+"use client";
+
+import { genVirtualTable } from 'rc-table';
+/**
+ * Same as `rc-table` but we modify trigger children update logic instead.
+ */
+const RcVirtualTable = genVirtualTable((prev, next) => {
+  const {
+    _renderTimes: prevRenderTimes
+  } = prev;
+  const {
+    _renderTimes: nextRenderTimes
+  } = next;
+  return prevRenderTimes !== nextRenderTimes;
+});
+export default RcVirtualTable;

node_modules/antd/es/table/RcTable/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Same as `rc-table` but we modify trigger children update logic instead.
+ */
+declare const RcTable: import("rc-table/lib/Table").ForwardGenericTable;
+export default RcTable;

node_modules/antd/es/table/RcTable/index.js

@@ -0,0 +1,16 @@
+"use client";
+
+import { genTable } from 'rc-table';
+/**
+ * Same as `rc-table` but we modify trigger children update logic instead.
+ */
+const RcTable = genTable((prev, next) => {
+  const {
+    _renderTimes: prevRenderTimes
+  } = prev;
+  const {
+    _renderTimes: nextRenderTimes
+  } = next;
+  return prevRenderTimes !== nextRenderTimes;
+});
+export default RcTable;

node_modules/antd/es/table/Table.d.ts

@@ -0,0 +1,17 @@
+import { EXPAND_COLUMN, Summary } from 'rc-table';
+import Column from './Column';
+import ColumnGroup from './ColumnGroup';
+import { SELECTION_ALL, SELECTION_COLUMN, SELECTION_INVERT, SELECTION_NONE } from './hooks/useSelection';
+import type { RefTable } from './interface';
+declare const ForwardTable: RefTable & {
+    displayName?: string;
+    SELECTION_COLUMN: typeof SELECTION_COLUMN;
+    EXPAND_COLUMN: typeof EXPAND_COLUMN;
+    SELECTION_ALL: typeof SELECTION_ALL;
+    SELECTION_INVERT: typeof SELECTION_INVERT;
+    SELECTION_NONE: typeof SELECTION_NONE;
+    Column: typeof Column;
+    ColumnGroup: typeof ColumnGroup;
+    Summary: typeof Summary;
+};
+export default ForwardTable;

node_modules/antd/es/table/Table.js

@@ -0,0 +1,29 @@
+"use client";
+
+import * as React from 'react';
+import { EXPAND_COLUMN, Summary } from 'rc-table';
+import Column from './Column';
+import ColumnGroup from './ColumnGroup';
+import { SELECTION_ALL, SELECTION_COLUMN, SELECTION_INVERT, SELECTION_NONE } from './hooks/useSelection';
+import InternalTable from './InternalTable';
+const Table = (props, ref) => {
+  const renderTimesRef = React.useRef(0);
+  renderTimesRef.current += 1;
+  return /*#__PURE__*/React.createElement(InternalTable, Object.assign({}, props, {
+    ref: ref,
+    _renderTimes: renderTimesRef.current
+  }));
+};
+const ForwardTable = /*#__PURE__*/React.forwardRef(Table);
+ForwardTable.SELECTION_COLUMN = SELECTION_COLUMN;
+ForwardTable.EXPAND_COLUMN = EXPAND_COLUMN;
+ForwardTable.SELECTION_ALL = SELECTION_ALL;
+ForwardTable.SELECTION_INVERT = SELECTION_INVERT;
+ForwardTable.SELECTION_NONE = SELECTION_NONE;
+ForwardTable.Column = Column;
+ForwardTable.ColumnGroup = ColumnGroup;
+ForwardTable.Summary = Summary;
+if (process.env.NODE_ENV !== 'production') {
+  ForwardTable.displayName = 'Table';
+}
+export default ForwardTable;

node_modules/antd/es/table/hooks/useContainerWidth.d.ts

@@ -0,0 +1 @@
+export default function useContainerWidth(prefixCls: string): (ele: HTMLElement, width: number) => number;

node_modules/antd/es/table/hooks/useContainerWidth.js

@@ -0,0 +1,14 @@
+export default function useContainerWidth(prefixCls) {
+  const getContainerWidth = (ele, width) => {
+    const container = ele.querySelector(`.${prefixCls}-container`);
+    let returnWidth = width;
+    if (container) {
+      const style = getComputedStyle(container);
+      const borderLeft = Number.parseInt(style.borderLeftWidth, 10);
+      const borderRight = Number.parseInt(style.borderRightWidth, 10);
+      returnWidth = width - borderLeft - borderRight;
+    }
+    return returnWidth;
+  };
+  return getContainerWidth;
+}

node_modules/antd/es/table/hooks/useFilter/FilterDropdown.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import type { AnyObject } from 'antd/es/_util/type';
+import type { FieldDataNode } from 'rc-tree';
+import type { FilterState } from '.';
+import type { ColumnFilterItem, ColumnType, FilterSearchType, FilterValue, GetPopupContainer, Key, TableLocale } from '../../interface';
+type FilterTreeDataNode = FieldDataNode<{
+    title: React.ReactNode;
+    key: string;
+}>;
+export declare function flattenKeys(filters?: ColumnFilterItem[]): FilterValue;
+export type TreeColumnFilterItem = ColumnFilterItem & FilterTreeDataNode;
+export interface FilterDropdownProps<RecordType = AnyObject> {
+    tablePrefixCls: string;
+    prefixCls: string;
+    dropdownPrefixCls: string;
+    column: ColumnType<RecordType>;
+    filterState?: FilterState<RecordType>;
+    filterOnClose: boolean;
+    filterMultiple: boolean;
+    filterMode?: 'menu' | 'tree';
+    filterSearch?: FilterSearchType<ColumnFilterItem | TreeColumnFilterItem>;
+    columnKey: Key;
+    children: React.ReactNode;
+    triggerFilter: (filterState: FilterState<RecordType>) => void;
+    locale: TableLocale;
+    getPopupContainer?: GetPopupContainer;
+    filterResetToDefaultFilteredValue?: boolean;
+    rootClassName?: string;
+}
+declare const FilterDropdown: <RecordType extends AnyObject = AnyObject>(props: FilterDropdownProps<RecordType>) => React.JSX.Element;
+export default FilterDropdown;

node_modules/antd/es/table/hooks/useFilter/FilterDropdown.js

@@ -0,0 +1,463 @@
+"use client";
+
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import FilterFilled from "@ant-design/icons/es/icons/FilterFilled";
+import classNames from 'classnames';
+import isEqual from "rc-util/es/isEqual";
+import extendsObject from '../../../_util/extendsObject';
+import { useSyncState } from '../../../_util/hooks';
+import { devUseWarning } from '../../../_util/warning';
+import Button from '../../../button';
+import Checkbox from '../../../checkbox';
+import { ConfigContext } from '../../../config-provider/context';
+import Dropdown from '../../../dropdown';
+import Empty from '../../../empty';
+import Menu from '../../../menu';
+import { OverrideProvider } from '../../../menu/OverrideContext';
+import Radio from '../../../radio';
+import Tree from '../../../tree';
+import FilterSearch from './FilterSearch';
+import FilterDropdownMenuWrapper from './FilterWrapper';
+export function flattenKeys(filters) {
+  let keys = [];
+  (filters || []).forEach(({
+    value,
+    children
+  }) => {
+    keys.push(value);
+    if (children) {
+      keys = [].concat(_toConsumableArray(keys), _toConsumableArray(flattenKeys(children)));
+    }
+  });
+  return keys;
+}
+function hasSubMenu(filters) {
+  return filters.some(({
+    children
+  }) => children);
+}
+function searchValueMatched(searchValue, text) {
+  if (typeof text === 'string' || typeof text === 'number') {
+    return text === null || text === void 0 ? void 0 : text.toString().toLowerCase().includes(searchValue.trim().toLowerCase());
+  }
+  return false;
+}
+function renderFilterItems({
+  filters,
+  prefixCls,
+  filteredKeys,
+  filterMultiple,
+  searchValue,
+  filterSearch
+}) {
+  return filters.map((filter, index) => {
+    const key = String(filter.value);
+    if (filter.children) {
+      return {
+        key: key || index,
+        label: filter.text,
+        popupClassName: `${prefixCls}-dropdown-submenu`,
+        children: renderFilterItems({
+          filters: filter.children,
+          prefixCls,
+          filteredKeys,
+          filterMultiple,
+          searchValue,
+          filterSearch
+        })
+      };
+    }
+    const Component = filterMultiple ? Checkbox : Radio;
+    const item = {
+      key: filter.value !== undefined ? key : index,
+      label: (/*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Component, {
+        checked: filteredKeys.includes(key)
+      }), /*#__PURE__*/React.createElement("span", null, filter.text)))
+    };
+    if (searchValue.trim()) {
+      if (typeof filterSearch === 'function') {
+        return filterSearch(searchValue, filter) ? item : null;
+      }
+      return searchValueMatched(searchValue, filter.text) ? item : null;
+    }
+    return item;
+  });
+}
+function wrapStringListType(keys) {
+  return keys || [];
+}
+const FilterDropdown = props => {
+  var _a, _b, _c, _d;
+  const {
+    tablePrefixCls,
+    prefixCls,
+    column,
+    dropdownPrefixCls,
+    columnKey,
+    filterOnClose,
+    filterMultiple,
+    filterMode = 'menu',
+    filterSearch = false,
+    filterState,
+    triggerFilter,
+    locale,
+    children,
+    getPopupContainer,
+    rootClassName
+  } = props;
+  const {
+    filterResetToDefaultFilteredValue,
+    defaultFilteredValue,
+    filterDropdownProps = {},
+    // Deprecated
+    filterDropdownOpen,
+    filterDropdownVisible,
+    onFilterDropdownVisibleChange,
+    onFilterDropdownOpenChange
+  } = column;
+  const [visible, setVisible] = React.useState(false);
+  const filtered = !!(filterState && (((_a = filterState.filteredKeys) === null || _a === void 0 ? void 0 : _a.length) || filterState.forceFiltered));
+  const triggerVisible = newVisible => {
+    var _a;
+    setVisible(newVisible);
+    (_a = filterDropdownProps.onOpenChange) === null || _a === void 0 ? void 0 : _a.call(filterDropdownProps, newVisible);
+    // deprecated
+    onFilterDropdownOpenChange === null || onFilterDropdownOpenChange === void 0 ? void 0 : onFilterDropdownOpenChange(newVisible);
+    onFilterDropdownVisibleChange === null || onFilterDropdownVisibleChange === void 0 ? void 0 : onFilterDropdownVisibleChange(newVisible);
+  };
+  // =================Warning===================
+  if (process.env.NODE_ENV !== 'production') {
+    const warning = devUseWarning('Table');
+    const deprecatedList = [['filterDropdownOpen', 'filterDropdownProps.open'], ['filterDropdownVisible', 'filterDropdownProps.open'], ['onFilterDropdownOpenChange', 'filterDropdownProps.onOpenChange'], ['onFilterDropdownVisibleChange', 'filterDropdownProps.onOpenChange']];
+    deprecatedList.forEach(([deprecatedName, newName]) => {
+      warning.deprecated(!(deprecatedName in column), deprecatedName, newName);
+    });
+    warning.deprecated(!('filterCheckall' in locale), 'filterCheckall', 'locale.filterCheckAll');
+  }
+  const mergedVisible = (_d = (_c = (_b = filterDropdownProps.open) !== null && _b !== void 0 ? _b : filterDropdownOpen) !== null && _c !== void 0 ? _c : filterDropdownVisible) !== null && _d !== void 0 ? _d : visible; // inner state
+  // ===================== Select Keys =====================
+  const propFilteredKeys = filterState === null || filterState === void 0 ? void 0 : filterState.filteredKeys;
+  const [getFilteredKeysSync, setFilteredKeysSync] = useSyncState(wrapStringListType(propFilteredKeys));
+  const onSelectKeys = ({
+    selectedKeys
+  }) => {
+    setFilteredKeysSync(selectedKeys);
+  };
+  const onCheck = (keys, {
+    node,
+    checked
+  }) => {
+    if (!filterMultiple) {
+      onSelectKeys({
+        selectedKeys: checked && node.key ? [node.key] : []
+      });
+    } else {
+      onSelectKeys({
+        selectedKeys: keys
+      });
+    }
+  };
+  React.useEffect(() => {
+    if (!visible) {
+      return;
+    }
+    onSelectKeys({
+      selectedKeys: wrapStringListType(propFilteredKeys)
+    });
+  }, [propFilteredKeys]);
+  // ====================== Open Keys ======================
+  const [openKeys, setOpenKeys] = React.useState([]);
+  const onOpenChange = keys => {
+    setOpenKeys(keys);
+  };
+  // search in tree mode column filter
+  const [searchValue, setSearchValue] = React.useState('');
+  const onSearch = e => {
+    const {
+      value
+    } = e.target;
+    setSearchValue(value);
+  };
+  // clear search value after close filter dropdown
+  React.useEffect(() => {
+    if (!visible) {
+      setSearchValue('');
+    }
+  }, [visible]);
+  // ======================= Submit ========================
+  const internalTriggerFilter = keys => {
+    const mergedKeys = (keys === null || keys === void 0 ? void 0 : keys.length) ? keys : null;
+    if (mergedKeys === null && (!filterState || !filterState.filteredKeys)) {
+      return null;
+    }
+    if (isEqual(mergedKeys, filterState === null || filterState === void 0 ? void 0 : filterState.filteredKeys, true)) {
+      return null;
+    }
+    triggerFilter({
+      column,
+      key: columnKey,
+      filteredKeys: mergedKeys
+    });
+  };
+  const onConfirm = () => {
+    triggerVisible(false);
+    internalTriggerFilter(getFilteredKeysSync());
+  };
+  const onReset = ({
+    confirm,
+    closeDropdown
+  } = {
+    confirm: false,
+    closeDropdown: false
+  }) => {
+    if (confirm) {
+      internalTriggerFilter([]);
+    }
+    if (closeDropdown) {
+      triggerVisible(false);
+    }
+    setSearchValue('');
+    if (filterResetToDefaultFilteredValue) {
+      setFilteredKeysSync((defaultFilteredValue || []).map(key => String(key)));
+    } else {
+      setFilteredKeysSync([]);
+    }
+  };
+  const doFilter = ({
+    closeDropdown
+  } = {
+    closeDropdown: true
+  }) => {
+    if (closeDropdown) {
+      triggerVisible(false);
+    }
+    internalTriggerFilter(getFilteredKeysSync());
+  };
+  const onVisibleChange = (newVisible, info) => {
+    if (info.source === 'trigger') {
+      if (newVisible && propFilteredKeys !== undefined) {
+        // Sync filteredKeys on appear in controlled mode (propFilteredKeys !== undefined)
+        setFilteredKeysSync(wrapStringListType(propFilteredKeys));
+      }
+      triggerVisible(newVisible);
+      if (!newVisible && !column.filterDropdown && filterOnClose) {
+        onConfirm();
+      }
+    }
+  };
+  // ======================== Style ========================
+  const dropdownMenuClass = classNames({
+    [`${dropdownPrefixCls}-menu-without-submenu`]: !hasSubMenu(column.filters || [])
+  });
+  const onCheckAll = e => {
+    if (e.target.checked) {
+      const allFilterKeys = flattenKeys(column === null || column === void 0 ? void 0 : column.filters).map(key => String(key));
+      setFilteredKeysSync(allFilterKeys);
+    } else {
+      setFilteredKeysSync([]);
+    }
+  };
+  const getTreeData = ({
+    filters
+  }) => (filters || []).map((filter, index) => {
+    const key = String(filter.value);
+    const item = {
+      title: filter.text,
+      key: filter.value !== undefined ? key : String(index)
+    };
+    if (filter.children) {
+      item.children = getTreeData({
+        filters: filter.children
+      });
+    }
+    return item;
+  });
+  const getFilterData = node => {
+    var _a;
+    return Object.assign(Object.assign({}, node), {
+      text: node.title,
+      value: node.key,
+      children: ((_a = node.children) === null || _a === void 0 ? void 0 : _a.map(item => getFilterData(item))) || []
+    });
+  };
+  let dropdownContent;
+  const {
+    direction,
+    renderEmpty
+  } = React.useContext(ConfigContext);
+  if (typeof column.filterDropdown === 'function') {
+    dropdownContent = column.filterDropdown({
+      prefixCls: `${dropdownPrefixCls}-custom`,
+      setSelectedKeys: selectedKeys => onSelectKeys({
+        selectedKeys: selectedKeys
+      }),
+      selectedKeys: getFilteredKeysSync(),
+      confirm: doFilter,
+      clearFilters: onReset,
+      filters: column.filters,
+      visible: mergedVisible,
+      close: () => {
+        triggerVisible(false);
+      }
+    });
+  } else if (column.filterDropdown) {
+    dropdownContent = column.filterDropdown;
+  } else {
+    const selectedKeys = getFilteredKeysSync() || [];
+    const getFilterComponent = () => {
+      var _a, _b;
+      const empty = (_a = renderEmpty === null || renderEmpty === void 0 ? void 0 : renderEmpty('Table.filter')) !== null && _a !== void 0 ? _a : (/*#__PURE__*/React.createElement(Empty, {
+        image: Empty.PRESENTED_IMAGE_SIMPLE,
+        description: locale.filterEmptyText,
+        styles: {
+          image: {
+            height: 24
+          }
+        },
+        style: {
+          margin: 0,
+          padding: '16px 0'
+        }
+      }));
+      if ((column.filters || []).length === 0) {
+        return empty;
+      }
+      if (filterMode === 'tree') {
+        return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(FilterSearch, {
+          filterSearch: filterSearch,
+          value: searchValue,
+          onChange: onSearch,
+          tablePrefixCls: tablePrefixCls,
+          locale: locale
+        }), /*#__PURE__*/React.createElement("div", {
+          className: `${tablePrefixCls}-filter-dropdown-tree`
+        }, filterMultiple ? (/*#__PURE__*/React.createElement(Checkbox, {
+          checked: selectedKeys.length === flattenKeys(column.filters).length,
+          indeterminate: selectedKeys.length > 0 && selectedKeys.length < flattenKeys(column.filters).length,
+          className: `${tablePrefixCls}-filter-dropdown-checkall`,
+          onChange: onCheckAll
+        }, (_b = locale === null || locale === void 0 ? void 0 : locale.filterCheckall) !== null && _b !== void 0 ? _b : locale === null || locale === void 0 ? void 0 : locale.filterCheckAll)) : null, /*#__PURE__*/React.createElement(Tree, {
+          checkable: true,
+          selectable: false,
+          blockNode: true,
+          multiple: filterMultiple,
+          checkStrictly: !filterMultiple,
+          className: `${dropdownPrefixCls}-menu`,
+          onCheck: onCheck,
+          checkedKeys: selectedKeys,
+          selectedKeys: selectedKeys,
+          showIcon: false,
+          treeData: getTreeData({
+            filters: column.filters
+          }),
+          autoExpandParent: true,
+          defaultExpandAll: true,
+          filterTreeNode: searchValue.trim() ? node => {
+            if (typeof filterSearch === 'function') {
+              return filterSearch(searchValue, getFilterData(node));
+            }
+            return searchValueMatched(searchValue, node.title);
+          } : undefined
+        })));
+      }
+      const items = renderFilterItems({
+        filters: column.filters || [],
+        filterSearch,
+        prefixCls,
+        filteredKeys: getFilteredKeysSync(),
+        filterMultiple,
+        searchValue
+      });
+      const isEmpty = items.every(item => item === null);
+      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(FilterSearch, {
+        filterSearch: filterSearch,
+        value: searchValue,
+        onChange: onSearch,
+        tablePrefixCls: tablePrefixCls,
+        locale: locale
+      }), isEmpty ? empty : (/*#__PURE__*/React.createElement(Menu, {
+        selectable: true,
+        multiple: filterMultiple,
+        prefixCls: `${dropdownPrefixCls}-menu`,
+        className: dropdownMenuClass,
+        onSelect: onSelectKeys,
+        onDeselect: onSelectKeys,
+        selectedKeys: selectedKeys,
+        getPopupContainer: getPopupContainer,
+        openKeys: openKeys,
+        onOpenChange: onOpenChange,
+        items: items
+      })));
+    };
+    const getResetDisabled = () => {
+      if (filterResetToDefaultFilteredValue) {
+        return isEqual((defaultFilteredValue || []).map(key => String(key)), selectedKeys, true);
+      }
+      return selectedKeys.length === 0;
+    };
+    dropdownContent = /*#__PURE__*/React.createElement(React.Fragment, null, getFilterComponent(), /*#__PURE__*/React.createElement("div", {
+      className: `${prefixCls}-dropdown-btns`
+    }, /*#__PURE__*/React.createElement(Button, {
+      type: "link",
+      size: "small",
+      disabled: getResetDisabled(),
+      onClick: () => onReset()
+    }, locale.filterReset), /*#__PURE__*/React.createElement(Button, {
+      type: "primary",
+      size: "small",
+      onClick: onConfirm
+    }, locale.filterConfirm)));
+  }
+  // We should not block customize Menu with additional props
+  if (column.filterDropdown) {
+    dropdownContent = /*#__PURE__*/React.createElement(OverrideProvider, {
+      selectable: undefined
+    }, dropdownContent);
+  }
+  dropdownContent = /*#__PURE__*/React.createElement(FilterDropdownMenuWrapper, {
+    className: `${prefixCls}-dropdown`
+  }, dropdownContent);
+  const getDropdownTrigger = () => {
+    let filterIcon;
+    if (typeof column.filterIcon === 'function') {
+      filterIcon = column.filterIcon(filtered);
+    } else if (column.filterIcon) {
+      filterIcon = column.filterIcon;
+    } else {
+      filterIcon = /*#__PURE__*/React.createElement(FilterFilled, null);
+    }
+    return /*#__PURE__*/React.createElement("span", {
+      role: "button",
+      tabIndex: -1,
+      className: classNames(`${prefixCls}-trigger`, {
+        active: filtered
+      }),
+      onClick: e => {
+        e.stopPropagation();
+      }
+    }, filterIcon);
+  };
+  const mergedDropdownProps = extendsObject({
+    trigger: ['click'],
+    placement: direction === 'rtl' ? 'bottomLeft' : 'bottomRight',
+    children: getDropdownTrigger(),
+    getPopupContainer
+  }, Object.assign(Object.assign({}, filterDropdownProps), {
+    rootClassName: classNames(rootClassName, filterDropdownProps.rootClassName),
+    open: mergedVisible,
+    onOpenChange: onVisibleChange,
+    popupRender: () => {
+      if (typeof (filterDropdownProps === null || filterDropdownProps === void 0 ? void 0 : filterDropdownProps.dropdownRender) === 'function') {
+        return filterDropdownProps.dropdownRender(dropdownContent);
+      }
+      return dropdownContent;
+    }
+  }));
+  return /*#__PURE__*/React.createElement("div", {
+    className: `${prefixCls}-column`
+  }, /*#__PURE__*/React.createElement("span", {
+    className: `${tablePrefixCls}-column-title`
+  }, children), /*#__PURE__*/React.createElement(Dropdown, Object.assign({}, mergedDropdownProps)));
+};
+export default FilterDropdown;

node_modules/antd/es/table/hooks/useFilter/FilterSearch.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import type { AnyObject } from '../../../_util/type';
+import type { FilterSearchType, TableLocale } from '../../interface';
+interface FilterSearchProps<RecordType = AnyObject> {
+    value: string;
+    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    filterSearch: FilterSearchType<RecordType>;
+    tablePrefixCls: string;
+    locale: TableLocale;
+}
+declare const FilterSearch: <RecordType extends AnyObject = AnyObject>(props: FilterSearchProps<RecordType>) => React.JSX.Element | null;
+export default FilterSearch;

node_modules/antd/es/table/hooks/useFilter/FilterSearch.js

@@ -0,0 +1,29 @@
+"use client";
+
+import * as React from 'react';
+import SearchOutlined from "@ant-design/icons/es/icons/SearchOutlined";
+import Input from '../../../input/Input';
+const FilterSearch = props => {
+  const {
+    value,
+    filterSearch,
+    tablePrefixCls,
+    locale,
+    onChange
+  } = props;
+  if (!filterSearch) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    className: `${tablePrefixCls}-filter-dropdown-search`
+  }, /*#__PURE__*/React.createElement(Input, {
+    prefix: /*#__PURE__*/React.createElement(SearchOutlined, null),
+    placeholder: locale.filterSearchPlaceholder,
+    onChange: onChange,
+    value: value,
+    // for skip min-width of input
+    htmlSize: 1,
+    className: `${tablePrefixCls}-filter-dropdown-search-input`
+  }));
+};
+export default FilterSearch;

node_modules/antd/es/table/hooks/useFilter/FilterWrapper.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export interface FilterDropdownMenuWrapperProps {
+    className?: string;
+}
+declare const FilterDropdownMenuWrapper: React.ForwardRefExoticComponent<FilterDropdownMenuWrapperProps & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+export default FilterDropdownMenuWrapper;

node_modules/antd/es/table/hooks/useFilter/FilterWrapper.js

@@ -0,0 +1,22 @@
+"use client";
+
+import * as React from 'react';
+import KeyCode from "rc-util/es/KeyCode";
+const onKeyDown = event => {
+  const {
+    keyCode
+  } = event;
+  if (keyCode === KeyCode.ENTER) {
+    event.stopPropagation();
+  }
+};
+const FilterDropdownMenuWrapper = /*#__PURE__*/React.forwardRef((props, ref) => (/*#__PURE__*/React.createElement("div", {
+  className: props.className,
+  onClick: e => e.stopPropagation(),
+  onKeyDown: onKeyDown,
+  ref: ref
+}, props.children)));
+if (process.env.NODE_ENV !== 'production') {
+  FilterDropdownMenuWrapper.displayName = 'FilterDropdownMenuWrapper';
+}
+export default FilterDropdownMenuWrapper;

node_modules/antd/es/table/hooks/useFilter/index.d.ts

@@ -0,0 +1,22 @@
+import type { AnyObject } from '../../../_util/type';
+import type { ColumnsType, ColumnType, FilterKey, FilterValue, GetPopupContainer, Key, TableLocale, TransformColumns } from '../../interface';
+import { flattenKeys } from './FilterDropdown';
+export interface FilterState<RecordType = AnyObject> {
+    column: ColumnType<RecordType>;
+    key: Key;
+    filteredKeys?: FilterKey;
+    forceFiltered?: boolean;
+}
+export declare const getFilterData: <RecordType extends AnyObject = AnyObject>(data: RecordType[], filterStates: FilterState<RecordType>[], childrenColumnName: string) => RecordType[];
+export interface FilterConfig<RecordType = AnyObject> {
+    prefixCls: string;
+    dropdownPrefixCls: string;
+    mergedColumns: ColumnsType<RecordType>;
+    locale: TableLocale;
+    onFilterChange: (filters: Record<string, FilterValue | null>, filterStates: FilterState<RecordType>[]) => void;
+    getPopupContainer?: GetPopupContainer;
+    rootClassName?: string;
+}
+declare const useFilter: <RecordType extends AnyObject = AnyObject>(props: FilterConfig<RecordType>) => [TransformColumns<RecordType>, FilterState<RecordType>[], Record<string, FilterValue | null>];
+export { flattenKeys };
+export default useFilter;

node_modules/antd/es/table/hooks/useFilter/index.js

@@ -0,0 +1,200 @@
+"use client";
+
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import { devUseWarning } from '../../../_util/warning';
+import { getColumnKey, getColumnPos, renderColumnTitle } from '../../util';
+import FilterDropdown, { flattenKeys } from './FilterDropdown';
+const collectFilterStates = (columns, init, pos) => {
+  let filterStates = [];
+  (columns || []).forEach((column, index) => {
+    var _a;
+    const columnPos = getColumnPos(index, pos);
+    const filterDropdownIsDefined = column.filterDropdown !== undefined;
+    if (column.filters || filterDropdownIsDefined || 'onFilter' in column) {
+      if ('filteredValue' in column) {
+        // Controlled
+        let filteredValues = column.filteredValue;
+        if (!filterDropdownIsDefined) {
+          filteredValues = (_a = filteredValues === null || filteredValues === void 0 ? void 0 : filteredValues.map(String)) !== null && _a !== void 0 ? _a : filteredValues;
+        }
+        filterStates.push({
+          column,
+          key: getColumnKey(column, columnPos),
+          filteredKeys: filteredValues,
+          forceFiltered: column.filtered
+        });
+      } else {
+        // Uncontrolled
+        filterStates.push({
+          column,
+          key: getColumnKey(column, columnPos),
+          filteredKeys: init && column.defaultFilteredValue ? column.defaultFilteredValue : undefined,
+          forceFiltered: column.filtered
+        });
+      }
+    }
+    if ('children' in column) {
+      filterStates = [].concat(_toConsumableArray(filterStates), _toConsumableArray(collectFilterStates(column.children, init, columnPos)));
+    }
+  });
+  return filterStates;
+};
+function injectFilter(prefixCls, dropdownPrefixCls, columns, filterStates, locale, triggerFilter, getPopupContainer, pos, rootClassName) {
+  return columns.map((column, index) => {
+    const columnPos = getColumnPos(index, pos);
+    const {
+      filterOnClose = true,
+      filterMultiple = true,
+      filterMode,
+      filterSearch
+    } = column;
+    let newColumn = column;
+    if (newColumn.filters || newColumn.filterDropdown) {
+      const columnKey = getColumnKey(newColumn, columnPos);
+      const filterState = filterStates.find(({
+        key
+      }) => columnKey === key);
+      newColumn = Object.assign(Object.assign({}, newColumn), {
+        title: renderProps => (/*#__PURE__*/React.createElement(FilterDropdown, {
+          tablePrefixCls: prefixCls,
+          prefixCls: `${prefixCls}-filter`,
+          dropdownPrefixCls: dropdownPrefixCls,
+          column: newColumn,
+          columnKey: columnKey,
+          filterState: filterState,
+          filterOnClose: filterOnClose,
+          filterMultiple: filterMultiple,
+          filterMode: filterMode,
+          filterSearch: filterSearch,
+          triggerFilter: triggerFilter,
+          locale: locale,
+          getPopupContainer: getPopupContainer,
+          rootClassName: rootClassName
+        }, renderColumnTitle(column.title, renderProps)))
+      });
+    }
+    if ('children' in newColumn) {
+      newColumn = Object.assign(Object.assign({}, newColumn), {
+        children: injectFilter(prefixCls, dropdownPrefixCls, newColumn.children, filterStates, locale, triggerFilter, getPopupContainer, columnPos, rootClassName)
+      });
+    }
+    return newColumn;
+  });
+}
+const generateFilterInfo = filterStates => {
+  const currentFilters = {};
+  filterStates.forEach(({
+    key,
+    filteredKeys,
+    column
+  }) => {
+    const keyAsString = key;
+    const {
+      filters,
+      filterDropdown
+    } = column;
+    if (filterDropdown) {
+      currentFilters[keyAsString] = filteredKeys || null;
+    } else if (Array.isArray(filteredKeys)) {
+      const keys = flattenKeys(filters);
+      currentFilters[keyAsString] = keys.filter(originKey => filteredKeys.includes(String(originKey)));
+    } else {
+      currentFilters[keyAsString] = null;
+    }
+  });
+  return currentFilters;
+};
+export const getFilterData = (data, filterStates, childrenColumnName) => {
+  const filterDatas = filterStates.reduce((currentData, filterState) => {
+    const {
+      column: {
+        onFilter,
+        filters
+      },
+      filteredKeys
+    } = filterState;
+    if (onFilter && filteredKeys && filteredKeys.length) {
+      return currentData
+      // shallow copy
+      .map(record => Object.assign({}, record)).filter(record => filteredKeys.some(key => {
+        const keys = flattenKeys(filters);
+        const keyIndex = keys.findIndex(k => String(k) === String(key));
+        const realKey = keyIndex !== -1 ? keys[keyIndex] : key;
+        // filter children
+        if (record[childrenColumnName]) {
+          record[childrenColumnName] = getFilterData(record[childrenColumnName], filterStates, childrenColumnName);
+        }
+        return onFilter(realKey, record);
+      }));
+    }
+    return currentData;
+  }, data);
+  return filterDatas;
+};
+const getMergedColumns = rawMergedColumns => rawMergedColumns.flatMap(column => {
+  if ('children' in column) {
+    return [column].concat(_toConsumableArray(getMergedColumns(column.children || [])));
+  }
+  return [column];
+});
+const useFilter = props => {
+  const {
+    prefixCls,
+    dropdownPrefixCls,
+    mergedColumns: rawMergedColumns,
+    onFilterChange,
+    getPopupContainer,
+    locale: tableLocale,
+    rootClassName
+  } = props;
+  const warning = devUseWarning('Table');
+  const mergedColumns = React.useMemo(() => getMergedColumns(rawMergedColumns || []), [rawMergedColumns]);
+  const [filterStates, setFilterStates] = React.useState(() => collectFilterStates(mergedColumns, true));
+  const mergedFilterStates = React.useMemo(() => {
+    const collectedStates = collectFilterStates(mergedColumns, false);
+    if (collectedStates.length === 0) {
+      return collectedStates;
+    }
+    let filteredKeysIsAllNotControlled = true;
+    let filteredKeysIsAllControlled = true;
+    collectedStates.forEach(({
+      filteredKeys
+    }) => {
+      if (filteredKeys !== undefined) {
+        filteredKeysIsAllNotControlled = false;
+      } else {
+        filteredKeysIsAllControlled = false;
+      }
+    });
+    // Return if not controlled
+    if (filteredKeysIsAllNotControlled) {
+      // Filter column may have been removed
+      const keyList = (mergedColumns || []).map((column, index) => getColumnKey(column, getColumnPos(index)));
+      return filterStates.filter(({
+        key
+      }) => keyList.includes(key)).map(item => {
+        const col = mergedColumns[keyList.indexOf(item.key)];
+        return Object.assign(Object.assign({}, item), {
+          column: Object.assign(Object.assign({}, item.column), col),
+          forceFiltered: col.filtered
+        });
+      });
+    }
+    process.env.NODE_ENV !== "production" ? warning(filteredKeysIsAllControlled, 'usage', 'Columns should all contain `filteredValue` or not contain `filteredValue`.') : void 0;
+    return collectedStates;
+  }, [mergedColumns, filterStates]);
+  const filters = React.useMemo(() => generateFilterInfo(mergedFilterStates), [mergedFilterStates]);
+  const triggerFilter = filterState => {
+    const newFilterStates = mergedFilterStates.filter(({
+      key
+    }) => key !== filterState.key);
+    newFilterStates.push(filterState);
+    setFilterStates(newFilterStates);
+    onFilterChange(generateFilterInfo(newFilterStates), newFilterStates);
+  };
+  const transformColumns = innerColumns => injectFilter(prefixCls, dropdownPrefixCls, innerColumns, mergedFilterStates, tableLocale, triggerFilter, getPopupContainer, undefined, rootClassName);
+  return [transformColumns, mergedFilterStates, filters];
+};
+export { flattenKeys };
+export default useFilter;

node_modules/antd/es/table/hooks/useLazyKVMap.d.ts

@@ -0,0 +1,4 @@
+import type { AnyObject } from '../../_util/type';
+import type { GetRowKey, Key } from '../interface';
+declare const useLazyKVMap: <RecordType extends AnyObject = AnyObject>(data: readonly RecordType[], childrenColumnName: string, getRowKey: GetRowKey<RecordType>) => readonly [(key: Key) => RecordType];
+export default useLazyKVMap;

node_modules/antd/es/table/hooks/useLazyKVMap.js

@@ -0,0 +1,29 @@
+import * as React from 'react';
+const useLazyKVMap = (data, childrenColumnName, getRowKey) => {
+  const mapCacheRef = React.useRef({});
+  function getRecordByKey(key) {
+    var _a;
+    if (!mapCacheRef.current || mapCacheRef.current.data !== data || mapCacheRef.current.childrenColumnName !== childrenColumnName || mapCacheRef.current.getRowKey !== getRowKey) {
+      const kvMap = new Map();
+      function dig(records) {
+        records.forEach((record, index) => {
+          const rowKey = getRowKey(record, index);
+          kvMap.set(rowKey, record);
+          if (record && typeof record === 'object' && childrenColumnName in record) {
+            dig(record[childrenColumnName] || []);
+          }
+        });
+      }
+      dig(data);
+      mapCacheRef.current = {
+        data,
+        childrenColumnName,
+        kvMap,
+        getRowKey
+      };
+    }
+    return (_a = mapCacheRef.current.kvMap) === null || _a === void 0 ? void 0 : _a.get(key);
+  }
+  return [getRecordByKey];
+};
+export default useLazyKVMap;

node_modules/antd/es/table/hooks/usePagination.d.ts

@@ -0,0 +1,5 @@
+import type { TablePaginationConfig } from '../interface';
+export declare const DEFAULT_PAGE_SIZE = 10;
+export declare function getPaginationParam(mergedPagination: TablePaginationConfig, pagination?: TablePaginationConfig | boolean): any;
+declare function usePagination(total: number, onChange: (current: number, pageSize: number) => void, pagination?: TablePaginationConfig | false): readonly [TablePaginationConfig, (current?: number, pageSize?: number) => void];
+export default usePagination;

node_modules/antd/es/table/hooks/usePagination.js

@@ -0,0 +1,67 @@
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { useState } from 'react';
+import extendsObject from '../../_util/extendsObject';
+export const DEFAULT_PAGE_SIZE = 10;
+export function getPaginationParam(mergedPagination, pagination) {
+  const param = {
+    current: mergedPagination.current,
+    pageSize: mergedPagination.pageSize
+  };
+  const paginationObj = pagination && typeof pagination === 'object' ? pagination : {};
+  Object.keys(paginationObj).forEach(pageProp => {
+    const value = mergedPagination[pageProp];
+    if (typeof value !== 'function') {
+      param[pageProp] = value;
+    }
+  });
+  return param;
+}
+function usePagination(total, onChange, pagination) {
+  const _a = pagination && typeof pagination === 'object' ? pagination : {},
+    {
+      total: paginationTotal = 0
+    } = _a,
+    paginationObj = __rest(_a, ["total"]);
+  const [innerPagination, setInnerPagination] = useState(() => ({
+    current: 'defaultCurrent' in paginationObj ? paginationObj.defaultCurrent : 1,
+    pageSize: 'defaultPageSize' in paginationObj ? paginationObj.defaultPageSize : DEFAULT_PAGE_SIZE
+  }));
+  // ============ Basic Pagination Config ============
+  const mergedPagination = extendsObject(innerPagination, paginationObj, {
+    total: paginationTotal > 0 ? paginationTotal : total
+  });
+  // Reset `current` if data length or pageSize changed
+  const maxPage = Math.ceil((paginationTotal || total) / mergedPagination.pageSize);
+  if (mergedPagination.current > maxPage) {
+    // Prevent a maximum page count of 0
+    mergedPagination.current = maxPage || 1;
+  }
+  const refreshPagination = (current, pageSize) => {
+    setInnerPagination({
+      current: current !== null && current !== void 0 ? current : 1,
+      pageSize: pageSize || mergedPagination.pageSize
+    });
+  };
+  const onInternalChange = (current, pageSize) => {
+    var _a;
+    if (pagination) {
+      (_a = pagination.onChange) === null || _a === void 0 ? void 0 : _a.call(pagination, current, pageSize);
+    }
+    refreshPagination(current, pageSize);
+    onChange(current, pageSize || (mergedPagination === null || mergedPagination === void 0 ? void 0 : mergedPagination.pageSize));
+  };
+  if (pagination === false) {
+    return [{}, () => {}];
+  }
+  return [Object.assign(Object.assign({}, mergedPagination), {
+    onChange: onInternalChange
+  }), refreshPagination];
+}
+export default usePagination;

node_modules/antd/es/table/hooks/useSelection.d.ts

@@ -0,0 +1,20 @@
+import type { AnyObject } from '../../_util/type';
+import type { ExpandType, GetPopupContainer, GetRowKey, Key, SelectionItem, TableLocale, TableRowSelection, TransformColumns } from '../interface';
+export declare const SELECTION_COLUMN: {};
+export declare const SELECTION_ALL: "SELECT_ALL";
+export declare const SELECTION_INVERT: "SELECT_INVERT";
+export declare const SELECTION_NONE: "SELECT_NONE";
+interface UseSelectionConfig<RecordType = AnyObject> {
+    prefixCls: string;
+    pageData: RecordType[];
+    data: RecordType[];
+    getRowKey: GetRowKey<RecordType>;
+    getRecordByKey: (key: Key) => RecordType;
+    expandType: ExpandType;
+    childrenColumnName: string;
+    locale: TableLocale;
+    getPopupContainer?: GetPopupContainer;
+}
+export type INTERNAL_SELECTION_ITEM = SelectionItem | typeof SELECTION_ALL | typeof SELECTION_INVERT | typeof SELECTION_NONE;
+declare const useSelection: <RecordType extends AnyObject = AnyObject>(config: UseSelectionConfig<RecordType>, rowSelection?: TableRowSelection<RecordType>) => readonly [TransformColumns<RecordType>, Set<Key>];
+export default useSelection;

node_modules/antd/es/table/hooks/useSelection.js

@@ -0,0 +1,536 @@
+"use client";
+
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import { useCallback, useMemo } from 'react';
+import DownOutlined from "@ant-design/icons/es/icons/DownOutlined";
+import classNames from 'classnames';
+import { INTERNAL_COL_DEFINE } from 'rc-table';
+import { arrAdd, arrDel } from "rc-tree/es/util";
+import { conductCheck } from "rc-tree/es/utils/conductUtil";
+import { convertDataToEntities } from "rc-tree/es/utils/treeUtil";
+import useMergedState from "rc-util/es/hooks/useMergedState";
+import { useMultipleSelect } from '../../_util/hooks';
+import { devUseWarning } from '../../_util/warning';
+import Checkbox from '../../checkbox';
+import Dropdown from '../../dropdown';
+import Radio from '../../radio';
+// TODO: warning if use ajax!!!
+export const SELECTION_COLUMN = {};
+export const SELECTION_ALL = 'SELECT_ALL';
+export const SELECTION_INVERT = 'SELECT_INVERT';
+export const SELECTION_NONE = 'SELECT_NONE';
+const EMPTY_LIST = [];
+const flattenData = (childrenColumnName, data, list = []) => {
+  (data || []).forEach(record => {
+    list.push(record);
+    if (record && typeof record === 'object' && childrenColumnName in record) {
+      flattenData(childrenColumnName, record[childrenColumnName], list);
+    }
+  });
+  return list;
+};
+const useSelection = (config, rowSelection) => {
+  const {
+    preserveSelectedRowKeys,
+    selectedRowKeys,
+    defaultSelectedRowKeys,
+    getCheckboxProps,
+    getTitleCheckboxProps,
+    onChange: onSelectionChange,
+    onSelect,
+    onSelectAll,
+    onSelectInvert,
+    onSelectNone,
+    onSelectMultiple,
+    columnWidth: selectionColWidth,
+    type: selectionType,
+    selections,
+    fixed,
+    renderCell: customizeRenderCell,
+    hideSelectAll,
+    checkStrictly = true
+  } = rowSelection || {};
+  const {
+    prefixCls,
+    data,
+    pageData,
+    getRecordByKey,
+    getRowKey,
+    expandType,
+    childrenColumnName,
+    locale: tableLocale,
+    getPopupContainer
+  } = config;
+  const warning = devUseWarning('Table');
+  // ========================= MultipleSelect =========================
+  const [multipleSelect, updatePrevSelectedIndex] = useMultipleSelect(item => item);
+  // ========================= Keys =========================
+  const [mergedSelectedKeys, setMergedSelectedKeys] = useMergedState(selectedRowKeys || defaultSelectedRowKeys || EMPTY_LIST, {
+    value: selectedRowKeys
+  });
+  // ======================== Caches ========================
+  const preserveRecordsRef = React.useRef(new Map());
+  const updatePreserveRecordsCache = useCallback(keys => {
+    if (preserveSelectedRowKeys) {
+      const newCache = new Map();
+      // Keep key if mark as preserveSelectedRowKeys
+      keys.forEach(key => {
+        let record = getRecordByKey(key);
+        if (!record && preserveRecordsRef.current.has(key)) {
+          record = preserveRecordsRef.current.get(key);
+        }
+        newCache.set(key, record);
+      });
+      // Refresh to new cache
+      preserveRecordsRef.current = newCache;
+    }
+  }, [getRecordByKey, preserveSelectedRowKeys]);
+  // Update cache with selectedKeys
+  React.useEffect(() => {
+    updatePreserveRecordsCache(mergedSelectedKeys);
+  }, [mergedSelectedKeys]);
+  // Get flatten data
+  const flattedData = useMemo(() => flattenData(childrenColumnName, pageData), [childrenColumnName, pageData]);
+  const {
+    keyEntities
+  } = useMemo(() => {
+    if (checkStrictly) {
+      return {
+        keyEntities: null
+      };
+    }
+    let convertData = data;
+    if (preserveSelectedRowKeys) {
+      // use flattedData keys
+      const keysSet = new Set(flattedData.map((record, index) => getRowKey(record, index)));
+      // remove preserveRecords that duplicate data
+      const preserveRecords = Array.from(preserveRecordsRef.current).reduce((total, [key, value]) => keysSet.has(key) ? total : total.concat(value), []);
+      convertData = [].concat(_toConsumableArray(convertData), _toConsumableArray(preserveRecords));
+    }
+    return convertDataToEntities(convertData, {
+      externalGetKey: getRowKey,
+      childrenPropName: childrenColumnName
+    });
+  }, [data, getRowKey, checkStrictly, childrenColumnName, preserveSelectedRowKeys, flattedData]);
+  // Get all checkbox props
+  const checkboxPropsMap = useMemo(() => {
+    const map = new Map();
+    flattedData.forEach((record, index) => {
+      const key = getRowKey(record, index);
+      const checkboxProps = (getCheckboxProps ? getCheckboxProps(record) : null) || {};
+      map.set(key, checkboxProps);
+      process.env.NODE_ENV !== "production" ? warning(!('checked' in checkboxProps || 'defaultChecked' in checkboxProps), 'usage', 'Do not set `checked` or `defaultChecked` in `getCheckboxProps`. Please use `selectedRowKeys` instead.') : void 0;
+    });
+    return map;
+  }, [flattedData, getRowKey, getCheckboxProps]);
+  const isCheckboxDisabled = useCallback(r => {
+    const rowKey = getRowKey(r);
+    let checkboxProps;
+    if (checkboxPropsMap.has(rowKey)) {
+      checkboxProps = checkboxPropsMap.get(getRowKey(r));
+    } else {
+      checkboxProps = getCheckboxProps ? getCheckboxProps(r) : undefined;
+    }
+    return !!(checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.disabled);
+  }, [checkboxPropsMap, getRowKey]);
+  const [derivedSelectedKeys, derivedHalfSelectedKeys] = useMemo(() => {
+    if (checkStrictly) {
+      return [mergedSelectedKeys || [], []];
+    }
+    const {
+      checkedKeys,
+      halfCheckedKeys
+    } = conductCheck(mergedSelectedKeys, true, keyEntities, isCheckboxDisabled);
+    return [checkedKeys || [], halfCheckedKeys];
+  }, [mergedSelectedKeys, checkStrictly, keyEntities, isCheckboxDisabled]);
+  const derivedSelectedKeySet = useMemo(() => {
+    const keys = selectionType === 'radio' ? derivedSelectedKeys.slice(0, 1) : derivedSelectedKeys;
+    return new Set(keys);
+  }, [derivedSelectedKeys, selectionType]);
+  const derivedHalfSelectedKeySet = useMemo(() => selectionType === 'radio' ? new Set() : new Set(derivedHalfSelectedKeys), [derivedHalfSelectedKeys, selectionType]);
+  // Reset if rowSelection reset
+  React.useEffect(() => {
+    if (!rowSelection) {
+      setMergedSelectedKeys(EMPTY_LIST);
+    }
+  }, [!!rowSelection]);
+  const setSelectedKeys = useCallback((keys, method) => {
+    let availableKeys;
+    let records;
+    updatePreserveRecordsCache(keys);
+    if (preserveSelectedRowKeys) {
+      availableKeys = keys;
+      records = keys.map(key => preserveRecordsRef.current.get(key));
+    } else {
+      // Filter key which not exist in the `dataSource`
+      availableKeys = [];
+      records = [];
+      keys.forEach(key => {
+        const record = getRecordByKey(key);
+        if (record !== undefined) {
+          availableKeys.push(key);
+          records.push(record);
+        }
+      });
+    }
+    setMergedSelectedKeys(availableKeys);
+    onSelectionChange === null || onSelectionChange === void 0 ? void 0 : onSelectionChange(availableKeys, records, {
+      type: method
+    });
+  }, [setMergedSelectedKeys, getRecordByKey, onSelectionChange, preserveSelectedRowKeys]);
+  // ====================== Selections ======================
+  // Trigger single `onSelect` event
+  const triggerSingleSelection = useCallback((key, selected, keys, event) => {
+    if (onSelect) {
+      const rows = keys.map(k => getRecordByKey(k));
+      onSelect(getRecordByKey(key), selected, rows, event);
+    }
+    setSelectedKeys(keys, 'single');
+  }, [onSelect, getRecordByKey, setSelectedKeys]);
+  const mergedSelections = useMemo(() => {
+    if (!selections || hideSelectAll) {
+      return null;
+    }
+    const selectionList = selections === true ? [SELECTION_ALL, SELECTION_INVERT, SELECTION_NONE] : selections;
+    return selectionList.map(selection => {
+      if (selection === SELECTION_ALL) {
+        return {
+          key: 'all',
+          text: tableLocale.selectionAll,
+          onSelect() {
+            setSelectedKeys(data.map((record, index) => getRowKey(record, index)).filter(key => {
+              const checkProps = checkboxPropsMap.get(key);
+              return !(checkProps === null || checkProps === void 0 ? void 0 : checkProps.disabled) || derivedSelectedKeySet.has(key);
+            }), 'all');
+          }
+        };
+      }
+      if (selection === SELECTION_INVERT) {
+        return {
+          key: 'invert',
+          text: tableLocale.selectInvert,
+          onSelect() {
+            const keySet = new Set(derivedSelectedKeySet);
+            pageData.forEach((record, index) => {
+              const key = getRowKey(record, index);
+              const checkProps = checkboxPropsMap.get(key);
+              if (!(checkProps === null || checkProps === void 0 ? void 0 : checkProps.disabled)) {
+                if (keySet.has(key)) {
+                  keySet.delete(key);
+                } else {
+                  keySet.add(key);
+                }
+              }
+            });
+            const keys = Array.from(keySet);
+            if (onSelectInvert) {
+              warning.deprecated(false, 'onSelectInvert', 'onChange');
+              onSelectInvert(keys);
+            }
+            setSelectedKeys(keys, 'invert');
+          }
+        };
+      }
+      if (selection === SELECTION_NONE) {
+        return {
+          key: 'none',
+          text: tableLocale.selectNone,
+          onSelect() {
+            onSelectNone === null || onSelectNone === void 0 ? void 0 : onSelectNone();
+            setSelectedKeys(Array.from(derivedSelectedKeySet).filter(key => {
+              const checkProps = checkboxPropsMap.get(key);
+              return checkProps === null || checkProps === void 0 ? void 0 : checkProps.disabled;
+            }), 'none');
+          }
+        };
+      }
+      return selection;
+    }).map(selection => Object.assign(Object.assign({}, selection), {
+      onSelect: (...rest) => {
+        var _a2;
+        var _a;
+        (_a = selection.onSelect) === null || _a === void 0 ? void 0 : (_a2 = _a).call.apply(_a2, [selection].concat(rest));
+        updatePrevSelectedIndex(null);
+      }
+    }));
+  }, [selections, derivedSelectedKeySet, pageData, getRowKey, onSelectInvert, setSelectedKeys]);
+  // ======================= Columns ========================
+  const transformColumns = useCallback(columns => {
+    var _a;
+    // >>>>>>>>>>> Skip if not exists `rowSelection`
+    if (!rowSelection) {
+      process.env.NODE_ENV !== "production" ? warning(!columns.includes(SELECTION_COLUMN), 'usage', '`rowSelection` is not config but `SELECTION_COLUMN` exists in the `columns`.') : void 0;
+      return columns.filter(col => col !== SELECTION_COLUMN);
+    }
+    // >>>>>>>>>>> Support selection
+    let cloneColumns = _toConsumableArray(columns);
+    const keySet = new Set(derivedSelectedKeySet);
+    // Record key only need check with enabled
+    const recordKeys = flattedData.map(getRowKey).filter(key => !checkboxPropsMap.get(key).disabled);
+    const checkedCurrentAll = recordKeys.every(key => keySet.has(key));
+    const checkedCurrentSome = recordKeys.some(key => keySet.has(key));
+    const onSelectAllChange = () => {
+      const changeKeys = [];
+      if (checkedCurrentAll) {
+        recordKeys.forEach(key => {
+          keySet.delete(key);
+          changeKeys.push(key);
+        });
+      } else {
+        recordKeys.forEach(key => {
+          if (!keySet.has(key)) {
+            keySet.add(key);
+            changeKeys.push(key);
+          }
+        });
+      }
+      const keys = Array.from(keySet);
+      onSelectAll === null || onSelectAll === void 0 ? void 0 : onSelectAll(!checkedCurrentAll, keys.map(k => getRecordByKey(k)), changeKeys.map(k => getRecordByKey(k)));
+      setSelectedKeys(keys, 'all');
+      updatePrevSelectedIndex(null);
+    };
+    // ===================== Render =====================
+    // Title Cell
+    let title;
+    let columnTitleCheckbox;
+    if (selectionType !== 'radio') {
+      let customizeSelections;
+      if (mergedSelections) {
+        const menu = {
+          getPopupContainer,
+          items: mergedSelections.map((selection, index) => {
+            const {
+              key,
+              text,
+              onSelect: onSelectionClick
+            } = selection;
+            return {
+              key: key !== null && key !== void 0 ? key : index,
+              onClick: () => {
+                onSelectionClick === null || onSelectionClick === void 0 ? void 0 : onSelectionClick(recordKeys);
+              },
+              label: text
+            };
+          })
+        };
+        customizeSelections = /*#__PURE__*/React.createElement("div", {
+          className: `${prefixCls}-selection-extra`
+        }, /*#__PURE__*/React.createElement(Dropdown, {
+          menu: menu,
+          getPopupContainer: getPopupContainer
+        }, /*#__PURE__*/React.createElement("span", null, /*#__PURE__*/React.createElement(DownOutlined, null))));
+      }
+      const allDisabledData = flattedData.map((record, index) => {
+        const key = getRowKey(record, index);
+        const checkboxProps = checkboxPropsMap.get(key) || {};
+        return Object.assign({
+          checked: keySet.has(key)
+        }, checkboxProps);
+      }).filter(({
+        disabled
+      }) => disabled);
+      const allDisabled = !!allDisabledData.length && allDisabledData.length === flattedData.length;
+      const allDisabledAndChecked = allDisabled && allDisabledData.every(({
+        checked
+      }) => checked);
+      const allDisabledSomeChecked = allDisabled && allDisabledData.some(({
+        checked
+      }) => checked);
+      const customCheckboxProps = (getTitleCheckboxProps === null || getTitleCheckboxProps === void 0 ? void 0 : getTitleCheckboxProps()) || {};
+      const {
+        onChange,
+        disabled
+      } = customCheckboxProps;
+      columnTitleCheckbox = /*#__PURE__*/React.createElement(Checkbox, Object.assign({
+        "aria-label": customizeSelections ? 'Custom selection' : 'Select all'
+      }, customCheckboxProps, {
+        checked: !allDisabled ? !!flattedData.length && checkedCurrentAll : allDisabledAndChecked,
+        indeterminate: !allDisabled ? !checkedCurrentAll && checkedCurrentSome : !allDisabledAndChecked && allDisabledSomeChecked,
+        onChange: e => {
+          onSelectAllChange();
+          onChange === null || onChange === void 0 ? void 0 : onChange(e);
+        },
+        disabled: disabled !== null && disabled !== void 0 ? disabled : flattedData.length === 0 || allDisabled,
+        skipGroup: true
+      }));
+      title = !hideSelectAll && (/*#__PURE__*/React.createElement("div", {
+        className: `${prefixCls}-selection`
+      }, columnTitleCheckbox, customizeSelections));
+    }
+    // Body Cell
+    let renderCell;
+    if (selectionType === 'radio') {
+      renderCell = (_, record, index) => {
+        const key = getRowKey(record, index);
+        const checked = keySet.has(key);
+        const checkboxProps = checkboxPropsMap.get(key);
+        return {
+          node: (/*#__PURE__*/React.createElement(Radio, Object.assign({}, checkboxProps, {
+            checked: checked,
+            onClick: e => {
+              var _a;
+              e.stopPropagation();
+              (_a = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.onClick) === null || _a === void 0 ? void 0 : _a.call(checkboxProps, e);
+            },
+            onChange: event => {
+              var _a;
+              if (!keySet.has(key)) {
+                triggerSingleSelection(key, true, [key], event.nativeEvent);
+              }
+              (_a = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.onChange) === null || _a === void 0 ? void 0 : _a.call(checkboxProps, event);
+            }
+          }))),
+          checked
+        };
+      };
+    } else {
+      renderCell = (_, record, index) => {
+        var _a;
+        const key = getRowKey(record, index);
+        const checked = keySet.has(key);
+        const indeterminate = derivedHalfSelectedKeySet.has(key);
+        const checkboxProps = checkboxPropsMap.get(key);
+        let mergedIndeterminate;
+        if (expandType === 'nest') {
+          mergedIndeterminate = indeterminate;
+          process.env.NODE_ENV !== "production" ? warning(typeof (checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.indeterminate) !== 'boolean', 'usage', 'set `indeterminate` using `rowSelection.getCheckboxProps` is not allowed with tree structured dataSource.') : void 0;
+        } else {
+          mergedIndeterminate = (_a = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.indeterminate) !== null && _a !== void 0 ? _a : indeterminate;
+        }
+        // Record checked
+        return {
+          node: (/*#__PURE__*/React.createElement(Checkbox, Object.assign({}, checkboxProps, {
+            indeterminate: mergedIndeterminate,
+            checked: checked,
+            skipGroup: true,
+            onClick: e => {
+              var _a;
+              e.stopPropagation();
+              (_a = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.onClick) === null || _a === void 0 ? void 0 : _a.call(checkboxProps, e);
+            },
+            onChange: event => {
+              var _a;
+              const {
+                nativeEvent
+              } = event;
+              const {
+                shiftKey
+              } = nativeEvent;
+              const currentSelectedIndex = recordKeys.indexOf(key);
+              const isMultiple = derivedSelectedKeys.some(item => recordKeys.includes(item));
+              if (shiftKey && checkStrictly && isMultiple) {
+                const changedKeys = multipleSelect(currentSelectedIndex, recordKeys, keySet);
+                const keys = Array.from(keySet);
+                onSelectMultiple === null || onSelectMultiple === void 0 ? void 0 : onSelectMultiple(!checked, keys.map(recordKey => getRecordByKey(recordKey)), changedKeys.map(recordKey => getRecordByKey(recordKey)));
+                setSelectedKeys(keys, 'multiple');
+              } else {
+                // Single record selected
+                const originCheckedKeys = derivedSelectedKeys;
+                if (checkStrictly) {
+                  const checkedKeys = checked ? arrDel(originCheckedKeys, key) : arrAdd(originCheckedKeys, key);
+                  triggerSingleSelection(key, !checked, checkedKeys, nativeEvent);
+                } else {
+                  // Always fill first
+                  const result = conductCheck([].concat(_toConsumableArray(originCheckedKeys), [key]), true, keyEntities, isCheckboxDisabled);
+                  const {
+                    checkedKeys,
+                    halfCheckedKeys
+                  } = result;
+                  let nextCheckedKeys = checkedKeys;
+                  // If remove, we do it again to correction
+                  if (checked) {
+                    const tempKeySet = new Set(checkedKeys);
+                    tempKeySet.delete(key);
+                    nextCheckedKeys = conductCheck(Array.from(tempKeySet), {
+                      checked: false,
+                      halfCheckedKeys
+                    }, keyEntities, isCheckboxDisabled).checkedKeys;
+                  }
+                  triggerSingleSelection(key, !checked, nextCheckedKeys, nativeEvent);
+                }
+              }
+              if (checked) {
+                updatePrevSelectedIndex(null);
+              } else {
+                updatePrevSelectedIndex(currentSelectedIndex);
+              }
+              (_a = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.onChange) === null || _a === void 0 ? void 0 : _a.call(checkboxProps, event);
+            }
+          }))),
+          checked
+        };
+      };
+    }
+    const renderSelectionCell = (_, record, index) => {
+      const {
+        node,
+        checked
+      } = renderCell(_, record, index);
+      if (customizeRenderCell) {
+        return customizeRenderCell(checked, record, index, node);
+      }
+      return node;
+    };
+    // Insert selection column if not exist
+    if (!cloneColumns.includes(SELECTION_COLUMN)) {
+      // Always after expand icon
+      if (cloneColumns.findIndex(col => {
+        var _a;
+        return ((_a = col[INTERNAL_COL_DEFINE]) === null || _a === void 0 ? void 0 : _a.columnType) === 'EXPAND_COLUMN';
+      }) === 0) {
+        const [expandColumn, ...restColumns] = cloneColumns;
+        cloneColumns = [expandColumn, SELECTION_COLUMN].concat(_toConsumableArray(restColumns));
+      } else {
+        // Normal insert at first column
+        cloneColumns = [SELECTION_COLUMN].concat(_toConsumableArray(cloneColumns));
+      }
+    }
+    // Deduplicate selection column
+    const selectionColumnIndex = cloneColumns.indexOf(SELECTION_COLUMN);
+    process.env.NODE_ENV !== "production" ? warning(cloneColumns.filter(col => col === SELECTION_COLUMN).length <= 1, 'usage', 'Multiple `SELECTION_COLUMN` exist in `columns`.') : void 0;
+    cloneColumns = cloneColumns.filter((column, index) => column !== SELECTION_COLUMN || index === selectionColumnIndex);
+    // Fixed column logic
+    const prevCol = cloneColumns[selectionColumnIndex - 1];
+    const nextCol = cloneColumns[selectionColumnIndex + 1];
+    let mergedFixed = fixed;
+    if (mergedFixed === undefined) {
+      if ((nextCol === null || nextCol === void 0 ? void 0 : nextCol.fixed) !== undefined) {
+        mergedFixed = nextCol.fixed;
+      } else if ((prevCol === null || prevCol === void 0 ? void 0 : prevCol.fixed) !== undefined) {
+        mergedFixed = prevCol.fixed;
+      }
+    }
+    if (mergedFixed && prevCol && ((_a = prevCol[INTERNAL_COL_DEFINE]) === null || _a === void 0 ? void 0 : _a.columnType) === 'EXPAND_COLUMN' && prevCol.fixed === undefined) {
+      prevCol.fixed = mergedFixed;
+    }
+    const columnCls = classNames(`${prefixCls}-selection-col`, {
+      [`${prefixCls}-selection-col-with-dropdown`]: selections && selectionType === 'checkbox'
+    });
+    const renderColumnTitle = () => {
+      if (!(rowSelection === null || rowSelection === void 0 ? void 0 : rowSelection.columnTitle)) {
+        return title;
+      }
+      if (typeof rowSelection.columnTitle === 'function') {
+        return rowSelection.columnTitle(columnTitleCheckbox);
+      }
+      return rowSelection.columnTitle;
+    };
+    // Replace with real selection column
+    const selectionColumn = {
+      fixed: mergedFixed,
+      width: selectionColWidth,
+      className: `${prefixCls}-selection-column`,
+      title: renderColumnTitle(),
+      render: renderSelectionCell,
+      onCell: rowSelection.onCell,
+      align: rowSelection.align,
+      [INTERNAL_COL_DEFINE]: {
+        className: columnCls
+      }
+    };
+    return cloneColumns.map(col => col === SELECTION_COLUMN ? selectionColumn : col);
+  }, [getRowKey, flattedData, rowSelection, derivedSelectedKeys, derivedSelectedKeySet, derivedHalfSelectedKeySet, selectionColWidth, mergedSelections, expandType, checkboxPropsMap, onSelectMultiple, triggerSingleSelection, isCheckboxDisabled]);
+  return [transformColumns, derivedSelectedKeySet];
+};
+export default useSelection;

node_modules/antd/es/table/hooks/useSorter.d.ts

@@ -0,0 +1,19 @@
+import type { AnyObject } from '../../_util/type';
+import type { ColumnsType, ColumnTitleProps, ColumnType, Key, SorterResult, SorterTooltipProps, SortOrder, TableLocale, TransformColumns } from '../interface';
+export interface SortState<RecordType = AnyObject> {
+    column: ColumnType<RecordType>;
+    key: Key;
+    sortOrder: SortOrder | null;
+    multiplePriority: number | false;
+}
+export declare const getSortData: <RecordType extends AnyObject = AnyObject>(data: readonly RecordType[], sortStates: SortState<RecordType>[], childrenColumnName: string) => RecordType[];
+interface SorterConfig<RecordType = AnyObject> {
+    prefixCls: string;
+    mergedColumns: ColumnsType<RecordType>;
+    onSorterChange: (sorterResult: SorterResult<RecordType> | SorterResult<RecordType>[], sortStates: SortState<RecordType>[]) => void;
+    sortDirections: SortOrder[];
+    tableLocale?: TableLocale;
+    showSorterTooltip?: boolean | SorterTooltipProps;
+}
+declare const useFilterSorter: <RecordType extends AnyObject = AnyObject>(props: SorterConfig<RecordType>) => [TransformColumns<RecordType>, SortState<RecordType>[], ColumnTitleProps<RecordType>, () => SorterResult<RecordType> | SorterResult<RecordType>[]];
+export default useFilterSorter;

node_modules/antd/es/table/hooks/useSorter.js

@@ -0,0 +1,363 @@
+"use client";
+
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import CaretDownOutlined from "@ant-design/icons/es/icons/CaretDownOutlined";
+import CaretUpOutlined from "@ant-design/icons/es/icons/CaretUpOutlined";
+import classNames from 'classnames';
+import KeyCode from "rc-util/es/KeyCode";
+import Tooltip from '../../tooltip';
+import { getColumnKey, getColumnPos, renderColumnTitle, safeColumnTitle } from '../util';
+const ASCEND = 'ascend';
+const DESCEND = 'descend';
+const getMultiplePriority = column => {
+  if (typeof column.sorter === 'object' && typeof column.sorter.multiple === 'number') {
+    return column.sorter.multiple;
+  }
+  return false;
+};
+const getSortFunction = sorter => {
+  if (typeof sorter === 'function') {
+    return sorter;
+  }
+  if (sorter && typeof sorter === 'object' && sorter.compare) {
+    return sorter.compare;
+  }
+  return false;
+};
+const nextSortDirection = (sortDirections, current) => {
+  if (!current) {
+    return sortDirections[0];
+  }
+  return sortDirections[sortDirections.indexOf(current) + 1];
+};
+const collectSortStates = (columns, init, pos) => {
+  let sortStates = [];
+  const pushState = (column, columnPos) => {
+    sortStates.push({
+      column,
+      key: getColumnKey(column, columnPos),
+      multiplePriority: getMultiplePriority(column),
+      sortOrder: column.sortOrder
+    });
+  };
+  (columns || []).forEach((column, index) => {
+    const columnPos = getColumnPos(index, pos);
+    if (column.children) {
+      if ('sortOrder' in column) {
+        // Controlled
+        pushState(column, columnPos);
+      }
+      sortStates = [].concat(_toConsumableArray(sortStates), _toConsumableArray(collectSortStates(column.children, init, columnPos)));
+    } else if (column.sorter) {
+      if ('sortOrder' in column) {
+        // Controlled
+        pushState(column, columnPos);
+      } else if (init && column.defaultSortOrder) {
+        // Default sorter
+        sortStates.push({
+          column,
+          key: getColumnKey(column, columnPos),
+          multiplePriority: getMultiplePriority(column),
+          sortOrder: column.defaultSortOrder
+        });
+      }
+    }
+  });
+  return sortStates;
+};
+const injectSorter = (prefixCls, columns, sorterStates, triggerSorter, defaultSortDirections, tableLocale, tableShowSorterTooltip, pos) => {
+  const finalColumns = (columns || []).map((column, index) => {
+    const columnPos = getColumnPos(index, pos);
+    let newColumn = column;
+    if (newColumn.sorter) {
+      const sortDirections = newColumn.sortDirections || defaultSortDirections;
+      const showSorterTooltip = newColumn.showSorterTooltip === undefined ? tableShowSorterTooltip : newColumn.showSorterTooltip;
+      const columnKey = getColumnKey(newColumn, columnPos);
+      const sorterState = sorterStates.find(({
+        key
+      }) => key === columnKey);
+      const sortOrder = sorterState ? sorterState.sortOrder : null;
+      const nextSortOrder = nextSortDirection(sortDirections, sortOrder);
+      let sorter;
+      if (column.sortIcon) {
+        sorter = column.sortIcon({
+          sortOrder
+        });
+      } else {
+        const upNode = sortDirections.includes(ASCEND) && (/*#__PURE__*/React.createElement(CaretUpOutlined, {
+          className: classNames(`${prefixCls}-column-sorter-up`, {
+            active: sortOrder === ASCEND
+          })
+        }));
+        const downNode = sortDirections.includes(DESCEND) && (/*#__PURE__*/React.createElement(CaretDownOutlined, {
+          className: classNames(`${prefixCls}-column-sorter-down`, {
+            active: sortOrder === DESCEND
+          })
+        }));
+        sorter = /*#__PURE__*/React.createElement("span", {
+          className: classNames(`${prefixCls}-column-sorter`, {
+            [`${prefixCls}-column-sorter-full`]: !!(upNode && downNode)
+          })
+        }, /*#__PURE__*/React.createElement("span", {
+          className: `${prefixCls}-column-sorter-inner`,
+          "aria-hidden": "true"
+        }, upNode, downNode));
+      }
+      const {
+        cancelSort,
+        triggerAsc,
+        triggerDesc
+      } = tableLocale || {};
+      let sortTip = cancelSort;
+      if (nextSortOrder === DESCEND) {
+        sortTip = triggerDesc;
+      } else if (nextSortOrder === ASCEND) {
+        sortTip = triggerAsc;
+      }
+      const tooltipProps = typeof showSorterTooltip === 'object' ? Object.assign({
+        title: sortTip
+      }, showSorterTooltip) : {
+        title: sortTip
+      };
+      newColumn = Object.assign(Object.assign({}, newColumn), {
+        className: classNames(newColumn.className, {
+          [`${prefixCls}-column-sort`]: sortOrder
+        }),
+        title: renderProps => {
+          const columnSortersClass = `${prefixCls}-column-sorters`;
+          const renderColumnTitleWrapper = /*#__PURE__*/React.createElement("span", {
+            className: `${prefixCls}-column-title`
+          }, renderColumnTitle(column.title, renderProps));
+          const renderSortTitle = /*#__PURE__*/React.createElement("div", {
+            className: columnSortersClass
+          }, renderColumnTitleWrapper, sorter);
+          if (showSorterTooltip) {
+            if (typeof showSorterTooltip !== 'boolean' && (showSorterTooltip === null || showSorterTooltip === void 0 ? void 0 : showSorterTooltip.target) === 'sorter-icon') {
+              return /*#__PURE__*/React.createElement("div", {
+                className: classNames(columnSortersClass, `${columnSortersClass}-tooltip-target-sorter`)
+              }, renderColumnTitleWrapper, /*#__PURE__*/React.createElement(Tooltip, Object.assign({}, tooltipProps), sorter));
+            }
+            return /*#__PURE__*/React.createElement(Tooltip, Object.assign({}, tooltipProps), renderSortTitle);
+          }
+          return renderSortTitle;
+        },
+        onHeaderCell: col => {
+          var _a;
+          const cell = ((_a = column.onHeaderCell) === null || _a === void 0 ? void 0 : _a.call(column, col)) || {};
+          const originOnClick = cell.onClick;
+          const originOKeyDown = cell.onKeyDown;
+          cell.onClick = event => {
+            triggerSorter({
+              column,
+              key: columnKey,
+              sortOrder: nextSortOrder,
+              multiplePriority: getMultiplePriority(column)
+            });
+            originOnClick === null || originOnClick === void 0 ? void 0 : originOnClick(event);
+          };
+          cell.onKeyDown = event => {
+            if (event.keyCode === KeyCode.ENTER) {
+              triggerSorter({
+                column,
+                key: columnKey,
+                sortOrder: nextSortOrder,
+                multiplePriority: getMultiplePriority(column)
+              });
+              originOKeyDown === null || originOKeyDown === void 0 ? void 0 : originOKeyDown(event);
+            }
+          };
+          const renderTitle = safeColumnTitle(column.title, {});
+          const displayTitle = renderTitle === null || renderTitle === void 0 ? void 0 : renderTitle.toString();
+          // Inform the screen-reader so it can tell the visually impaired user which column is sorted
+          if (sortOrder) {
+            cell['aria-sort'] = sortOrder === 'ascend' ? 'ascending' : 'descending';
+          }
+          cell['aria-label'] = displayTitle || '';
+          cell.className = classNames(cell.className, `${prefixCls}-column-has-sorters`);
+          cell.tabIndex = 0;
+          if (column.ellipsis) {
+            cell.title = (renderTitle !== null && renderTitle !== void 0 ? renderTitle : '').toString();
+          }
+          return cell;
+        }
+      });
+    }
+    if ('children' in newColumn) {
+      newColumn = Object.assign(Object.assign({}, newColumn), {
+        children: injectSorter(prefixCls, newColumn.children, sorterStates, triggerSorter, defaultSortDirections, tableLocale, tableShowSorterTooltip, columnPos)
+      });
+    }
+    return newColumn;
+  });
+  return finalColumns;
+};
+const stateToInfo = sorterState => {
+  const {
+    column,
+    sortOrder
+  } = sorterState;
+  return {
+    column,
+    order: sortOrder,
+    field: column.dataIndex,
+    columnKey: column.key
+  };
+};
+const generateSorterInfo = sorterStates => {
+  const activeSorters = sorterStates.filter(({
+    sortOrder
+  }) => sortOrder).map(stateToInfo);
+  // =========== Legacy compatible support ===========
+  // https://github.com/ant-design/ant-design/pull/19226
+  if (activeSorters.length === 0 && sorterStates.length) {
+    const lastIndex = sorterStates.length - 1;
+    return Object.assign(Object.assign({}, stateToInfo(sorterStates[lastIndex])), {
+      column: undefined,
+      order: undefined,
+      field: undefined,
+      columnKey: undefined
+    });
+  }
+  if (activeSorters.length <= 1) {
+    return activeSorters[0] || {};
+  }
+  return activeSorters;
+};
+export const getSortData = (data, sortStates, childrenColumnName) => {
+  const innerSorterStates = sortStates.slice().sort((a, b) => b.multiplePriority - a.multiplePriority);
+  const cloneData = data.slice();
+  const runningSorters = innerSorterStates.filter(({
+    column: {
+      sorter
+    },
+    sortOrder
+  }) => getSortFunction(sorter) && sortOrder);
+  // Skip if no sorter needed
+  if (!runningSorters.length) {
+    return cloneData;
+  }
+  return cloneData.sort((record1, record2) => {
+    for (let i = 0; i < runningSorters.length; i += 1) {
+      const sorterState = runningSorters[i];
+      const {
+        column: {
+          sorter
+        },
+        sortOrder
+      } = sorterState;
+      const compareFn = getSortFunction(sorter);
+      if (compareFn && sortOrder) {
+        const compareResult = compareFn(record1, record2, sortOrder);
+        if (compareResult !== 0) {
+          return sortOrder === ASCEND ? compareResult : -compareResult;
+        }
+      }
+    }
+    return 0;
+  }).map(record => {
+    const subRecords = record[childrenColumnName];
+    if (subRecords) {
+      return Object.assign(Object.assign({}, record), {
+        [childrenColumnName]: getSortData(subRecords, sortStates, childrenColumnName)
+      });
+    }
+    return record;
+  });
+};
+const useFilterSorter = props => {
+  const {
+    prefixCls,
+    mergedColumns,
+    sortDirections,
+    tableLocale,
+    showSorterTooltip,
+    onSorterChange
+  } = props;
+  const [sortStates, setSortStates] = React.useState(() => collectSortStates(mergedColumns, true));
+  const getColumnKeys = (columns, pos) => {
+    const newKeys = [];
+    columns.forEach((item, index) => {
+      const columnPos = getColumnPos(index, pos);
+      newKeys.push(getColumnKey(item, columnPos));
+      if (Array.isArray(item.children)) {
+        const childKeys = getColumnKeys(item.children, columnPos);
+        newKeys.push.apply(newKeys, _toConsumableArray(childKeys));
+      }
+    });
+    return newKeys;
+  };
+  const mergedSorterStates = React.useMemo(() => {
+    let validate = true;
+    const collectedStates = collectSortStates(mergedColumns, false);
+    // Return if not controlled
+    if (!collectedStates.length) {
+      const mergedColumnsKeys = getColumnKeys(mergedColumns);
+      return sortStates.filter(({
+        key
+      }) => mergedColumnsKeys.includes(key));
+    }
+    const validateStates = [];
+    function patchStates(state) {
+      if (validate) {
+        validateStates.push(state);
+      } else {
+        validateStates.push(Object.assign(Object.assign({}, state), {
+          sortOrder: null
+        }));
+      }
+    }
+    let multipleMode = null;
+    collectedStates.forEach(state => {
+      if (multipleMode === null) {
+        patchStates(state);
+        if (state.sortOrder) {
+          if (state.multiplePriority === false) {
+            validate = false;
+          } else {
+            multipleMode = true;
+          }
+        }
+      } else if (multipleMode && state.multiplePriority !== false) {
+        patchStates(state);
+      } else {
+        validate = false;
+        patchStates(state);
+      }
+    });
+    return validateStates;
+  }, [mergedColumns, sortStates]);
+  // Get render columns title required props
+  const columnTitleSorterProps = React.useMemo(() => {
+    var _a, _b;
+    const sortColumns = mergedSorterStates.map(({
+      column,
+      sortOrder
+    }) => ({
+      column,
+      order: sortOrder
+    }));
+    return {
+      sortColumns,
+      // Legacy
+      sortColumn: (_a = sortColumns[0]) === null || _a === void 0 ? void 0 : _a.column,
+      sortOrder: (_b = sortColumns[0]) === null || _b === void 0 ? void 0 : _b.order
+    };
+  }, [mergedSorterStates]);
+  const triggerSorter = sortState => {
+    let newSorterStates;
+    if (sortState.multiplePriority === false || !mergedSorterStates.length || mergedSorterStates[0].multiplePriority === false) {
+      newSorterStates = [sortState];
+    } else {
+      newSorterStates = [].concat(_toConsumableArray(mergedSorterStates.filter(({
+        key
+      }) => key !== sortState.key)), [sortState]);
+    }
+    setSortStates(newSorterStates);
+    onSorterChange(generateSorterInfo(newSorterStates), newSorterStates);
+  };
+  const transformColumns = innerColumns => injectSorter(prefixCls, innerColumns, mergedSorterStates, triggerSorter, sortDirections, tableLocale, showSorterTooltip);
+  const getSorters = () => generateSorterInfo(mergedSorterStates);
+  return [transformColumns, mergedSorterStates, columnTitleSorterProps, getSorters];
+};
+export default useFilterSorter;

node_modules/antd/es/table/hooks/useTitleColumns.d.ts

@@ -0,0 +1,4 @@
+import type { AnyObject } from 'antd/es/_util/type';
+import type { ColumnTitleProps, TransformColumns } from '../interface';
+declare const useTitleColumns: <RecordType extends AnyObject = AnyObject>(columnTitleProps: ColumnTitleProps<RecordType>) => readonly [TransformColumns<RecordType>];
+export default useTitleColumns;

node_modules/antd/es/table/hooks/useTitleColumns.js

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { renderColumnTitle } from '../util';
+const fillTitle = (columns, columnTitleProps) => {
+  const finalColumns = columns.map(column => {
+    const cloneColumn = Object.assign({}, column);
+    cloneColumn.title = renderColumnTitle(column.title, columnTitleProps);
+    if ('children' in cloneColumn) {
+      cloneColumn.children = fillTitle(cloneColumn.children, columnTitleProps);
+    }
+    return cloneColumn;
+  });
+  return finalColumns;
+};
+const useTitleColumns = columnTitleProps => {
+  const filledColumns = React.useCallback(columns => fillTitle(columns, columnTitleProps), [columnTitleProps]);
+  return [filledColumns];
+};
+export default useTitleColumns;

node_modules/antd/es/table/index.d.ts

@@ -0,0 +1,7 @@
+import type { TablePaginationConfig, TableProps } from './InternalTable';
+import Table from './Table';
+export type { ColumnProps } from './Column';
+export type { ColumnGroupType, ColumnType, ColumnsType } from './interface';
+export type { Reference as TableRef } from 'rc-table';
+export type { TablePaginationConfig, TableProps };
+export default Table;

node_modules/antd/es/table/index.js

@@ -0,0 +1,4 @@
+"use client";
+
+import Table from './Table';
+export default Table;

node_modules/antd/es/table/interface.d.ts

@@ -0,0 +1,201 @@
+import type * as React from 'react';
+import type { Reference } from 'rc-table';
+import type { FixedType, GetComponentProps, ColumnType as RcColumnType, RenderedCell as RcRenderedCell } from 'rc-table/lib/interface';
+import { ExpandableConfig, GetRowKey } from 'rc-table/lib/interface';
+import type { Breakpoint } from '../_util/responsiveObserver';
+import type { AnyObject } from '../_util/type';
+import type { CheckboxProps } from '../checkbox';
+import type { DropdownProps } from '../dropdown';
+import type { PaginationProps } from '../pagination';
+import type { TooltipProps } from '../tooltip';
+import type { INTERNAL_SELECTION_ITEM } from './hooks/useSelection';
+import type { InternalTableProps, TableProps } from './InternalTable';
+export type RefTable = <RecordType = AnyObject>(props: React.PropsWithChildren<TableProps<RecordType>> & React.RefAttributes<Reference>) => React.ReactElement;
+export type RefInternalTable = <RecordType = AnyObject>(props: React.PropsWithChildren<InternalTableProps<RecordType>> & React.RefAttributes<Reference>) => React.ReactElement;
+export { ExpandableConfig, GetRowKey };
+export type Key = React.Key;
+export type SafeKey = Exclude<Key, bigint>;
+export type RowSelectionType = 'checkbox' | 'radio';
+export type SelectionItemSelectFn = (currentRowKeys: Key[]) => void;
+export type ExpandType = null | 'row' | 'nest';
+export interface TableLocale {
+    filterTitle?: string;
+    filterConfirm?: React.ReactNode;
+    filterReset?: React.ReactNode;
+    filterEmptyText?: React.ReactNode;
+    /**
+     * @deprecated Please use `filterCheckAll` instead.
+     */
+    filterCheckall?: React.ReactNode;
+    filterCheckAll?: React.ReactNode;
+    filterSearchPlaceholder?: string;
+    emptyText?: React.ReactNode | (() => React.ReactNode);
+    selectAll?: React.ReactNode;
+    selectNone?: React.ReactNode;
+    selectInvert?: React.ReactNode;
+    selectionAll?: React.ReactNode;
+    sortTitle?: string;
+    expand?: string;
+    collapse?: string;
+    triggerDesc?: string;
+    triggerAsc?: string;
+    cancelSort?: string;
+}
+export type SortOrder = 'descend' | 'ascend' | null;
+export type SorterTooltipTarget = 'full-header' | 'sorter-icon';
+export type SorterTooltipProps = TooltipProps & {
+    target?: SorterTooltipTarget;
+};
+declare const _TableActions: readonly ["paginate", "sort", "filter"];
+export type TableAction = (typeof _TableActions)[number];
+export type CompareFn<T = AnyObject> = (a: T, b: T, sortOrder?: SortOrder) => number;
+export interface ColumnFilterItem {
+    text: React.ReactNode;
+    value: React.Key | boolean;
+    children?: ColumnFilterItem[];
+}
+export interface ColumnTitleProps<RecordType = AnyObject> {
+    /** @deprecated Please use `sorterColumns` instead. */
+    sortOrder?: SortOrder;
+    /** @deprecated Please use `sorterColumns` instead. */
+    sortColumn?: ColumnType<RecordType>;
+    sortColumns?: {
+        column: ColumnType<RecordType>;
+        order: SortOrder;
+    }[];
+    filters?: Record<string, FilterValue>;
+}
+export type ColumnTitle<RecordType = AnyObject> = React.ReactNode | ((props: ColumnTitleProps<RecordType>) => React.ReactNode);
+export type FilterValue = (Key | boolean)[];
+export type FilterKey = (string | number)[] | null;
+export type FilterSearchType<RecordType = AnyObject> = boolean | ((input: string, record: RecordType) => boolean);
+export interface FilterConfirmProps {
+    closeDropdown: boolean;
+}
+export interface FilterRestProps {
+    confirm?: boolean;
+    closeDropdown?: boolean;
+}
+export interface FilterDropdownProps {
+    prefixCls: string;
+    setSelectedKeys: (selectedKeys: React.Key[]) => void;
+    selectedKeys: React.Key[];
+    /**
+     * Confirm filter value, if you want to close dropdown before commit, you can call with
+     * {closeDropdown: true}
+     */
+    confirm: (param?: FilterConfirmProps) => void;
+    clearFilters?: (param?: FilterRestProps) => void;
+    filters?: ColumnFilterItem[];
+    /** Only close filterDropdown */
+    close: () => void;
+    visible: boolean;
+}
+interface CoverableDropdownProps extends Omit<DropdownProps, 'onOpenChange' | 'overlay' | 'visible' | 'onVisibleChange'> {
+    onOpenChange?: (open: boolean) => void;
+}
+export interface ColumnType<RecordType = AnyObject> extends Omit<RcColumnType<RecordType>, 'title'> {
+    title?: ColumnTitle<RecordType>;
+    sorter?: boolean | CompareFn<RecordType> | {
+        compare?: CompareFn<RecordType>;
+        /** Config multiple sorter order priority */
+        multiple?: number;
+    };
+    sortOrder?: SortOrder;
+    defaultSortOrder?: SortOrder;
+    sortDirections?: SortOrder[];
+    sortIcon?: (props: {
+        sortOrder: SortOrder;
+    }) => React.ReactNode;
+    showSorterTooltip?: boolean | SorterTooltipProps;
+    filtered?: boolean;
+    filters?: ColumnFilterItem[];
+    filterDropdown?: React.ReactNode | ((props: FilterDropdownProps) => React.ReactNode);
+    filterOnClose?: boolean;
+    filterMultiple?: boolean;
+    filteredValue?: FilterValue | null;
+    defaultFilteredValue?: FilterValue | null;
+    filterIcon?: React.ReactNode | ((filtered: boolean) => React.ReactNode);
+    filterMode?: 'menu' | 'tree';
+    filterSearch?: FilterSearchType<ColumnFilterItem>;
+    onFilter?: (value: React.Key | boolean, record: RecordType) => boolean;
+    /**
+     * Can cover `<Dropdown>` props
+     * @since 5.22.0
+     */
+    filterDropdownProps?: CoverableDropdownProps;
+    filterResetToDefaultFilteredValue?: boolean;
+    responsive?: Breakpoint[];
+    /**
+     * @deprecated Please use `filterDropdownProps.open` instead.
+     * @since 4.23.0
+     */
+    filterDropdownOpen?: boolean;
+    /**
+     * @deprecated Please use `filterDropdownProps.onOpenChange` instead.
+     * @since 4.23.0
+     */
+    onFilterDropdownOpenChange?: (visible: boolean) => void;
+    /** @deprecated Please use `filterDropdownProps.open` instead. */
+    filterDropdownVisible?: boolean;
+    /** @deprecated Please use `filterDropdownProps.onOpenChange` instead */
+    onFilterDropdownVisibleChange?: (visible: boolean) => void;
+}
+export interface ColumnGroupType<RecordType = AnyObject> extends Omit<ColumnType<RecordType>, 'dataIndex'> {
+    children: ColumnsType<RecordType>;
+}
+export type ColumnsType<RecordType = AnyObject> = (ColumnGroupType<RecordType> | ColumnType<RecordType>)[];
+export interface SelectionItem {
+    key: string;
+    text: React.ReactNode;
+    onSelect?: SelectionItemSelectFn;
+}
+export type SelectionSelectFn<T = AnyObject> = (record: T, selected: boolean, selectedRows: T[], nativeEvent: Event) => void;
+export type RowSelectMethod = 'all' | 'none' | 'invert' | 'single' | 'multiple';
+export interface TableRowSelection<T = AnyObject> {
+    /** Keep the selection keys in list even the key not exist in `dataSource` anymore */
+    preserveSelectedRowKeys?: boolean;
+    type?: RowSelectionType;
+    selectedRowKeys?: Key[];
+    defaultSelectedRowKeys?: Key[];
+    onChange?: (selectedRowKeys: Key[], selectedRows: T[], info: {
+        type: RowSelectMethod;
+    }) => void;
+    getCheckboxProps?: (record: T) => Partial<Omit<CheckboxProps, 'checked' | 'defaultChecked'>>;
+    onSelect?: SelectionSelectFn<T>;
+    /** @deprecated This function is deprecated and should use `onChange` instead */
+    onSelectMultiple?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+    /** @deprecated This function is deprecated and should use `onChange` instead */
+    onSelectAll?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+    /** @deprecated This function is deprecated and should use `onChange` instead */
+    onSelectInvert?: (selectedRowKeys: Key[]) => void;
+    /** @deprecated This function is deprecated and should use `onChange` instead */
+    onSelectNone?: () => void;
+    selections?: INTERNAL_SELECTION_ITEM[] | boolean;
+    hideSelectAll?: boolean;
+    fixed?: FixedType;
+    columnWidth?: string | number;
+    columnTitle?: React.ReactNode | ((checkboxNode: React.ReactNode) => React.ReactNode);
+    checkStrictly?: boolean;
+    /** Set the alignment of the selection column */
+    align?: 'left' | 'center' | 'right';
+    renderCell?: (value: boolean, record: T, index: number, originNode: React.ReactNode) => React.ReactNode | RcRenderedCell<T>;
+    onCell?: GetComponentProps<T>;
+    getTitleCheckboxProps?: () => Partial<Omit<CheckboxProps, 'checked' | 'defaultChecked'>> & React.AriaAttributes;
+}
+export type TransformColumns<RecordType = AnyObject> = (columns: ColumnsType<RecordType>) => ColumnsType<RecordType>;
+export interface TableCurrentDataSource<RecordType = AnyObject> {
+    currentDataSource: RecordType[];
+    action: TableAction;
+}
+export interface SorterResult<RecordType = AnyObject> {
+    column?: ColumnType<RecordType>;
+    order?: SortOrder;
+    field?: Key | readonly Key[];
+    columnKey?: Key;
+}
+export type GetPopupContainer = (triggerNode: HTMLElement) => HTMLElement;
+type TablePaginationPosition = 'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight' | 'none';
+export interface TablePaginationConfig extends PaginationProps {
+    position?: TablePaginationPosition[];
+}

node_modules/antd/es/table/interface.js

@@ -0,0 +1,2 @@
+const _TableActions = ['paginate', 'sort', 'filter'];
+export {};

node_modules/antd/es/table/style/bordered.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genBorderedStyle: GenerateStyle<TableToken, CSSObject>;
+export default genBorderedStyle;

node_modules/antd/es/table/style/bordered.js

@@ -0,0 +1,139 @@
+import { unit } from '@ant-design/cssinjs';
+const genBorderedStyle = token => {
+  const {
+    componentCls,
+    lineWidth,
+    lineType,
+    tableBorderColor,
+    tableHeaderBg,
+    tablePaddingVertical,
+    tablePaddingHorizontal,
+    calc
+  } = token;
+  const tableBorder = `${unit(lineWidth)} ${lineType} ${tableBorderColor}`;
+  const getSizeBorderStyle = (size, paddingVertical, paddingHorizontal) => ({
+    [`&${componentCls}-${size}`]: {
+      [`> ${componentCls}-container`]: {
+        [`> ${componentCls}-content, > ${componentCls}-body`]: {
+          [`
+            > table > tbody > tr > th,
+            > table > tbody > tr > td
+          `]: {
+            [`> ${componentCls}-expanded-row-fixed`]: {
+              margin: `${unit(calc(paddingVertical).mul(-1).equal())}
+              ${unit(calc(calc(paddingHorizontal).add(lineWidth)).mul(-1).equal())}`
+            }
+          }
+        }
+      }
+    }
+  });
+  return {
+    [`${componentCls}-wrapper`]: {
+      [`${componentCls}${componentCls}-bordered`]: Object.assign(Object.assign(Object.assign({
+        // ============================ Title =============================
+        [`> ${componentCls}-title`]: {
+          border: tableBorder,
+          borderBottom: 0
+        },
+        // ============================ Content ============================
+        [`> ${componentCls}-container`]: {
+          borderInlineStart: tableBorder,
+          borderTop: tableBorder,
+          [`
+            > ${componentCls}-content,
+            > ${componentCls}-header,
+            > ${componentCls}-body,
+            > ${componentCls}-summary
+          `]: {
+            '> table': {
+              // ============================= Cell =============================
+              [`
+                > thead > tr > th,
+                > thead > tr > td,
+                > tbody > tr > th,
+                > tbody > tr > td,
+                > tfoot > tr > th,
+                > tfoot > tr > td
+              `]: {
+                borderInlineEnd: tableBorder
+              },
+              // ============================ Header ============================
+              '> thead': {
+                '> tr:not(:last-child) > th': {
+                  borderBottom: tableBorder
+                },
+                '> tr > th::before': {
+                  backgroundColor: 'transparent !important'
+                }
+              },
+              // Fixed right should provides additional border
+              [`
+                > thead > tr,
+                > tbody > tr,
+                > tfoot > tr
+              `]: {
+                [`> ${componentCls}-cell-fix-right-first::after`]: {
+                  borderInlineEnd: tableBorder
+                }
+              },
+              // ========================== Expandable ==========================
+              [`
+                > tbody > tr > th,
+                > tbody > tr > td
+              `]: {
+                [`> ${componentCls}-expanded-row-fixed`]: {
+                  margin: `${unit(calc(tablePaddingVertical).mul(-1).equal())} ${unit(calc(calc(tablePaddingHorizontal).add(lineWidth)).mul(-1).equal())}`,
+                  '&::after': {
+                    position: 'absolute',
+                    top: 0,
+                    insetInlineEnd: lineWidth,
+                    bottom: 0,
+                    borderInlineEnd: tableBorder,
+                    content: '""'
+                  }
+                }
+              }
+            }
+          }
+        },
+        // ============================ Scroll ============================
+        [`&${componentCls}-scroll-horizontal`]: {
+          [`> ${componentCls}-container > ${componentCls}-body`]: {
+            '> table > tbody': {
+              [`
+                > tr${componentCls}-expanded-row,
+                > tr${componentCls}-placeholder
+              `]: {
+                '> th, > td': {
+                  borderInlineEnd: 0
+                }
+              }
+            }
+          }
+        }
+      }, getSizeBorderStyle('middle', token.tablePaddingVerticalMiddle, token.tablePaddingHorizontalMiddle)), getSizeBorderStyle('small', token.tablePaddingVerticalSmall, token.tablePaddingHorizontalSmall)), {
+        // ============================ Footer ============================
+        [`> ${componentCls}-footer`]: {
+          border: tableBorder,
+          borderTop: 0
+        }
+      }),
+      // ============================ Nested ============================
+      [`${componentCls}-cell`]: {
+        [`${componentCls}-container:first-child`]: {
+          // :first-child to avoid the case when bordered and title is set
+          borderTop: 0
+        },
+        // https://github.com/ant-design/ant-design/issues/35577
+        '&-scrollbar:not([rowspan])': {
+          boxShadow: `0 ${unit(lineWidth)} 0 ${unit(lineWidth)} ${tableHeaderBg}`
+        }
+      },
+      [`${componentCls}-bordered ${componentCls}-cell-scrollbar`]: {
+        borderInlineEnd: tableBorder
+      }
+    }
+  };
+};
+export default genBorderedStyle;

node_modules/antd/es/table/style/ellipsis.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genEllipsisStyle: GenerateStyle<TableToken, CSSObject>;
+export default genEllipsisStyle;

node_modules/antd/es/table/style/ellipsis.js

@@ -0,0 +1,31 @@
+import { textEllipsis } from '../../style';
+const genEllipsisStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [`${componentCls}-wrapper`]: {
+      [`${componentCls}-cell-ellipsis`]: Object.assign(Object.assign({}, textEllipsis), {
+        wordBreak: 'keep-all',
+        // Fixed first or last should special process
+        [`
+          &${componentCls}-cell-fix-left-last,
+          &${componentCls}-cell-fix-right-first
+        `]: {
+          overflow: 'visible',
+          [`${componentCls}-cell-content`]: {
+            display: 'block',
+            overflow: 'hidden',
+            textOverflow: 'ellipsis'
+          }
+        },
+        [`${componentCls}-column-title`]: {
+          overflow: 'hidden',
+          textOverflow: 'ellipsis',
+          wordBreak: 'keep-all'
+        }
+      })
+    }
+  };
+};
+export default genEllipsisStyle;

node_modules/antd/es/table/style/empty.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genEmptyStyle: GenerateStyle<TableToken, CSSObject>;
+export default genEmptyStyle;

node_modules/antd/es/table/style/empty.js

@@ -0,0 +1,21 @@
+// ========================= Placeholder ==========================
+const genEmptyStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [`${componentCls}-wrapper`]: {
+      [`${componentCls}-tbody > tr${componentCls}-placeholder`]: {
+        textAlign: 'center',
+        color: token.colorTextDisabled,
+        [`
+          &:hover > th,
+          &:hover > td,
+        `]: {
+          background: token.colorBgContainer
+        }
+      }
+    }
+  };
+};
+export default genEmptyStyle;

node_modules/antd/es/table/style/expand.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genExpandStyle: GenerateStyle<TableToken, CSSObject>;
+export default genExpandStyle;

node_modules/antd/es/table/style/expand.js

@@ -0,0 +1,122 @@
+import { unit } from '@ant-design/cssinjs';
+import { operationUnit } from '../../style';
+const genExpandStyle = token => {
+  const {
+    componentCls,
+    antCls,
+    motionDurationSlow,
+    lineWidth,
+    paddingXS,
+    lineType,
+    tableBorderColor,
+    tableExpandIconBg,
+    tableExpandColumnWidth,
+    borderRadius,
+    tablePaddingVertical,
+    tablePaddingHorizontal,
+    tableExpandedRowBg,
+    paddingXXS,
+    expandIconMarginTop,
+    expandIconSize,
+    expandIconHalfInner,
+    expandIconScale,
+    calc
+  } = token;
+  const tableBorder = `${unit(lineWidth)} ${lineType} ${tableBorderColor}`;
+  const expandIconLineOffset = calc(paddingXXS).sub(lineWidth).equal();
+  return {
+    [`${componentCls}-wrapper`]: {
+      [`${componentCls}-expand-icon-col`]: {
+        width: tableExpandColumnWidth
+      },
+      [`${componentCls}-row-expand-icon-cell`]: {
+        textAlign: 'center',
+        [`${componentCls}-row-expand-icon`]: {
+          display: 'inline-flex',
+          float: 'none',
+          verticalAlign: 'sub'
+        }
+      },
+      [`${componentCls}-row-indent`]: {
+        height: 1,
+        float: 'left'
+      },
+      [`${componentCls}-row-expand-icon`]: Object.assign(Object.assign({}, operationUnit(token)), {
+        position: 'relative',
+        float: 'left',
+        width: expandIconSize,
+        height: expandIconSize,
+        color: 'inherit',
+        lineHeight: unit(expandIconSize),
+        background: tableExpandIconBg,
+        border: tableBorder,
+        borderRadius,
+        transform: `scale(${expandIconScale})`,
+        '&:focus, &:hover, &:active': {
+          borderColor: 'currentcolor'
+        },
+        '&::before, &::after': {
+          position: 'absolute',
+          background: 'currentcolor',
+          transition: `transform ${motionDurationSlow} ease-out`,
+          content: '""'
+        },
+        '&::before': {
+          top: expandIconHalfInner,
+          insetInlineEnd: expandIconLineOffset,
+          insetInlineStart: expandIconLineOffset,
+          height: lineWidth
+        },
+        '&::after': {
+          top: expandIconLineOffset,
+          bottom: expandIconLineOffset,
+          insetInlineStart: expandIconHalfInner,
+          width: lineWidth,
+          transform: 'rotate(90deg)'
+        },
+        // Motion effect
+        '&-collapsed::before': {
+          transform: 'rotate(-180deg)'
+        },
+        '&-collapsed::after': {
+          transform: 'rotate(0deg)'
+        },
+        '&-spaced': {
+          '&::before, &::after': {
+            display: 'none',
+            content: 'none'
+          },
+          background: 'transparent',
+          border: 0,
+          visibility: 'hidden'
+        }
+      }),
+      [`${componentCls}-row-indent + ${componentCls}-row-expand-icon`]: {
+        marginTop: expandIconMarginTop,
+        marginInlineEnd: paddingXS
+      },
+      [`tr${componentCls}-expanded-row`]: {
+        '&, &:hover': {
+          '> th, > td': {
+            background: tableExpandedRowBg
+          }
+        },
+        // https://github.com/ant-design/ant-design/issues/25573
+        [`${antCls}-descriptions-view`]: {
+          display: 'flex',
+          table: {
+            flex: 'auto',
+            width: '100%'
+          }
+        }
+      },
+      // With fixed
+      [`${componentCls}-expanded-row-fixed`]: {
+        position: 'relative',
+        margin: `${unit(calc(tablePaddingVertical).mul(-1).equal())} ${unit(calc(tablePaddingHorizontal).mul(-1).equal())}`,
+        padding: `${unit(tablePaddingVertical)} ${unit(tablePaddingHorizontal)}`
+      }
+    }
+  };
+};
+export default genExpandStyle;

node_modules/antd/es/table/style/filter.d.ts

@@ -0,0 +1,4 @@
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genFilterStyle: GenerateStyle<TableToken>;
+export default genFilterStyle;

node_modules/antd/es/table/style/filter.js

@@ -0,0 +1,152 @@
+import { unit } from '@ant-design/cssinjs';
+import { resetComponent } from '../../style';
+const genFilterStyle = token => {
+  const {
+    componentCls,
+    antCls,
+    iconCls,
+    tableFilterDropdownWidth,
+    tableFilterDropdownSearchWidth,
+    paddingXXS,
+    paddingXS,
+    colorText,
+    lineWidth,
+    lineType,
+    tableBorderColor,
+    headerIconColor,
+    fontSizeSM,
+    tablePaddingHorizontal,
+    borderRadius,
+    motionDurationSlow,
+    colorIcon,
+    colorPrimary,
+    tableHeaderFilterActiveBg,
+    colorTextDisabled,
+    tableFilterDropdownBg,
+    tableFilterDropdownHeight,
+    controlItemBgHover,
+    controlItemBgActive,
+    boxShadowSecondary,
+    filterDropdownMenuBg,
+    calc
+  } = token;
+  const dropdownPrefixCls = `${antCls}-dropdown`;
+  const tableFilterDropdownPrefixCls = `${componentCls}-filter-dropdown`;
+  const treePrefixCls = `${antCls}-tree`;
+  const tableBorder = `${unit(lineWidth)} ${lineType} ${tableBorderColor}`;
+  return [{
+    [`${componentCls}-wrapper`]: {
+      [`${componentCls}-filter-column`]: {
+        display: 'flex',
+        justifyContent: 'space-between'
+      },
+      [`${componentCls}-filter-trigger`]: {
+        position: 'relative',
+        display: 'flex',
+        alignItems: 'center',
+        marginBlock: calc(paddingXXS).mul(-1).equal(),
+        marginInline: `${unit(paddingXXS)} ${unit(calc(tablePaddingHorizontal).div(2).mul(-1).equal())}`,
+        padding: `0 ${unit(paddingXXS)}`,
+        color: headerIconColor,
+        fontSize: fontSizeSM,
+        borderRadius,
+        cursor: 'pointer',
+        transition: `all ${motionDurationSlow}`,
+        '&:hover': {
+          color: colorIcon,
+          background: tableHeaderFilterActiveBg
+        },
+        '&.active': {
+          color: colorPrimary
+        }
+      }
+    }
+  }, {
+    // Dropdown
+    [`${antCls}-dropdown`]: {
+      [tableFilterDropdownPrefixCls]: Object.assign(Object.assign({}, resetComponent(token)), {
+        minWidth: tableFilterDropdownWidth,
+        backgroundColor: tableFilterDropdownBg,
+        borderRadius,
+        boxShadow: boxShadowSecondary,
+        overflow: 'hidden',
+        // Reset menu
+        [`${dropdownPrefixCls}-menu`]: {
+          // https://github.com/ant-design/ant-design/issues/4916
+          // https://github.com/ant-design/ant-design/issues/19542
+          maxHeight: tableFilterDropdownHeight,
+          overflowX: 'hidden',
+          border: 0,
+          boxShadow: 'none',
+          borderRadius: 'unset',
+          backgroundColor: filterDropdownMenuBg,
+          '&:empty::after': {
+            display: 'block',
+            padding: `${unit(paddingXS)} 0`,
+            color: colorTextDisabled,
+            fontSize: fontSizeSM,
+            textAlign: 'center',
+            content: '"Not Found"'
+          }
+        },
+        [`${tableFilterDropdownPrefixCls}-tree`]: {
+          paddingBlock: `${unit(paddingXS)} 0`,
+          paddingInline: paddingXS,
+          [treePrefixCls]: {
+            padding: 0
+          },
+          [`${treePrefixCls}-treenode ${treePrefixCls}-node-content-wrapper:hover`]: {
+            backgroundColor: controlItemBgHover
+          },
+          [`${treePrefixCls}-treenode-checkbox-checked ${treePrefixCls}-node-content-wrapper`]: {
+            '&, &:hover': {
+              backgroundColor: controlItemBgActive
+            }
+          }
+        },
+        [`${tableFilterDropdownPrefixCls}-search`]: {
+          padding: paddingXS,
+          borderBottom: tableBorder,
+          '&-input': {
+            input: {
+              minWidth: tableFilterDropdownSearchWidth
+            },
+            [iconCls]: {
+              color: colorTextDisabled
+            }
+          }
+        },
+        [`${tableFilterDropdownPrefixCls}-checkall`]: {
+          width: '100%',
+          marginBottom: paddingXXS,
+          marginInlineStart: paddingXXS
+        },
+        // Operation
+        [`${tableFilterDropdownPrefixCls}-btns`]: {
+          display: 'flex',
+          justifyContent: 'space-between',
+          padding: `${unit(calc(paddingXS).sub(lineWidth).equal())} ${unit(paddingXS)}`,
+          overflow: 'hidden',
+          borderTop: tableBorder
+        }
+      })
+    }
+  },
+  // Dropdown Menu & SubMenu
+  {
+    // submenu of table filter dropdown
+    [`${antCls}-dropdown ${tableFilterDropdownPrefixCls}, ${tableFilterDropdownPrefixCls}-submenu`]: {
+      // Checkbox
+      [`${antCls}-checkbox-wrapper + span`]: {
+        paddingInlineStart: paddingXS,
+        color: colorText
+      },
+      '> ul': {
+        maxHeight: 'calc(100vh - 130px)',
+        overflowX: 'hidden',
+        overflowY: 'auto'
+      }
+    }
+  }];
+};
+export default genFilterStyle;

node_modules/antd/es/table/style/fixed.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genFixedStyle: GenerateStyle<TableToken, CSSObject>;
+export default genFixedStyle;

node_modules/antd/es/table/style/fixed.js

@@ -0,0 +1,123 @@
+const genFixedStyle = token => {
+  const {
+    componentCls,
+    lineWidth,
+    colorSplit,
+    motionDurationSlow,
+    zIndexTableFixed,
+    tableBg,
+    zIndexTableSticky,
+    calc
+  } = token;
+  const shadowColor = colorSplit;
+  // Follow style is magic of shadow which should not follow token:
+  return {
+    [`${componentCls}-wrapper`]: {
+      [`
+        ${componentCls}-cell-fix-left,
+        ${componentCls}-cell-fix-right
+      `]: {
+        position: 'sticky !important',
+        zIndex: zIndexTableFixed,
+        background: tableBg
+      },
+      [`
+        ${componentCls}-cell-fix-left-first::after,
+        ${componentCls}-cell-fix-left-last::after
+      `]: {
+        position: 'absolute',
+        top: 0,
+        right: {
+          _skip_check_: true,
+          value: 0
+        },
+        bottom: calc(lineWidth).mul(-1).equal(),
+        width: 30,
+        transform: 'translateX(100%)',
+        transition: `box-shadow ${motionDurationSlow}`,
+        content: '""',
+        pointerEvents: 'none',
+        // fix issues: https://github.com/ant-design/ant-design/issues/54587
+        willChange: 'transform'
+      },
+      [`${componentCls}-cell-fix-left-all::after`]: {
+        display: 'none'
+      },
+      [`
+        ${componentCls}-cell-fix-right-first::after,
+        ${componentCls}-cell-fix-right-last::after
+      `]: {
+        position: 'absolute',
+        top: 0,
+        bottom: calc(lineWidth).mul(-1).equal(),
+        left: {
+          _skip_check_: true,
+          value: 0
+        },
+        width: 30,
+        transform: 'translateX(-100%)',
+        transition: `box-shadow ${motionDurationSlow}`,
+        content: '""',
+        pointerEvents: 'none'
+      },
+      [`${componentCls}-container`]: {
+        position: 'relative',
+        '&::before, &::after': {
+          position: 'absolute',
+          top: 0,
+          bottom: 0,
+          zIndex: calc(zIndexTableSticky).add(1).equal({
+            unit: false
+          }),
+          width: 30,
+          transition: `box-shadow ${motionDurationSlow}`,
+          content: '""',
+          pointerEvents: 'none'
+        },
+        '&::before': {
+          insetInlineStart: 0
+        },
+        '&::after': {
+          insetInlineEnd: 0
+        }
+      },
+      [`${componentCls}-ping-left`]: {
+        [`&:not(${componentCls}-has-fix-left) ${componentCls}-container::before`]: {
+          boxShadow: `inset 10px 0 8px -8px ${shadowColor}`
+        },
+        [`
+          ${componentCls}-cell-fix-left-first::after,
+          ${componentCls}-cell-fix-left-last::after
+        `]: {
+          boxShadow: `inset 10px 0 8px -8px ${shadowColor}`
+        },
+        [`${componentCls}-cell-fix-left-last::before`]: {
+          backgroundColor: 'transparent !important'
+        }
+      },
+      [`${componentCls}-ping-right`]: {
+        [`&:not(${componentCls}-has-fix-right) ${componentCls}-container::after`]: {
+          boxShadow: `inset -10px 0 8px -8px ${shadowColor}`
+        },
+        [`
+          ${componentCls}-cell-fix-right-first::after,
+          ${componentCls}-cell-fix-right-last::after
+        `]: {
+          boxShadow: `inset -10px 0 8px -8px ${shadowColor}`
+        }
+      },
+      // Gapped fixed Columns do not show the shadow
+      [`${componentCls}-fixed-column-gapped`]: {
+        [`
+        ${componentCls}-cell-fix-left-first::after,
+        ${componentCls}-cell-fix-left-last::after,
+        ${componentCls}-cell-fix-right-first::after,
+        ${componentCls}-cell-fix-right-last::after
+      `]: {
+          boxShadow: 'none'
+        }
+      }
+    }
+  };
+};
+export default genFixedStyle;

node_modules/antd/es/table/style/index.d.ts

@@ -0,0 +1,202 @@
+import type { FullToken, GetDefaultToken } from '../../theme/internal';
+export interface ComponentToken {
+    /**
+     * @desc 表头背景
+     * @descEN Background of table header
+     */
+    headerBg: string;
+    /**
+     * @desc 表头文字颜色
+     * @descEN Color of table header text
+     */
+    headerColor: string;
+    /**
+     * @desc 表头排序激活态背景色
+     * @descEN Background color of table header when sorted
+     */
+    headerSortActiveBg: string;
+    /**
+     * @desc 表头排序激活态悬浮背景色
+     * @descEN Background color of table header when sorted and hovered
+     */
+    headerSortHoverBg: string;
+    /**
+     * @desc 表格排序列背景色
+     * @descEN Background color of table sorted column
+     */
+    bodySortBg: string;
+    /**
+     * @desc 表格行悬浮背景色
+     * @descEN Background color of table hovered row
+     */
+    rowHoverBg: string;
+    /**
+     * @desc 表格行选中背景色
+     * @descEN Background color of table selected row
+     */
+    rowSelectedBg: string;
+    /**
+     * @desc 表格行选中悬浮背景色
+     * @descEN Background color of table selected row when hovered
+     */
+    rowSelectedHoverBg: string;
+    /**
+     * @desc 表格行展开背景色
+     * @descEN Background color of table expanded row
+     */
+    rowExpandedBg: string;
+    /**
+     * @desc 单元格纵向内间距
+     * @descEN Vertical padding of table cell
+     */
+    cellPaddingBlock: number;
+    /**
+     * @desc 单元格横向内间距（默认大尺寸）
+     * @descEN Horizontal padding of table cell (large size by default)
+     */
+    cellPaddingInline: number;
+    /**
+     * @desc 单元格纵向内间距（中等尺寸）
+     * @descEN Vertical padding of table cell (middle size)
+     */
+    cellPaddingBlockMD: number;
+    /**
+     * @desc 单元格横向内间距（中等尺寸）
+     * @descEN Horizontal padding of table cell (middle size)
+     */
+    cellPaddingInlineMD: number;
+    /**
+     * @desc 单元格纵向内间距（小尺寸）
+     * @descEN Vertical padding of table cell (small size)
+     */
+    cellPaddingBlockSM: number;
+    /**
+     * @desc 单元格横向内间距（小尺寸）
+     * @descEN Horizontal padding of table cell (small size)
+     */
+    cellPaddingInlineSM: number;
+    /**
+     * @desc 表格边框/分割线颜色
+     * @descEN Border color of table
+     */
+    borderColor: string;
+    /**
+     * @desc 表头圆角
+     * @descEN Border radius of table header
+     */
+    headerBorderRadius: number;
+    /**
+     * @desc 表格底部背景色
+     * @descEN Background of footer
+     */
+    footerBg: string;
+    /**
+     * @desc 表格底部文字颜色
+     * @descEN Color of footer text
+     */
+    footerColor: string;
+    /**
+     * @desc 单元格文字大小（默认大尺寸）
+     * @descEN Font size of table cell (large size by default)
+     */
+    cellFontSize: number;
+    /**
+     * @desc 单元格文字大小（中等尺寸）
+     * @descEN Font size of table cell (middle size)
+     */
+    cellFontSizeMD: number;
+    /**
+     * @desc 单元格文字大小（小尺寸）
+     * @descEN Font size of table cell (small size)
+     */
+    cellFontSizeSM: number;
+    /**
+     * @desc 表头分割线颜色
+     * @descEN Split border color of table header
+     */
+    headerSplitColor: string;
+    /**
+     * @desc 固定表头排序激活态背景色
+     * @descEN Background color of fixed table header when sorted
+     */
+    fixedHeaderSortActiveBg: string;
+    /**
+     * @desc 表头过滤按钮悬浮背景色
+     * @descEN Background color of table header filter button when hovered
+     */
+    headerFilterHoverBg: string;
+    /**
+     * @desc 过滤下拉菜单选项背景
+     * @descEN Background of filter dropdown menu item
+     */
+    filterDropdownMenuBg: string;
+    /**
+     * @desc 过滤下拉菜单颜色
+     * @descEN Color of filter dropdown
+     */
+    filterDropdownBg: string;
+    /**
+     * @desc 展开按钮背景色
+     * @descEN Background of expand button
+     */
+    expandIconBg: string;
+    /**
+     * @desc 选择列宽度
+     * @descEN Width of selection column
+     */
+    selectionColumnWidth: number | string;
+    /**
+     * @desc Sticky 模式下滚动条背景色
+     * @descEN Background of sticky scrollbar
+     */
+    stickyScrollBarBg: string;
+    /**
+     * @desc Sticky 模式下滚动条圆角
+     * @descEN Border radius of sticky scrollbar
+     */
+    stickyScrollBarBorderRadius: number;
+}
+export interface TableToken extends FullToken<'Table'> {
+    tableFontSize: number;
+    tableBg: string;
+    tableRadius: number;
+    tablePaddingHorizontal: number;
+    tablePaddingVertical: number;
+    tablePaddingHorizontalMiddle: number;
+    tablePaddingVerticalMiddle: number;
+    tablePaddingHorizontalSmall: number;
+    tablePaddingVerticalSmall: number;
+    tableBorderColor: string;
+    tableHeaderTextColor: string;
+    tableHeaderBg: string;
+    tableFooterTextColor: string;
+    tableFooterBg: string;
+    tableHeaderCellSplitColor: string;
+    tableHeaderSortBg: string;
+    tableHeaderSortHoverBg: string;
+    tableBodySortBg: string;
+    tableFixedHeaderSortActiveBg: string;
+    tableHeaderFilterActiveBg: string;
+    tableFilterDropdownBg: string;
+    tableFilterDropdownHeight: number | string;
+    tableRowHoverBg: string;
+    tableSelectedRowBg: string;
+    tableSelectedRowHoverBg: string;
+    tableFontSizeMiddle: number;
+    tableFontSizeSmall: number;
+    tableSelectionColumnWidth: number | string;
+    tableExpandIconBg: string;
+    tableExpandColumnWidth: number | string;
+    tableExpandedRowBg: string;
+    tableFilterDropdownWidth: number;
+    tableFilterDropdownSearchWidth: number;
+    zIndexTableFixed: number;
+    zIndexTableSticky: number | string;
+    tableScrollThumbSize: number;
+    tableScrollThumbBg: string;
+    tableScrollThumbBgHover: string;
+    tableScrollBg: string;
+}
+export declare const prepareComponentToken: GetDefaultToken<'Table'>;
+declare const _default: (prefixCls: string, rootCls?: string) => readonly [(node: React.ReactElement) => React.ReactElement, string, string];
+export default _default;

node_modules/antd/es/table/style/index.js

@@ -0,0 +1,329 @@
+import { unit } from '@ant-design/cssinjs';
+import { FastColor } from '@ant-design/fast-color';
+import { clearFix, resetComponent } from '../../style';
+import { genStyleHooks, mergeToken } from '../../theme/internal';
+import genBorderedStyle from './bordered';
+import genEllipsisStyle from './ellipsis';
+import genEmptyStyle from './empty';
+import genExpandStyle from './expand';
+import genFilterStyle from './filter';
+import genFixedStyle from './fixed';
+import genPaginationStyle from './pagination';
+import genRadiusStyle from './radius';
+import genRtlStyle from './rtl';
+import genSelectionStyle from './selection';
+import genSizeStyle from './size';
+import genSorterStyle from './sorter';
+import genStickyStyle from './sticky';
+import genSummaryStyle from './summary';
+import genVirtualStyle from './virtual';
+const genTableStyle = token => {
+  const {
+    componentCls,
+    fontWeightStrong,
+    tablePaddingVertical,
+    tablePaddingHorizontal,
+    tableExpandColumnWidth,
+    lineWidth,
+    lineType,
+    tableBorderColor,
+    tableFontSize,
+    tableBg,
+    tableRadius,
+    tableHeaderTextColor,
+    motionDurationMid,
+    tableHeaderBg,
+    tableHeaderCellSplitColor,
+    tableFooterTextColor,
+    tableFooterBg,
+    calc
+  } = token;
+  const tableBorder = `${unit(lineWidth)} ${lineType} ${tableBorderColor}`;
+  return {
+    [`${componentCls}-wrapper`]: Object.assign(Object.assign({
+      clear: 'both',
+      maxWidth: '100%',
+      // fix https://github.com/ant-design/ant-design/issues/46177
+      ['--rc-virtual-list-scrollbar-bg']: token.tableScrollBg
+    }, clearFix()), {
+      [componentCls]: Object.assign(Object.assign({}, resetComponent(token)), {
+        fontSize: tableFontSize,
+        background: tableBg,
+        borderRadius: `${unit(tableRadius)} ${unit(tableRadius)} 0 0`,
+        // https://github.com/ant-design/ant-design/issues/47486
+        scrollbarColor: `${token.tableScrollThumbBg} ${token.tableScrollBg}`
+      }),
+      // https://github.com/ant-design/ant-design/issues/17611
+      table: {
+        width: '100%',
+        textAlign: 'start',
+        borderRadius: `${unit(tableRadius)} ${unit(tableRadius)} 0 0`,
+        borderCollapse: 'separate',
+        borderSpacing: 0
+      },
+      // ============================= Cell ==============================
+      [`
+          ${componentCls}-cell,
+          ${componentCls}-thead > tr > th,
+          ${componentCls}-tbody > tr > th,
+          ${componentCls}-tbody > tr > td,
+          tfoot > tr > th,
+          tfoot > tr > td
+        `]: {
+        position: 'relative',
+        padding: `${unit(tablePaddingVertical)} ${unit(tablePaddingHorizontal)}`,
+        overflowWrap: 'break-word'
+      },
+      // ============================ Title =============================
+      [`${componentCls}-title`]: {
+        padding: `${unit(tablePaddingVertical)} ${unit(tablePaddingHorizontal)}`
+      },
+      // ============================ Header ============================
+      [`${componentCls}-thead`]: {
+        [`
+          > tr > th,
+          > tr > td
+        `]: {
+          position: 'relative',
+          color: tableHeaderTextColor,
+          fontWeight: fontWeightStrong,
+          textAlign: 'start',
+          background: tableHeaderBg,
+          borderBottom: tableBorder,
+          transition: `background ${motionDurationMid} ease`,
+          "&[colspan]:not([colspan='1'])": {
+            textAlign: 'center'
+          },
+          [`&:not(:last-child):not(${componentCls}-selection-column):not(${componentCls}-row-expand-icon-cell):not([colspan])::before`]: {
+            position: 'absolute',
+            top: '50%',
+            insetInlineEnd: 0,
+            width: 1,
+            height: '1.6em',
+            backgroundColor: tableHeaderCellSplitColor,
+            transform: 'translateY(-50%)',
+            transition: `background-color ${motionDurationMid}`,
+            content: '""'
+          }
+        },
+        '> tr:not(:last-child) > th[colspan]': {
+          borderBottom: 0
+        }
+      },
+      // ============================ Body ============================
+      [`${componentCls}-tbody`]: {
+        '> tr': {
+          '> th, > td': {
+            transition: `background ${motionDurationMid}, border-color ${motionDurationMid}`,
+            borderBottom: tableBorder,
+            // ========================= Nest Table ===========================
+            [`
+              > ${componentCls}-wrapper:only-child,
+              > ${componentCls}-expanded-row-fixed > ${componentCls}-wrapper:only-child
+            `]: {
+              [componentCls]: {
+                marginBlock: unit(calc(tablePaddingVertical).mul(-1).equal()),
+                marginInline: `${unit(calc(tableExpandColumnWidth).sub(tablePaddingHorizontal).equal())}
+                ${unit(calc(tablePaddingHorizontal).mul(-1).equal())}`,
+                [`${componentCls}-tbody > tr:last-child > td`]: {
+                  borderBottomWidth: 0,
+                  '&:first-child, &:last-child': {
+                    borderRadius: 0
+                  }
+                }
+              }
+            }
+          },
+          '> th': {
+            position: 'relative',
+            color: tableHeaderTextColor,
+            fontWeight: fontWeightStrong,
+            textAlign: 'start',
+            background: tableHeaderBg,
+            borderBottom: tableBorder,
+            transition: `background ${motionDurationMid} ease`
+          },
+          // measure cell styles
+          [`& > ${componentCls}-measure-cell`]: {
+            paddingBlock: `0 !important`,
+            borderBlock: `0 !important`,
+            [`${componentCls}-measure-cell-content`]: {
+              height: 0,
+              overflow: 'hidden',
+              pointerEvents: 'none'
+            }
+          }
+        }
+      },
+      // ============================ Footer ============================
+      [`${componentCls}-footer`]: {
+        padding: `${unit(tablePaddingVertical)} ${unit(tablePaddingHorizontal)}`,
+        color: tableFooterTextColor,
+        background: tableFooterBg
+      }
+    })
+  };
+};
+export const prepareComponentToken = token => {
+  const {
+    colorFillAlter,
+    colorBgContainer,
+    colorTextHeading,
+    colorFillSecondary,
+    colorFillContent,
+    controlItemBgActive,
+    controlItemBgActiveHover,
+    padding,
+    paddingSM,
+    paddingXS,
+    colorBorderSecondary,
+    borderRadiusLG,
+    controlHeight,
+    colorTextPlaceholder,
+    fontSize,
+    fontSizeSM,
+    lineHeight,
+    lineWidth,
+    colorIcon,
+    colorIconHover,
+    opacityLoading,
+    controlInteractiveSize
+  } = token;
+  const colorFillSecondarySolid = new FastColor(colorFillSecondary).onBackground(colorBgContainer).toHexString();
+  const colorFillContentSolid = new FastColor(colorFillContent).onBackground(colorBgContainer).toHexString();
+  const colorFillAlterSolid = new FastColor(colorFillAlter).onBackground(colorBgContainer).toHexString();
+  const baseColorAction = new FastColor(colorIcon);
+  const baseColorActionHover = new FastColor(colorIconHover);
+  const expandIconHalfInner = controlInteractiveSize / 2 - lineWidth;
+  const expandIconSize = expandIconHalfInner * 2 + lineWidth * 3;
+  return {
+    headerBg: colorFillAlterSolid,
+    headerColor: colorTextHeading,
+    headerSortActiveBg: colorFillSecondarySolid,
+    headerSortHoverBg: colorFillContentSolid,
+    bodySortBg: colorFillAlterSolid,
+    rowHoverBg: colorFillAlterSolid,
+    rowSelectedBg: controlItemBgActive,
+    rowSelectedHoverBg: controlItemBgActiveHover,
+    rowExpandedBg: colorFillAlter,
+    cellPaddingBlock: padding,
+    cellPaddingInline: padding,
+    cellPaddingBlockMD: paddingSM,
+    cellPaddingInlineMD: paddingXS,
+    cellPaddingBlockSM: paddingXS,
+    cellPaddingInlineSM: paddingXS,
+    borderColor: colorBorderSecondary,
+    headerBorderRadius: borderRadiusLG,
+    footerBg: colorFillAlterSolid,
+    footerColor: colorTextHeading,
+    cellFontSize: fontSize,
+    cellFontSizeMD: fontSize,
+    cellFontSizeSM: fontSize,
+    headerSplitColor: colorBorderSecondary,
+    fixedHeaderSortActiveBg: colorFillSecondarySolid,
+    headerFilterHoverBg: colorFillContent,
+    filterDropdownMenuBg: colorBgContainer,
+    filterDropdownBg: colorBgContainer,
+    expandIconBg: colorBgContainer,
+    selectionColumnWidth: controlHeight,
+    stickyScrollBarBg: colorTextPlaceholder,
+    stickyScrollBarBorderRadius: 100,
+    expandIconMarginTop: (fontSize * lineHeight - lineWidth * 3) / 2 - Math.ceil((fontSizeSM * 1.4 - lineWidth * 3) / 2),
+    headerIconColor: baseColorAction.clone().setA(baseColorAction.a * opacityLoading).toRgbString(),
+    headerIconHoverColor: baseColorActionHover.clone().setA(baseColorActionHover.a * opacityLoading).toRgbString(),
+    expandIconHalfInner,
+    expandIconSize,
+    expandIconScale: controlInteractiveSize / expandIconSize
+  };
+};
+const zIndexTableFixed = 2;
+// ============================== Export ==============================
+export default genStyleHooks('Table', token => {
+  const {
+    colorTextHeading,
+    colorSplit,
+    colorBgContainer,
+    controlInteractiveSize: checkboxSize,
+    headerBg,
+    headerColor,
+    headerSortActiveBg,
+    headerSortHoverBg,
+    bodySortBg,
+    rowHoverBg,
+    rowSelectedBg,
+    rowSelectedHoverBg,
+    rowExpandedBg,
+    cellPaddingBlock,
+    cellPaddingInline,
+    cellPaddingBlockMD,
+    cellPaddingInlineMD,
+    cellPaddingBlockSM,
+    cellPaddingInlineSM,
+    borderColor,
+    footerBg,
+    footerColor,
+    headerBorderRadius,
+    cellFontSize,
+    cellFontSizeMD,
+    cellFontSizeSM,
+    headerSplitColor,
+    fixedHeaderSortActiveBg,
+    headerFilterHoverBg,
+    filterDropdownBg,
+    expandIconBg,
+    selectionColumnWidth,
+    stickyScrollBarBg,
+    calc
+  } = token;
+  const tableToken = mergeToken(token, {
+    tableFontSize: cellFontSize,
+    tableBg: colorBgContainer,
+    tableRadius: headerBorderRadius,
+    tablePaddingVertical: cellPaddingBlock,
+    tablePaddingHorizontal: cellPaddingInline,
+    tablePaddingVerticalMiddle: cellPaddingBlockMD,
+    tablePaddingHorizontalMiddle: cellPaddingInlineMD,
+    tablePaddingVerticalSmall: cellPaddingBlockSM,
+    tablePaddingHorizontalSmall: cellPaddingInlineSM,
+    tableBorderColor: borderColor,
+    tableHeaderTextColor: headerColor,
+    tableHeaderBg: headerBg,
+    tableFooterTextColor: footerColor,
+    tableFooterBg: footerBg,
+    tableHeaderCellSplitColor: headerSplitColor,
+    tableHeaderSortBg: headerSortActiveBg,
+    tableHeaderSortHoverBg: headerSortHoverBg,
+    tableBodySortBg: bodySortBg,
+    tableFixedHeaderSortActiveBg: fixedHeaderSortActiveBg,
+    tableHeaderFilterActiveBg: headerFilterHoverBg,
+    tableFilterDropdownBg: filterDropdownBg,
+    tableRowHoverBg: rowHoverBg,
+    tableSelectedRowBg: rowSelectedBg,
+    tableSelectedRowHoverBg: rowSelectedHoverBg,
+    zIndexTableFixed,
+    zIndexTableSticky: calc(zIndexTableFixed).add(1).equal({
+      unit: false
+    }),
+    tableFontSizeMiddle: cellFontSizeMD,
+    tableFontSizeSmall: cellFontSizeSM,
+    tableSelectionColumnWidth: selectionColumnWidth,
+    tableExpandIconBg: expandIconBg,
+    tableExpandColumnWidth: calc(checkboxSize).add(calc(token.padding).mul(2)).equal(),
+    tableExpandedRowBg: rowExpandedBg,
+    // Dropdown
+    tableFilterDropdownWidth: 120,
+    tableFilterDropdownHeight: 264,
+    tableFilterDropdownSearchWidth: 140,
+    // Virtual Scroll Bar
+    tableScrollThumbSize: 8,
+    // Mac scroll bar size
+    tableScrollThumbBg: stickyScrollBarBg,
+    tableScrollThumbBgHover: colorTextHeading,
+    tableScrollBg: colorSplit
+  });
+  return [genTableStyle(tableToken), genPaginationStyle(tableToken), genSummaryStyle(tableToken), genSorterStyle(tableToken), genFilterStyle(tableToken), genBorderedStyle(tableToken), genRadiusStyle(tableToken), genExpandStyle(tableToken), genSummaryStyle(tableToken), genEmptyStyle(tableToken), genSelectionStyle(tableToken), genFixedStyle(tableToken), genStickyStyle(tableToken), genEllipsisStyle(tableToken), genSizeStyle(tableToken), genRtlStyle(tableToken), genVirtualStyle(tableToken)];
+}, prepareComponentToken, {
+  unitless: {
+    expandIconScale: true
+  }
+});

node_modules/antd/es/table/style/pagination.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genPaginationStyle: GenerateStyle<TableToken, CSSObject>;
+export default genPaginationStyle;

node_modules/antd/es/table/style/pagination.js

@@ -0,0 +1,14 @@
+import { unit } from '@ant-design/cssinjs';
+const genPaginationStyle = token => {
+  const {
+    componentCls,
+    antCls,
+    margin
+  } = token;
+  return {
+    [`${componentCls}-wrapper ${componentCls}-pagination${antCls}-pagination`]: {
+      margin: `${unit(margin)} 0`
+    }
+  };
+};
+export default genPaginationStyle;

node_modules/antd/es/table/style/radius.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genRadiusStyle: GenerateStyle<TableToken, CSSObject>;
+export default genRadiusStyle;

node_modules/antd/es/table/style/radius.js

@@ -0,0 +1,46 @@
+import { unit } from '@ant-design/cssinjs';
+const genRadiusStyle = token => {
+  const {
+    componentCls,
+    tableRadius
+  } = token;
+  return {
+    [`${componentCls}-wrapper`]: {
+      [componentCls]: {
+        // https://github.com/ant-design/ant-design/issues/39115#issuecomment-1362314574
+        [`${componentCls}-title, ${componentCls}-header`]: {
+          borderRadius: `${unit(tableRadius)} ${unit(tableRadius)} 0 0`
+        },
+        [`${componentCls}-title + ${componentCls}-container`]: {
+          borderStartStartRadius: 0,
+          borderStartEndRadius: 0,
+          // https://github.com/ant-design/ant-design/issues/41975
+          [`${componentCls}-header, table`]: {
+            borderRadius: 0
+          },
+          'table > thead > tr:first-child': {
+            'th:first-child, th:last-child, td:first-child, td:last-child': {
+              borderRadius: 0
+            }
+          }
+        },
+        '&-container': {
+          borderStartStartRadius: tableRadius,
+          borderStartEndRadius: tableRadius,
+          'table > thead > tr:first-child': {
+            '> *:first-child': {
+              borderStartStartRadius: tableRadius
+            },
+            '> *:last-child': {
+              borderStartEndRadius: tableRadius
+            }
+          }
+        },
+        '&-footer': {
+          borderRadius: `0 0 ${unit(tableRadius)} ${unit(tableRadius)}`
+        }
+      }
+    }
+  };
+};
+export default genRadiusStyle;

node_modules/antd/es/table/style/rtl.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genStyle: GenerateStyle<TableToken, CSSObject>;
+export default genStyle;

node_modules/antd/es/table/style/rtl.js

@@ -0,0 +1,45 @@
+const genStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [`${componentCls}-wrapper-rtl`]: {
+      direction: 'rtl',
+      table: {
+        direction: 'rtl'
+      },
+      [`${componentCls}-pagination-left`]: {
+        justifyContent: 'flex-end'
+      },
+      [`${componentCls}-pagination-right`]: {
+        justifyContent: 'flex-start'
+      },
+      [`${componentCls}-row-expand-icon`]: {
+        float: 'right',
+        '&::after': {
+          transform: 'rotate(-90deg)'
+        },
+        '&-collapsed::before': {
+          transform: 'rotate(180deg)'
+        },
+        '&-collapsed::after': {
+          transform: 'rotate(0deg)'
+        }
+      },
+      [`${componentCls}-container`]: {
+        '&::before': {
+          insetInlineStart: 'unset',
+          insetInlineEnd: 0
+        },
+        '&::after': {
+          insetInlineStart: 0,
+          insetInlineEnd: 'unset'
+        },
+        [`${componentCls}-row-indent`]: {
+          float: 'right'
+        }
+      }
+    }
+  };
+};
+export default genStyle;

node_modules/antd/es/table/style/selection.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genSelectionStyle: GenerateStyle<TableToken, CSSObject>;
+export default genSelectionStyle;

node_modules/antd/es/table/style/selection.js

@@ -0,0 +1,95 @@
+import { unit } from '@ant-design/cssinjs';
+const genSelectionStyle = token => {
+  const {
+    componentCls,
+    antCls,
+    iconCls,
+    fontSizeIcon,
+    padding,
+    paddingXS,
+    headerIconColor,
+    headerIconHoverColor,
+    tableSelectionColumnWidth,
+    tableSelectedRowBg,
+    tableSelectedRowHoverBg,
+    tableRowHoverBg,
+    tablePaddingHorizontal,
+    calc
+  } = token;
+  return {
+    [`${componentCls}-wrapper`]: {
+      // ========================== Selections ==========================
+      [`${componentCls}-selection-col`]: {
+        width: tableSelectionColumnWidth,
+        [`&${componentCls}-selection-col-with-dropdown`]: {
+          width: calc(tableSelectionColumnWidth).add(fontSizeIcon).add(calc(padding).div(4)).equal()
+        }
+      },
+      [`${componentCls}-bordered ${componentCls}-selection-col`]: {
+        width: calc(tableSelectionColumnWidth).add(calc(paddingXS).mul(2)).equal(),
+        [`&${componentCls}-selection-col-with-dropdown`]: {
+          width: calc(tableSelectionColumnWidth).add(fontSizeIcon).add(calc(padding).div(4)).add(calc(paddingXS).mul(2)).equal()
+        }
+      },
+      [`
+        table tr th${componentCls}-selection-column,
+        table tr td${componentCls}-selection-column,
+        ${componentCls}-selection-column
+      `]: {
+        paddingInlineEnd: token.paddingXS,
+        paddingInlineStart: token.paddingXS,
+        textAlign: 'center',
+        [`${antCls}-radio-wrapper`]: {
+          marginInlineEnd: 0
+        }
+      },
+      [`table tr th${componentCls}-selection-column${componentCls}-cell-fix-left`]: {
+        zIndex: calc(token.zIndexTableFixed).add(1).equal({
+          unit: false
+        })
+      },
+      [`table tr th${componentCls}-selection-column::after`]: {
+        backgroundColor: 'transparent !important'
+      },
+      [`${componentCls}-selection`]: {
+        position: 'relative',
+        display: 'inline-flex',
+        flexDirection: 'column'
+      },
+      [`${componentCls}-selection-extra`]: {
+        position: 'absolute',
+        top: 0,
+        zIndex: 1,
+        cursor: 'pointer',
+        transition: `all ${token.motionDurationSlow}`,
+        marginInlineStart: '100%',
+        paddingInlineStart: unit(calc(tablePaddingHorizontal).div(4).equal()),
+        [iconCls]: {
+          color: headerIconColor,
+          fontSize: fontSizeIcon,
+          verticalAlign: 'baseline',
+          '&:hover': {
+            color: headerIconHoverColor
+          }
+        }
+      },
+      // ============================= Rows =============================
+      [`${componentCls}-tbody`]: {
+        [`${componentCls}-row`]: {
+          [`&${componentCls}-row-selected`]: {
+            [`> ${componentCls}-cell`]: {
+              background: tableSelectedRowBg,
+              '&-row-hover': {
+                background: tableSelectedRowHoverBg
+              }
+            }
+          },
+          [`> ${componentCls}-cell-row-hover`]: {
+            background: tableRowHoverBg
+          }
+        }
+      }
+    }
+  };
+};
+export default genSelectionStyle;

node_modules/antd/es/table/style/size.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genSizeStyle: GenerateStyle<TableToken, CSSObject>;
+export default genSizeStyle;

node_modules/antd/es/table/style/size.js

@@ -0,0 +1,46 @@
+import { unit } from '@ant-design/cssinjs';
+const genSizeStyle = token => {
+  const {
+    componentCls,
+    tableExpandColumnWidth,
+    calc
+  } = token;
+  const getSizeStyle = (size, paddingVertical, paddingHorizontal, fontSize) => ({
+    [`${componentCls}${componentCls}-${size}`]: {
+      fontSize,
+      [`
+        ${componentCls}-title,
+        ${componentCls}-footer,
+        ${componentCls}-cell,
+        ${componentCls}-thead > tr > th,
+        ${componentCls}-tbody > tr > th,
+        ${componentCls}-tbody > tr > td,
+        tfoot > tr > th,
+        tfoot > tr > td
+      `]: {
+        padding: `${unit(paddingVertical)} ${unit(paddingHorizontal)}`
+      },
+      [`${componentCls}-filter-trigger`]: {
+        marginInlineEnd: unit(calc(paddingHorizontal).div(2).mul(-1).equal())
+      },
+      [`${componentCls}-expanded-row-fixed`]: {
+        margin: `${unit(calc(paddingVertical).mul(-1).equal())} ${unit(calc(paddingHorizontal).mul(-1).equal())}`
+      },
+      [`${componentCls}-tbody`]: {
+        // ========================= Nest Table ===========================
+        [`${componentCls}-wrapper:only-child ${componentCls}`]: {
+          marginBlock: unit(calc(paddingVertical).mul(-1).equal()),
+          marginInline: `${unit(calc(tableExpandColumnWidth).sub(paddingHorizontal).equal())} ${unit(calc(paddingHorizontal).mul(-1).equal())}`
+        }
+      },
+      // https://github.com/ant-design/ant-design/issues/35167
+      [`${componentCls}-selection-extra`]: {
+        paddingInlineStart: unit(calc(paddingHorizontal).div(4).equal())
+      }
+    }
+  });
+  return {
+    [`${componentCls}-wrapper`]: Object.assign(Object.assign({}, getSizeStyle('middle', token.tablePaddingVerticalMiddle, token.tablePaddingHorizontalMiddle, token.tableFontSizeMiddle)), getSizeStyle('small', token.tablePaddingVerticalSmall, token.tablePaddingHorizontalSmall, token.tableFontSizeSmall))
+  };
+};
+export default genSizeStyle;

node_modules/antd/es/table/style/sorter.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genSorterStyle: GenerateStyle<TableToken, CSSObject>;
+export default genSorterStyle;

node_modules/antd/es/table/style/sorter.js

@@ -0,0 +1,93 @@
+const genSorterStyle = token => {
+  const {
+    componentCls,
+    marginXXS,
+    fontSizeIcon,
+    headerIconColor,
+    headerIconHoverColor
+  } = token;
+  return {
+    [`${componentCls}-wrapper`]: {
+      [`${componentCls}-thead th${componentCls}-column-has-sorters`]: {
+        outline: 'none',
+        cursor: 'pointer',
+        // why left 0s? Avoid column header move with transition when left is changed
+        // https://github.com/ant-design/ant-design/issues/50588
+        transition: `all ${token.motionDurationSlow}, left 0s`,
+        '&:hover': {
+          background: token.tableHeaderSortHoverBg,
+          '&::before': {
+            backgroundColor: 'transparent !important'
+          }
+        },
+        '&:focus-visible': {
+          color: token.colorPrimary
+        },
+        // https://github.com/ant-design/ant-design/issues/30969
+        [`
+          &${componentCls}-cell-fix-left:hover,
+          &${componentCls}-cell-fix-right:hover
+        `]: {
+          background: token.tableFixedHeaderSortActiveBg
+        }
+      },
+      [`${componentCls}-thead th${componentCls}-column-sort`]: {
+        background: token.tableHeaderSortBg,
+        '&::before': {
+          backgroundColor: 'transparent !important'
+        }
+      },
+      [`td${componentCls}-column-sort`]: {
+        background: token.tableBodySortBg
+      },
+      [`${componentCls}-column-title`]: {
+        position: 'relative',
+        zIndex: 1,
+        flex: 1,
+        minWidth: 0
+      },
+      [`${componentCls}-column-sorters`]: {
+        display: 'flex',
+        flex: 'auto',
+        alignItems: 'center',
+        justifyContent: 'space-between',
+        '&::after': {
+          position: 'absolute',
+          inset: 0,
+          width: '100%',
+          height: '100%',
+          content: '""'
+        }
+      },
+      [`${componentCls}-column-sorters-tooltip-target-sorter`]: {
+        '&::after': {
+          content: 'none'
+        }
+      },
+      [`${componentCls}-column-sorter`]: {
+        marginInlineStart: marginXXS,
+        color: headerIconColor,
+        fontSize: 0,
+        transition: `color ${token.motionDurationSlow}`,
+        '&-inner': {
+          display: 'inline-flex',
+          flexDirection: 'column',
+          alignItems: 'center'
+        },
+        '&-up, &-down': {
+          fontSize: fontSizeIcon,
+          '&.active': {
+            color: token.colorPrimary
+          }
+        },
+        [`${componentCls}-column-sorter-up + ${componentCls}-column-sorter-down`]: {
+          marginTop: '-0.3em'
+        }
+      },
+      [`${componentCls}-column-sorters:hover ${componentCls}-column-sorter`]: {
+        color: headerIconHoverColor
+      }
+    }
+  };
+};
+export default genSorterStyle;

node_modules/antd/es/table/style/sticky.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genStickyStyle: GenerateStyle<TableToken, CSSObject>;
+export default genStickyStyle;

node_modules/antd/es/table/style/sticky.js

@@ -0,0 +1,55 @@
+import { unit } from '@ant-design/cssinjs';
+const genStickyStyle = token => {
+  const {
+    componentCls,
+    opacityLoading,
+    tableScrollThumbBg,
+    tableScrollThumbBgHover,
+    tableScrollThumbSize,
+    tableScrollBg,
+    zIndexTableSticky,
+    stickyScrollBarBorderRadius,
+    lineWidth,
+    lineType,
+    tableBorderColor
+  } = token;
+  const tableBorder = `${unit(lineWidth)} ${lineType} ${tableBorderColor}`;
+  return {
+    [`${componentCls}-wrapper`]: {
+      [`${componentCls}-sticky`]: {
+        '&-holder': {
+          position: 'sticky',
+          zIndex: zIndexTableSticky,
+          background: token.colorBgContainer
+        },
+        '&-scroll': {
+          position: 'sticky',
+          bottom: 0,
+          height: `${unit(tableScrollThumbSize)} !important`,
+          zIndex: zIndexTableSticky,
+          display: 'flex',
+          alignItems: 'center',
+          background: tableScrollBg,
+          borderTop: tableBorder,
+          opacity: opacityLoading,
+          '&:hover': {
+            transformOrigin: 'center bottom'
+          },
+          // fake scrollbar style of sticky
+          '&-bar': {
+            height: tableScrollThumbSize,
+            backgroundColor: tableScrollThumbBg,
+            borderRadius: stickyScrollBarBorderRadius,
+            transition: `all ${token.motionDurationSlow}, transform 0s`,
+            position: 'absolute',
+            bottom: 0,
+            '&:hover, &-active': {
+              backgroundColor: tableScrollThumbBgHover
+            }
+          }
+        }
+      }
+    }
+  };
+};
+export default genStickyStyle;

node_modules/antd/es/table/style/summary.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genSummaryStyle: GenerateStyle<TableToken, CSSObject>;
+export default genSummaryStyle;

node_modules/antd/es/table/style/summary.js

@@ -0,0 +1,28 @@
+import { unit } from '@ant-design/cssinjs';
+const genSummaryStyle = token => {
+  const {
+    componentCls,
+    lineWidth,
+    tableBorderColor,
+    calc
+  } = token;
+  const tableBorder = `${unit(lineWidth)} ${token.lineType} ${tableBorderColor}`;
+  return {
+    [`${componentCls}-wrapper`]: {
+      [`${componentCls}-summary`]: {
+        position: 'relative',
+        zIndex: token.zIndexTableFixed,
+        background: token.tableBg,
+        '> tr': {
+          '> th, > td': {
+            borderBottom: tableBorder
+          }
+        }
+      },
+      [`div${componentCls}-summary`]: {
+        boxShadow: `0 ${unit(calc(lineWidth).mul(-1).equal())} 0 ${tableBorderColor}`
+      }
+    }
+  };
+};
+export default genSummaryStyle;

node_modules/antd/es/table/style/virtual.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genVirtualStyle: GenerateStyle<TableToken, CSSObject>;
+export default genVirtualStyle;

node_modules/antd/es/table/style/virtual.js

@@ -0,0 +1,73 @@
+import { unit } from '@ant-design/cssinjs';
+const genVirtualStyle = token => {
+  const {
+    componentCls,
+    motionDurationMid,
+    lineWidth,
+    lineType,
+    tableBorderColor,
+    calc
+  } = token;
+  const tableBorder = `${unit(lineWidth)} ${lineType} ${tableBorderColor}`;
+  const rowCellCls = `${componentCls}-expanded-row-cell`;
+  return {
+    [`${componentCls}-wrapper`]: {
+      // ========================== Row ==========================
+      [`${componentCls}-tbody-virtual`]: {
+        [`${componentCls}-tbody-virtual-holder-inner`]: {
+          [`
+            & > ${componentCls}-row, 
+            & > div:not(${componentCls}-row) > ${componentCls}-row
+          `]: {
+            display: 'flex',
+            boxSizing: 'border-box',
+            width: '100%'
+          }
+        },
+        [`${componentCls}-cell`]: {
+          borderBottom: tableBorder,
+          transition: `background ${motionDurationMid}`
+        },
+        [`${componentCls}-expanded-row`]: {
+          [`${rowCellCls}${rowCellCls}-fixed`]: {
+            position: 'sticky',
+            insetInlineStart: 0,
+            overflow: 'hidden',
+            width: `calc(var(--virtual-width) - ${unit(lineWidth)})`,
+            borderInlineEnd: 'none'
+          }
+        }
+      },
+      // ======================== Border =========================
+      [`${componentCls}-bordered`]: {
+        [`${componentCls}-tbody-virtual`]: {
+          '&:after': {
+            content: '""',
+            insetInline: 0,
+            bottom: 0,
+            borderBottom: tableBorder,
+            position: 'absolute'
+          },
+          [`${componentCls}-cell`]: {
+            borderInlineEnd: tableBorder,
+            [`&${componentCls}-cell-fix-right-first:before`]: {
+              content: '""',
+              position: 'absolute',
+              insetBlock: 0,
+              insetInlineStart: calc(lineWidth).mul(-1).equal(),
+              borderInlineStart: tableBorder
+            }
+          }
+        },
+        // Empty placeholder
+        [`&${componentCls}-virtual`]: {
+          [`${componentCls}-placeholder ${componentCls}-cell`]: {
+            borderInlineEnd: tableBorder,
+            borderBottom: tableBorder
+          }
+        }
+      }
+    }
+  };
+};
+export default genVirtualStyle;

node_modules/antd/es/table/util.d.ts

@@ -0,0 +1,13 @@
+import type { AnyObject } from '../_util/type';
+import type { ColumnTitle, ColumnTitleProps, ColumnType, Key } from './interface';
+export declare const getColumnKey: <RecordType extends AnyObject = AnyObject>(column: ColumnType<RecordType>, defaultKey: string) => Key;
+export declare function getColumnPos(index: number, pos?: string): string;
+export declare const renderColumnTitle: <RecordType extends AnyObject = AnyObject>(title: ColumnTitle<RecordType>, props: ColumnTitleProps<RecordType>) => import("react").ReactNode;
+/**
+ * Safe get column title
+ *
+ * Should filter [object Object]
+ *
+ * @param title
+ */
+export declare const safeColumnTitle: <RecordType extends AnyObject = AnyObject>(title: ColumnTitle<RecordType>, props: ColumnTitleProps<RecordType>) => import("react").ReactNode;

node_modules/antd/es/table/util.js

@@ -0,0 +1,32 @@
+export const getColumnKey = (column, defaultKey) => {
+  if ('key' in column && column.key !== undefined && column.key !== null) {
+    return column.key;
+  }
+  if (column.dataIndex) {
+    return Array.isArray(column.dataIndex) ? column.dataIndex.join('.') : column.dataIndex;
+  }
+  return defaultKey;
+};
+export function getColumnPos(index, pos) {
+  return pos ? `${pos}-${index}` : `${index}`;
+}
+export const renderColumnTitle = (title, props) => {
+  if (typeof title === 'function') {
+    return title(props);
+  }
+  return title;
+};
+/**
+ * Safe get column title
+ *
+ * Should filter [object Object]
+ *
+ * @param title
+ */
+export const safeColumnTitle = (title, props) => {
+  const res = renderColumnTitle(title, props);
+  if (Object.prototype.toString.call(res) === '[object Object]') {
+    return '';
+  }
+  return res;
+};