add all frontend files

2026-01-17 15:16:36 -05:00
parent ff16ae7858
commit e40287e4aa
25704 changed files with 1935289 additions and 0 deletions
--- a/node_modules/rc-table/LICENSE.md
+++ b/node_modules/rc-table/LICENSE.md
@@ -0,0 +1,9 @@
+MIT LICENSE
+
+Copyright (c) 2015-present Alipay.com, https://www.alipay.com/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/rc-table/README.md
+++ b/node_modules/rc-table/README.md
@@ -0,0 +1,161 @@
+# rc-table
+
+React table component with useful functions.
+
+[![NPM version][npm-image]][npm-url] [![dumi](https://img.shields.io/badge/docs%20by-dumi-blue?style=flat-square)](https://github.com/umijs/dumi) [![build status][github-actions-image]][github-actions-url] [![Test coverage][codecov-image]][codecov-url] [![npm download][download-image]][download-url] [![bundle size][bundlephobia-image]][bundlephobia-url]
+
+[npm-image]: http://img.shields.io/npm/v/rc-table.svg?style=flat-square
+[npm-url]: http://npmjs.org/package/rc-table
+[github-actions-image]: https://github.com/react-component/table/workflows/CI/badge.svg
+[github-actions-url]: https://github.com/react-component/table/actions
+[coveralls-image]: https://img.shields.io/coveralls/react-component/table.svg?style=flat-square
+[coveralls-url]: https://coveralls.io/r/react-component/table?branch=master
+[codecov-image]: https://img.shields.io/codecov/c/github/react-component/table/master.svg?style=flat-square
+[codecov-url]: https://codecov.io/gh/react-component/table/branch/master
+[david-url]: https://david-dm.org/react-component/table
+[david-image]: https://david-dm.org/react-component/table/status.svg?style=flat-square
+[david-dev-url]: https://david-dm.org/react-component/table?type=dev
+[david-dev-image]: https://david-dm.org/react-component/table/dev-status.svg?style=flat-square
+[download-image]: https://img.shields.io/npm/dm/rc-table.svg?style=flat-square
+[download-url]: https://npmjs.org/package/rc-table
+[bundlephobia-url]: https://bundlephobia.com/result?p=rc-table
+[bundlephobia-image]: https://badgen.net/bundlephobia/minzip/rc-table
+
+## install
+
+[![rc-table](https://nodei.co/npm/rc-table.png)](https://npmjs.org/package/rc-table)
+
+## Development
+
+```
+npm install
+npm start
+```
+
+## Example
+
+https://table-react-component.vercel.app/
+
+## Usage
+
+```js
+import Table from 'rc-table';
+
+const columns = [
+  {
+    title: 'Name',
+    dataIndex: 'name',
+    key: 'name',
+    width: 100,
+  },
+  {
+    title: 'Age',
+    dataIndex: 'age',
+    key: 'age',
+    width: 100,
+  },
+  {
+    title: 'Address',
+    dataIndex: 'address',
+    key: 'address',
+    width: 200,
+  },
+  {
+    title: 'Operations',
+    dataIndex: '',
+    key: 'operations',
+    render: () => <a href="#">Delete</a>,
+  },
+];
+
+const data = [
+  { name: 'Jack', age: 28, address: 'some where', key: '1' },
+  { name: 'Rose', age: 36, address: 'some where', key: '2' },
+];
+
+React.render(<Table columns={columns} data={data} />, mountNode);
+```
+
+## API
+
+### Properties
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| tableLayout | `auto` \| `fixed` | `auto` \| `fixed` for any columns is fixed or ellipsis or header is fixed | https://developer.mozilla.org/en-US/docs/Web/CSS/table-layout |
+| prefixCls | String | rc-table |  |
+| className | String |  | additional className |
+| id | String |  | identifier of the container div |
+| useFixedHeader | Boolean | false | whether use separator table for header. better set width for columns |
+| scroll | Object | {x: false, y: false} | whether table can be scroll in x/y direction, `x` or `y` can be a number that indicated the width and height of table body |
+| expandable | Object |  | Config expand props |
+| expandable.defaultExpandAllRows | Boolean | false | Expand All Rows initially |
+| expandable.defaultExpandedRowKeys | String[] | [] | initial expanded rows keys |
+| expandable.expandedRowKeys | String[] |  | current expanded rows keys |
+| expandable.expandedRowRender | Function(recode, index, indent, expanded):ReactNode |  | Content render to expanded row |
+| expandable.expandedRowClassName | `string` \| `(recode, index, indent) => string` |  | get expanded row's className |
+| expandable.expandRowByClick | boolean |  | Support expand by click row |
+| expandable.expandIconColumnIndex | Number | 0 | The index of expandIcon which column will be inserted when expandIconAsCell is false |
+| expandable.expandIcon | props => ReactNode |  | Customize expand icon |
+| expandable.indentSize | Number | 15 | indentSize for every level of data.i.children, better using with column.width specified |
+| expandable.rowExpandable | (record) => boolean |  | Config row support expandable |
+| expandable.onExpand | Function(expanded, record) |  | function to call when click expand icon |
+| expandable.onExpandedRowsChange | Function(expandedRows) |  | function to call when the expanded rows change |
+| expandable.fixed | String \| Boolean | - | this expand icon will be fixed when table scroll horizontally: true or `left` or `right` and `expandIconColumnIndex` need to stay first or last |
+| rowKey | string or Function(record, index):string | 'key' | If rowKey is string, `record[rowKey]` will be used as key. If rowKey is function, the return value of `rowKey(record, index)` will be use as key. |
+| rowClassName | string or Function(record, index, indent):string |  | get row's className |
+| rowRef | Function(record, index, indent):string |  | get row's ref key |
+| data | Object[] |  | data record array to be rendered |
+| onRow | Function(record, index) |  | Set custom props per each row. |
+| onHeaderRow | Function(record, index) |  | Set custom props per each header row. |
+| showHeader | Boolean | true | whether table head is shown |
+| hidden | Boolean | `false` | Hidden column. |
+| title | Function(currentData) |  | table title render function |
+| footer | Function(currentData) |  | table footer render function |
+| emptyText | React.Node or Function | `No Data` | Display text when data is empty |
+| columns | Object[] |  | The columns config of table, see table below |
+| components | Object |  | Override table elements, see [#171](https://github.com/react-component/table/pull/171) for more details |
+| sticky | boolean \| {offsetHeader?: number, offsetScroll?: number, getContainer?: () => Window \| HTMLElement } | false | stick header and scroll bar |
+| summary | (data: readonly RecordType[]) => React.ReactNode | - | `summary` attribute in `table` component is used to define the summary row. |
+| rowHoverable | boolean | true | Table hover interaction |
+
+## Column Props
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| key | String |  | key of this column |
+| className | String |  | className of this column |
+| colSpan | Number |  | thead colSpan of this column |
+| title | React Node |  | title of this column |
+| dataIndex | String |  | display field of the data record |
+| width | String \| Number |  | width of the specific proportion calculation according to the width of the columns |
+| minWidth | Number |  | the minimum width of the column, only worked when tableLayout is auto |
+| fixed | String \| Boolean |  | this column will be fixed when table scroll horizontally: true or 'left' or 'right' |
+| align | String |  | specify how cell content is aligned |
+| ellipsis | Boolean |  | specify whether cell content be ellipsized |
+| rowScope | 'row' \| 'rowgroup' |  | Set scope attribute for all cells in this column |
+| onCell | Function(record, index) |  | Set custom props per each cell. |
+| onHeaderCell | Function(record) |  | Set custom props per each header cell. |
+| render | Function(value, row, index) |  | The render function of cell, has three params: the text of this cell, the record of this row, the index of this row, it's return an object:{ children: value, props: { colSpan: 1, rowSpan:1 } } ==> 'children' is the text of this cell, props is some setting of this cell, eg: 'colspan' set td colspan, 'rowspan' set td rowspan |
+
+## Summary Props
+
+### Table.Summary
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| key | String |  | key of this summary |
+| fixed | boolean \| 'top' \| 'bottom' | - | `true` fixes the summary row at the bottom of the table. `top` fixes the summary row at the top of the table, while `bottom` fixes it at the bottom. `undefined` or `false` makes the summary row scrollable along with the table. |
+
+### Table.Summary.Row
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| key | String |  | key of this summary |
+| className | String | - | className of this summary row |
+| style | React.CSSProperties | - | style of this summary row |
+| onClick | (e?: React.MouseEvent\<HTMLElement>) => void | - | The `onClick` attribute in `Table.Summary.Row` component can be used to set a click event handler for the summary row. |
+
+## License
+
+rc-table is released under the MIT license.
--- a/node_modules/rc-table/assets/index.css
+++ b/node_modules/rc-table/assets/index.css
@@ -0,0 +1,297 @@
+.rc-table-tbody-virtual {
+  border-left: 1px solid red;
+}
+.rc-table-tbody-virtual * {
+  box-sizing: border-box;
+}
+.rc-table-tbody-virtual .rc-table-row {
+  display: flex;
+  box-sizing: border-box;
+  width: 100%;
+}
+.rc-table-tbody-virtual .rc-table-row-extra .rc-table-cell {
+  background: rgba(200, 200, 255) !important;
+}
+.rc-table-tbody-virtual .rc-table-cell {
+  flex: 0 0 var(--virtual-width);
+  width: var(--virtual-width);
+  padding: 8px 16px;
+  border-right: 1px solid red;
+  border-bottom: 1px solid red;
+}
+.rc-table {
+  position: relative;
+  box-sizing: border-box;
+  color: #666;
+  font-size: 12px;
+  line-height: 1.5;
+}
+.rc-table-rtl {
+  direction: rtl;
+}
+.rc-table table {
+  width: 100%;
+  border-spacing: 0px;
+}
+.rc-table th,
+.rc-table td {
+  position: relative;
+  box-sizing: border-box;
+  padding: 0;
+  padding: 16px 8px;
+  white-space: normal;
+  border: 1px solid red;
+  border-top: 0;
+  border-left: 0;
+  transition: box-shadow 0.3s;
+}
+.rc-table-rtl.rc-table th,
+.rc-table-rtl.rc-table td {
+  border-right: 0;
+  border-left: 1px solid red;
+}
+.rc-table-fixed-column-gapped .rc-table-cell-fix-left-last::after,
+.rc-table-fixed-column-gapped .rc-table-cell-fix-right-first::after {
+  display: none !important;
+}
+.rc-table-cell {
+  background: #f4f4f4;
+}
+.rc-table-cell-fix-left,
+.rc-table-cell-fix-right {
+  z-index: 2;
+}
+.rc-table-cell-fix-right:last-child:not(.rc-table-cell-fix-sticky) {
+  border-right-color: transparent;
+}
+.rc-table-rtl .rc-table-cell-fix-right:last-child {
+  border-right-color: red;
+}
+.rc-table-rtl .rc-table-cell-fix-left:last-child {
+  border-left-color: transparent;
+}
+.rc-table-rtl .rc-table-cell-fix-left-first {
+  box-shadow: 1px 0 0 red;
+}
+.rc-table-cell-fix-left-first::after,
+.rc-table-cell-fix-left-last::after {
+  position: absolute;
+  top: 0;
+  right: -1px;
+  bottom: -1px;
+  width: 20px;
+  transform: translateX(100%);
+  transition: box-shadow 0.3s;
+  content: '';
+  pointer-events: none;
+}
+.rc-table-cell-fix-left-all::after {
+  display: none;
+}
+.rc-table-cell-fix-right-first,
+.rc-table-cell-fix-right-last {
+  box-shadow: -1px 0 0 red;
+}
+.rc-table-rtl .rc-table-cell-fix-right-first,
+.rc-table-rtl .rc-table-cell-fix-right-last {
+  box-shadow: none;
+}
+.rc-table-cell-fix-right-first::after,
+.rc-table-cell-fix-right-last::after {
+  position: absolute;
+  top: 0;
+  bottom: -1px;
+  left: -1px;
+  width: 20px;
+  transform: translateX(-100%);
+  transition: box-shadow 0.3s;
+  content: '';
+  pointer-events: none;
+}
+.rc-table-cell.rc-table-cell-ellipsis {
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+.rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-left-first,
+.rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-left-last,
+.rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-right-first .rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-right-last {
+  overflow: visible;
+}
+.rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-left-first .rc-table-cell-content,
+.rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-left-last .rc-table-cell-content,
+.rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-right-first .rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-right-last .rc-table-cell-content {
+  display: block;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.rc-table-cell.rc-table-cell-row-hover {
+  background: #fff4f4;
+}
+.rc-table-ping-left .rc-table-cell-fix-left-first::after,
+.rc-table-ping-left .rc-table-cell-fix-left-last::after {
+  box-shadow: inset 10px 0 8px -8px green;
+}
+.rc-table-ping-right .rc-table-cell-fix-right-first::after,
+.rc-table-ping-right .rc-table-cell-fix-right-last::after {
+  box-shadow: inset -10px 0 8px -8px green;
+}
+.rc-table-expand-icon-col {
+  width: 60px;
+}
+.rc-table-row-expand-icon-cell {
+  text-align: center;
+}
+.rc-table thead th {
+  text-align: center;
+  background: #f7f7f7;
+}
+.rc-table thead .rc-table-cell-scrollbar::after {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: -1px;
+  width: 1px;
+  background: #f7f7f7;
+  content: '';
+}
+.rc-table-rtl.rc-table thead .rc-table-cell-scrollbar::after {
+  right: -1px;
+  left: auto;
+}
+.rc-table-header {
+  border: 1px solid red;
+  border-right: 0;
+  border-bottom: 0;
+}
+.rc-table-placeholder {
+  text-align: center;
+}
+.rc-table tbody tr td {
+  background: #fff;
+}
+.rc-table tbody tr th {
+  background: #f7f7f7;
+}
+th.rc-table-measure-cell {
+  padding-top: 0;
+  padding-bottom: 0;
+  border-top: 0;
+  border-bottom: 0;
+}
+.rc-table-measure-cell-content {
+  height: 0;
+  overflow: hidden;
+  visibility: hidden;
+  pointer-events: none;
+}
+.rc-table-content {
+  border: 1px solid red;
+  border-right: 0;
+  border-bottom: 0;
+  border-radius: 5px 0 0 0;
+}
+.rc-table-body {
+  border: 1px solid red;
+  border-right: 0;
+  border-bottom: 0;
+  border-top: 0;
+}
+.rc-table-fixed-column .rc-table-body::after {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 1;
+  border-right: 1px solid red;
+  content: '';
+}
+.rc-table-expanded-row .rc-table-cell {
+  box-shadow: inset 0 8px 8px -8px green;
+}
+.rc-table-expanded-row-fixed {
+  box-sizing: border-box;
+  margin: -16px -8px;
+  margin-right: -10px;
+  padding: 16px 8px;
+}
+.rc-table-expanded-row-fixed::after {
+  position: absolute;
+  top: 0;
+  right: 1px;
+  bottom: 0;
+  width: 0;
+  border-right: 1px solid red;
+  content: '';
+}
+.rc-table-row-expand-icon {
+  display: inline-block;
+  width: 16px;
+  height: 16px;
+  color: #aaa;
+  line-height: 16px;
+  text-align: center;
+  vertical-align: middle;
+  border: 1px solid currentColor;
+  cursor: pointer;
+}
+.rc-table-row-expand-icon.rc-table-row-expanded::after {
+  content: '-';
+}
+.rc-table-row-expand-icon.rc-table-row-collapsed::after {
+  content: '+';
+}
+.rc-table-row-expand-icon.rc-table-row-spaced {
+  visibility: hidden;
+}
+.rc-table-title {
+  padding: 16px 8px;
+  border: 1px solid red;
+  border-bottom: 0;
+}
+.rc-table-caption {
+  padding: 16px 8px;
+  border-right: 1px solid red;
+  border-bottom: 1px solid red;
+}
+.rc-table-footer {
+  padding: 16px 8px;
+  border: 1px solid red;
+  border-top: 0;
+}
+.rc-table tfoot td {
+  background: #fff;
+}
+.rc-table-summary {
+  border-top: 1px solid red;
+  border-left: 1px solid red;
+}
+.rc-table-sticky-holder {
+  position: sticky;
+  z-index: 2;
+}
+.rc-table-sticky-scroll {
+  position: sticky;
+  bottom: 0;
+  z-index: 2;
+  display: flex;
+  align-items: center;
+  border-top: 1px solid #f3f3f3;
+  opacity: 0.6;
+  transition: transform 0.1s ease-in 0s;
+}
+.rc-table-sticky-scroll:hover {
+  transform: scaleY(1.2);
+  transform-origin: center bottom;
+}
+.rc-table-sticky-scroll-bar {
+  height: 8px;
+  background-color: #bbb;
+  border-radius: 4px;
+}
+.rc-table-sticky-scroll-bar:hover {
+  background-color: #999;
+}
+.rc-table-sticky-scroll-bar-active {
+  background-color: #999;
+}
--- a/node_modules/rc-table/es/Body/BodyRow.d.ts
+++ b/node_modules/rc-table/es/Body/BodyRow.d.ts
@@ -0,0 +1,35 @@
+import * as React from 'react';
+import useRowInfo from '../hooks/useRowInfo';
+import type { ColumnType, CustomizeComponent } from '../interface';
+export interface BodyRowProps<RecordType> {
+    record: RecordType;
+    index: number;
+    renderIndex: number;
+    className?: string;
+    style?: React.CSSProperties;
+    rowComponent: CustomizeComponent;
+    cellComponent: CustomizeComponent;
+    scopeCellComponent: CustomizeComponent;
+    indent?: number;
+    rowKey: React.Key;
+    rowKeys: React.Key[];
+    expandedRowInfo?: {
+        offset: number;
+        colSpan: number;
+        sticky: number;
+    };
+}
+export declare function getCellProps<RecordType>(rowInfo: ReturnType<typeof useRowInfo<RecordType>>, column: ColumnType<RecordType>, colIndex: number, indent: number, index: number, rowKeys?: React.Key[], expandedRowOffset?: number): {
+    key: React.Key;
+    fixedInfo: import("../utils/fixUtil").FixedInfo;
+    appendCellNode: React.ReactNode;
+    additionalCellProps: React.HTMLAttributes<any> & React.TdHTMLAttributes<any>;
+};
+declare function BodyRow<RecordType extends {
+    children?: readonly RecordType[];
+}>(props: BodyRowProps<RecordType>): React.JSX.Element;
+declare namespace BodyRow {
+    var displayName: string;
+}
+declare const _default: typeof BodyRow;
+export default _default;
--- a/node_modules/rc-table/es/Body/BodyRow.js
+++ b/node_modules/rc-table/es/Body/BodyRow.js
@@ -0,0 +1,173 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import classNames from 'classnames';
+import * as React from 'react';
+import Cell from "../Cell";
+import { responseImmutable } from "../context/TableContext";
+import devRenderTimes from "../hooks/useRenderTimes";
+import useRowInfo from "../hooks/useRowInfo";
+import ExpandedRow from "./ExpandedRow";
+import { computedExpandedClassName } from "../utils/expandUtil";
+// ==================================================================================
+// ==                                 getCellProps                                 ==
+// ==================================================================================
+export function getCellProps(rowInfo, column, colIndex, indent, index) {
+  var _column$onCell;
+  var rowKeys = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
+  var expandedRowOffset = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
+  var record = rowInfo.record,
+    prefixCls = rowInfo.prefixCls,
+    columnsKey = rowInfo.columnsKey,
+    fixedInfoList = rowInfo.fixedInfoList,
+    expandIconColumnIndex = rowInfo.expandIconColumnIndex,
+    nestExpandable = rowInfo.nestExpandable,
+    indentSize = rowInfo.indentSize,
+    expandIcon = rowInfo.expandIcon,
+    expanded = rowInfo.expanded,
+    hasNestChildren = rowInfo.hasNestChildren,
+    onTriggerExpand = rowInfo.onTriggerExpand,
+    expandable = rowInfo.expandable,
+    expandedKeys = rowInfo.expandedKeys;
+  var key = columnsKey[colIndex];
+  var fixedInfo = fixedInfoList[colIndex];
+
+  // ============= Used for nest expandable =============
+  var appendCellNode;
+  if (colIndex === (expandIconColumnIndex || 0) && nestExpandable) {
+    appendCellNode = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
+      style: {
+        paddingLeft: "".concat(indentSize * indent, "px")
+      },
+      className: "".concat(prefixCls, "-row-indent indent-level-").concat(indent)
+    }), expandIcon({
+      prefixCls: prefixCls,
+      expanded: expanded,
+      expandable: hasNestChildren,
+      record: record,
+      onExpand: onTriggerExpand
+    }));
+  }
+  var additionalCellProps = ((_column$onCell = column.onCell) === null || _column$onCell === void 0 ? void 0 : _column$onCell.call(column, record, index)) || {};
+
+  // Expandable row has offset
+  if (expandedRowOffset) {
+    var _additionalCellProps$ = additionalCellProps.rowSpan,
+      rowSpan = _additionalCellProps$ === void 0 ? 1 : _additionalCellProps$;
+
+    // For expandable row with rowSpan,
+    // We should increase the rowSpan if the row is expanded
+    if (expandable && rowSpan && colIndex < expandedRowOffset) {
+      var currentRowSpan = rowSpan;
+      for (var i = index; i < index + rowSpan; i += 1) {
+        var rowKey = rowKeys[i];
+        if (expandedKeys.has(rowKey)) {
+          currentRowSpan += 1;
+        }
+      }
+      additionalCellProps.rowSpan = currentRowSpan;
+    }
+  }
+  return {
+    key: key,
+    fixedInfo: fixedInfo,
+    appendCellNode: appendCellNode,
+    additionalCellProps: additionalCellProps
+  };
+}
+
+// ==================================================================================
+// ==                                 getCellProps                                 ==
+// ==================================================================================
+function BodyRow(props) {
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+  var className = props.className,
+    style = props.style,
+    record = props.record,
+    index = props.index,
+    renderIndex = props.renderIndex,
+    rowKey = props.rowKey,
+    rowKeys = props.rowKeys,
+    _props$indent = props.indent,
+    indent = _props$indent === void 0 ? 0 : _props$indent,
+    RowComponent = props.rowComponent,
+    cellComponent = props.cellComponent,
+    scopeCellComponent = props.scopeCellComponent,
+    expandedRowInfo = props.expandedRowInfo;
+  var rowInfo = useRowInfo(record, rowKey, index, indent);
+  var prefixCls = rowInfo.prefixCls,
+    flattenColumns = rowInfo.flattenColumns,
+    expandedRowClassName = rowInfo.expandedRowClassName,
+    expandedRowRender = rowInfo.expandedRowRender,
+    rowProps = rowInfo.rowProps,
+    expanded = rowInfo.expanded,
+    rowSupportExpand = rowInfo.rowSupportExpand;
+
+  // Force render expand row if expanded before
+  var expandedRef = React.useRef(false);
+  expandedRef.current || (expandedRef.current = expanded);
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+
+  // 若没有 expandedRowRender 参数, 将使用 baseRowNode 渲染 Children
+  // 此时如果 level > 1 则说明是 expandedRow, 一样需要附加 computedExpandedRowClassName
+  var expandedClsName = computedExpandedClassName(expandedRowClassName, record, index, indent);
+
+  // ======================== Base tr row ========================
+  var baseRowNode = /*#__PURE__*/React.createElement(RowComponent, _extends({}, rowProps, {
+    "data-row-key": rowKey,
+    className: classNames(className, "".concat(prefixCls, "-row"), "".concat(prefixCls, "-row-level-").concat(indent), rowProps === null || rowProps === void 0 ? void 0 : rowProps.className, _defineProperty({}, expandedClsName, indent >= 1)),
+    style: _objectSpread(_objectSpread({}, style), rowProps === null || rowProps === void 0 ? void 0 : rowProps.style)
+  }), flattenColumns.map(function (column, colIndex) {
+    var render = column.render,
+      dataIndex = column.dataIndex,
+      columnClassName = column.className;
+    var _getCellProps = getCellProps(rowInfo, column, colIndex, indent, index, rowKeys, expandedRowInfo === null || expandedRowInfo === void 0 ? void 0 : expandedRowInfo.offset),
+      key = _getCellProps.key,
+      fixedInfo = _getCellProps.fixedInfo,
+      appendCellNode = _getCellProps.appendCellNode,
+      additionalCellProps = _getCellProps.additionalCellProps;
+    return /*#__PURE__*/React.createElement(Cell, _extends({
+      className: columnClassName,
+      ellipsis: column.ellipsis,
+      align: column.align,
+      scope: column.rowScope,
+      component: column.rowScope ? scopeCellComponent : cellComponent,
+      prefixCls: prefixCls,
+      key: key,
+      record: record,
+      index: index,
+      renderIndex: renderIndex,
+      dataIndex: dataIndex,
+      render: render,
+      shouldCellUpdate: column.shouldCellUpdate
+    }, fixedInfo, {
+      appendNode: appendCellNode,
+      additionalProps: additionalCellProps
+    }));
+  }));
+
+  // ======================== Expand Row =========================
+  var expandRowNode;
+  if (rowSupportExpand && (expandedRef.current || expanded)) {
+    var expandContent = expandedRowRender(record, index, indent + 1, expanded);
+    expandRowNode = /*#__PURE__*/React.createElement(ExpandedRow, {
+      expanded: expanded,
+      className: classNames("".concat(prefixCls, "-expanded-row"), "".concat(prefixCls, "-expanded-row-level-").concat(indent + 1), expandedClsName),
+      prefixCls: prefixCls,
+      component: RowComponent,
+      cellComponent: cellComponent,
+      colSpan: expandedRowInfo ? expandedRowInfo.colSpan : flattenColumns.length,
+      stickyOffset: expandedRowInfo === null || expandedRowInfo === void 0 ? void 0 : expandedRowInfo.sticky,
+      isEmpty: false
+    }, expandContent);
+  }
+  return /*#__PURE__*/React.createElement(React.Fragment, null, baseRowNode, expandRowNode);
+}
+if (process.env.NODE_ENV !== 'production') {
+  BodyRow.displayName = 'BodyRow';
+}
+export default responseImmutable(BodyRow);
--- a/node_modules/rc-table/es/Body/ExpandedRow.d.ts
+++ b/node_modules/rc-table/es/Body/ExpandedRow.d.ts
@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { CustomizeComponent } from '../interface';
+export interface ExpandedRowProps {
+    prefixCls: string;
+    component: CustomizeComponent;
+    cellComponent: CustomizeComponent;
+    className: string;
+    expanded: boolean;
+    children: React.ReactNode;
+    colSpan: number;
+    isEmpty: boolean;
+    stickyOffset?: number;
+}
+declare function ExpandedRow(props: ExpandedRowProps): React.JSX.Element;
+export default ExpandedRow;
--- a/node_modules/rc-table/es/Body/ExpandedRow.js
+++ b/node_modules/rc-table/es/Body/ExpandedRow.js
@@ -0,0 +1,51 @@
+import { useContext } from '@rc-component/context';
+import * as React from 'react';
+import Cell from "../Cell";
+import TableContext from "../context/TableContext";
+import devRenderTimes from "../hooks/useRenderTimes";
+function ExpandedRow(props) {
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+  var prefixCls = props.prefixCls,
+    children = props.children,
+    Component = props.component,
+    cellComponent = props.cellComponent,
+    className = props.className,
+    expanded = props.expanded,
+    colSpan = props.colSpan,
+    isEmpty = props.isEmpty,
+    _props$stickyOffset = props.stickyOffset,
+    stickyOffset = _props$stickyOffset === void 0 ? 0 : _props$stickyOffset;
+  var _useContext = useContext(TableContext, ['scrollbarSize', 'fixHeader', 'fixColumn', 'componentWidth', 'horizonScroll']),
+    scrollbarSize = _useContext.scrollbarSize,
+    fixHeader = _useContext.fixHeader,
+    fixColumn = _useContext.fixColumn,
+    componentWidth = _useContext.componentWidth,
+    horizonScroll = _useContext.horizonScroll;
+
+  // Cache render node
+  var contentNode = children;
+  if (isEmpty ? horizonScroll && componentWidth : fixColumn) {
+    contentNode = /*#__PURE__*/React.createElement("div", {
+      style: {
+        width: componentWidth - stickyOffset - (fixHeader && !isEmpty ? scrollbarSize : 0),
+        position: 'sticky',
+        left: stickyOffset,
+        overflow: 'hidden'
+      },
+      className: "".concat(prefixCls, "-expanded-row-fixed")
+    }, contentNode);
+  }
+  return /*#__PURE__*/React.createElement(Component, {
+    className: className,
+    style: {
+      display: expanded ? null : 'none'
+    }
+  }, /*#__PURE__*/React.createElement(Cell, {
+    component: cellComponent,
+    prefixCls: prefixCls,
+    colSpan: colSpan
+  }, contentNode));
+}
+export default ExpandedRow;
--- a/node_modules/rc-table/es/Body/MeasureCell.d.ts
+++ b/node_modules/rc-table/es/Body/MeasureCell.d.ts
@@ -0,0 +1,8 @@
+import * as React from 'react';
+export interface MeasureCellProps {
+    columnKey: React.Key;
+    onColumnResize: (key: React.Key, width: number) => void;
+    prefixCls: string;
+    title?: React.ReactNode;
+}
+export default function MeasureCell({ columnKey, onColumnResize, prefixCls, title, }: MeasureCellProps): React.JSX.Element;
--- a/node_modules/rc-table/es/Body/MeasureCell.js
+++ b/node_modules/rc-table/es/Body/MeasureCell.js
@@ -0,0 +1,23 @@
+import * as React from 'react';
+import ResizeObserver from 'rc-resize-observer';
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+export default function MeasureCell(_ref) {
+  var columnKey = _ref.columnKey,
+    onColumnResize = _ref.onColumnResize,
+    prefixCls = _ref.prefixCls,
+    title = _ref.title;
+  var cellRef = React.useRef();
+  useLayoutEffect(function () {
+    if (cellRef.current) {
+      onColumnResize(columnKey, cellRef.current.offsetWidth);
+    }
+  }, []);
+  return /*#__PURE__*/React.createElement(ResizeObserver, {
+    data: columnKey
+  }, /*#__PURE__*/React.createElement("th", {
+    ref: cellRef,
+    className: "".concat(prefixCls, "-measure-cell")
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-measure-cell-content")
+  }, title || '\xa0')));
+}
--- a/node_modules/rc-table/es/Body/MeasureRow.d.ts
+++ b/node_modules/rc-table/es/Body/MeasureRow.d.ts
@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { ColumnType } from '../interface';
+export interface MeasureRowProps {
+    prefixCls: string;
+    onColumnResize: (key: React.Key, width: number) => void;
+    columnsKey: React.Key[];
+    columns: readonly ColumnType<any>[];
+}
+export default function MeasureRow({ prefixCls, columnsKey, onColumnResize, columns, }: MeasureRowProps): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element;
--- a/node_modules/rc-table/es/Body/MeasureRow.js
+++ b/node_modules/rc-table/es/Body/MeasureRow.js
@@ -0,0 +1,47 @@
+import * as React from 'react';
+import ResizeObserver from 'rc-resize-observer';
+import MeasureCell from "./MeasureCell";
+import isVisible from "rc-util/es/Dom/isVisible";
+import { useContext } from '@rc-component/context';
+import TableContext from "../context/TableContext";
+export default function MeasureRow(_ref) {
+  var prefixCls = _ref.prefixCls,
+    columnsKey = _ref.columnsKey,
+    onColumnResize = _ref.onColumnResize,
+    columns = _ref.columns;
+  var ref = React.useRef(null);
+  var _useContext = useContext(TableContext, ['measureRowRender']),
+    measureRowRender = _useContext.measureRowRender;
+  var measureRow = /*#__PURE__*/React.createElement("tr", {
+    "aria-hidden": "true",
+    className: "".concat(prefixCls, "-measure-row"),
+    ref: ref,
+    tabIndex: -1
+  }, /*#__PURE__*/React.createElement(ResizeObserver.Collection, {
+    onBatchResize: function onBatchResize(infoList) {
+      if (isVisible(ref.current)) {
+        infoList.forEach(function (_ref2) {
+          var columnKey = _ref2.data,
+            size = _ref2.size;
+          onColumnResize(columnKey, size.offsetWidth);
+        });
+      }
+    }
+  }, columnsKey.map(function (columnKey) {
+    var column = columns.find(function (col) {
+      return col.key === columnKey;
+    });
+    var rawTitle = column === null || column === void 0 ? void 0 : column.title;
+    var titleForMeasure = /*#__PURE__*/React.isValidElement(rawTitle) ? /*#__PURE__*/React.cloneElement(rawTitle, {
+      ref: null
+    }) : rawTitle;
+    return /*#__PURE__*/React.createElement(MeasureCell, {
+      prefixCls: prefixCls,
+      key: columnKey,
+      columnKey: columnKey,
+      onColumnResize: onColumnResize,
+      title: titleForMeasure
+    });
+  })));
+  return measureRowRender ? measureRowRender(measureRow) : measureRow;
+}
--- a/node_modules/rc-table/es/Body/index.d.ts
+++ b/node_modules/rc-table/es/Body/index.d.ts
@@ -0,0 +1,11 @@
+import * as React from 'react';
+export interface BodyProps<RecordType> {
+    data: readonly RecordType[];
+    measureColumnWidth: boolean;
+}
+declare function Body<RecordType>(props: BodyProps<RecordType>): React.JSX.Element;
+declare namespace Body {
+    var displayName: string;
+}
+declare const _default: typeof Body;
+export default _default;
--- a/node_modules/rc-table/es/Body/index.js
+++ b/node_modules/rc-table/es/Body/index.js
@@ -0,0 +1,111 @@
+import { useContext } from '@rc-component/context';
+import * as React from 'react';
+import PerfContext from "../context/PerfContext";
+import TableContext, { responseImmutable } from "../context/TableContext";
+import useFlattenRecords from "../hooks/useFlattenRecords";
+import devRenderTimes from "../hooks/useRenderTimes";
+import { getColumnsKey } from "../utils/valueUtil";
+import BodyRow from "./BodyRow";
+import ExpandedRow from "./ExpandedRow";
+import MeasureRow from "./MeasureRow";
+function Body(props) {
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+  var data = props.data,
+    measureColumnWidth = props.measureColumnWidth;
+  var _useContext = useContext(TableContext, ['prefixCls', 'getComponent', 'onColumnResize', 'flattenColumns', 'getRowKey', 'expandedKeys', 'childrenColumnName', 'emptyNode', 'expandedRowOffset', 'fixedInfoList', 'colWidths']),
+    prefixCls = _useContext.prefixCls,
+    getComponent = _useContext.getComponent,
+    onColumnResize = _useContext.onColumnResize,
+    flattenColumns = _useContext.flattenColumns,
+    getRowKey = _useContext.getRowKey,
+    expandedKeys = _useContext.expandedKeys,
+    childrenColumnName = _useContext.childrenColumnName,
+    emptyNode = _useContext.emptyNode,
+    _useContext$expandedR = _useContext.expandedRowOffset,
+    expandedRowOffset = _useContext$expandedR === void 0 ? 0 : _useContext$expandedR,
+    colWidths = _useContext.colWidths;
+  var flattenData = useFlattenRecords(data, childrenColumnName, expandedKeys, getRowKey);
+  var rowKeys = React.useMemo(function () {
+    return flattenData.map(function (item) {
+      return item.rowKey;
+    });
+  }, [flattenData]);
+
+  // =================== Performance ====================
+  var perfRef = React.useRef({
+    renderWithProps: false
+  });
+
+  // ===================== Expanded =====================
+  // `expandedRowOffset` data is same for all the rows.
+  // Let's calc on Body side to save performance.
+  var expandedRowInfo = React.useMemo(function () {
+    var expandedColSpan = flattenColumns.length - expandedRowOffset;
+    var expandedStickyStart = 0;
+    for (var i = 0; i < expandedRowOffset; i += 1) {
+      expandedStickyStart += colWidths[i] || 0;
+    }
+    return {
+      offset: expandedRowOffset,
+      colSpan: expandedColSpan,
+      sticky: expandedStickyStart
+    };
+  }, [flattenColumns.length, expandedRowOffset, colWidths]);
+
+  // ====================== Render ======================
+  var WrapperComponent = getComponent(['body', 'wrapper'], 'tbody');
+  var trComponent = getComponent(['body', 'row'], 'tr');
+  var tdComponent = getComponent(['body', 'cell'], 'td');
+  var thComponent = getComponent(['body', 'cell'], 'th');
+  var rows;
+  if (data.length) {
+    rows = flattenData.map(function (item, idx) {
+      var record = item.record,
+        indent = item.indent,
+        renderIndex = item.index,
+        rowKey = item.rowKey;
+      return /*#__PURE__*/React.createElement(BodyRow, {
+        key: rowKey,
+        rowKey: rowKey,
+        rowKeys: rowKeys,
+        record: record,
+        index: idx,
+        renderIndex: renderIndex,
+        rowComponent: trComponent,
+        cellComponent: tdComponent,
+        scopeCellComponent: thComponent,
+        indent: indent
+        // Expanded row info
+        ,
+        expandedRowInfo: expandedRowInfo
+      });
+    });
+  } else {
+    rows = /*#__PURE__*/React.createElement(ExpandedRow, {
+      expanded: true,
+      className: "".concat(prefixCls, "-placeholder"),
+      prefixCls: prefixCls,
+      component: trComponent,
+      cellComponent: tdComponent,
+      colSpan: flattenColumns.length,
+      isEmpty: true
+    }, emptyNode);
+  }
+  var columnsKey = getColumnsKey(flattenColumns);
+  return /*#__PURE__*/React.createElement(PerfContext.Provider, {
+    value: perfRef.current
+  }, /*#__PURE__*/React.createElement(WrapperComponent, {
+    className: "".concat(prefixCls, "-tbody")
+  }, measureColumnWidth && /*#__PURE__*/React.createElement(MeasureRow, {
+    prefixCls: prefixCls,
+    columnsKey: columnsKey,
+    onColumnResize: onColumnResize,
+    columns: flattenColumns
+  }), rows));
+}
+if (process.env.NODE_ENV !== 'production') {
+  Body.displayName = 'Body';
+}
+export default responseImmutable(Body);
--- a/node_modules/rc-table/es/Cell/index.d.ts
+++ b/node_modules/rc-table/es/Cell/index.d.ts
@@ -0,0 +1,36 @@
+import * as React from 'react';
+import type { AlignType, CellEllipsisType, ColumnType, CustomizeComponent, DataIndex, DefaultRecordType, ScopeType } from '../interface';
+export interface CellProps<RecordType extends DefaultRecordType> {
+    prefixCls?: string;
+    className?: string;
+    record?: RecordType;
+    /** `column` index is the real show rowIndex */
+    index?: number;
+    /** the index of the record. For the render(value, record, renderIndex) */
+    renderIndex?: number;
+    dataIndex?: DataIndex<RecordType>;
+    render?: ColumnType<RecordType>['render'];
+    component?: CustomizeComponent;
+    children?: React.ReactNode;
+    colSpan?: number;
+    rowSpan?: number;
+    scope?: ScopeType;
+    ellipsis?: CellEllipsisType;
+    align?: AlignType;
+    shouldCellUpdate?: (record: RecordType, prevRecord: RecordType) => boolean;
+    fixLeft?: number | false;
+    fixRight?: number | false;
+    firstFixLeft?: boolean;
+    lastFixLeft?: boolean;
+    firstFixRight?: boolean;
+    lastFixRight?: boolean;
+    allColsFixedLeft?: boolean;
+    /** @private Used for `expandable` with nest tree */
+    appendNode?: React.ReactNode;
+    additionalProps?: React.TdHTMLAttributes<HTMLTableCellElement>;
+    rowType?: 'header' | 'body' | 'footer';
+    isSticky?: boolean;
+}
+declare function Cell<RecordType>(props: CellProps<RecordType>): React.JSX.Element;
+declare const _default: typeof Cell;
+export default _default;
--- a/node_modules/rc-table/es/Cell/index.js
+++ b/node_modules/rc-table/es/Cell/index.js
@@ -0,0 +1,165 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useContext } from '@rc-component/context';
+import classNames from 'classnames';
+import * as React from 'react';
+import TableContext from "../context/TableContext";
+import devRenderTimes from "../hooks/useRenderTimes";
+import useCellRender from "./useCellRender";
+import useHoverState from "./useHoverState";
+import { useEvent } from 'rc-util';
+var getTitleFromCellRenderChildren = function getTitleFromCellRenderChildren(_ref) {
+  var ellipsis = _ref.ellipsis,
+    rowType = _ref.rowType,
+    children = _ref.children;
+  var title;
+  var ellipsisConfig = ellipsis === true ? {
+    showTitle: true
+  } : ellipsis;
+  if (ellipsisConfig && (ellipsisConfig.showTitle || rowType === 'header')) {
+    if (typeof children === 'string' || typeof children === 'number') {
+      title = children.toString();
+    } else if ( /*#__PURE__*/React.isValidElement(children) && typeof children.props.children === 'string') {
+      title = children.props.children;
+    }
+  }
+  return title;
+};
+function Cell(props) {
+  var _ref2, _ref3, _legacyCellProps$colS, _ref4, _ref5, _legacyCellProps$rowS, _additionalProps$titl, _classNames;
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+  var Component = props.component,
+    children = props.children,
+    ellipsis = props.ellipsis,
+    scope = props.scope,
+    prefixCls = props.prefixCls,
+    className = props.className,
+    align = props.align,
+    record = props.record,
+    render = props.render,
+    dataIndex = props.dataIndex,
+    renderIndex = props.renderIndex,
+    shouldCellUpdate = props.shouldCellUpdate,
+    index = props.index,
+    rowType = props.rowType,
+    colSpan = props.colSpan,
+    rowSpan = props.rowSpan,
+    fixLeft = props.fixLeft,
+    fixRight = props.fixRight,
+    firstFixLeft = props.firstFixLeft,
+    lastFixLeft = props.lastFixLeft,
+    firstFixRight = props.firstFixRight,
+    lastFixRight = props.lastFixRight,
+    appendNode = props.appendNode,
+    _props$additionalProp = props.additionalProps,
+    additionalProps = _props$additionalProp === void 0 ? {} : _props$additionalProp,
+    isSticky = props.isSticky;
+  var cellPrefixCls = "".concat(prefixCls, "-cell");
+  var _useContext = useContext(TableContext, ['supportSticky', 'allColumnsFixedLeft', 'rowHoverable']),
+    supportSticky = _useContext.supportSticky,
+    allColumnsFixedLeft = _useContext.allColumnsFixedLeft,
+    rowHoverable = _useContext.rowHoverable;
+
+  // ====================== Value =======================
+  var _useCellRender = useCellRender(record, dataIndex, renderIndex, children, render, shouldCellUpdate),
+    _useCellRender2 = _slicedToArray(_useCellRender, 2),
+    childNode = _useCellRender2[0],
+    legacyCellProps = _useCellRender2[1];
+
+  // ====================== Fixed =======================
+  var fixedStyle = {};
+  var isFixLeft = typeof fixLeft === 'number' && supportSticky;
+  var isFixRight = typeof fixRight === 'number' && supportSticky;
+  if (isFixLeft) {
+    fixedStyle.position = 'sticky';
+    fixedStyle.left = fixLeft;
+  }
+  if (isFixRight) {
+    fixedStyle.position = 'sticky';
+    fixedStyle.right = fixRight;
+  }
+
+  // ================ RowSpan & ColSpan =================
+  var mergedColSpan = (_ref2 = (_ref3 = (_legacyCellProps$colS = legacyCellProps === null || legacyCellProps === void 0 ? void 0 : legacyCellProps.colSpan) !== null && _legacyCellProps$colS !== void 0 ? _legacyCellProps$colS : additionalProps.colSpan) !== null && _ref3 !== void 0 ? _ref3 : colSpan) !== null && _ref2 !== void 0 ? _ref2 : 1;
+  var mergedRowSpan = (_ref4 = (_ref5 = (_legacyCellProps$rowS = legacyCellProps === null || legacyCellProps === void 0 ? void 0 : legacyCellProps.rowSpan) !== null && _legacyCellProps$rowS !== void 0 ? _legacyCellProps$rowS : additionalProps.rowSpan) !== null && _ref5 !== void 0 ? _ref5 : rowSpan) !== null && _ref4 !== void 0 ? _ref4 : 1;
+
+  // ====================== Hover =======================
+  var _useHoverState = useHoverState(index, mergedRowSpan),
+    _useHoverState2 = _slicedToArray(_useHoverState, 2),
+    hovering = _useHoverState2[0],
+    onHover = _useHoverState2[1];
+  var onMouseEnter = useEvent(function (event) {
+    var _additionalProps$onMo;
+    if (record) {
+      onHover(index, index + mergedRowSpan - 1);
+    }
+    additionalProps === null || additionalProps === void 0 || (_additionalProps$onMo = additionalProps.onMouseEnter) === null || _additionalProps$onMo === void 0 || _additionalProps$onMo.call(additionalProps, event);
+  });
+  var onMouseLeave = useEvent(function (event) {
+    var _additionalProps$onMo2;
+    if (record) {
+      onHover(-1, -1);
+    }
+    additionalProps === null || additionalProps === void 0 || (_additionalProps$onMo2 = additionalProps.onMouseLeave) === null || _additionalProps$onMo2 === void 0 || _additionalProps$onMo2.call(additionalProps, event);
+  });
+
+  // ====================== Render ======================
+  if (mergedColSpan === 0 || mergedRowSpan === 0) {
+    return null;
+  }
+
+  // >>>>> Title
+  var title = (_additionalProps$titl = additionalProps.title) !== null && _additionalProps$titl !== void 0 ? _additionalProps$titl : getTitleFromCellRenderChildren({
+    rowType: rowType,
+    ellipsis: ellipsis,
+    children: childNode
+  });
+
+  // >>>>> ClassName
+  var mergedClassName = classNames(cellPrefixCls, className, (_classNames = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-left"), isFixLeft && supportSticky), "".concat(cellPrefixCls, "-fix-left-first"), firstFixLeft && supportSticky), "".concat(cellPrefixCls, "-fix-left-last"), lastFixLeft && supportSticky), "".concat(cellPrefixCls, "-fix-left-all"), lastFixLeft && allColumnsFixedLeft && supportSticky), "".concat(cellPrefixCls, "-fix-right"), isFixRight && supportSticky), "".concat(cellPrefixCls, "-fix-right-first"), firstFixRight && supportSticky), "".concat(cellPrefixCls, "-fix-right-last"), lastFixRight && supportSticky), "".concat(cellPrefixCls, "-ellipsis"), ellipsis), "".concat(cellPrefixCls, "-with-append"), appendNode), "".concat(cellPrefixCls, "-fix-sticky"), (isFixLeft || isFixRight) && isSticky && supportSticky), _defineProperty(_classNames, "".concat(cellPrefixCls, "-row-hover"), !legacyCellProps && hovering)), additionalProps.className, legacyCellProps === null || legacyCellProps === void 0 ? void 0 : legacyCellProps.className);
+
+  // >>>>> Style
+  var alignStyle = {};
+  if (align) {
+    alignStyle.textAlign = align;
+  }
+
+  // The order is important since user can overwrite style.
+  // For example ant-design/ant-design#51763
+  var mergedStyle = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, legacyCellProps === null || legacyCellProps === void 0 ? void 0 : legacyCellProps.style), fixedStyle), alignStyle), additionalProps.style);
+
+  // >>>>> Children Node
+  var mergedChildNode = childNode;
+
+  // Not crash if final `childNode` is not validate ReactNode
+  if (_typeof(mergedChildNode) === 'object' && !Array.isArray(mergedChildNode) && ! /*#__PURE__*/React.isValidElement(mergedChildNode)) {
+    mergedChildNode = null;
+  }
+  if (ellipsis && (lastFixLeft || firstFixRight)) {
+    mergedChildNode = /*#__PURE__*/React.createElement("span", {
+      className: "".concat(cellPrefixCls, "-content")
+    }, mergedChildNode);
+  }
+  return /*#__PURE__*/React.createElement(Component, _extends({}, legacyCellProps, additionalProps, {
+    className: mergedClassName,
+    style: mergedStyle
+    // A11y
+    ,
+    title: title,
+    scope: scope
+    // Hover
+    ,
+    onMouseEnter: rowHoverable ? onMouseEnter : undefined,
+    onMouseLeave: rowHoverable ? onMouseLeave : undefined
+    //Span
+    ,
+    colSpan: mergedColSpan !== 1 ? mergedColSpan : null,
+    rowSpan: mergedRowSpan !== 1 ? mergedRowSpan : null
+  }), appendNode, mergedChildNode);
+}
+export default /*#__PURE__*/React.memo(Cell);
--- a/node_modules/rc-table/es/Cell/useCellRender.d.ts
+++ b/node_modules/rc-table/es/Cell/useCellRender.d.ts
@@ -0,0 +1,3 @@
+import * as React from 'react';
+import type { CellType, ColumnType, DataIndex } from '../interface';
+export default function useCellRender<RecordType>(record: RecordType, dataIndex: DataIndex<RecordType>, renderIndex: number, children?: React.ReactNode, render?: ColumnType<RecordType>['render'], shouldCellUpdate?: ColumnType<RecordType>['shouldCellUpdate']): [React.ReactNode, CellType<RecordType>] | [React.ReactNode];
--- a/node_modules/rc-table/es/Cell/useCellRender.js
+++ b/node_modules/rc-table/es/Cell/useCellRender.js
@@ -0,0 +1,64 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import useMemo from "rc-util/es/hooks/useMemo";
+import isEqual from "rc-util/es/isEqual";
+import getValue from "rc-util/es/utils/get";
+import warning from "rc-util/es/warning";
+import * as React from 'react';
+import PerfContext from "../context/PerfContext";
+import { validateValue } from "../utils/valueUtil";
+import { useImmutableMark } from "../context/TableContext";
+function isRenderCell(data) {
+  return data && _typeof(data) === 'object' && !Array.isArray(data) && ! /*#__PURE__*/React.isValidElement(data);
+}
+export default function useCellRender(record, dataIndex, renderIndex, children, render, shouldCellUpdate) {
+  // TODO: Remove this after next major version
+  var perfRecord = React.useContext(PerfContext);
+  var mark = useImmutableMark();
+
+  // ======================== Render ========================
+  var retData = useMemo(function () {
+    if (validateValue(children)) {
+      return [children];
+    }
+    var path = dataIndex === null || dataIndex === undefined || dataIndex === '' ? [] : Array.isArray(dataIndex) ? dataIndex : [dataIndex];
+    var value = getValue(record, path);
+
+    // Customize render node
+    var returnChildNode = value;
+    var returnCellProps = undefined;
+    if (render) {
+      var renderData = render(value, record, renderIndex);
+      if (isRenderCell(renderData)) {
+        if (process.env.NODE_ENV !== 'production') {
+          warning(false, '`columns.render` return cell props is deprecated with perf issue, please use `onCell` instead.');
+        }
+        returnChildNode = renderData.children;
+        returnCellProps = renderData.props;
+        perfRecord.renderWithProps = true;
+      } else {
+        returnChildNode = renderData;
+      }
+    }
+    return [returnChildNode, returnCellProps];
+  }, [
+  // Force update deps
+  mark,
+  // Normal deps
+  record, children, dataIndex, render, renderIndex], function (prev, next) {
+    if (shouldCellUpdate) {
+      var _prev = _slicedToArray(prev, 2),
+        prevRecord = _prev[1];
+      var _next = _slicedToArray(next, 2),
+        nextRecord = _next[1];
+      return shouldCellUpdate(nextRecord, prevRecord);
+    }
+
+    // Legacy mode should always update
+    if (perfRecord.renderWithProps) {
+      return true;
+    }
+    return !isEqual(prev, next, true);
+  });
+  return retData;
+}
--- a/node_modules/rc-table/es/Cell/useHoverState.d.ts
+++ b/node_modules/rc-table/es/Cell/useHoverState.d.ts
@@ -0,0 +1,2 @@
+import type { OnHover } from '../hooks/useHover';
+export default function useHoverState(rowIndex: number, rowSpan: number): [hovering: boolean, onHover: OnHover];
--- a/node_modules/rc-table/es/Cell/useHoverState.js
+++ b/node_modules/rc-table/es/Cell/useHoverState.js
@@ -0,0 +1,13 @@
+import { useContext } from '@rc-component/context';
+import TableContext from "../context/TableContext";
+/** Check if cell is in hover range */
+function inHoverRange(cellStartRow, cellRowSpan, startRow, endRow) {
+  var cellEndRow = cellStartRow + cellRowSpan - 1;
+  return cellStartRow <= endRow && cellEndRow >= startRow;
+}
+export default function useHoverState(rowIndex, rowSpan) {
+  return useContext(TableContext, function (ctx) {
+    var hovering = inHoverRange(rowIndex, rowSpan || 1, ctx.hoverStartRow, ctx.hoverEndRow);
+    return [hovering, ctx.onHover];
+  });
+}
--- a/node_modules/rc-table/es/ColGroup.d.ts
+++ b/node_modules/rc-table/es/ColGroup.d.ts
@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { ColumnType } from './interface';
+export interface ColGroupProps<RecordType> {
+    colWidths: readonly (number | string)[];
+    columns?: readonly ColumnType<RecordType>[];
+    columCount?: number;
+}
+declare function ColGroup<RecordType>({ colWidths, columns, columCount }: ColGroupProps<RecordType>): React.JSX.Element;
+export default ColGroup;
--- a/node_modules/rc-table/es/ColGroup.js
+++ b/node_modules/rc-table/es/ColGroup.js
@@ -0,0 +1,49 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["columnType"];
+import * as React from 'react';
+import { INTERNAL_COL_DEFINE } from "./utils/legacyUtil";
+import { useContext } from '@rc-component/context';
+import TableContext from "./context/TableContext";
+function ColGroup(_ref) {
+  var colWidths = _ref.colWidths,
+    columns = _ref.columns,
+    columCount = _ref.columCount;
+  var _useContext = useContext(TableContext, ['tableLayout']),
+    tableLayout = _useContext.tableLayout;
+  var cols = [];
+  var len = columCount || columns.length;
+
+  // Only insert col with width & additional props
+  // Skip if rest col do not have any useful info
+  var mustInsert = false;
+  for (var i = len - 1; i >= 0; i -= 1) {
+    var width = colWidths[i];
+    var column = columns && columns[i];
+    var additionalProps = void 0;
+    var minWidth = void 0;
+    if (column) {
+      additionalProps = column[INTERNAL_COL_DEFINE];
+
+      // fixed will cause layout problems
+      if (tableLayout === 'auto') {
+        minWidth = column.minWidth;
+      }
+    }
+    if (width || minWidth || additionalProps || mustInsert) {
+      var _ref2 = additionalProps || {},
+        columnType = _ref2.columnType,
+        restAdditionalProps = _objectWithoutProperties(_ref2, _excluded);
+      cols.unshift( /*#__PURE__*/React.createElement("col", _extends({
+        key: i,
+        style: {
+          width: width,
+          minWidth: minWidth
+        }
+      }, restAdditionalProps)));
+      mustInsert = true;
+    }
+  }
+  return cols.length > 0 ? /*#__PURE__*/React.createElement("colgroup", null, cols) : null;
+}
+export default ColGroup;
--- a/node_modules/rc-table/es/FixedHolder/index.d.ts
+++ b/node_modules/rc-table/es/FixedHolder/index.d.ts
@@ -0,0 +1,25 @@
+import * as React from 'react';
+import type { HeaderProps } from '../Header/Header';
+import type { Direction, TableLayout } from '../interface';
+export interface FixedHeaderProps<RecordType> extends HeaderProps<RecordType> {
+    className: string;
+    noData: boolean;
+    colWidths: readonly number[];
+    columCount: number;
+    direction: Direction;
+    fixHeader: boolean;
+    stickyTopOffset?: number;
+    stickyBottomOffset?: number;
+    stickyClassName?: string;
+    scrollX?: number | string | true;
+    tableLayout?: TableLayout;
+    onScroll: (info: {
+        currentTarget: HTMLDivElement;
+        scrollLeft?: number;
+    }) => void;
+    children: (info: HeaderProps<RecordType>) => React.ReactNode;
+    colGroup?: React.ReactNode;
+}
+/** Return a table in div as fixed element which contains sticky info */
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<FixedHeaderProps<any> & React.RefAttributes<HTMLDivElement>>>;
+export default _default;
--- a/node_modules/rc-table/es/FixedHolder/index.js
+++ b/node_modules/rc-table/es/FixedHolder/index.js
@@ -0,0 +1,160 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["className", "noData", "columns", "flattenColumns", "colWidths", "colGroup", "columCount", "stickyOffsets", "direction", "fixHeader", "stickyTopOffset", "stickyBottomOffset", "stickyClassName", "scrollX", "tableLayout", "onScroll", "children"];
+import { useContext } from '@rc-component/context';
+import classNames from 'classnames';
+import { fillRef } from "rc-util/es/ref";
+import * as React from 'react';
+import { useMemo } from 'react';
+import ColGroup from "../ColGroup";
+import TableContext from "../context/TableContext";
+import devRenderTimes from "../hooks/useRenderTimes";
+function useColumnWidth(colWidths, columCount) {
+  return useMemo(function () {
+    var cloneColumns = [];
+    for (var i = 0; i < columCount; i += 1) {
+      var val = colWidths[i];
+      if (val !== undefined) {
+        cloneColumns[i] = val;
+      } else {
+        return null;
+      }
+    }
+    return cloneColumns;
+  }, [colWidths.join('_'), columCount]);
+}
+var FixedHolder = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+  var className = props.className,
+    noData = props.noData,
+    columns = props.columns,
+    flattenColumns = props.flattenColumns,
+    colWidths = props.colWidths,
+    colGroup = props.colGroup,
+    columCount = props.columCount,
+    stickyOffsets = props.stickyOffsets,
+    direction = props.direction,
+    fixHeader = props.fixHeader,
+    stickyTopOffset = props.stickyTopOffset,
+    stickyBottomOffset = props.stickyBottomOffset,
+    stickyClassName = props.stickyClassName,
+    scrollX = props.scrollX,
+    _props$tableLayout = props.tableLayout,
+    tableLayout = _props$tableLayout === void 0 ? 'fixed' : _props$tableLayout,
+    onScroll = props.onScroll,
+    children = props.children,
+    restProps = _objectWithoutProperties(props, _excluded);
+  var _useContext = useContext(TableContext, ['prefixCls', 'scrollbarSize', 'isSticky', 'getComponent']),
+    prefixCls = _useContext.prefixCls,
+    scrollbarSize = _useContext.scrollbarSize,
+    isSticky = _useContext.isSticky,
+    getComponent = _useContext.getComponent;
+  var TableComponent = getComponent(['header', 'table'], 'table');
+  var combinationScrollBarSize = isSticky && !fixHeader ? 0 : scrollbarSize;
+
+  // Pass wheel to scroll event
+  var scrollRef = React.useRef(null);
+  var setScrollRef = React.useCallback(function (element) {
+    fillRef(ref, element);
+    fillRef(scrollRef, element);
+  }, []);
+  React.useEffect(function () {
+    function onWheel(e) {
+      var _ref = e,
+        currentTarget = _ref.currentTarget,
+        deltaX = _ref.deltaX;
+      if (deltaX) {
+        onScroll({
+          currentTarget: currentTarget,
+          scrollLeft: currentTarget.scrollLeft + deltaX
+        });
+        e.preventDefault();
+      }
+    }
+    var scrollEle = scrollRef.current;
+    scrollEle === null || scrollEle === void 0 || scrollEle.addEventListener('wheel', onWheel, {
+      passive: false
+    });
+    return function () {
+      scrollEle === null || scrollEle === void 0 || scrollEle.removeEventListener('wheel', onWheel);
+    };
+  }, []);
+
+  // Add scrollbar column
+  var lastColumn = flattenColumns[flattenColumns.length - 1];
+  var ScrollBarColumn = {
+    fixed: lastColumn ? lastColumn.fixed : null,
+    scrollbar: true,
+    onHeaderCell: function onHeaderCell() {
+      return {
+        className: "".concat(prefixCls, "-cell-scrollbar")
+      };
+    }
+  };
+  var columnsWithScrollbar = useMemo(function () {
+    return combinationScrollBarSize ? [].concat(_toConsumableArray(columns), [ScrollBarColumn]) : columns;
+  }, [combinationScrollBarSize, columns]);
+  var flattenColumnsWithScrollbar = useMemo(function () {
+    return combinationScrollBarSize ? [].concat(_toConsumableArray(flattenColumns), [ScrollBarColumn]) : flattenColumns;
+  }, [combinationScrollBarSize, flattenColumns]);
+
+  // Calculate the sticky offsets
+  var headerStickyOffsets = useMemo(function () {
+    var right = stickyOffsets.right,
+      left = stickyOffsets.left;
+    return _objectSpread(_objectSpread({}, stickyOffsets), {}, {
+      left: direction === 'rtl' ? [].concat(_toConsumableArray(left.map(function (width) {
+        return width + combinationScrollBarSize;
+      })), [0]) : left,
+      right: direction === 'rtl' ? right : [].concat(_toConsumableArray(right.map(function (width) {
+        return width + combinationScrollBarSize;
+      })), [0]),
+      isSticky: isSticky
+    });
+  }, [combinationScrollBarSize, stickyOffsets, isSticky]);
+  var mergedColumnWidth = useColumnWidth(colWidths, columCount);
+  var isColGroupEmpty = useMemo(function () {
+    // use original ColGroup if no data or no calculated column width, otherwise use calculated column width
+    // Return original colGroup if no data, or mergedColumnWidth is empty, or all widths are falsy
+    var noWidth = !mergedColumnWidth || !mergedColumnWidth.length || mergedColumnWidth.every(function (w) {
+      return !w;
+    });
+    return noData || noWidth;
+  }, [noData, mergedColumnWidth]);
+  return /*#__PURE__*/React.createElement("div", {
+    style: _objectSpread({
+      overflow: 'hidden'
+    }, isSticky ? {
+      top: stickyTopOffset,
+      bottom: stickyBottomOffset
+    } : {}),
+    ref: setScrollRef,
+    className: classNames(className, _defineProperty({}, stickyClassName, !!stickyClassName))
+  }, /*#__PURE__*/React.createElement(TableComponent, {
+    style: {
+      tableLayout: tableLayout,
+      minWidth: '100%',
+      // https://github.com/ant-design/ant-design/issues/54894
+      width: scrollX
+    }
+  }, isColGroupEmpty ? colGroup : /*#__PURE__*/React.createElement(ColGroup, {
+    colWidths: [].concat(_toConsumableArray(mergedColumnWidth), [combinationScrollBarSize]),
+    columCount: columCount + 1,
+    columns: flattenColumnsWithScrollbar
+  }), children(_objectSpread(_objectSpread({}, restProps), {}, {
+    stickyOffsets: headerStickyOffsets,
+    columns: columnsWithScrollbar,
+    flattenColumns: flattenColumnsWithScrollbar
+  }))));
+});
+if (process.env.NODE_ENV !== 'production') {
+  FixedHolder.displayName = 'FixedHolder';
+}
+
+/** Return a table in div as fixed element which contains sticky info */
+// export default responseImmutable(FixedHolder);
+export default /*#__PURE__*/React.memo(FixedHolder);
--- a/node_modules/rc-table/es/Footer/Cell.d.ts
+++ b/node_modules/rc-table/es/Footer/Cell.d.ts
@@ -0,0 +1,11 @@
+import * as React from 'react';
+import type { AlignType } from '../interface';
+export interface SummaryCellProps {
+    className?: string;
+    children?: React.ReactNode;
+    index: number;
+    colSpan?: number;
+    rowSpan?: number;
+    align?: AlignType;
+}
+export default function SummaryCell({ className, index, children, colSpan, rowSpan, align, }: SummaryCellProps): React.JSX.Element;
--- a/node_modules/rc-table/es/Footer/Cell.js
+++ b/node_modules/rc-table/es/Footer/Cell.js
@@ -0,0 +1,40 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import Cell from "../Cell";
+import TableContext from "../context/TableContext";
+import { useContext } from '@rc-component/context';
+import { getCellFixedInfo } from "../utils/fixUtil";
+import SummaryContext from "./SummaryContext";
+export default function SummaryCell(_ref) {
+  var className = _ref.className,
+    index = _ref.index,
+    children = _ref.children,
+    _ref$colSpan = _ref.colSpan,
+    colSpan = _ref$colSpan === void 0 ? 1 : _ref$colSpan,
+    rowSpan = _ref.rowSpan,
+    align = _ref.align;
+  var _useContext = useContext(TableContext, ['prefixCls', 'direction']),
+    prefixCls = _useContext.prefixCls,
+    direction = _useContext.direction;
+  var _React$useContext = React.useContext(SummaryContext),
+    scrollColumnIndex = _React$useContext.scrollColumnIndex,
+    stickyOffsets = _React$useContext.stickyOffsets,
+    flattenColumns = _React$useContext.flattenColumns;
+  var lastIndex = index + colSpan - 1;
+  var mergedColSpan = lastIndex + 1 === scrollColumnIndex ? colSpan + 1 : colSpan;
+  var fixedInfo = getCellFixedInfo(index, index + mergedColSpan - 1, flattenColumns, stickyOffsets, direction);
+  return /*#__PURE__*/React.createElement(Cell, _extends({
+    className: className,
+    index: index,
+    component: "td",
+    prefixCls: prefixCls,
+    record: null,
+    dataIndex: null,
+    align: align,
+    colSpan: mergedColSpan,
+    rowSpan: rowSpan,
+    render: function render() {
+      return children;
+    }
+  }, fixedInfo));
+}
--- a/node_modules/rc-table/es/Footer/Row.d.ts
+++ b/node_modules/rc-table/es/Footer/Row.d.ts
@@ -0,0 +1,8 @@
+import * as React from 'react';
+export interface FooterRowProps {
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    onClick?: (e?: React.MouseEvent<HTMLElement>) => void;
+}
+export default function FooterRow({ children, ...props }: FooterRowProps): React.JSX.Element;
--- a/node_modules/rc-table/es/Footer/Row.js
+++ b/node_modules/rc-table/es/Footer/Row.js
@@ -0,0 +1,8 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["children"];
+import * as React from 'react';
+export default function FooterRow(_ref) {
+  var children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded);
+  return /*#__PURE__*/React.createElement("tr", props, children);
+}
--- a/node_modules/rc-table/es/Footer/Summary.d.ts
+++ b/node_modules/rc-table/es/Footer/Summary.d.ts
@@ -0,0 +1,14 @@
+import type * as React from 'react';
+export interface SummaryProps {
+    fixed?: boolean | 'top' | 'bottom';
+    children?: React.ReactNode;
+}
+/**
+ * Syntactic sugar. Do not support HOC.
+ */
+declare function Summary({ children }: SummaryProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+declare namespace Summary {
+    var Row: typeof import("./Row").default;
+    var Cell: typeof import("./Cell").default;
+}
+export default Summary;
--- a/node_modules/rc-table/es/Footer/Summary.js
+++ b/node_modules/rc-table/es/Footer/Summary.js
@@ -0,0 +1,12 @@
+import Cell from "./Cell";
+import Row from "./Row";
+/**
+ * Syntactic sugar. Do not support HOC.
+ */
+function Summary(_ref) {
+  var children = _ref.children;
+  return children;
+}
+Summary.Row = Row;
+Summary.Cell = Cell;
+export default Summary;
--- a/node_modules/rc-table/es/Footer/SummaryContext.d.ts
+++ b/node_modules/rc-table/es/Footer/SummaryContext.d.ts
@@ -0,0 +1,11 @@
+import * as React from 'react';
+import type { ColumnType, StickyOffsets } from '../interface';
+type FlattenColumns<RecordType> = readonly (ColumnType<RecordType> & {
+    scrollbar?: boolean;
+})[];
+declare const SummaryContext: React.Context<{
+    stickyOffsets?: StickyOffsets;
+    scrollColumnIndex?: number;
+    flattenColumns?: FlattenColumns<any>;
+}>;
+export default SummaryContext;
--- a/node_modules/rc-table/es/Footer/SummaryContext.js
+++ b/node_modules/rc-table/es/Footer/SummaryContext.js
@@ -0,0 +1,3 @@
+import * as React from 'react';
+var SummaryContext = /*#__PURE__*/React.createContext({});
+export default SummaryContext;
--- a/node_modules/rc-table/es/Footer/index.d.ts
+++ b/node_modules/rc-table/es/Footer/index.d.ts
@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { ColumnType, StickyOffsets } from '../interface';
+import Summary from './Summary';
+type FlattenColumns<RecordType> = readonly (ColumnType<RecordType> & {
+    scrollbar?: boolean;
+})[];
+export interface FooterProps<RecordType> {
+    children: React.ReactNode;
+    stickyOffsets: StickyOffsets;
+    flattenColumns: FlattenColumns<RecordType>;
+}
+declare function Footer<RecordType>(props: FooterProps<RecordType>): React.JSX.Element;
+declare const _default: typeof Footer;
+export default _default;
+export declare const FooterComponents: typeof Summary;
--- a/node_modules/rc-table/es/Footer/index.js
+++ b/node_modules/rc-table/es/Footer/index.js
@@ -0,0 +1,31 @@
+import { useContext } from '@rc-component/context';
+import * as React from 'react';
+import TableContext, { responseImmutable } from "../context/TableContext";
+import devRenderTimes from "../hooks/useRenderTimes";
+import Summary from "./Summary";
+import SummaryContext from "./SummaryContext";
+function Footer(props) {
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+  var children = props.children,
+    stickyOffsets = props.stickyOffsets,
+    flattenColumns = props.flattenColumns;
+  var prefixCls = useContext(TableContext, 'prefixCls');
+  var lastColumnIndex = flattenColumns.length - 1;
+  var scrollColumn = flattenColumns[lastColumnIndex];
+  var summaryContext = React.useMemo(function () {
+    return {
+      stickyOffsets: stickyOffsets,
+      flattenColumns: flattenColumns,
+      scrollColumnIndex: scrollColumn !== null && scrollColumn !== void 0 && scrollColumn.scrollbar ? lastColumnIndex : null
+    };
+  }, [scrollColumn, flattenColumns, lastColumnIndex, stickyOffsets]);
+  return /*#__PURE__*/React.createElement(SummaryContext.Provider, {
+    value: summaryContext
+  }, /*#__PURE__*/React.createElement("tfoot", {
+    className: "".concat(prefixCls, "-summary")
+  }, children));
+}
+export default responseImmutable(Footer);
+export var FooterComponents = Summary;
--- a/node_modules/rc-table/es/Header/Header.d.ts
+++ b/node_modules/rc-table/es/Header/Header.d.ts
@@ -0,0 +1,10 @@
+import * as React from 'react';
+import type { ColumnsType, ColumnType, GetComponentProps, StickyOffsets } from '../interface';
+export interface HeaderProps<RecordType> {
+    columns: ColumnsType<RecordType>;
+    flattenColumns: readonly ColumnType<RecordType>[];
+    stickyOffsets: StickyOffsets;
+    onHeaderRow: GetComponentProps<readonly ColumnType<RecordType>[]>;
+}
+declare const _default: <RecordType extends unknown>(props: HeaderProps<RecordType>) => React.JSX.Element;
+export default _default;
--- a/node_modules/rc-table/es/Header/Header.js
+++ b/node_modules/rc-table/es/Header/Header.js
@@ -0,0 +1,95 @@
+import { useContext } from '@rc-component/context';
+import * as React from 'react';
+import TableContext, { responseImmutable } from "../context/TableContext";
+import devRenderTimes from "../hooks/useRenderTimes";
+import HeaderRow from "./HeaderRow";
+function parseHeaderRows(rootColumns) {
+  var rows = [];
+  function fillRowCells(columns, colIndex) {
+    var rowIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    // Init rows
+    rows[rowIndex] = rows[rowIndex] || [];
+    var currentColIndex = colIndex;
+    var colSpans = columns.filter(Boolean).map(function (column) {
+      var cell = {
+        key: column.key,
+        className: column.className || '',
+        children: column.title,
+        column: column,
+        colStart: currentColIndex
+      };
+      var colSpan = 1;
+      var subColumns = column.children;
+      if (subColumns && subColumns.length > 0) {
+        colSpan = fillRowCells(subColumns, currentColIndex, rowIndex + 1).reduce(function (total, count) {
+          return total + count;
+        }, 0);
+        cell.hasSubColumns = true;
+      }
+      if ('colSpan' in column) {
+        colSpan = column.colSpan;
+      }
+      if ('rowSpan' in column) {
+        cell.rowSpan = column.rowSpan;
+      }
+      cell.colSpan = colSpan;
+      cell.colEnd = cell.colStart + colSpan - 1;
+      rows[rowIndex].push(cell);
+      currentColIndex += colSpan;
+      return colSpan;
+    });
+    return colSpans;
+  }
+
+  // Generate `rows` cell data
+  fillRowCells(rootColumns, 0);
+
+  // Handle `rowSpan`
+  var rowCount = rows.length;
+  var _loop = function _loop(rowIndex) {
+    rows[rowIndex].forEach(function (cell) {
+      if (!('rowSpan' in cell) && !cell.hasSubColumns) {
+        // eslint-disable-next-line no-param-reassign
+        cell.rowSpan = rowCount - rowIndex;
+      }
+    });
+  };
+  for (var rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+    _loop(rowIndex);
+  }
+  return rows;
+}
+var Header = function Header(props) {
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+  var stickyOffsets = props.stickyOffsets,
+    columns = props.columns,
+    flattenColumns = props.flattenColumns,
+    onHeaderRow = props.onHeaderRow;
+  var _useContext = useContext(TableContext, ['prefixCls', 'getComponent']),
+    prefixCls = _useContext.prefixCls,
+    getComponent = _useContext.getComponent;
+  var rows = React.useMemo(function () {
+    return parseHeaderRows(columns);
+  }, [columns]);
+  var WrapperComponent = getComponent(['header', 'wrapper'], 'thead');
+  var trComponent = getComponent(['header', 'row'], 'tr');
+  var thComponent = getComponent(['header', 'cell'], 'th');
+  return /*#__PURE__*/React.createElement(WrapperComponent, {
+    className: "".concat(prefixCls, "-thead")
+  }, rows.map(function (row, rowIndex) {
+    var rowNode = /*#__PURE__*/React.createElement(HeaderRow, {
+      key: rowIndex,
+      flattenColumns: flattenColumns,
+      cells: row,
+      stickyOffsets: stickyOffsets,
+      rowComponent: trComponent,
+      cellComponent: thComponent,
+      onHeaderRow: onHeaderRow,
+      index: rowIndex
+    });
+    return rowNode;
+  }));
+};
+export default responseImmutable(Header);
--- a/node_modules/rc-table/es/Header/HeaderRow.d.ts
+++ b/node_modules/rc-table/es/Header/HeaderRow.d.ts
@@ -0,0 +1,16 @@
+import * as React from 'react';
+import type { CellType, ColumnType, CustomizeComponent, GetComponentProps, StickyOffsets } from '../interface';
+export interface RowProps<RecordType> {
+    cells: readonly CellType<RecordType>[];
+    stickyOffsets: StickyOffsets;
+    flattenColumns: readonly ColumnType<RecordType>[];
+    rowComponent: CustomizeComponent;
+    cellComponent: CustomizeComponent;
+    onHeaderRow: GetComponentProps<readonly ColumnType<RecordType>[]>;
+    index: number;
+}
+declare const HeaderRow: {
+    <RecordType extends unknown>(props: RowProps<RecordType>): React.JSX.Element;
+    displayName: string;
+};
+export default HeaderRow;
--- a/node_modules/rc-table/es/Header/HeaderRow.js
+++ b/node_modules/rc-table/es/Header/HeaderRow.js
@@ -0,0 +1,51 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import Cell from "../Cell";
+import TableContext from "../context/TableContext";
+import { useContext } from '@rc-component/context';
+import { getCellFixedInfo } from "../utils/fixUtil";
+import { getColumnsKey } from "../utils/valueUtil";
+var HeaderRow = function HeaderRow(props) {
+  var cells = props.cells,
+    stickyOffsets = props.stickyOffsets,
+    flattenColumns = props.flattenColumns,
+    RowComponent = props.rowComponent,
+    CellComponent = props.cellComponent,
+    onHeaderRow = props.onHeaderRow,
+    index = props.index;
+  var _useContext = useContext(TableContext, ['prefixCls', 'direction']),
+    prefixCls = _useContext.prefixCls,
+    direction = _useContext.direction;
+  var rowProps;
+  if (onHeaderRow) {
+    rowProps = onHeaderRow(cells.map(function (cell) {
+      return cell.column;
+    }), index);
+  }
+  var columnsKey = getColumnsKey(cells.map(function (cell) {
+    return cell.column;
+  }));
+  return /*#__PURE__*/React.createElement(RowComponent, rowProps, cells.map(function (cell, cellIndex) {
+    var column = cell.column;
+    var fixedInfo = getCellFixedInfo(cell.colStart, cell.colEnd, flattenColumns, stickyOffsets, direction);
+    var additionalProps;
+    if (column && column.onHeaderCell) {
+      additionalProps = cell.column.onHeaderCell(column);
+    }
+    return /*#__PURE__*/React.createElement(Cell, _extends({}, cell, {
+      scope: column.title ? cell.colSpan > 1 ? 'colgroup' : 'col' : null,
+      ellipsis: column.ellipsis,
+      align: column.align,
+      component: CellComponent,
+      prefixCls: prefixCls,
+      key: columnsKey[cellIndex]
+    }, fixedInfo, {
+      additionalProps: additionalProps,
+      rowType: "header"
+    }));
+  }));
+};
+if (process.env.NODE_ENV !== 'production') {
+  HeaderRow.displayName = 'HeaderRow';
+}
+export default HeaderRow;
--- a/node_modules/rc-table/es/Panel/index.d.ts
+++ b/node_modules/rc-table/es/Panel/index.d.ts
@@ -0,0 +1,7 @@
+import * as React from 'react';
+export interface TitleProps {
+    className: string;
+    children: React.ReactNode;
+}
+declare function Panel({ className, children }: TitleProps): React.JSX.Element;
+export default Panel;
--- a/node_modules/rc-table/es/Panel/index.js
+++ b/node_modules/rc-table/es/Panel/index.js
@@ -0,0 +1,9 @@
+import * as React from 'react';
+function Panel(_ref) {
+  var className = _ref.className,
+    children = _ref.children;
+  return /*#__PURE__*/React.createElement("div", {
+    className: className
+  }, children);
+}
+export default Panel;
--- a/node_modules/rc-table/es/Table.d.ts
+++ b/node_modules/rc-table/es/Table.d.ts
@@ -0,0 +1,117 @@
+/**
+ * Feature:
+ *  - fixed not need to set width
+ *  - support `rowExpandable` to config row expand logic
+ *  - add `summary` to support `() => ReactNode`
+ *
+ * Update:
+ *  - `dataIndex` is `array[]` now
+ *  - `expandable` wrap all the expand related props
+ *
+ * Removed:
+ *  - expandIconAsCell
+ *  - useFixedHeader
+ *  - rowRef
+ *  - columns[number].onCellClick
+ *  - onRowClick
+ *  - onRowDoubleClick
+ *  - onRowMouseEnter
+ *  - onRowMouseLeave
+ *  - getBodyWrapper
+ *  - bodyStyle
+ *
+ * Deprecated:
+ *  - All expanded props, move into expandable
+ */
+import type { CompareProps } from '@rc-component/context/lib/Immutable';
+import * as React from 'react';
+import { EXPAND_COLUMN, INTERNAL_HOOKS } from './constant';
+import { FooterComponents } from './Footer';
+import type { ColumnsType, ColumnType, DefaultRecordType, Direction, ExpandableConfig, GetComponentProps, GetRowKey, LegacyExpandableProps, PanelRender, Reference, RowClassName, TableComponents, TableLayout, TableSticky } from './interface';
+import Column from './sugar/Column';
+import ColumnGroup from './sugar/ColumnGroup';
+export declare const DEFAULT_PREFIX = "rc-table";
+export interface TableProps<RecordType = any> extends Omit<LegacyExpandableProps<RecordType>, 'showExpandColumn'> {
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+    data?: readonly RecordType[];
+    columns?: ColumnsType<RecordType>;
+    rowKey?: string | keyof RecordType | GetRowKey<RecordType>;
+    tableLayout?: TableLayout;
+    scroll?: {
+        x?: number | true | string;
+        y?: number | string;
+    };
+    /** Config expand rows */
+    expandable?: ExpandableConfig<RecordType>;
+    indentSize?: number;
+    rowClassName?: string | RowClassName<RecordType>;
+    footer?: PanelRender<RecordType>;
+    summary?: (data: readonly RecordType[]) => React.ReactNode;
+    caption?: React.ReactNode;
+    id?: string;
+    showHeader?: boolean;
+    components?: TableComponents<RecordType>;
+    onRow?: GetComponentProps<RecordType>;
+    onHeaderRow?: GetComponentProps<readonly ColumnType<RecordType>[]>;
+    emptyText?: React.ReactNode | (() => React.ReactNode);
+    direction?: Direction;
+    sticky?: boolean | TableSticky;
+    rowHoverable?: boolean;
+    onScroll?: React.UIEventHandler<HTMLDivElement>;
+    /**
+     * @private Internal usage, may remove by refactor. Should always use `columns` instead.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    internalHooks?: string;
+    /**
+     * @private Internal usage, may remove by refactor. Should always use `columns` instead.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    transformColumns?: (columns: ColumnsType<RecordType>) => ColumnsType<RecordType>;
+    /**
+     * @private Internal usage, may remove by refactor.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    tailor?: boolean;
+    /**
+     * @private Internal usage, may remove by refactor.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    getContainerWidth?: (ele: HTMLElement, width: number) => number;
+    /**
+     * @private Internal usage, may remove by refactor.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    internalRefs?: {
+        body: React.MutableRefObject<HTMLDivElement>;
+    };
+    /**
+     * @private Internal usage, may remove by refactor.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    measureRowRender?: (measureRow: React.ReactNode) => React.ReactNode;
+}
+declare function Table<RecordType extends DefaultRecordType>(tableProps: TableProps<RecordType>, ref: React.Ref<Reference>): React.JSX.Element;
+export type ForwardGenericTable = (<RecordType extends DefaultRecordType = any>(props: TableProps<RecordType> & React.RefAttributes<Reference>) => React.ReactElement) & {
+    displayName?: string;
+};
+export declare function genTable(shouldTriggerRender?: CompareProps<typeof Table>): ForwardGenericTable;
+declare const ImmutableTable: ForwardGenericTable;
+type ImmutableTableType = typeof ImmutableTable & {
+    EXPAND_COLUMN: typeof EXPAND_COLUMN;
+    INTERNAL_HOOKS: typeof INTERNAL_HOOKS;
+    Column: typeof Column;
+    ColumnGroup: typeof ColumnGroup;
+    Summary: typeof FooterComponents;
+};
+declare const _default: ImmutableTableType;
+export default _default;
--- a/node_modules/rc-table/es/Table.js
+++ b/node_modules/rc-table/es/Table.js
@@ -0,0 +1,685 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+/**
+ * Feature:
+ *  - fixed not need to set width
+ *  - support `rowExpandable` to config row expand logic
+ *  - add `summary` to support `() => ReactNode`
+ *
+ * Update:
+ *  - `dataIndex` is `array[]` now
+ *  - `expandable` wrap all the expand related props
+ *
+ * Removed:
+ *  - expandIconAsCell
+ *  - useFixedHeader
+ *  - rowRef
+ *  - columns[number].onCellClick
+ *  - onRowClick
+ *  - onRowDoubleClick
+ *  - onRowMouseEnter
+ *  - onRowMouseLeave
+ *  - getBodyWrapper
+ *  - bodyStyle
+ *
+ * Deprecated:
+ *  - All expanded props, move into expandable
+ */
+
+import classNames from 'classnames';
+import ResizeObserver from 'rc-resize-observer';
+import { isStyleSupport } from "rc-util/es/Dom/styleChecker";
+import { getTargetScrollBarSize } from "rc-util/es/getScrollBarSize";
+import useEvent from "rc-util/es/hooks/useEvent";
+import pickAttrs from "rc-util/es/pickAttrs";
+import getValue from "rc-util/es/utils/get";
+import warning from "rc-util/es/warning";
+import * as React from 'react';
+import Body from "./Body";
+import ColGroup from "./ColGroup";
+import { EXPAND_COLUMN, INTERNAL_HOOKS } from "./constant";
+import TableContext, { makeImmutable } from "./context/TableContext";
+import FixedHolder from "./FixedHolder";
+import Footer, { FooterComponents } from "./Footer";
+import Summary from "./Footer/Summary";
+import Header from "./Header/Header";
+import useColumns from "./hooks/useColumns";
+import useExpand from "./hooks/useExpand";
+import useFixedInfo from "./hooks/useFixedInfo";
+import { useTimeoutLock } from "./hooks/useFrame";
+import useHover from "./hooks/useHover";
+import useSticky from "./hooks/useSticky";
+import useStickyOffsets from "./hooks/useStickyOffsets";
+import Panel from "./Panel";
+import StickyScrollBar from "./stickyScrollBar";
+import Column from "./sugar/Column";
+import ColumnGroup from "./sugar/ColumnGroup";
+import { getColumnsKey, validateValue, validNumberValue } from "./utils/valueUtil";
+import { getDOM } from "rc-util/es/Dom/findDOMNode";
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+export var DEFAULT_PREFIX = 'rc-table';
+
+// Used for conditions cache
+var EMPTY_DATA = [];
+
+// Used for customize scroll
+var EMPTY_SCROLL_TARGET = {};
+function defaultEmpty() {
+  return 'No Data';
+}
+function Table(tableProps, ref) {
+  var props = _objectSpread({
+    rowKey: 'key',
+    prefixCls: DEFAULT_PREFIX,
+    emptyText: defaultEmpty
+  }, tableProps);
+  var prefixCls = props.prefixCls,
+    className = props.className,
+    rowClassName = props.rowClassName,
+    style = props.style,
+    data = props.data,
+    rowKey = props.rowKey,
+    scroll = props.scroll,
+    tableLayout = props.tableLayout,
+    direction = props.direction,
+    title = props.title,
+    footer = props.footer,
+    summary = props.summary,
+    caption = props.caption,
+    id = props.id,
+    showHeader = props.showHeader,
+    components = props.components,
+    emptyText = props.emptyText,
+    onRow = props.onRow,
+    onHeaderRow = props.onHeaderRow,
+    measureRowRender = props.measureRowRender,
+    onScroll = props.onScroll,
+    internalHooks = props.internalHooks,
+    transformColumns = props.transformColumns,
+    internalRefs = props.internalRefs,
+    tailor = props.tailor,
+    getContainerWidth = props.getContainerWidth,
+    sticky = props.sticky,
+    _props$rowHoverable = props.rowHoverable,
+    rowHoverable = _props$rowHoverable === void 0 ? true : _props$rowHoverable;
+  var mergedData = data || EMPTY_DATA;
+  var hasData = !!mergedData.length;
+  var useInternalHooks = internalHooks === INTERNAL_HOOKS;
+
+  // ===================== Warning ======================
+  if (process.env.NODE_ENV !== 'production') {
+    ['onRowClick', 'onRowDoubleClick', 'onRowContextMenu', 'onRowMouseEnter', 'onRowMouseLeave'].forEach(function (name) {
+      warning(props[name] === undefined, "`".concat(name, "` is removed, please use `onRow` instead."));
+    });
+    warning(!('getBodyWrapper' in props), '`getBodyWrapper` is deprecated, please use custom `components` instead.');
+  }
+
+  // ==================== Customize =====================
+  var getComponent = React.useCallback(function (path, defaultComponent) {
+    return getValue(components, path) || defaultComponent;
+  }, [components]);
+  var getRowKey = React.useMemo(function () {
+    if (typeof rowKey === 'function') {
+      return rowKey;
+    }
+    return function (record) {
+      var key = record && record[rowKey];
+      if (process.env.NODE_ENV !== 'production') {
+        warning(key !== undefined, 'Each record in table should have a unique `key` prop, or set `rowKey` to an unique primary key.');
+      }
+      return key;
+    };
+  }, [rowKey]);
+  var customizeScrollBody = getComponent(['body']);
+
+  // ====================== Hover =======================
+  var _useHover = useHover(),
+    _useHover2 = _slicedToArray(_useHover, 3),
+    startRow = _useHover2[0],
+    endRow = _useHover2[1],
+    onHover = _useHover2[2];
+
+  // ====================== Expand ======================
+  var _useExpand = useExpand(props, mergedData, getRowKey),
+    _useExpand2 = _slicedToArray(_useExpand, 6),
+    expandableConfig = _useExpand2[0],
+    expandableType = _useExpand2[1],
+    mergedExpandedKeys = _useExpand2[2],
+    mergedExpandIcon = _useExpand2[3],
+    mergedChildrenColumnName = _useExpand2[4],
+    onTriggerExpand = _useExpand2[5];
+
+  // ====================== Column ======================
+  var scrollX = scroll === null || scroll === void 0 ? void 0 : scroll.x;
+  var _React$useState = React.useState(0),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    componentWidth = _React$useState2[0],
+    setComponentWidth = _React$useState2[1];
+  var _useColumns = useColumns(_objectSpread(_objectSpread(_objectSpread({}, props), expandableConfig), {}, {
+      expandable: !!expandableConfig.expandedRowRender,
+      columnTitle: expandableConfig.columnTitle,
+      expandedKeys: mergedExpandedKeys,
+      getRowKey: getRowKey,
+      // https://github.com/ant-design/ant-design/issues/23894
+      onTriggerExpand: onTriggerExpand,
+      expandIcon: mergedExpandIcon,
+      expandIconColumnIndex: expandableConfig.expandIconColumnIndex,
+      direction: direction,
+      scrollWidth: useInternalHooks && tailor && typeof scrollX === 'number' ? scrollX : null,
+      clientWidth: componentWidth
+    }), useInternalHooks ? transformColumns : null),
+    _useColumns2 = _slicedToArray(_useColumns, 4),
+    columns = _useColumns2[0],
+    flattenColumns = _useColumns2[1],
+    flattenScrollX = _useColumns2[2],
+    hasGapFixed = _useColumns2[3];
+  var mergedScrollX = flattenScrollX !== null && flattenScrollX !== void 0 ? flattenScrollX : scrollX;
+  var columnContext = React.useMemo(function () {
+    return {
+      columns: columns,
+      flattenColumns: flattenColumns
+    };
+  }, [columns, flattenColumns]);
+
+  // ======================= Refs =======================
+  var fullTableRef = React.useRef();
+  var scrollHeaderRef = React.useRef();
+  var scrollBodyRef = React.useRef();
+  var scrollBodyContainerRef = React.useRef();
+  React.useImperativeHandle(ref, function () {
+    return {
+      nativeElement: fullTableRef.current,
+      scrollTo: function scrollTo(config) {
+        var _scrollBodyRef$curren3;
+        if (scrollBodyRef.current instanceof HTMLElement) {
+          // Native scroll
+          var index = config.index,
+            top = config.top,
+            key = config.key;
+          if (validNumberValue(top)) {
+            var _scrollBodyRef$curren;
+            (_scrollBodyRef$curren = scrollBodyRef.current) === null || _scrollBodyRef$curren === void 0 || _scrollBodyRef$curren.scrollTo({
+              top: top
+            });
+          } else {
+            var _scrollBodyRef$curren2;
+            var mergedKey = key !== null && key !== void 0 ? key : getRowKey(mergedData[index]);
+            (_scrollBodyRef$curren2 = scrollBodyRef.current.querySelector("[data-row-key=\"".concat(mergedKey, "\"]"))) === null || _scrollBodyRef$curren2 === void 0 || _scrollBodyRef$curren2.scrollIntoView();
+          }
+        } else if ((_scrollBodyRef$curren3 = scrollBodyRef.current) !== null && _scrollBodyRef$curren3 !== void 0 && _scrollBodyRef$curren3.scrollTo) {
+          // Pass to proxy
+          scrollBodyRef.current.scrollTo(config);
+        }
+      }
+    };
+  });
+
+  // ====================== Scroll ======================
+  var scrollSummaryRef = React.useRef();
+  var _React$useState3 = React.useState(false),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    pingedLeft = _React$useState4[0],
+    setPingedLeft = _React$useState4[1];
+  var _React$useState5 = React.useState(false),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    pingedRight = _React$useState6[0],
+    setPingedRight = _React$useState6[1];
+  var _React$useState7 = React.useState(new Map()),
+    _React$useState8 = _slicedToArray(_React$useState7, 2),
+    colsWidths = _React$useState8[0],
+    updateColsWidths = _React$useState8[1];
+
+  // Convert map to number width
+  var colsKeys = getColumnsKey(flattenColumns);
+  var pureColWidths = colsKeys.map(function (columnKey) {
+    return colsWidths.get(columnKey);
+  });
+  var colWidths = React.useMemo(function () {
+    return pureColWidths;
+  }, [pureColWidths.join('_')]);
+  var stickyOffsets = useStickyOffsets(colWidths, flattenColumns, direction);
+  var fixHeader = scroll && validateValue(scroll.y);
+  var horizonScroll = scroll && validateValue(mergedScrollX) || Boolean(expandableConfig.fixed);
+  var fixColumn = horizonScroll && flattenColumns.some(function (_ref) {
+    var fixed = _ref.fixed;
+    return fixed;
+  });
+
+  // Sticky
+  var stickyRef = React.useRef();
+  var _useSticky = useSticky(sticky, prefixCls),
+    isSticky = _useSticky.isSticky,
+    offsetHeader = _useSticky.offsetHeader,
+    offsetSummary = _useSticky.offsetSummary,
+    offsetScroll = _useSticky.offsetScroll,
+    stickyClassName = _useSticky.stickyClassName,
+    container = _useSticky.container;
+
+  // Footer (Fix footer must fixed header)
+  var summaryNode = React.useMemo(function () {
+    return summary === null || summary === void 0 ? void 0 : summary(mergedData);
+  }, [summary, mergedData]);
+  var fixFooter = (fixHeader || isSticky) && /*#__PURE__*/React.isValidElement(summaryNode) && summaryNode.type === Summary && summaryNode.props.fixed;
+
+  // Scroll
+  var scrollXStyle;
+  var scrollYStyle;
+  var scrollTableStyle;
+  if (fixHeader) {
+    scrollYStyle = {
+      overflowY: hasData ? 'scroll' : 'auto',
+      maxHeight: scroll.y
+    };
+  }
+  if (horizonScroll) {
+    scrollXStyle = {
+      overflowX: 'auto'
+    };
+    // When no vertical scrollbar, should hide it
+    // https://github.com/ant-design/ant-design/pull/20705
+    // https://github.com/ant-design/ant-design/issues/21879
+    if (!fixHeader) {
+      scrollYStyle = {
+        overflowY: 'hidden'
+      };
+    }
+    scrollTableStyle = {
+      width: mergedScrollX === true ? 'auto' : mergedScrollX,
+      minWidth: '100%'
+    };
+  }
+  var onColumnResize = React.useCallback(function (columnKey, width) {
+    updateColsWidths(function (widths) {
+      if (widths.get(columnKey) !== width) {
+        var newWidths = new Map(widths);
+        newWidths.set(columnKey, width);
+        return newWidths;
+      }
+      return widths;
+    });
+  }, []);
+  var _useTimeoutLock = useTimeoutLock(null),
+    _useTimeoutLock2 = _slicedToArray(_useTimeoutLock, 2),
+    setScrollTarget = _useTimeoutLock2[0],
+    getScrollTarget = _useTimeoutLock2[1];
+  function forceScroll(scrollLeft, target) {
+    if (!target) {
+      return;
+    }
+    if (typeof target === 'function') {
+      target(scrollLeft);
+    } else if (target.scrollLeft !== scrollLeft) {
+      target.scrollLeft = scrollLeft;
+
+      // Delay to force scroll position if not sync
+      // ref: https://github.com/ant-design/ant-design/issues/37179
+      if (target.scrollLeft !== scrollLeft) {
+        setTimeout(function () {
+          target.scrollLeft = scrollLeft;
+        }, 0);
+      }
+    }
+  }
+  var onInternalScroll = useEvent(function (_ref2) {
+    var currentTarget = _ref2.currentTarget,
+      scrollLeft = _ref2.scrollLeft;
+    var isRTL = direction === 'rtl';
+    var mergedScrollLeft = typeof scrollLeft === 'number' ? scrollLeft : currentTarget.scrollLeft;
+    var compareTarget = currentTarget || EMPTY_SCROLL_TARGET;
+    if (!getScrollTarget() || getScrollTarget() === compareTarget) {
+      var _stickyRef$current;
+      setScrollTarget(compareTarget);
+      forceScroll(mergedScrollLeft, scrollHeaderRef.current);
+      forceScroll(mergedScrollLeft, scrollBodyRef.current);
+      forceScroll(mergedScrollLeft, scrollSummaryRef.current);
+      forceScroll(mergedScrollLeft, (_stickyRef$current = stickyRef.current) === null || _stickyRef$current === void 0 ? void 0 : _stickyRef$current.setScrollLeft);
+    }
+    var measureTarget = currentTarget || scrollHeaderRef.current;
+    if (measureTarget) {
+      var scrollWidth =
+      // Should use mergedScrollX in virtual table(useInternalHooks && tailor === true)
+      useInternalHooks && tailor && typeof mergedScrollX === 'number' ? mergedScrollX : measureTarget.scrollWidth;
+      var clientWidth = measureTarget.clientWidth;
+      // There is no space to scroll
+      if (scrollWidth === clientWidth) {
+        setPingedLeft(false);
+        setPingedRight(false);
+        return;
+      }
+      if (isRTL) {
+        setPingedLeft(-mergedScrollLeft < scrollWidth - clientWidth);
+        setPingedRight(-mergedScrollLeft > 0);
+      } else {
+        setPingedLeft(mergedScrollLeft > 0);
+        setPingedRight(mergedScrollLeft < scrollWidth - clientWidth);
+      }
+    }
+  });
+  var onBodyScroll = useEvent(function (e) {
+    onInternalScroll(e);
+    onScroll === null || onScroll === void 0 || onScroll(e);
+  });
+  var triggerOnScroll = function triggerOnScroll() {
+    if (horizonScroll && scrollBodyRef.current) {
+      var _scrollBodyRef$curren4;
+      onInternalScroll({
+        currentTarget: getDOM(scrollBodyRef.current),
+        scrollLeft: (_scrollBodyRef$curren4 = scrollBodyRef.current) === null || _scrollBodyRef$curren4 === void 0 ? void 0 : _scrollBodyRef$curren4.scrollLeft
+      });
+    } else {
+      setPingedLeft(false);
+      setPingedRight(false);
+    }
+  };
+  var onFullTableResize = function onFullTableResize(_ref3) {
+    var _stickyRef$current2;
+    var width = _ref3.width;
+    (_stickyRef$current2 = stickyRef.current) === null || _stickyRef$current2 === void 0 || _stickyRef$current2.checkScrollBarVisible();
+    var mergedWidth = fullTableRef.current ? fullTableRef.current.offsetWidth : width;
+    if (useInternalHooks && getContainerWidth && fullTableRef.current) {
+      mergedWidth = getContainerWidth(fullTableRef.current, mergedWidth) || mergedWidth;
+    }
+    if (mergedWidth !== componentWidth) {
+      triggerOnScroll();
+      setComponentWidth(mergedWidth);
+    }
+  };
+
+  // Sync scroll bar when init or `horizonScroll`, `data` and `columns.length` changed
+  var mounted = React.useRef(false);
+  React.useEffect(function () {
+    // onFullTableResize will be trigger once when ResizeObserver is mounted
+    // This will reduce one duplicated triggerOnScroll time
+    if (mounted.current) {
+      triggerOnScroll();
+    }
+  }, [horizonScroll, data, columns.length]);
+  React.useEffect(function () {
+    mounted.current = true;
+  }, []);
+
+  // ===================== Effects ======================
+  var _React$useState9 = React.useState(0),
+    _React$useState10 = _slicedToArray(_React$useState9, 2),
+    scrollbarSize = _React$useState10[0],
+    setScrollbarSize = _React$useState10[1];
+  var _React$useState11 = React.useState(true),
+    _React$useState12 = _slicedToArray(_React$useState11, 2),
+    supportSticky = _React$useState12[0],
+    setSupportSticky = _React$useState12[1]; // Only IE not support, we mark as support first
+
+  useLayoutEffect(function () {
+    if (!tailor || !useInternalHooks) {
+      if (scrollBodyRef.current instanceof Element) {
+        setScrollbarSize(getTargetScrollBarSize(scrollBodyRef.current).width);
+      } else {
+        setScrollbarSize(getTargetScrollBarSize(scrollBodyContainerRef.current).width);
+      }
+    }
+    setSupportSticky(isStyleSupport('position', 'sticky'));
+  }, []);
+
+  // ================== INTERNAL HOOKS ==================
+  React.useEffect(function () {
+    if (useInternalHooks && internalRefs) {
+      internalRefs.body.current = scrollBodyRef.current;
+    }
+  });
+
+  // ========================================================================
+  // ==                               Render                               ==
+  // ========================================================================
+  // =================== Render: Func ===================
+  var renderFixedHeaderTable = React.useCallback(function (fixedHolderPassProps) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Header, fixedHolderPassProps), fixFooter === 'top' && /*#__PURE__*/React.createElement(Footer, fixedHolderPassProps, summaryNode));
+  }, [fixFooter, summaryNode]);
+  var renderFixedFooterTable = React.useCallback(function (fixedHolderPassProps) {
+    return /*#__PURE__*/React.createElement(Footer, fixedHolderPassProps, summaryNode);
+  }, [summaryNode]);
+
+  // =================== Render: Node ===================
+  var TableComponent = getComponent(['table'], 'table');
+
+  // Table layout
+  var mergedTableLayout = React.useMemo(function () {
+    if (tableLayout) {
+      return tableLayout;
+    }
+    // https://github.com/ant-design/ant-design/issues/25227
+    // When scroll.x is max-content, no need to fix table layout
+    // it's width should stretch out to fit content
+    if (fixColumn) {
+      return mergedScrollX === 'max-content' ? 'auto' : 'fixed';
+    }
+    if (fixHeader || isSticky || flattenColumns.some(function (_ref4) {
+      var ellipsis = _ref4.ellipsis;
+      return ellipsis;
+    })) {
+      return 'fixed';
+    }
+    return 'auto';
+  }, [fixHeader, fixColumn, flattenColumns, tableLayout, isSticky]);
+  var groupTableNode;
+
+  // Header props
+  var headerProps = {
+    colWidths: colWidths,
+    columCount: flattenColumns.length,
+    stickyOffsets: stickyOffsets,
+    onHeaderRow: onHeaderRow,
+    fixHeader: fixHeader,
+    scroll: scroll
+  };
+
+  // Empty
+  var emptyNode = React.useMemo(function () {
+    if (hasData) {
+      return null;
+    }
+    if (typeof emptyText === 'function') {
+      return emptyText();
+    }
+    return emptyText;
+  }, [hasData, emptyText]);
+
+  // Body
+  var bodyTable = /*#__PURE__*/React.createElement(Body, {
+    data: mergedData,
+    measureColumnWidth: fixHeader || horizonScroll || isSticky
+  });
+  var bodyColGroup = /*#__PURE__*/React.createElement(ColGroup, {
+    colWidths: flattenColumns.map(function (_ref5) {
+      var width = _ref5.width;
+      return width;
+    }),
+    columns: flattenColumns
+  });
+  var captionElement = caption !== null && caption !== undefined ? /*#__PURE__*/React.createElement("caption", {
+    className: "".concat(prefixCls, "-caption")
+  }, caption) : undefined;
+  var dataProps = pickAttrs(props, {
+    data: true
+  });
+  var ariaProps = pickAttrs(props, {
+    aria: true
+  });
+  if (fixHeader || isSticky) {
+    // >>>>>> Fixed Header
+    var bodyContent;
+    if (typeof customizeScrollBody === 'function') {
+      bodyContent = customizeScrollBody(mergedData, {
+        scrollbarSize: scrollbarSize,
+        ref: scrollBodyRef,
+        onScroll: onInternalScroll
+      });
+      headerProps.colWidths = flattenColumns.map(function (_ref6, index) {
+        var width = _ref6.width;
+        var colWidth = index === flattenColumns.length - 1 ? width - scrollbarSize : width;
+        if (typeof colWidth === 'number' && !Number.isNaN(colWidth)) {
+          return colWidth;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+          warning(props.columns.length === 0, 'When use `components.body` with render props. Each column should have a fixed `width` value.');
+        }
+        return 0;
+      });
+    } else {
+      bodyContent = /*#__PURE__*/React.createElement("div", {
+        style: _objectSpread(_objectSpread({}, scrollXStyle), scrollYStyle),
+        onScroll: onBodyScroll,
+        ref: scrollBodyRef,
+        className: classNames("".concat(prefixCls, "-body"))
+      }, /*#__PURE__*/React.createElement(TableComponent, _extends({
+        style: _objectSpread(_objectSpread({}, scrollTableStyle), {}, {
+          tableLayout: mergedTableLayout
+        })
+      }, ariaProps), captionElement, bodyColGroup, bodyTable, !fixFooter && summaryNode && /*#__PURE__*/React.createElement(Footer, {
+        stickyOffsets: stickyOffsets,
+        flattenColumns: flattenColumns
+      }, summaryNode)));
+    }
+
+    // Fixed holder share the props
+    var fixedHolderProps = _objectSpread(_objectSpread(_objectSpread({
+      noData: !mergedData.length
+    }, headerProps), columnContext), {}, {
+      direction: direction,
+      stickyClassName: stickyClassName,
+      scrollX: mergedScrollX,
+      tableLayout: mergedTableLayout,
+      onScroll: onInternalScroll
+    });
+    groupTableNode = /*#__PURE__*/React.createElement(React.Fragment, null, showHeader !== false && /*#__PURE__*/React.createElement(FixedHolder, _extends({}, fixedHolderProps, {
+      stickyTopOffset: offsetHeader,
+      className: "".concat(prefixCls, "-header"),
+      ref: scrollHeaderRef,
+      colGroup: bodyColGroup
+    }), renderFixedHeaderTable), bodyContent, fixFooter && fixFooter !== 'top' && /*#__PURE__*/React.createElement(FixedHolder, _extends({}, fixedHolderProps, {
+      stickyBottomOffset: offsetSummary,
+      className: "".concat(prefixCls, "-summary"),
+      ref: scrollSummaryRef,
+      colGroup: bodyColGroup
+    }), renderFixedFooterTable), isSticky && scrollBodyRef.current && scrollBodyRef.current instanceof Element && /*#__PURE__*/React.createElement(StickyScrollBar, {
+      ref: stickyRef,
+      offsetScroll: offsetScroll,
+      scrollBodyRef: scrollBodyRef,
+      onScroll: onInternalScroll,
+      container: container,
+      direction: direction
+    }));
+  } else {
+    // >>>>>> Unique table
+    groupTableNode = /*#__PURE__*/React.createElement("div", {
+      style: _objectSpread(_objectSpread({}, scrollXStyle), scrollYStyle),
+      className: classNames("".concat(prefixCls, "-content")),
+      onScroll: onInternalScroll,
+      ref: scrollBodyRef
+    }, /*#__PURE__*/React.createElement(TableComponent, _extends({
+      style: _objectSpread(_objectSpread({}, scrollTableStyle), {}, {
+        tableLayout: mergedTableLayout
+      })
+    }, ariaProps), captionElement, bodyColGroup, showHeader !== false && /*#__PURE__*/React.createElement(Header, _extends({}, headerProps, columnContext)), bodyTable, summaryNode && /*#__PURE__*/React.createElement(Footer, {
+      stickyOffsets: stickyOffsets,
+      flattenColumns: flattenColumns
+    }, summaryNode)));
+  }
+  var fullTable = /*#__PURE__*/React.createElement("div", _extends({
+    className: classNames(prefixCls, className, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, "".concat(prefixCls, "-rtl"), direction === 'rtl'), "".concat(prefixCls, "-ping-left"), pingedLeft), "".concat(prefixCls, "-ping-right"), pingedRight), "".concat(prefixCls, "-layout-fixed"), tableLayout === 'fixed'), "".concat(prefixCls, "-fixed-header"), fixHeader), "".concat(prefixCls, "-fixed-column"), fixColumn), "".concat(prefixCls, "-fixed-column-gapped"), fixColumn && hasGapFixed), "".concat(prefixCls, "-scroll-horizontal"), horizonScroll), "".concat(prefixCls, "-has-fix-left"), flattenColumns[0] && flattenColumns[0].fixed), "".concat(prefixCls, "-has-fix-right"), flattenColumns[flattenColumns.length - 1] && flattenColumns[flattenColumns.length - 1].fixed === 'right')),
+    style: style,
+    id: id,
+    ref: fullTableRef
+  }, dataProps), title && /*#__PURE__*/React.createElement(Panel, {
+    className: "".concat(prefixCls, "-title")
+  }, title(mergedData)), /*#__PURE__*/React.createElement("div", {
+    ref: scrollBodyContainerRef,
+    className: "".concat(prefixCls, "-container")
+  }, groupTableNode), footer && /*#__PURE__*/React.createElement(Panel, {
+    className: "".concat(prefixCls, "-footer")
+  }, footer(mergedData)));
+  if (horizonScroll) {
+    fullTable = /*#__PURE__*/React.createElement(ResizeObserver, {
+      onResize: onFullTableResize
+    }, fullTable);
+  }
+  var fixedInfoList = useFixedInfo(flattenColumns, stickyOffsets, direction);
+  var TableContextValue = React.useMemo(function () {
+    return {
+      // Scroll
+      scrollX: mergedScrollX,
+      // Table
+      prefixCls: prefixCls,
+      getComponent: getComponent,
+      scrollbarSize: scrollbarSize,
+      direction: direction,
+      fixedInfoList: fixedInfoList,
+      isSticky: isSticky,
+      supportSticky: supportSticky,
+      componentWidth: componentWidth,
+      fixHeader: fixHeader,
+      fixColumn: fixColumn,
+      horizonScroll: horizonScroll,
+      // Body
+      tableLayout: mergedTableLayout,
+      rowClassName: rowClassName,
+      expandedRowClassName: expandableConfig.expandedRowClassName,
+      expandIcon: mergedExpandIcon,
+      expandableType: expandableType,
+      expandRowByClick: expandableConfig.expandRowByClick,
+      expandedRowRender: expandableConfig.expandedRowRender,
+      expandedRowOffset: expandableConfig.expandedRowOffset,
+      onTriggerExpand: onTriggerExpand,
+      expandIconColumnIndex: expandableConfig.expandIconColumnIndex,
+      indentSize: expandableConfig.indentSize,
+      allColumnsFixedLeft: flattenColumns.every(function (col) {
+        return col.fixed === 'left';
+      }),
+      emptyNode: emptyNode,
+      // Column
+      columns: columns,
+      flattenColumns: flattenColumns,
+      onColumnResize: onColumnResize,
+      colWidths: colWidths,
+      // Row
+      hoverStartRow: startRow,
+      hoverEndRow: endRow,
+      onHover: onHover,
+      rowExpandable: expandableConfig.rowExpandable,
+      onRow: onRow,
+      getRowKey: getRowKey,
+      expandedKeys: mergedExpandedKeys,
+      childrenColumnName: mergedChildrenColumnName,
+      rowHoverable: rowHoverable,
+      // Measure Row
+      measureRowRender: measureRowRender
+    };
+  }, [
+  // Scroll
+  mergedScrollX,
+  // Table
+  prefixCls, getComponent, scrollbarSize, direction, fixedInfoList, isSticky, supportSticky, componentWidth, fixHeader, fixColumn, horizonScroll,
+  // Body
+  mergedTableLayout, rowClassName, expandableConfig.expandedRowClassName, mergedExpandIcon, expandableType, expandableConfig.expandRowByClick, expandableConfig.expandedRowRender, expandableConfig.expandedRowOffset, onTriggerExpand, expandableConfig.expandIconColumnIndex, expandableConfig.indentSize, emptyNode,
+  // Column
+  columns, flattenColumns, onColumnResize, colWidths,
+  // Row
+  startRow, endRow, onHover, expandableConfig.rowExpandable, onRow, getRowKey, mergedExpandedKeys, mergedChildrenColumnName, rowHoverable, measureRowRender]);
+  return /*#__PURE__*/React.createElement(TableContext.Provider, {
+    value: TableContextValue
+  }, fullTable);
+}
+var RefTable = /*#__PURE__*/React.forwardRef(Table);
+if (process.env.NODE_ENV !== 'production') {
+  RefTable.displayName = 'Table';
+}
+export function genTable(shouldTriggerRender) {
+  return makeImmutable(RefTable, shouldTriggerRender);
+}
+var ImmutableTable = genTable();
+ImmutableTable.EXPAND_COLUMN = EXPAND_COLUMN;
+ImmutableTable.INTERNAL_HOOKS = INTERNAL_HOOKS;
+ImmutableTable.Column = Column;
+ImmutableTable.ColumnGroup = ColumnGroup;
+ImmutableTable.Summary = FooterComponents;
+export default ImmutableTable;
--- a/node_modules/rc-table/es/VirtualTable/BodyGrid.d.ts
+++ b/node_modules/rc-table/es/VirtualTable/BodyGrid.d.ts
@@ -0,0 +1,13 @@
+import * as React from 'react';
+import type { OnCustomizeScroll, ScrollConfig } from '../interface';
+export interface GridProps<RecordType = any> {
+    data: RecordType[];
+    onScroll: OnCustomizeScroll;
+}
+export interface GridRef {
+    scrollLeft: number;
+    nativeElement: HTMLDivElement;
+    scrollTo: (scrollConfig: ScrollConfig) => void;
+}
+declare const ResponseGrid: React.ForwardRefExoticComponent<GridProps<any> & React.RefAttributes<GridRef>>;
+export default ResponseGrid;
--- a/node_modules/rc-table/es/VirtualTable/BodyGrid.js
+++ b/node_modules/rc-table/es/VirtualTable/BodyGrid.js
@@ -0,0 +1,273 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useContext } from '@rc-component/context';
+import VirtualList from 'rc-virtual-list';
+import * as React from 'react';
+import TableContext, { responseImmutable } from "../context/TableContext";
+import useFlattenRecords from "../hooks/useFlattenRecords";
+import BodyLine from "./BodyLine";
+import { GridContext, StaticContext } from "./context";
+var Grid = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var data = props.data,
+    onScroll = props.onScroll;
+  var _useContext = useContext(TableContext, ['flattenColumns', 'onColumnResize', 'getRowKey', 'prefixCls', 'expandedKeys', 'childrenColumnName', 'scrollX', 'direction']),
+    flattenColumns = _useContext.flattenColumns,
+    onColumnResize = _useContext.onColumnResize,
+    getRowKey = _useContext.getRowKey,
+    expandedKeys = _useContext.expandedKeys,
+    prefixCls = _useContext.prefixCls,
+    childrenColumnName = _useContext.childrenColumnName,
+    scrollX = _useContext.scrollX,
+    direction = _useContext.direction;
+  var _useContext2 = useContext(StaticContext),
+    sticky = _useContext2.sticky,
+    scrollY = _useContext2.scrollY,
+    listItemHeight = _useContext2.listItemHeight,
+    getComponent = _useContext2.getComponent,
+    onTablePropScroll = _useContext2.onScroll;
+
+  // =========================== Ref ============================
+  var listRef = React.useRef();
+
+  // =========================== Data ===========================
+  var flattenData = useFlattenRecords(data, childrenColumnName, expandedKeys, getRowKey);
+
+  // ========================== Column ==========================
+  var columnsWidth = React.useMemo(function () {
+    var total = 0;
+    return flattenColumns.map(function (_ref) {
+      var width = _ref.width,
+        minWidth = _ref.minWidth,
+        key = _ref.key;
+      var finalWidth = Math.max(width || 0, minWidth || 0);
+      total += finalWidth;
+      return [key, finalWidth, total];
+    });
+  }, [flattenColumns]);
+  var columnsOffset = React.useMemo(function () {
+    return columnsWidth.map(function (colWidth) {
+      return colWidth[2];
+    });
+  }, [columnsWidth]);
+  React.useEffect(function () {
+    columnsWidth.forEach(function (_ref2) {
+      var _ref3 = _slicedToArray(_ref2, 2),
+        key = _ref3[0],
+        width = _ref3[1];
+      onColumnResize(key, width);
+    });
+  }, [columnsWidth]);
+
+  // =========================== Ref ============================
+  React.useImperativeHandle(ref, function () {
+    var _listRef$current2;
+    var obj = {
+      scrollTo: function scrollTo(config) {
+        var _listRef$current;
+        (_listRef$current = listRef.current) === null || _listRef$current === void 0 || _listRef$current.scrollTo(config);
+      },
+      nativeElement: (_listRef$current2 = listRef.current) === null || _listRef$current2 === void 0 ? void 0 : _listRef$current2.nativeElement
+    };
+    Object.defineProperty(obj, 'scrollLeft', {
+      get: function get() {
+        var _listRef$current3;
+        return ((_listRef$current3 = listRef.current) === null || _listRef$current3 === void 0 ? void 0 : _listRef$current3.getScrollInfo().x) || 0;
+      },
+      set: function set(value) {
+        var _listRef$current4;
+        (_listRef$current4 = listRef.current) === null || _listRef$current4 === void 0 || _listRef$current4.scrollTo({
+          left: value
+        });
+      }
+    });
+
+    // https://github.com/ant-design/ant-design/issues/54734
+    Object.defineProperty(obj, 'scrollTop', {
+      get: function get() {
+        var _listRef$current5;
+        return ((_listRef$current5 = listRef.current) === null || _listRef$current5 === void 0 ? void 0 : _listRef$current5.getScrollInfo().y) || 0;
+      },
+      set: function set(value) {
+        var _listRef$current6;
+        (_listRef$current6 = listRef.current) === null || _listRef$current6 === void 0 || _listRef$current6.scrollTo({
+          top: value
+        });
+      }
+    });
+    return obj;
+  });
+
+  // ======================= Col/Row Span =======================
+  var getRowSpan = function getRowSpan(column, index) {
+    var _flattenData$index;
+    var record = (_flattenData$index = flattenData[index]) === null || _flattenData$index === void 0 ? void 0 : _flattenData$index.record;
+    var onCell = column.onCell;
+    if (onCell) {
+      var _cellProps$rowSpan;
+      var cellProps = onCell(record, index);
+      return (_cellProps$rowSpan = cellProps === null || cellProps === void 0 ? void 0 : cellProps.rowSpan) !== null && _cellProps$rowSpan !== void 0 ? _cellProps$rowSpan : 1;
+    }
+    return 1;
+  };
+  var extraRender = function extraRender(info) {
+    var start = info.start,
+      end = info.end,
+      getSize = info.getSize,
+      offsetY = info.offsetY;
+
+    // Do nothing if no data
+    if (end < 0) {
+      return null;
+    }
+
+    // Find first rowSpan column
+    var firstRowSpanColumns = flattenColumns.filter(
+    // rowSpan is 0
+    function (column) {
+      return getRowSpan(column, start) === 0;
+    });
+    var startIndex = start;
+    var _loop = function _loop(i) {
+      firstRowSpanColumns = firstRowSpanColumns.filter(function (column) {
+        return getRowSpan(column, i) === 0;
+      });
+      if (!firstRowSpanColumns.length) {
+        startIndex = i;
+        return 1; // break
+      }
+    };
+    for (var i = start; i >= 0; i -= 1) {
+      if (_loop(i)) break;
+    }
+
+    // Find last rowSpan column
+    var lastRowSpanColumns = flattenColumns.filter(
+    // rowSpan is not 1
+    function (column) {
+      return getRowSpan(column, end) !== 1;
+    });
+    var endIndex = end;
+    var _loop2 = function _loop2(_i) {
+      lastRowSpanColumns = lastRowSpanColumns.filter(function (column) {
+        return getRowSpan(column, _i) !== 1;
+      });
+      if (!lastRowSpanColumns.length) {
+        endIndex = Math.max(_i - 1, end);
+        return 1; // break
+      }
+    };
+    for (var _i = end; _i < flattenData.length; _i += 1) {
+      if (_loop2(_i)) break;
+    }
+
+    // Collect the line who has rowSpan
+    var spanLines = [];
+    var _loop3 = function _loop3(_i2) {
+      var item = flattenData[_i2];
+
+      // This code will never reach, just incase
+      if (!item) {
+        return 1; // continue
+      }
+      if (flattenColumns.some(function (column) {
+        return getRowSpan(column, _i2) > 1;
+      })) {
+        spanLines.push(_i2);
+      }
+    };
+    for (var _i2 = startIndex; _i2 <= endIndex; _i2 += 1) {
+      if (_loop3(_i2)) continue;
+    }
+
+    // Patch extra line on the page
+    var nodes = spanLines.map(function (index) {
+      var item = flattenData[index];
+      var rowKey = getRowKey(item.record, index);
+      var getHeight = function getHeight(rowSpan) {
+        var endItemIndex = index + rowSpan - 1;
+        var endItemKey = getRowKey(flattenData[endItemIndex].record, endItemIndex);
+        var sizeInfo = getSize(rowKey, endItemKey);
+        return sizeInfo.bottom - sizeInfo.top;
+      };
+      var sizeInfo = getSize(rowKey);
+      return /*#__PURE__*/React.createElement(BodyLine, {
+        key: index,
+        data: item,
+        rowKey: rowKey,
+        index: index,
+        style: {
+          top: -offsetY + sizeInfo.top
+        },
+        extra: true,
+        getHeight: getHeight
+      });
+    });
+    return nodes;
+  };
+
+  // ========================= Context ==========================
+  var gridContext = React.useMemo(function () {
+    return {
+      columnsOffset: columnsOffset
+    };
+  }, [columnsOffset]);
+
+  // ========================== Render ==========================
+  var tblPrefixCls = "".concat(prefixCls, "-tbody");
+
+  // default 'div' in rc-virtual-list
+  var wrapperComponent = getComponent(['body', 'wrapper']);
+
+  // ========================== Sticky Scroll Bar ==========================
+  var horizontalScrollBarStyle = {};
+  if (sticky) {
+    horizontalScrollBarStyle.position = 'sticky';
+    horizontalScrollBarStyle.bottom = 0;
+    if (_typeof(sticky) === 'object' && sticky.offsetScroll) {
+      horizontalScrollBarStyle.bottom = sticky.offsetScroll;
+    }
+  }
+  return /*#__PURE__*/React.createElement(GridContext.Provider, {
+    value: gridContext
+  }, /*#__PURE__*/React.createElement(VirtualList, {
+    fullHeight: false,
+    ref: listRef,
+    prefixCls: "".concat(tblPrefixCls, "-virtual"),
+    styles: {
+      horizontalScrollBar: horizontalScrollBarStyle
+    },
+    className: tblPrefixCls,
+    height: scrollY,
+    itemHeight: listItemHeight || 24,
+    data: flattenData,
+    itemKey: function itemKey(item) {
+      return getRowKey(item.record);
+    },
+    component: wrapperComponent,
+    scrollWidth: scrollX,
+    direction: direction,
+    onVirtualScroll: function onVirtualScroll(_ref4) {
+      var _listRef$current7;
+      var x = _ref4.x;
+      onScroll({
+        currentTarget: (_listRef$current7 = listRef.current) === null || _listRef$current7 === void 0 ? void 0 : _listRef$current7.nativeElement,
+        scrollLeft: x
+      });
+    },
+    onScroll: onTablePropScroll,
+    extraRender: extraRender
+  }, function (item, index, itemProps) {
+    var rowKey = getRowKey(item.record, index);
+    return /*#__PURE__*/React.createElement(BodyLine, {
+      data: item,
+      rowKey: rowKey,
+      index: index,
+      style: itemProps.style
+    });
+  }));
+});
+var ResponseGrid = responseImmutable(Grid);
+if (process.env.NODE_ENV !== 'production') {
+  ResponseGrid.displayName = 'ResponseGrid';
+}
+export default ResponseGrid;
--- a/node_modules/rc-table/es/VirtualTable/BodyLine.d.ts
+++ b/node_modules/rc-table/es/VirtualTable/BodyLine.d.ts
@@ -0,0 +1,14 @@
+import * as React from 'react';
+import type { FlattenData } from '../hooks/useFlattenRecords';
+export interface BodyLineProps<RecordType = any> {
+    data: FlattenData<RecordType>;
+    index: number;
+    className?: string;
+    style?: React.CSSProperties;
+    rowKey: React.Key;
+    /** Render cell only when it has `rowSpan > 1` */
+    extra?: boolean;
+    getHeight?: (rowSpan: number) => number;
+}
+declare const ResponseBodyLine: React.ForwardRefExoticComponent<BodyLineProps<any> & React.RefAttributes<HTMLDivElement>>;
+export default ResponseBodyLine;
--- a/node_modules/rc-table/es/VirtualTable/BodyLine.js
+++ b/node_modules/rc-table/es/VirtualTable/BodyLine.js
@@ -0,0 +1,105 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["data", "index", "className", "rowKey", "style", "extra", "getHeight"];
+import { useContext } from '@rc-component/context';
+import classNames from 'classnames';
+import * as React from 'react';
+import Cell from "../Cell";
+import TableContext, { responseImmutable } from "../context/TableContext";
+import useRowInfo from "../hooks/useRowInfo";
+import VirtualCell from "./VirtualCell";
+import { StaticContext } from "./context";
+import { computedExpandedClassName } from "../utils/expandUtil";
+var BodyLine = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var data = props.data,
+    index = props.index,
+    className = props.className,
+    rowKey = props.rowKey,
+    style = props.style,
+    extra = props.extra,
+    getHeight = props.getHeight,
+    restProps = _objectWithoutProperties(props, _excluded);
+  var record = data.record,
+    indent = data.indent,
+    renderIndex = data.index;
+  var _useContext = useContext(TableContext, ['prefixCls', 'flattenColumns', 'fixColumn', 'componentWidth', 'scrollX']),
+    scrollX = _useContext.scrollX,
+    flattenColumns = _useContext.flattenColumns,
+    prefixCls = _useContext.prefixCls,
+    fixColumn = _useContext.fixColumn,
+    componentWidth = _useContext.componentWidth;
+  var _useContext2 = useContext(StaticContext, ['getComponent']),
+    getComponent = _useContext2.getComponent;
+  var rowInfo = useRowInfo(record, rowKey, index, indent);
+  var RowComponent = getComponent(['body', 'row'], 'div');
+  var cellComponent = getComponent(['body', 'cell'], 'div');
+
+  // ========================== Expand ==========================
+  var rowSupportExpand = rowInfo.rowSupportExpand,
+    expanded = rowInfo.expanded,
+    rowProps = rowInfo.rowProps,
+    expandedRowRender = rowInfo.expandedRowRender,
+    expandedRowClassName = rowInfo.expandedRowClassName;
+  var expandRowNode;
+  if (rowSupportExpand && expanded) {
+    var expandContent = expandedRowRender(record, index, indent + 1, expanded);
+    var expandedClsName = computedExpandedClassName(expandedRowClassName, record, index, indent);
+    var additionalProps = {};
+    if (fixColumn) {
+      additionalProps = {
+        style: _defineProperty({}, '--virtual-width', "".concat(componentWidth, "px"))
+      };
+    }
+    var rowCellCls = "".concat(prefixCls, "-expanded-row-cell");
+    expandRowNode = /*#__PURE__*/React.createElement(RowComponent, {
+      className: classNames("".concat(prefixCls, "-expanded-row"), "".concat(prefixCls, "-expanded-row-level-").concat(indent + 1), expandedClsName)
+    }, /*#__PURE__*/React.createElement(Cell, {
+      component: cellComponent,
+      prefixCls: prefixCls,
+      className: classNames(rowCellCls, _defineProperty({}, "".concat(rowCellCls, "-fixed"), fixColumn)),
+      additionalProps: additionalProps
+    }, expandContent));
+  }
+
+  // ========================== Render ==========================
+  var rowStyle = _objectSpread(_objectSpread({}, style), {}, {
+    width: scrollX
+  });
+  if (extra) {
+    rowStyle.position = 'absolute';
+    rowStyle.pointerEvents = 'none';
+  }
+  var rowNode = /*#__PURE__*/React.createElement(RowComponent, _extends({}, rowProps, restProps, {
+    "data-row-key": rowKey,
+    ref: rowSupportExpand ? null : ref,
+    className: classNames(className, "".concat(prefixCls, "-row"), rowProps === null || rowProps === void 0 ? void 0 : rowProps.className, _defineProperty({}, "".concat(prefixCls, "-row-extra"), extra)),
+    style: _objectSpread(_objectSpread({}, rowStyle), rowProps === null || rowProps === void 0 ? void 0 : rowProps.style)
+  }), flattenColumns.map(function (column, colIndex) {
+    return /*#__PURE__*/React.createElement(VirtualCell, {
+      key: colIndex,
+      component: cellComponent,
+      rowInfo: rowInfo,
+      column: column,
+      colIndex: colIndex,
+      indent: indent,
+      index: index,
+      renderIndex: renderIndex,
+      record: record,
+      inverse: extra,
+      getHeight: getHeight
+    });
+  }));
+  if (rowSupportExpand) {
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref
+    }, rowNode, expandRowNode);
+  }
+  return rowNode;
+});
+var ResponseBodyLine = responseImmutable(BodyLine);
+if (process.env.NODE_ENV !== 'production') {
+  ResponseBodyLine.displayName = 'BodyLine';
+}
+export default ResponseBodyLine;
--- a/node_modules/rc-table/es/VirtualTable/VirtualCell.d.ts
+++ b/node_modules/rc-table/es/VirtualTable/VirtualCell.d.ts
@@ -0,0 +1,26 @@
+import * as React from 'react';
+import type useRowInfo from '../hooks/useRowInfo';
+import type { ColumnType, CustomizeComponent } from '../interface';
+export interface VirtualCellProps<RecordType> {
+    rowInfo: ReturnType<typeof useRowInfo<RecordType>>;
+    column: ColumnType<RecordType>;
+    colIndex: number;
+    indent: number;
+    index: number;
+    component?: CustomizeComponent;
+    /** Used for `column.render` */
+    renderIndex: number;
+    record: RecordType;
+    style?: React.CSSProperties;
+    className?: string;
+    /** Render cell only when it has `rowSpan > 1` */
+    inverse?: boolean;
+    getHeight?: (rowSpan: number) => number;
+}
+/**
+ * Return the width of the column by `colSpan`.
+ * When `colSpan` is `0` will be trade as `1`.
+ */
+export declare function getColumnWidth(colIndex: number, colSpan: number, columnsOffset: number[]): number;
+declare function VirtualCell<RecordType = any>(props: VirtualCellProps<RecordType>): React.JSX.Element;
+export default VirtualCell;
--- a/node_modules/rc-table/es/VirtualTable/VirtualCell.js
+++ b/node_modules/rc-table/es/VirtualTable/VirtualCell.js
@@ -0,0 +1,113 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { useContext } from '@rc-component/context';
+import classNames from 'classnames';
+import * as React from 'react';
+import { getCellProps } from "../Body/BodyRow";
+import Cell from "../Cell";
+import { GridContext } from "./context";
+/**
+ * Return the width of the column by `colSpan`.
+ * When `colSpan` is `0` will be trade as `1`.
+ */
+export function getColumnWidth(colIndex, colSpan, columnsOffset) {
+  var mergedColSpan = colSpan || 1;
+  return columnsOffset[colIndex + mergedColSpan] - (columnsOffset[colIndex] || 0);
+}
+function VirtualCell(props) {
+  var rowInfo = props.rowInfo,
+    column = props.column,
+    colIndex = props.colIndex,
+    indent = props.indent,
+    index = props.index,
+    component = props.component,
+    renderIndex = props.renderIndex,
+    record = props.record,
+    style = props.style,
+    className = props.className,
+    inverse = props.inverse,
+    getHeight = props.getHeight;
+  var render = column.render,
+    dataIndex = column.dataIndex,
+    columnClassName = column.className,
+    colWidth = column.width;
+  var _useContext = useContext(GridContext, ['columnsOffset']),
+    columnsOffset = _useContext.columnsOffset;
+
+  // TODO: support `expandableRowOffset`
+  var _getCellProps = getCellProps(rowInfo, column, colIndex, indent, index),
+    key = _getCellProps.key,
+    fixedInfo = _getCellProps.fixedInfo,
+    appendCellNode = _getCellProps.appendCellNode,
+    additionalCellProps = _getCellProps.additionalCellProps;
+  var cellStyle = additionalCellProps.style,
+    _additionalCellProps$ = additionalCellProps.colSpan,
+    colSpan = _additionalCellProps$ === void 0 ? 1 : _additionalCellProps$,
+    _additionalCellProps$2 = additionalCellProps.rowSpan,
+    rowSpan = _additionalCellProps$2 === void 0 ? 1 : _additionalCellProps$2;
+
+  // ========================= ColWidth =========================
+  // column width
+  var startColIndex = colIndex - 1;
+  var concatColWidth = getColumnWidth(startColIndex, colSpan, columnsOffset);
+
+  // margin offset
+  var marginOffset = colSpan > 1 ? colWidth - concatColWidth : 0;
+
+  // ========================== Style ===========================
+  var mergedStyle = _objectSpread(_objectSpread(_objectSpread({}, cellStyle), style), {}, {
+    flex: "0 0 ".concat(concatColWidth, "px"),
+    width: "".concat(concatColWidth, "px"),
+    marginRight: marginOffset,
+    pointerEvents: 'auto'
+  });
+
+  // When `colSpan` or `rowSpan` is `0`, should skip render.
+  var needHide = React.useMemo(function () {
+    if (inverse) {
+      return rowSpan <= 1;
+    } else {
+      return colSpan === 0 || rowSpan === 0 || rowSpan > 1;
+    }
+  }, [rowSpan, colSpan, inverse]);
+
+  // 0 rowSpan or colSpan should not render
+  if (needHide) {
+    mergedStyle.visibility = 'hidden';
+  } else if (inverse) {
+    mergedStyle.height = getHeight === null || getHeight === void 0 ? void 0 : getHeight(rowSpan);
+  }
+  var mergedRender = needHide ? function () {
+    return null;
+  } : render;
+
+  // ========================== Render ==========================
+  var cellSpan = {};
+
+  // Virtual should reset `colSpan` & `rowSpan`
+  if (rowSpan === 0 || colSpan === 0) {
+    cellSpan.rowSpan = 1;
+    cellSpan.colSpan = 1;
+  }
+  return /*#__PURE__*/React.createElement(Cell, _extends({
+    className: classNames(columnClassName, className),
+    ellipsis: column.ellipsis,
+    align: column.align,
+    scope: column.rowScope,
+    component: component,
+    prefixCls: rowInfo.prefixCls,
+    key: key,
+    record: record,
+    index: index,
+    renderIndex: renderIndex,
+    dataIndex: dataIndex,
+    render: mergedRender,
+    shouldCellUpdate: column.shouldCellUpdate
+  }, fixedInfo, {
+    appendNode: appendCellNode,
+    additionalProps: _objectSpread(_objectSpread({}, additionalCellProps), {}, {
+      style: mergedStyle
+    }, cellSpan)
+  }));
+}
+export default VirtualCell;
--- a/node_modules/rc-table/es/VirtualTable/context.d.ts
+++ b/node_modules/rc-table/es/VirtualTable/context.d.ts
@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import type { GetComponent, TableSticky } from '../interface';
+export interface StaticContextProps {
+    scrollY: number;
+    listItemHeight: number;
+    sticky: boolean | TableSticky;
+    getComponent: GetComponent;
+    onScroll?: React.UIEventHandler<HTMLDivElement>;
+}
+export declare const StaticContext: import("@rc-component/context").SelectorContext<StaticContextProps>;
+export interface GridContextProps {
+    columnsOffset: number[];
+}
+export declare const GridContext: import("@rc-component/context").SelectorContext<GridContextProps>;
--- a/node_modules/rc-table/es/VirtualTable/context.js
+++ b/node_modules/rc-table/es/VirtualTable/context.js
@@ -0,0 +1,3 @@
+import { createContext } from '@rc-component/context';
+export var StaticContext = createContext(null);
+export var GridContext = createContext(null);
--- a/node_modules/rc-table/es/VirtualTable/index.d.ts
+++ b/node_modules/rc-table/es/VirtualTable/index.d.ts
@@ -0,0 +1,17 @@
+import type { CompareProps } from '@rc-component/context/lib/Immutable';
+import * as React from 'react';
+import type { Reference } from '../interface';
+import Table, { type TableProps } from '../Table';
+export interface VirtualTableProps<RecordType> extends Omit<TableProps<RecordType>, 'scroll'> {
+    scroll: {
+        x?: number;
+        y: number;
+    };
+    listItemHeight?: number;
+}
+export type ForwardGenericVirtualTable = (<RecordType>(props: TableProps<RecordType> & React.RefAttributes<Reference>) => React.ReactElement) & {
+    displayName?: string;
+};
+export declare function genVirtualTable(shouldTriggerRender?: CompareProps<typeof Table>): ForwardGenericVirtualTable;
+declare const _default: ForwardGenericVirtualTable;
+export default _default;
--- a/node_modules/rc-table/es/VirtualTable/index.js
+++ b/node_modules/rc-table/es/VirtualTable/index.js
@@ -0,0 +1,94 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import classNames from 'classnames';
+import { useEvent, warning } from 'rc-util';
+import * as React from 'react';
+import { INTERNAL_HOOKS } from "../constant";
+import { makeImmutable } from "../context/TableContext";
+import Table, { DEFAULT_PREFIX } from "../Table";
+import Grid from "./BodyGrid";
+import { StaticContext } from "./context";
+import getValue from "rc-util/es/utils/get";
+var renderBody = function renderBody(rawData, props) {
+  var ref = props.ref,
+    onScroll = props.onScroll;
+  return /*#__PURE__*/React.createElement(Grid, {
+    ref: ref,
+    data: rawData,
+    onScroll: onScroll
+  });
+};
+function VirtualTable(props, ref) {
+  var data = props.data,
+    columns = props.columns,
+    scroll = props.scroll,
+    sticky = props.sticky,
+    _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? DEFAULT_PREFIX : _props$prefixCls,
+    className = props.className,
+    listItemHeight = props.listItemHeight,
+    components = props.components,
+    onScroll = props.onScroll;
+  var _ref = scroll || {},
+    scrollX = _ref.x,
+    scrollY = _ref.y;
+
+  // Fill scrollX
+  if (typeof scrollX !== 'number') {
+    if (process.env.NODE_ENV !== 'production') {
+      warning(!scrollX, '`scroll.x` in virtual table must be number.');
+    }
+    scrollX = 1;
+  }
+
+  // Fill scrollY
+  if (typeof scrollY !== 'number') {
+    scrollY = 500;
+    if (process.env.NODE_ENV !== 'production') {
+      warning(false, '`scroll.y` in virtual table must be number.');
+    }
+  }
+  var getComponent = useEvent(function (path, defaultComponent) {
+    return getValue(components, path) || defaultComponent;
+  });
+
+  // Memo this
+  var onInternalScroll = useEvent(onScroll);
+
+  // ========================= Context ==========================
+  var context = React.useMemo(function () {
+    return {
+      sticky: sticky,
+      scrollY: scrollY,
+      listItemHeight: listItemHeight,
+      getComponent: getComponent,
+      onScroll: onInternalScroll
+    };
+  }, [sticky, scrollY, listItemHeight, getComponent, onInternalScroll]);
+
+  // ========================== Render ==========================
+  return /*#__PURE__*/React.createElement(StaticContext.Provider, {
+    value: context
+  }, /*#__PURE__*/React.createElement(Table, _extends({}, props, {
+    className: classNames(className, "".concat(prefixCls, "-virtual")),
+    scroll: _objectSpread(_objectSpread({}, scroll), {}, {
+      x: scrollX
+    }),
+    components: _objectSpread(_objectSpread({}, components), {}, {
+      // fix https://github.com/ant-design/ant-design/issues/48991
+      body: data !== null && data !== void 0 && data.length ? renderBody : undefined
+    }),
+    columns: columns,
+    internalHooks: INTERNAL_HOOKS,
+    tailor: true,
+    ref: ref
+  })));
+}
+var RefVirtualTable = /*#__PURE__*/React.forwardRef(VirtualTable);
+if (process.env.NODE_ENV !== 'production') {
+  RefVirtualTable.displayName = 'VirtualTable';
+}
+export function genVirtualTable(shouldTriggerRender) {
+  return makeImmutable(RefVirtualTable, shouldTriggerRender);
+}
+export default genVirtualTable();
--- a/node_modules/rc-table/es/constant.d.ts
+++ b/node_modules/rc-table/es/constant.d.ts
@@ -0,0 +1,2 @@
+export declare const EXPAND_COLUMN: {};
+export declare const INTERNAL_HOOKS = "rc-table-internal-hook";
--- a/node_modules/rc-table/es/constant.js
+++ b/node_modules/rc-table/es/constant.js
@@ -0,0 +1,2 @@
+export var EXPAND_COLUMN = {};
+export var INTERNAL_HOOKS = 'rc-table-internal-hook';
--- a/node_modules/rc-table/es/context/PerfContext.d.ts
+++ b/node_modules/rc-table/es/context/PerfContext.d.ts
@@ -0,0 +1,6 @@
+import * as React from 'react';
+export interface PerfRecord {
+    renderWithProps: boolean;
+}
+declare const PerfContext: React.Context<PerfRecord>;
+export default PerfContext;
--- a/node_modules/rc-table/es/context/PerfContext.js
+++ b/node_modules/rc-table/es/context/PerfContext.js
@@ -0,0 +1,6 @@
+import * as React from 'react';
+// TODO: Remove when use `responsiveImmutable`
+var PerfContext = /*#__PURE__*/React.createContext({
+  renderWithProps: false
+});
+export default PerfContext;
--- a/node_modules/rc-table/es/context/TableContext.d.ts
+++ b/node_modules/rc-table/es/context/TableContext.d.ts
@@ -0,0 +1,48 @@
+/// <reference types="react" />
+import type { ColumnsType, ColumnType, Direction, ExpandableConfig, ExpandableType, ExpandedRowRender, GetComponent, GetComponentProps, GetRowKey, RenderExpandIcon, RowClassName, TableLayout, TriggerEventHandler } from '../interface';
+import type { FixedInfo } from '../utils/fixUtil';
+declare const makeImmutable: <T extends import("react").ComponentType<any>>(Component: T, shouldTriggerRender?: import("@rc-component/context/lib/Immutable").CompareProps<T>) => T, responseImmutable: <T_1 extends import("react").ComponentType<any>>(Component: T_1, propsAreEqual?: import("@rc-component/context/lib/Immutable").CompareProps<T_1>) => T_1, useImmutableMark: () => number;
+export { makeImmutable, responseImmutable, useImmutableMark };
+export interface TableContextProps<RecordType = any> {
+    scrollX: number | string | true;
+    prefixCls: string;
+    getComponent: GetComponent;
+    scrollbarSize: number;
+    direction: Direction;
+    fixedInfoList: readonly FixedInfo[];
+    isSticky: boolean;
+    supportSticky: boolean;
+    componentWidth: number;
+    fixHeader: boolean;
+    fixColumn: boolean;
+    horizonScroll: boolean;
+    rowClassName: string | RowClassName<RecordType>;
+    expandedRowClassName: string | RowClassName<RecordType>;
+    onRow?: GetComponentProps<RecordType>;
+    emptyNode?: React.ReactNode;
+    tableLayout: TableLayout;
+    indentSize: number;
+    expandableType: ExpandableType;
+    expandRowByClick: boolean;
+    expandedRowRender: ExpandedRowRender<RecordType>;
+    expandIcon: RenderExpandIcon<RecordType>;
+    onTriggerExpand: TriggerEventHandler<RecordType>;
+    expandIconColumnIndex: number;
+    allColumnsFixedLeft: boolean;
+    columns: ColumnsType<RecordType>;
+    flattenColumns: readonly ColumnType<RecordType>[];
+    onColumnResize: (columnKey: React.Key, width: number) => void;
+    colWidths: number[];
+    hoverStartRow: number;
+    hoverEndRow: number;
+    onHover: (start: number, end: number) => void;
+    rowExpandable: (record: RecordType) => boolean;
+    expandedKeys: Set<React.Key>;
+    getRowKey: GetRowKey<RecordType>;
+    childrenColumnName: string;
+    rowHoverable?: boolean;
+    expandedRowOffset: ExpandableConfig<RecordType>['expandedRowOffset'];
+    measureRowRender?: (measureRow: React.ReactNode) => React.ReactNode;
+}
+declare const TableContext: import("@rc-component/context").SelectorContext<TableContextProps<any>>;
+export default TableContext;
--- a/node_modules/rc-table/es/context/TableContext.js
+++ b/node_modules/rc-table/es/context/TableContext.js
@@ -0,0 +1,8 @@
+import { createContext, createImmutable } from '@rc-component/context';
+var _createImmutable = createImmutable(),
+  makeImmutable = _createImmutable.makeImmutable,
+  responseImmutable = _createImmutable.responseImmutable,
+  useImmutableMark = _createImmutable.useImmutableMark;
+export { makeImmutable, responseImmutable, useImmutableMark };
+var TableContext = createContext();
+export default TableContext;
--- a/node_modules/rc-table/es/hooks/useColumns/index.d.ts
+++ b/node_modules/rc-table/es/hooks/useColumns/index.d.ts
@@ -0,0 +1,32 @@
+import * as React from 'react';
+import type { ColumnsType, ColumnType, Direction, FixedType, GetRowKey, Key, RenderExpandIcon, TriggerEventHandler } from '../../interface';
+export declare function convertChildrenToColumns<RecordType>(children: React.ReactNode): ColumnsType<RecordType>;
+/**
+ * Parse `columns` & `children` into `columns`.
+ */
+declare function useColumns<RecordType>({ prefixCls, columns, children, expandable, expandedKeys, columnTitle, getRowKey, onTriggerExpand, expandIcon, rowExpandable, expandIconColumnIndex, expandedRowOffset, direction, expandRowByClick, columnWidth, fixed, scrollWidth, clientWidth, }: {
+    prefixCls?: string;
+    columns?: ColumnsType<RecordType>;
+    children?: React.ReactNode;
+    expandable: boolean;
+    expandedKeys: Set<Key>;
+    columnTitle?: React.ReactNode;
+    getRowKey: GetRowKey<RecordType>;
+    onTriggerExpand: TriggerEventHandler<RecordType>;
+    expandIcon?: RenderExpandIcon<RecordType>;
+    rowExpandable?: (record: RecordType) => boolean;
+    expandIconColumnIndex?: number;
+    direction?: Direction;
+    expandRowByClick?: boolean;
+    columnWidth?: number | string;
+    clientWidth: number;
+    fixed?: FixedType;
+    scrollWidth?: number;
+    expandedRowOffset?: number;
+}, transformColumns: (columns: ColumnsType<RecordType>) => ColumnsType<RecordType>): [
+    columns: ColumnsType<RecordType>,
+    flattenColumns: readonly ColumnType<RecordType>[],
+    realScrollWidth: undefined | number,
+    hasGapFixed: boolean
+];
+export default useColumns;
--- a/node_modules/rc-table/es/hooks/useColumns/index.js
+++ b/node_modules/rc-table/es/hooks/useColumns/index.js
@@ -0,0 +1,269 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["children"],
+  _excluded2 = ["fixed"];
+import toArray from "rc-util/es/Children/toArray";
+import warning from "rc-util/es/warning";
+import * as React from 'react';
+import { EXPAND_COLUMN } from "../../constant";
+import { INTERNAL_COL_DEFINE } from "../../utils/legacyUtil";
+import useWidthColumns from "./useWidthColumns";
+export function convertChildrenToColumns(children) {
+  return toArray(children).filter(function (node) {
+    return /*#__PURE__*/React.isValidElement(node);
+  }).map(function (_ref) {
+    var key = _ref.key,
+      props = _ref.props;
+    var nodeChildren = props.children,
+      restProps = _objectWithoutProperties(props, _excluded);
+    var column = _objectSpread({
+      key: key
+    }, restProps);
+    if (nodeChildren) {
+      column.children = convertChildrenToColumns(nodeChildren);
+    }
+    return column;
+  });
+}
+function filterHiddenColumns(columns) {
+  return columns.filter(function (column) {
+    return column && _typeof(column) === 'object' && !column.hidden;
+  }).map(function (column) {
+    var subColumns = column.children;
+    if (subColumns && subColumns.length > 0) {
+      return _objectSpread(_objectSpread({}, column), {}, {
+        children: filterHiddenColumns(subColumns)
+      });
+    }
+    return column;
+  });
+}
+function flatColumns(columns) {
+  var parentKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key';
+  return columns.filter(function (column) {
+    return column && _typeof(column) === 'object';
+  }).reduce(function (list, column, index) {
+    var fixed = column.fixed;
+    // Convert `fixed='true'` to `fixed='left'` instead
+    var parsedFixed = fixed === true ? 'left' : fixed;
+    var mergedKey = "".concat(parentKey, "-").concat(index);
+    var subColumns = column.children;
+    if (subColumns && subColumns.length > 0) {
+      return [].concat(_toConsumableArray(list), _toConsumableArray(flatColumns(subColumns, mergedKey).map(function (subColum) {
+        var _subColum$fixed;
+        return _objectSpread(_objectSpread({}, subColum), {}, {
+          fixed: (_subColum$fixed = subColum.fixed) !== null && _subColum$fixed !== void 0 ? _subColum$fixed : parsedFixed
+        });
+      })));
+    }
+    return [].concat(_toConsumableArray(list), [_objectSpread(_objectSpread({
+      key: mergedKey
+    }, column), {}, {
+      fixed: parsedFixed
+    })]);
+  }, []);
+}
+function revertForRtl(columns) {
+  return columns.map(function (column) {
+    var fixed = column.fixed,
+      restProps = _objectWithoutProperties(column, _excluded2);
+
+    // Convert `fixed='left'` to `fixed='right'` instead
+    var parsedFixed = fixed;
+    if (fixed === 'left') {
+      parsedFixed = 'right';
+    } else if (fixed === 'right') {
+      parsedFixed = 'left';
+    }
+    return _objectSpread({
+      fixed: parsedFixed
+    }, restProps);
+  });
+}
+
+/**
+ * Parse `columns` & `children` into `columns`.
+ */
+function useColumns(_ref2, transformColumns) {
+  var prefixCls = _ref2.prefixCls,
+    columns = _ref2.columns,
+    children = _ref2.children,
+    expandable = _ref2.expandable,
+    expandedKeys = _ref2.expandedKeys,
+    columnTitle = _ref2.columnTitle,
+    getRowKey = _ref2.getRowKey,
+    onTriggerExpand = _ref2.onTriggerExpand,
+    expandIcon = _ref2.expandIcon,
+    rowExpandable = _ref2.rowExpandable,
+    expandIconColumnIndex = _ref2.expandIconColumnIndex,
+    _ref2$expandedRowOffs = _ref2.expandedRowOffset,
+    expandedRowOffset = _ref2$expandedRowOffs === void 0 ? 0 : _ref2$expandedRowOffs,
+    direction = _ref2.direction,
+    expandRowByClick = _ref2.expandRowByClick,
+    columnWidth = _ref2.columnWidth,
+    fixed = _ref2.fixed,
+    scrollWidth = _ref2.scrollWidth,
+    clientWidth = _ref2.clientWidth;
+  var baseColumns = React.useMemo(function () {
+    var newColumns = columns || convertChildrenToColumns(children) || [];
+    return filterHiddenColumns(newColumns.slice());
+  }, [columns, children]);
+
+  // ========================== Expand ==========================
+  var withExpandColumns = React.useMemo(function () {
+    if (expandable) {
+      var cloneColumns = baseColumns.slice();
+
+      // >>> Warning if use `expandIconColumnIndex`
+      if (process.env.NODE_ENV !== 'production' && expandIconColumnIndex >= 0) {
+        warning(false, '`expandIconColumnIndex` is deprecated. Please use `Table.EXPAND_COLUMN` in `columns` instead.');
+      }
+
+      // >>> Insert expand column if not exist
+      if (!cloneColumns.includes(EXPAND_COLUMN)) {
+        var expandColIndex = expandIconColumnIndex || 0;
+        var insertIndex = expandColIndex === 0 && fixed === 'right' ? baseColumns.length : expandColIndex;
+        if (insertIndex >= 0) {
+          cloneColumns.splice(insertIndex, 0, EXPAND_COLUMN);
+        }
+      }
+
+      // >>> Deduplicate additional expand column
+      if (process.env.NODE_ENV !== 'production' && cloneColumns.filter(function (c) {
+        return c === EXPAND_COLUMN;
+      }).length > 1) {
+        warning(false, 'There exist more than one `EXPAND_COLUMN` in `columns`.');
+      }
+      var expandColumnIndex = cloneColumns.indexOf(EXPAND_COLUMN);
+      cloneColumns = cloneColumns.filter(function (column, index) {
+        return column !== EXPAND_COLUMN || index === expandColumnIndex;
+      });
+
+      // >>> Check if expand column need to fixed
+      var prevColumn = baseColumns[expandColumnIndex];
+      var fixedColumn;
+      if (fixed) {
+        fixedColumn = fixed;
+      } else {
+        fixedColumn = prevColumn ? prevColumn.fixed : null;
+      }
+
+      // >>> Create expandable column
+      var expandColumn = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, INTERNAL_COL_DEFINE, {
+        className: "".concat(prefixCls, "-expand-icon-col"),
+        columnType: 'EXPAND_COLUMN'
+      }), "title", columnTitle), "fixed", fixedColumn), "className", "".concat(prefixCls, "-row-expand-icon-cell")), "width", columnWidth), "render", function render(_, record, index) {
+        var rowKey = getRowKey(record, index);
+        var expanded = expandedKeys.has(rowKey);
+        var recordExpandable = rowExpandable ? rowExpandable(record) : true;
+        var icon = expandIcon({
+          prefixCls: prefixCls,
+          expanded: expanded,
+          expandable: recordExpandable,
+          record: record,
+          onExpand: onTriggerExpand
+        });
+        if (expandRowByClick) {
+          return /*#__PURE__*/React.createElement("span", {
+            onClick: function onClick(e) {
+              return e.stopPropagation();
+            }
+          }, icon);
+        }
+        return icon;
+      });
+      return cloneColumns.map(function (col, index) {
+        var column = col === EXPAND_COLUMN ? expandColumn : col;
+        if (index < expandedRowOffset) {
+          return _objectSpread(_objectSpread({}, column), {}, {
+            fixed: column.fixed || 'left'
+          });
+        }
+        return column;
+      });
+    }
+    if (process.env.NODE_ENV !== 'production' && baseColumns.includes(EXPAND_COLUMN)) {
+      warning(false, '`expandable` is not config but there exist `EXPAND_COLUMN` in `columns`.');
+    }
+    return baseColumns.filter(function (col) {
+      return col !== EXPAND_COLUMN;
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [expandable, baseColumns, getRowKey, expandedKeys, expandIcon, direction, expandedRowOffset]);
+
+  // ========================= Transform ========================
+  var mergedColumns = React.useMemo(function () {
+    var finalColumns = withExpandColumns;
+    if (transformColumns) {
+      finalColumns = transformColumns(finalColumns);
+    }
+
+    // Always provides at least one column for table display
+    if (!finalColumns.length) {
+      finalColumns = [{
+        render: function render() {
+          return null;
+        }
+      }];
+    }
+    return finalColumns;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [transformColumns, withExpandColumns, direction]);
+
+  // ========================== Flatten =========================
+  var flattenColumns = React.useMemo(function () {
+    if (direction === 'rtl') {
+      return revertForRtl(flatColumns(mergedColumns));
+    }
+    return flatColumns(mergedColumns);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [mergedColumns, direction, scrollWidth]);
+
+  // ========================= Gap Fixed ========================
+  var hasGapFixed = React.useMemo(function () {
+    // Fixed: left, since old browser not support `findLastIndex`, we should use reverse loop
+    var lastLeftIndex = -1;
+    for (var i = flattenColumns.length - 1; i >= 0; i -= 1) {
+      var colFixed = flattenColumns[i].fixed;
+      if (colFixed === 'left' || colFixed === true) {
+        lastLeftIndex = i;
+        break;
+      }
+    }
+    if (lastLeftIndex >= 0) {
+      for (var _i = 0; _i <= lastLeftIndex; _i += 1) {
+        var _colFixed = flattenColumns[_i].fixed;
+        if (_colFixed !== 'left' && _colFixed !== true) {
+          return true;
+        }
+      }
+    }
+
+    // Fixed: right
+    var firstRightIndex = flattenColumns.findIndex(function (_ref3) {
+      var colFixed = _ref3.fixed;
+      return colFixed === 'right';
+    });
+    if (firstRightIndex >= 0) {
+      for (var _i2 = firstRightIndex; _i2 < flattenColumns.length; _i2 += 1) {
+        var _colFixed2 = flattenColumns[_i2].fixed;
+        if (_colFixed2 !== 'right') {
+          return true;
+        }
+      }
+    }
+    return false;
+  }, [flattenColumns]);
+
+  // ========================= FillWidth ========================
+  var _useWidthColumns = useWidthColumns(flattenColumns, scrollWidth, clientWidth),
+    _useWidthColumns2 = _slicedToArray(_useWidthColumns, 2),
+    filledColumns = _useWidthColumns2[0],
+    realScrollWidth = _useWidthColumns2[1];
+  return [mergedColumns, filledColumns, realScrollWidth, hasGapFixed];
+}
+export default useColumns;
--- a/node_modules/rc-table/es/hooks/useColumns/useWidthColumns.d.ts
+++ b/node_modules/rc-table/es/hooks/useColumns/useWidthColumns.d.ts
@@ -0,0 +1,5 @@
+import type { ColumnsType } from '../../interface';
+/**
+ * Fill all column with width
+ */
+export default function useWidthColumns(flattenColumns: ColumnsType<any>, scrollWidth: number, clientWidth: number): [columns: ColumnsType<any>, realScrollWidth: number];
--- a/node_modules/rc-table/es/hooks/useColumns/useWidthColumns.js
+++ b/node_modules/rc-table/es/hooks/useColumns/useWidthColumns.js
@@ -0,0 +1,70 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import * as React from 'react';
+function parseColWidth(totalWidth) {
+  var width = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  if (typeof width === 'number') {
+    return width;
+  }
+  if (width.endsWith('%')) {
+    return totalWidth * parseFloat(width) / 100;
+  }
+  return null;
+}
+
+/**
+ * Fill all column with width
+ */
+export default function useWidthColumns(flattenColumns, scrollWidth, clientWidth) {
+  return React.useMemo(function () {
+    // Fill width if needed
+    if (scrollWidth && scrollWidth > 0) {
+      var totalWidth = 0;
+      var missWidthCount = 0;
+
+      // collect not given width column
+      flattenColumns.forEach(function (col) {
+        var colWidth = parseColWidth(scrollWidth, col.width);
+        if (colWidth) {
+          totalWidth += colWidth;
+        } else {
+          missWidthCount += 1;
+        }
+      });
+
+      // Fill width
+      var maxFitWidth = Math.max(scrollWidth, clientWidth);
+      var restWidth = Math.max(maxFitWidth - totalWidth, missWidthCount);
+      var restCount = missWidthCount;
+      var avgWidth = restWidth / missWidthCount;
+      var realTotal = 0;
+      var filledColumns = flattenColumns.map(function (col) {
+        var clone = _objectSpread({}, col);
+        var colWidth = parseColWidth(scrollWidth, clone.width);
+        if (colWidth) {
+          clone.width = colWidth;
+        } else {
+          var colAvgWidth = Math.floor(avgWidth);
+          clone.width = restCount === 1 ? restWidth : colAvgWidth;
+          restWidth -= colAvgWidth;
+          restCount -= 1;
+        }
+        realTotal += clone.width;
+        return clone;
+      });
+
+      // If realTotal is less than clientWidth,
+      // We need extend column width
+      if (realTotal < maxFitWidth) {
+        var scale = maxFitWidth / realTotal;
+        restWidth = maxFitWidth;
+        filledColumns.forEach(function (col, index) {
+          var colWidth = Math.floor(col.width * scale);
+          col.width = index === filledColumns.length - 1 ? restWidth : colWidth;
+          restWidth -= colWidth;
+        });
+      }
+      return [filledColumns, Math.max(realTotal, maxFitWidth)];
+    }
+    return [flattenColumns, scrollWidth];
+  }, [flattenColumns, scrollWidth, clientWidth]);
+}
--- a/node_modules/rc-table/es/hooks/useExpand.d.ts
+++ b/node_modules/rc-table/es/hooks/useExpand.d.ts
@@ -0,0 +1,10 @@
+import type { ExpandableConfig, ExpandableType, GetRowKey, Key, RenderExpandIcon, TriggerEventHandler } from '../interface';
+import type { TableProps } from '../Table';
+export default function useExpand<RecordType>(props: TableProps<RecordType>, mergedData: readonly RecordType[], getRowKey: GetRowKey<RecordType>): [
+    expandableConfig: ExpandableConfig<RecordType>,
+    expandableType: ExpandableType,
+    expandedKeys: Set<Key>,
+    expandIcon: RenderExpandIcon<RecordType>,
+    childrenColumnName: string,
+    onTriggerExpand: TriggerEventHandler<RecordType>
+];
--- a/node_modules/rc-table/es/hooks/useExpand.js
+++ b/node_modules/rc-table/es/hooks/useExpand.js
@@ -0,0 +1,83 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import warning from "rc-util/es/warning";
+import * as React from 'react';
+import { INTERNAL_HOOKS } from "../constant";
+import { findAllChildrenKeys, renderExpandIcon } from "../utils/expandUtil";
+import { getExpandableProps } from "../utils/legacyUtil";
+export default function useExpand(props, mergedData, getRowKey) {
+  var expandableConfig = getExpandableProps(props);
+  var expandIcon = expandableConfig.expandIcon,
+    expandedRowKeys = expandableConfig.expandedRowKeys,
+    defaultExpandedRowKeys = expandableConfig.defaultExpandedRowKeys,
+    defaultExpandAllRows = expandableConfig.defaultExpandAllRows,
+    expandedRowRender = expandableConfig.expandedRowRender,
+    onExpand = expandableConfig.onExpand,
+    onExpandedRowsChange = expandableConfig.onExpandedRowsChange,
+    childrenColumnName = expandableConfig.childrenColumnName;
+  var mergedExpandIcon = expandIcon || renderExpandIcon;
+  var mergedChildrenColumnName = childrenColumnName || 'children';
+  var expandableType = React.useMemo(function () {
+    if (expandedRowRender) {
+      return 'row';
+    }
+    /* eslint-disable no-underscore-dangle */
+    /**
+     * Fix https://github.com/ant-design/ant-design/issues/21154
+     * This is a workaround to not to break current behavior.
+     * We can remove follow code after final release.
+     *
+     * To other developer:
+     *  Do not use `__PARENT_RENDER_ICON__` in prod since we will remove this when refactor
+     */
+    if (props.expandable && props.internalHooks === INTERNAL_HOOKS && props.expandable.__PARENT_RENDER_ICON__ || mergedData.some(function (record) {
+      return record && _typeof(record) === 'object' && record[mergedChildrenColumnName];
+    })) {
+      return 'nest';
+    }
+    /* eslint-enable */
+    return false;
+  }, [!!expandedRowRender, mergedData]);
+  var _React$useState = React.useState(function () {
+      if (defaultExpandedRowKeys) {
+        return defaultExpandedRowKeys;
+      }
+      if (defaultExpandAllRows) {
+        return findAllChildrenKeys(mergedData, getRowKey, mergedChildrenColumnName);
+      }
+      return [];
+    }),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    innerExpandedKeys = _React$useState2[0],
+    setInnerExpandedKeys = _React$useState2[1];
+  var mergedExpandedKeys = React.useMemo(function () {
+    return new Set(expandedRowKeys || innerExpandedKeys || []);
+  }, [expandedRowKeys, innerExpandedKeys]);
+  var onTriggerExpand = React.useCallback(function (record) {
+    var key = getRowKey(record, mergedData.indexOf(record));
+    var newExpandedKeys;
+    var hasKey = mergedExpandedKeys.has(key);
+    if (hasKey) {
+      mergedExpandedKeys.delete(key);
+      newExpandedKeys = _toConsumableArray(mergedExpandedKeys);
+    } else {
+      newExpandedKeys = [].concat(_toConsumableArray(mergedExpandedKeys), [key]);
+    }
+    setInnerExpandedKeys(newExpandedKeys);
+    if (onExpand) {
+      onExpand(!hasKey, record);
+    }
+    if (onExpandedRowsChange) {
+      onExpandedRowsChange(newExpandedKeys);
+    }
+  }, [getRowKey, mergedExpandedKeys, mergedData, onExpand, onExpandedRowsChange]);
+
+  // Warning if use `expandedRowRender` and nest children in the same time
+  if (process.env.NODE_ENV !== 'production' && expandedRowRender && mergedData.some(function (record) {
+    return Array.isArray(record === null || record === void 0 ? void 0 : record[mergedChildrenColumnName]);
+  })) {
+    warning(false, '`expandedRowRender` should not use with nested Table');
+  }
+  return [expandableConfig, expandableType, mergedExpandedKeys, mergedExpandIcon, mergedChildrenColumnName, onTriggerExpand];
+}
--- a/node_modules/rc-table/es/hooks/useFixedInfo.d.ts
+++ b/node_modules/rc-table/es/hooks/useFixedInfo.d.ts
@@ -0,0 +1,2 @@
+import type { ColumnType, Direction, StickyOffsets } from '../interface';
+export default function useFixedInfo<RecordType>(flattenColumns: readonly ColumnType<RecordType>[], stickyOffsets: StickyOffsets, direction: Direction): import("../utils/fixUtil").FixedInfo[];
--- a/node_modules/rc-table/es/hooks/useFixedInfo.js
+++ b/node_modules/rc-table/es/hooks/useFixedInfo.js
@@ -0,0 +1,13 @@
+import useMemo from "rc-util/es/hooks/useMemo";
+import isEqual from "rc-util/es/isEqual";
+import { getCellFixedInfo } from "../utils/fixUtil";
+export default function useFixedInfo(flattenColumns, stickyOffsets, direction) {
+  var fixedInfoList = flattenColumns.map(function (_, colIndex) {
+    return getCellFixedInfo(colIndex, colIndex, flattenColumns, stickyOffsets, direction);
+  });
+  return useMemo(function () {
+    return fixedInfoList;
+  }, [fixedInfoList], function (prev, next) {
+    return !isEqual(prev, next);
+  });
+}
--- a/node_modules/rc-table/es/hooks/useFlattenRecords.d.ts
+++ b/node_modules/rc-table/es/hooks/useFlattenRecords.d.ts
@@ -0,0 +1,19 @@
+import type { GetRowKey, Key } from '../interface';
+export interface FlattenData<RecordType> {
+    record: RecordType;
+    indent: number;
+    index: number;
+    rowKey: Key;
+}
+/**
+ * flat tree data on expanded state
+ *
+ * @export
+ * @template T
+ * @param {*} data : table data
+ * @param {string} childrenColumnName : 指定树形结构的列名
+ * @param {Set<Key>} expandedKeys : 展开的行对应的keys
+ * @param {GetRowKey<T>} getRowKey  : 获取当前rowKey的方法
+ * @returns flattened data
+ */
+export default function useFlattenRecords<T>(data: T[] | readonly T[], childrenColumnName: string, expandedKeys: Set<Key>, getRowKey: GetRowKey<T>): FlattenData<T>[];
--- a/node_modules/rc-table/es/hooks/useFlattenRecords.js
+++ b/node_modules/rc-table/es/hooks/useFlattenRecords.js
@@ -0,0 +1,54 @@
+import * as React from 'react';
+// recursion (flat tree structure)
+function fillRecords(list, record, indent, childrenColumnName, expandedKeys, getRowKey, index) {
+  var key = getRowKey(record, index);
+  list.push({
+    record: record,
+    indent: indent,
+    index: index,
+    rowKey: key
+  });
+  var expanded = expandedKeys === null || expandedKeys === void 0 ? void 0 : expandedKeys.has(key);
+  if (record && Array.isArray(record[childrenColumnName]) && expanded) {
+    // expanded state, flat record
+    for (var i = 0; i < record[childrenColumnName].length; i += 1) {
+      fillRecords(list, record[childrenColumnName][i], indent + 1, childrenColumnName, expandedKeys, getRowKey, i);
+    }
+  }
+}
+/**
+ * flat tree data on expanded state
+ *
+ * @export
+ * @template T
+ * @param {*} data : table data
+ * @param {string} childrenColumnName : 指定树形结构的列名
+ * @param {Set<Key>} expandedKeys : 展开的行对应的keys
+ * @param {GetRowKey<T>} getRowKey  : 获取当前rowKey的方法
+ * @returns flattened data
+ */
+export default function useFlattenRecords(data, childrenColumnName, expandedKeys, getRowKey) {
+  var arr = React.useMemo(function () {
+    if (expandedKeys !== null && expandedKeys !== void 0 && expandedKeys.size) {
+      var list = [];
+
+      // collect flattened record
+      for (var i = 0; i < (data === null || data === void 0 ? void 0 : data.length); i += 1) {
+        var record = data[i];
+
+        // using array.push or spread operator may cause "Maximum call stack size exceeded" exception if array size is big enough.
+        fillRecords(list, record, 0, childrenColumnName, expandedKeys, getRowKey, i);
+      }
+      return list;
+    }
+    return data === null || data === void 0 ? void 0 : data.map(function (item, index) {
+      return {
+        record: item,
+        indent: 0,
+        index: index,
+        rowKey: getRowKey(item, index)
+      };
+    });
+  }, [data, childrenColumnName, expandedKeys, getRowKey]);
+  return arr;
+}
--- a/node_modules/rc-table/es/hooks/useFrame.d.ts
+++ b/node_modules/rc-table/es/hooks/useFrame.d.ts
@@ -0,0 +1,7 @@
+export type Updater<State> = (prev: State) => State;
+/**
+ * Execute code before next frame but async
+ */
+export declare function useLayoutState<State>(defaultState: State): [State, (updater: Updater<State>) => void];
+/** Lock frame, when frame pass reset the lock. */
+export declare function useTimeoutLock<State>(defaultState?: State): [(state: State) => void, () => State | null];
--- a/node_modules/rc-table/es/hooks/useFrame.js
+++ b/node_modules/rc-table/es/hooks/useFrame.js
@@ -0,0 +1,62 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useRef, useState, useEffect } from 'react';
+/**
+ * Execute code before next frame but async
+ */
+export function useLayoutState(defaultState) {
+  var stateRef = useRef(defaultState);
+  var _useState = useState({}),
+    _useState2 = _slicedToArray(_useState, 2),
+    forceUpdate = _useState2[1];
+  var lastPromiseRef = useRef(null);
+  var updateBatchRef = useRef([]);
+  function setFrameState(updater) {
+    updateBatchRef.current.push(updater);
+    var promise = Promise.resolve();
+    lastPromiseRef.current = promise;
+    promise.then(function () {
+      if (lastPromiseRef.current === promise) {
+        var prevBatch = updateBatchRef.current;
+        var prevState = stateRef.current;
+        updateBatchRef.current = [];
+        prevBatch.forEach(function (batchUpdater) {
+          stateRef.current = batchUpdater(stateRef.current);
+        });
+        lastPromiseRef.current = null;
+        if (prevState !== stateRef.current) {
+          forceUpdate({});
+        }
+      }
+    });
+  }
+  useEffect(function () {
+    return function () {
+      lastPromiseRef.current = null;
+    };
+  }, []);
+  return [stateRef.current, setFrameState];
+}
+
+/** Lock frame, when frame pass reset the lock. */
+export function useTimeoutLock(defaultState) {
+  var frameRef = useRef(defaultState || null);
+  var timeoutRef = useRef();
+  function cleanUp() {
+    window.clearTimeout(timeoutRef.current);
+  }
+  function setState(newState) {
+    frameRef.current = newState;
+    cleanUp();
+    timeoutRef.current = window.setTimeout(function () {
+      frameRef.current = null;
+      timeoutRef.current = undefined;
+    }, 100);
+  }
+  function getState() {
+    return frameRef.current;
+  }
+  useEffect(function () {
+    return cleanUp;
+  }, []);
+  return [setState, getState];
+}
--- a/node_modules/rc-table/es/hooks/useHover.d.ts
+++ b/node_modules/rc-table/es/hooks/useHover.d.ts
@@ -0,0 +1,2 @@
+export type OnHover = (start: number, end: number) => void;
+export default function useHover(): [startRow: number, endRow: number, onHover: OnHover];
--- a/node_modules/rc-table/es/hooks/useHover.js
+++ b/node_modules/rc-table/es/hooks/useHover.js
@@ -0,0 +1,17 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+export default function useHover() {
+  var _React$useState = React.useState(-1),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    startRow = _React$useState2[0],
+    setStartRow = _React$useState2[1];
+  var _React$useState3 = React.useState(-1),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    endRow = _React$useState4[0],
+    setEndRow = _React$useState4[1];
+  var onHover = React.useCallback(function (start, end) {
+    setStartRow(start);
+    setEndRow(end);
+  }, []);
+  return [startRow, endRow, onHover];
+}
--- a/node_modules/rc-table/es/hooks/useRenderTimes.d.ts
+++ b/node_modules/rc-table/es/hooks/useRenderTimes.d.ts
@@ -0,0 +1,5 @@
+import * as React from 'react';
+declare function useRenderTimes<T extends object>(props?: T, debug?: string): number;
+declare const _default: typeof useRenderTimes | (() => void);
+export default _default;
+export declare const RenderBlock: React.MemoExoticComponent<() => React.JSX.Element>;
--- a/node_modules/rc-table/es/hooks/useRenderTimes.js
+++ b/node_modules/rc-table/es/hooks/useRenderTimes.js
@@ -0,0 +1,38 @@
+/* istanbul ignore file */
+import * as React from 'react';
+function useRenderTimes(props, debug) {
+  // Render times
+  var timesRef = React.useRef(0);
+  timesRef.current += 1;
+
+  // Props changed
+  var propsRef = React.useRef(props);
+  var keys = [];
+  Object.keys(props || {}).map(function (key) {
+    var _propsRef$current;
+    if ((props === null || props === void 0 ? void 0 : props[key]) !== ((_propsRef$current = propsRef.current) === null || _propsRef$current === void 0 ? void 0 : _propsRef$current[key])) {
+      keys.push(key);
+    }
+  });
+  propsRef.current = props;
+
+  // Cache keys since React rerender may cause it lost
+  var keysRef = React.useRef([]);
+  if (keys.length) {
+    keysRef.current = keys;
+  }
+  React.useDebugValue(timesRef.current);
+  React.useDebugValue(keysRef.current.join(', '));
+  if (debug) {
+    console.log("".concat(debug, ":"), timesRef.current, keysRef.current);
+  }
+  return timesRef.current;
+}
+export default process.env.NODE_ENV !== 'production' ? useRenderTimes : function () {};
+export var RenderBlock = /*#__PURE__*/React.memo(function () {
+  var times = useRenderTimes();
+  return /*#__PURE__*/React.createElement("h1", null, "Render Times: ", times);
+});
+if (process.env.NODE_ENV !== 'production') {
+  RenderBlock.displayName = 'RenderBlock';
+}
--- a/node_modules/rc-table/es/hooks/useRowInfo.d.ts
+++ b/node_modules/rc-table/es/hooks/useRowInfo.d.ts
@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { TableContextProps } from '../context/TableContext';
+export default function useRowInfo<RecordType>(record: RecordType, rowKey: React.Key, recordIndex: number, indent: number): Pick<TableContextProps, 'prefixCls' | 'fixedInfoList' | 'flattenColumns' | 'expandableType' | 'expandRowByClick' | 'onTriggerExpand' | 'rowClassName' | 'expandedRowClassName' | 'indentSize' | 'expandIcon' | 'expandedRowRender' | 'expandIconColumnIndex' | 'expandedKeys' | 'childrenColumnName' | 'onRow'> & {
+    columnsKey: React.Key[];
+    nestExpandable: boolean;
+    expanded: boolean;
+    hasNestChildren: boolean;
+    record: RecordType;
+    rowSupportExpand: boolean;
+    expandable: boolean;
+    rowProps: React.HTMLAttributes<any> & React.TdHTMLAttributes<any>;
+};
--- a/node_modules/rc-table/es/hooks/useRowInfo.js
+++ b/node_modules/rc-table/es/hooks/useRowInfo.js
@@ -0,0 +1,65 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { useContext } from '@rc-component/context';
+import TableContext from "../context/TableContext";
+import { getColumnsKey } from "../utils/valueUtil";
+import { useEvent } from 'rc-util';
+import classNames from 'classnames';
+export default function useRowInfo(record, rowKey, recordIndex, indent) {
+  var context = useContext(TableContext, ['prefixCls', 'fixedInfoList', 'flattenColumns', 'expandableType', 'expandRowByClick', 'onTriggerExpand', 'rowClassName', 'expandedRowClassName', 'indentSize', 'expandIcon', 'expandedRowRender', 'expandIconColumnIndex', 'expandedKeys', 'childrenColumnName', 'rowExpandable', 'onRow']);
+  var flattenColumns = context.flattenColumns,
+    expandableType = context.expandableType,
+    expandedKeys = context.expandedKeys,
+    childrenColumnName = context.childrenColumnName,
+    onTriggerExpand = context.onTriggerExpand,
+    rowExpandable = context.rowExpandable,
+    onRow = context.onRow,
+    expandRowByClick = context.expandRowByClick,
+    rowClassName = context.rowClassName;
+
+  // ======================= Expandable =======================
+  // Only when row is not expandable and `children` exist in record
+  var nestExpandable = expandableType === 'nest';
+  var rowSupportExpand = expandableType === 'row' && (!rowExpandable || rowExpandable(record));
+  var mergedExpandable = rowSupportExpand || nestExpandable;
+  var expanded = expandedKeys && expandedKeys.has(rowKey);
+  var hasNestChildren = childrenColumnName && record && record[childrenColumnName];
+  var onInternalTriggerExpand = useEvent(onTriggerExpand);
+
+  // ========================= onRow ==========================
+  var rowProps = onRow === null || onRow === void 0 ? void 0 : onRow(record, recordIndex);
+  var onRowClick = rowProps === null || rowProps === void 0 ? void 0 : rowProps.onClick;
+  var onClick = function onClick(event) {
+    if (expandRowByClick && mergedExpandable) {
+      onTriggerExpand(record, event);
+    }
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    onRowClick === null || onRowClick === void 0 || onRowClick.apply(void 0, [event].concat(args));
+  };
+
+  // ====================== RowClassName ======================
+  var computeRowClassName;
+  if (typeof rowClassName === 'string') {
+    computeRowClassName = rowClassName;
+  } else if (typeof rowClassName === 'function') {
+    computeRowClassName = rowClassName(record, recordIndex, indent);
+  }
+
+  // ========================= Column =========================
+  var columnsKey = getColumnsKey(flattenColumns);
+  return _objectSpread(_objectSpread({}, context), {}, {
+    columnsKey: columnsKey,
+    nestExpandable: nestExpandable,
+    expanded: expanded,
+    hasNestChildren: hasNestChildren,
+    record: record,
+    onTriggerExpand: onInternalTriggerExpand,
+    rowSupportExpand: rowSupportExpand,
+    expandable: mergedExpandable,
+    rowProps: _objectSpread(_objectSpread({}, rowProps), {}, {
+      className: classNames(computeRowClassName, rowProps === null || rowProps === void 0 ? void 0 : rowProps.className),
+      onClick: onClick
+    })
+  });
+}
--- a/node_modules/rc-table/es/hooks/useSticky.d.ts
+++ b/node_modules/rc-table/es/hooks/useSticky.d.ts
@@ -0,0 +1,10 @@
+import type { TableSticky } from '../interface';
+/** Sticky header hooks */
+export default function useSticky(sticky: boolean | TableSticky, prefixCls: string): {
+    isSticky: boolean;
+    offsetHeader: number;
+    offsetSummary: number;
+    offsetScroll: number;
+    stickyClassName: string;
+    container: Window | HTMLElement;
+};
--- a/node_modules/rc-table/es/hooks/useSticky.js
+++ b/node_modules/rc-table/es/hooks/useSticky.js
@@ -0,0 +1,32 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import * as React from 'react';
+import canUseDom from "rc-util/es/Dom/canUseDom";
+// fix ssr render
+var defaultContainer = canUseDom() ? window : null;
+
+/** Sticky header hooks */
+export default function useSticky(sticky, prefixCls) {
+  var _ref = _typeof(sticky) === 'object' ? sticky : {},
+    _ref$offsetHeader = _ref.offsetHeader,
+    offsetHeader = _ref$offsetHeader === void 0 ? 0 : _ref$offsetHeader,
+    _ref$offsetSummary = _ref.offsetSummary,
+    offsetSummary = _ref$offsetSummary === void 0 ? 0 : _ref$offsetSummary,
+    _ref$offsetScroll = _ref.offsetScroll,
+    offsetScroll = _ref$offsetScroll === void 0 ? 0 : _ref$offsetScroll,
+    _ref$getContainer = _ref.getContainer,
+    getContainer = _ref$getContainer === void 0 ? function () {
+      return defaultContainer;
+    } : _ref$getContainer;
+  var container = getContainer() || defaultContainer;
+  var isSticky = !!sticky;
+  return React.useMemo(function () {
+    return {
+      isSticky: isSticky,
+      stickyClassName: isSticky ? "".concat(prefixCls, "-sticky-holder") : '',
+      offsetHeader: offsetHeader,
+      offsetSummary: offsetSummary,
+      offsetScroll: offsetScroll,
+      container: container
+    };
+  }, [isSticky, offsetScroll, offsetHeader, offsetSummary, prefixCls, container]);
+}
--- a/node_modules/rc-table/es/hooks/useStickyOffsets.d.ts
+++ b/node_modules/rc-table/es/hooks/useStickyOffsets.d.ts
@@ -0,0 +1,6 @@
+import type { ColumnType, Direction, StickyOffsets } from '../interface';
+/**
+ * Get sticky column offset width
+ */
+declare function useStickyOffsets<RecordType>(colWidths: number[], flattenColumns: readonly ColumnType<RecordType>[], direction: Direction): StickyOffsets;
+export default useStickyOffsets;
--- a/node_modules/rc-table/es/hooks/useStickyOffsets.js
+++ b/node_modules/rc-table/es/hooks/useStickyOffsets.js
@@ -0,0 +1,31 @@
+import { useMemo } from 'react';
+/**
+ * Get sticky column offset width
+ */
+function useStickyOffsets(colWidths, flattenColumns, direction) {
+  var stickyOffsets = useMemo(function () {
+    var columnCount = flattenColumns.length;
+    var getOffsets = function getOffsets(startIndex, endIndex, offset) {
+      var offsets = [];
+      var total = 0;
+      for (var i = startIndex; i !== endIndex; i += offset) {
+        offsets.push(total);
+        if (flattenColumns[i].fixed) {
+          total += colWidths[i] || 0;
+        }
+      }
+      return offsets;
+    };
+    var startOffsets = getOffsets(0, columnCount, 1);
+    var endOffsets = getOffsets(columnCount - 1, -1, -1).reverse();
+    return direction === 'rtl' ? {
+      left: endOffsets,
+      right: startOffsets
+    } : {
+      left: startOffsets,
+      right: endOffsets
+    };
+  }, [colWidths, flattenColumns, direction]);
+  return stickyOffsets;
+}
+export default useStickyOffsets;
--- a/node_modules/rc-table/es/index.d.ts
+++ b/node_modules/rc-table/es/index.d.ts
@@ -0,0 +1,12 @@
+import { EXPAND_COLUMN, INTERNAL_HOOKS } from './constant';
+import { FooterComponents as Summary } from './Footer';
+import type { ColumnType, ColumnsType, Reference } from './interface';
+import Column from './sugar/Column';
+import ColumnGroup from './sugar/ColumnGroup';
+import type { TableProps } from './Table';
+import Table, { genTable } from './Table';
+import { INTERNAL_COL_DEFINE } from './utils/legacyUtil';
+import type { VirtualTableProps } from './VirtualTable';
+import VirtualTable, { genVirtualTable } from './VirtualTable';
+export { genTable, Summary, Column, ColumnGroup, type TableProps, INTERNAL_COL_DEFINE, EXPAND_COLUMN, INTERNAL_HOOKS, VirtualTable, genVirtualTable, type VirtualTableProps, type Reference, type ColumnType, type ColumnsType, };
+export default Table;
--- a/node_modules/rc-table/es/index.js
+++ b/node_modules/rc-table/es/index.js
@@ -0,0 +1,9 @@
+import { EXPAND_COLUMN, INTERNAL_HOOKS } from "./constant";
+import { FooterComponents as Summary } from "./Footer";
+import Column from "./sugar/Column";
+import ColumnGroup from "./sugar/ColumnGroup";
+import Table, { genTable } from "./Table";
+import { INTERNAL_COL_DEFINE } from "./utils/legacyUtil";
+import VirtualTable, { genVirtualTable } from "./VirtualTable";
+export { genTable, Summary, Column, ColumnGroup, INTERNAL_COL_DEFINE, EXPAND_COLUMN, INTERNAL_HOOKS, VirtualTable, genVirtualTable };
+export default Table;
--- a/node_modules/rc-table/es/interface.d.ts
+++ b/node_modules/rc-table/es/interface.d.ts
@@ -0,0 +1,189 @@
+import type * as React from 'react';
+import type { DeepNamePath } from './namePathType';
+/**
+ * ColumnType which applied in antd: https://ant.design/components/table-cn/#Column
+ * - defaultSortOrder
+ * - filterDropdown
+ * - filterDropdownVisible
+ * - filtered
+ * - filteredValue
+ * - filterIcon
+ * - filterMultiple
+ * - filters
+ * - sorter
+ * - sortOrder
+ * - sortDirections
+ * - onFilter
+ * - onFilterDropdownVisibleChange
+ */
+export type Key = React.Key;
+export type FixedType = 'left' | 'right' | boolean;
+export type DefaultRecordType = Record<string, any>;
+export type TableLayout = 'auto' | 'fixed';
+export type ScrollConfig = {
+    index?: number;
+    key?: Key;
+    top?: number;
+};
+export type Reference = {
+    nativeElement: HTMLDivElement;
+    scrollTo: (config: ScrollConfig) => void;
+};
+export type RowClassName<RecordType> = (record: RecordType, index: number, indent: number) => string;
+export interface CellType<RecordType> {
+    key?: Key;
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+    column?: ColumnsType<RecordType>[number];
+    colSpan?: number;
+    rowSpan?: number;
+    /** Only used for table header */
+    hasSubColumns?: boolean;
+    colStart?: number;
+    colEnd?: number;
+}
+export interface RenderedCell<RecordType> {
+    props?: CellType<RecordType>;
+    children?: React.ReactNode;
+}
+export type Direction = 'ltr' | 'rtl';
+export type SpecialString<T> = T | (string & NonNullable<unknown>);
+export type DataIndex<T = any> = DeepNamePath<T> | SpecialString<T> | number | (SpecialString<T> | number)[];
+export type CellEllipsisType = {
+    showTitle?: boolean;
+} | boolean;
+export type ColScopeType = 'col' | 'colgroup';
+export type RowScopeType = 'row' | 'rowgroup';
+export type ScopeType = ColScopeType | RowScopeType;
+interface ColumnSharedType<RecordType> {
+    title?: React.ReactNode;
+    key?: Key;
+    className?: string;
+    hidden?: boolean;
+    fixed?: FixedType;
+    onHeaderCell?: GetComponentProps<ColumnsType<RecordType>[number]>;
+    ellipsis?: CellEllipsisType;
+    align?: AlignType;
+    rowScope?: RowScopeType;
+}
+export interface ColumnGroupType<RecordType> extends ColumnSharedType<RecordType> {
+    children: ColumnsType<RecordType>;
+}
+export type AlignType = 'start' | 'end' | 'left' | 'right' | 'center' | 'justify' | 'match-parent';
+export interface ColumnType<RecordType> extends ColumnSharedType<RecordType> {
+    colSpan?: number;
+    dataIndex?: DataIndex<RecordType>;
+    render?: (value: any, record: RecordType, index: number) => React.ReactNode | RenderedCell<RecordType>;
+    shouldCellUpdate?: (record: RecordType, prevRecord: RecordType) => boolean;
+    rowSpan?: number;
+    width?: number | string;
+    minWidth?: number;
+    onCell?: GetComponentProps<RecordType>;
+    /** @deprecated Please use `onCell` instead */
+    onCellClick?: (record: RecordType, e: React.MouseEvent<HTMLElement>) => void;
+}
+export type ColumnsType<RecordType = unknown> = readonly (ColumnGroupType<RecordType> | ColumnType<RecordType>)[];
+export type GetRowKey<RecordType> = (record: RecordType, index?: number) => Key;
+export interface StickyOffsets {
+    left: readonly number[];
+    right: readonly number[];
+    isSticky?: boolean;
+}
+export type GetComponentProps<DataType> = (data: DataType, index?: number) => React.HTMLAttributes<any> & React.TdHTMLAttributes<any>;
+type Component<P> = React.ComponentType<P> | React.ForwardRefExoticComponent<P> | React.FC<P> | keyof React.JSX.IntrinsicElements;
+export type CustomizeComponent = Component<any>;
+export type OnCustomizeScroll = (info: {
+    currentTarget?: HTMLElement;
+    scrollLeft?: number;
+}) => void;
+export type CustomizeScrollBody<RecordType> = (data: readonly RecordType[], info: {
+    scrollbarSize: number;
+    ref: React.Ref<{
+        scrollLeft: number;
+        scrollTo?: (scrollConfig: ScrollConfig) => void;
+    }>;
+    onScroll: OnCustomizeScroll;
+}) => React.ReactNode;
+export interface TableComponents<RecordType> {
+    table?: CustomizeComponent;
+    header?: {
+        table?: CustomizeComponent;
+        wrapper?: CustomizeComponent;
+        row?: CustomizeComponent;
+        cell?: CustomizeComponent;
+    };
+    body?: CustomizeScrollBody<RecordType> | {
+        wrapper?: CustomizeComponent;
+        row?: CustomizeComponent;
+        cell?: CustomizeComponent;
+    };
+}
+export type GetComponent = (path: readonly string[], defaultComponent?: CustomizeComponent) => CustomizeComponent;
+export type ExpandableType = false | 'row' | 'nest';
+export interface LegacyExpandableProps<RecordType> {
+    /** @deprecated Use `expandable.expandedRowKeys` instead */
+    expandedRowKeys?: Key[];
+    /** @deprecated Use `expandable.defaultExpandedRowKeys` instead */
+    defaultExpandedRowKeys?: Key[];
+    /** @deprecated Use `expandable.expandedRowRender` instead */
+    expandedRowRender?: ExpandedRowRender<RecordType>;
+    /** @deprecated Use `expandable.expandRowByClick` instead */
+    expandRowByClick?: boolean;
+    /** @deprecated Use `expandable.expandIcon` instead */
+    expandIcon?: RenderExpandIcon<RecordType>;
+    /** @deprecated Use `expandable.onExpand` instead */
+    onExpand?: (expanded: boolean, record: RecordType) => void;
+    /** @deprecated Use `expandable.onExpandedRowsChange` instead */
+    onExpandedRowsChange?: (expandedKeys: Key[]) => void;
+    /** @deprecated Use `expandable.defaultExpandAllRows` instead */
+    defaultExpandAllRows?: boolean;
+    /** @deprecated Use `expandable.indentSize` instead */
+    indentSize?: number;
+    /** @deprecated Use `expandable.expandIconColumnIndex` instead */
+    expandIconColumnIndex?: number;
+    /** @deprecated Use `expandable.expandedRowClassName` instead */
+    expandedRowClassName?: RowClassName<RecordType>;
+    /** @deprecated Use `expandable.childrenColumnName` instead */
+    childrenColumnName?: string;
+    title?: PanelRender<RecordType>;
+}
+export type ExpandedRowRender<ValueType> = (record: ValueType, index: number, indent: number, expanded: boolean) => React.ReactNode;
+export interface RenderExpandIconProps<RecordType> {
+    prefixCls: string;
+    expanded: boolean;
+    record: RecordType;
+    expandable: boolean;
+    onExpand: TriggerEventHandler<RecordType>;
+}
+export type RenderExpandIcon<RecordType> = (props: RenderExpandIconProps<RecordType>) => React.ReactNode;
+export interface ExpandableConfig<RecordType> {
+    expandedRowKeys?: readonly Key[];
+    defaultExpandedRowKeys?: readonly Key[];
+    expandedRowRender?: ExpandedRowRender<RecordType>;
+    columnTitle?: React.ReactNode;
+    expandRowByClick?: boolean;
+    expandIcon?: RenderExpandIcon<RecordType>;
+    onExpand?: (expanded: boolean, record: RecordType) => void;
+    onExpandedRowsChange?: (expandedKeys: readonly Key[]) => void;
+    defaultExpandAllRows?: boolean;
+    indentSize?: number;
+    /** @deprecated Please use `EXPAND_COLUMN` in `columns` directly */
+    expandIconColumnIndex?: number;
+    showExpandColumn?: boolean;
+    expandedRowClassName?: string | RowClassName<RecordType>;
+    childrenColumnName?: string;
+    rowExpandable?: (record: RecordType) => boolean;
+    columnWidth?: number | string;
+    fixed?: FixedType;
+    expandedRowOffset?: number;
+}
+export type PanelRender<RecordType> = (data: readonly RecordType[]) => React.ReactNode;
+export type TriggerEventHandler<RecordType> = (record: RecordType, event: React.MouseEvent<HTMLElement>) => void;
+export interface TableSticky {
+    offsetHeader?: number;
+    offsetSummary?: number;
+    offsetScroll?: number;
+    getContainer?: () => Window | HTMLElement;
+}
+export {};
--- a/node_modules/rc-table/es/interface.js
+++ b/node_modules/rc-table/es/interface.js
@@ -0,0 +1 @@
+export {};
--- a/node_modules/rc-table/es/namePathType.d.ts
+++ b/node_modules/rc-table/es/namePathType.d.ts
@@ -0,0 +1,13 @@
+type BaseNamePath = string | number | boolean | (string | number | boolean)[];
+/**
+ * Store: The store type from `FormInstance<Store>`
+ * ParentNamePath: Auto generate by nest logic. Do not fill manually.
+ */
+export type DeepNamePath<Store = any, ParentNamePath extends any[] = []> = ParentNamePath['length'] extends 3 ? never : true extends (Store extends BaseNamePath ? true : false) ? ParentNamePath['length'] extends 0 ? Store | BaseNamePath : Store extends any[] ? [...ParentNamePath, number] : never : Store extends any[] ? // Connect path. e.g. { a: { b: string }[] }
+[
+    ...ParentNamePath,
+    number
+] | DeepNamePath<Store[number], [...ParentNamePath, number]> : keyof Store extends never ? Store : {
+    [FieldKey in keyof Store]: Store[FieldKey] extends Function ? never : (ParentNamePath['length'] extends 0 ? FieldKey : never) | [...ParentNamePath, FieldKey] | DeepNamePath<Required<Store>[FieldKey], [...ParentNamePath, FieldKey]>;
+}[keyof Store];
+export {};
--- a/node_modules/rc-table/es/namePathType.js
+++ b/node_modules/rc-table/es/namePathType.js
@@ -0,0 +1 @@
+export {};
--- a/node_modules/rc-table/es/stickyScrollBar.d.ts
+++ b/node_modules/rc-table/es/stickyScrollBar.d.ts
@@ -0,0 +1,12 @@
+import * as React from 'react';
+interface StickyScrollBarProps {
+    scrollBodyRef: React.RefObject<HTMLDivElement>;
+    onScroll: (params: {
+        scrollLeft?: number;
+    }) => void;
+    offsetScroll: number;
+    container: HTMLElement | Window;
+    direction: string;
+}
+declare const _default: React.ForwardRefExoticComponent<StickyScrollBarProps & React.RefAttributes<unknown>>;
+export default _default;
--- a/node_modules/rc-table/es/stickyScrollBar.js
+++ b/node_modules/rc-table/es/stickyScrollBar.js
@@ -0,0 +1,178 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useContext } from '@rc-component/context';
+import classNames from 'classnames';
+import addEventListener from "rc-util/es/Dom/addEventListener";
+import getScrollBarSize from "rc-util/es/getScrollBarSize";
+import * as React from 'react';
+import TableContext from "./context/TableContext";
+import { useLayoutState } from "./hooks/useFrame";
+import raf from "rc-util/es/raf";
+import { getOffset } from "./utils/offsetUtil";
+import { getDOM } from "rc-util/es/Dom/findDOMNode";
+var StickyScrollBar = function StickyScrollBar(_ref, ref) {
+  var _scrollBodyRef$curren, _scrollBodyRef$curren2;
+  var scrollBodyRef = _ref.scrollBodyRef,
+    onScroll = _ref.onScroll,
+    offsetScroll = _ref.offsetScroll,
+    container = _ref.container,
+    direction = _ref.direction;
+  var prefixCls = useContext(TableContext, 'prefixCls');
+  var bodyScrollWidth = ((_scrollBodyRef$curren = scrollBodyRef.current) === null || _scrollBodyRef$curren === void 0 ? void 0 : _scrollBodyRef$curren.scrollWidth) || 0;
+  var bodyWidth = ((_scrollBodyRef$curren2 = scrollBodyRef.current) === null || _scrollBodyRef$curren2 === void 0 ? void 0 : _scrollBodyRef$curren2.clientWidth) || 0;
+  var scrollBarWidth = bodyScrollWidth && bodyWidth * (bodyWidth / bodyScrollWidth);
+  var scrollBarRef = React.useRef();
+  var _useLayoutState = useLayoutState({
+      scrollLeft: 0,
+      isHiddenScrollBar: true
+    }),
+    _useLayoutState2 = _slicedToArray(_useLayoutState, 2),
+    scrollState = _useLayoutState2[0],
+    setScrollState = _useLayoutState2[1];
+  var refState = React.useRef({
+    delta: 0,
+    x: 0
+  });
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    isActive = _React$useState2[0],
+    setActive = _React$useState2[1];
+  var rafRef = React.useRef(null);
+  React.useEffect(function () {
+    return function () {
+      raf.cancel(rafRef.current);
+    };
+  }, []);
+  var onMouseUp = function onMouseUp() {
+    setActive(false);
+  };
+  var onMouseDown = function onMouseDown(event) {
+    event.persist();
+    refState.current.delta = event.pageX - scrollState.scrollLeft;
+    refState.current.x = 0;
+    setActive(true);
+    event.preventDefault();
+  };
+  var onMouseMove = function onMouseMove(event) {
+    var _window;
+    // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons
+    var _ref2 = event || ((_window = window) === null || _window === void 0 ? void 0 : _window.event),
+      buttons = _ref2.buttons;
+    if (!isActive || buttons === 0) {
+      // If out body mouse up, we can set isActive false when mouse move
+      if (isActive) {
+        setActive(false);
+      }
+      return;
+    }
+    var left = refState.current.x + event.pageX - refState.current.x - refState.current.delta;
+    var isRTL = direction === 'rtl';
+    // Limit scroll range
+    left = Math.max(isRTL ? scrollBarWidth - bodyWidth : 0, Math.min(isRTL ? 0 : bodyWidth - scrollBarWidth, left));
+    // Calculate the scroll position and update
+    var shouldScroll = !isRTL || Math.abs(left) + Math.abs(scrollBarWidth) < bodyWidth;
+    if (shouldScroll) {
+      onScroll({
+        scrollLeft: left / bodyWidth * (bodyScrollWidth + 2)
+      });
+      refState.current.x = event.pageX;
+    }
+  };
+  var checkScrollBarVisible = function checkScrollBarVisible() {
+    raf.cancel(rafRef.current);
+    rafRef.current = raf(function () {
+      if (!scrollBodyRef.current) {
+        return;
+      }
+      var tableOffsetTop = getOffset(scrollBodyRef.current).top;
+      var tableBottomOffset = tableOffsetTop + scrollBodyRef.current.offsetHeight;
+      var currentClientOffset = container === window ? document.documentElement.scrollTop + window.innerHeight : getOffset(container).top + container.clientHeight;
+      setScrollState(function (state) {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          isHiddenScrollBar: tableBottomOffset - getScrollBarSize() <= currentClientOffset || tableOffsetTop >= currentClientOffset - offsetScroll
+        });
+      });
+    });
+  };
+  var setScrollLeft = function setScrollLeft(left) {
+    setScrollState(function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        scrollLeft: bodyScrollWidth ? left / bodyScrollWidth * bodyWidth : 0
+      });
+    });
+  };
+  React.useImperativeHandle(ref, function () {
+    return {
+      setScrollLeft: setScrollLeft,
+      checkScrollBarVisible: checkScrollBarVisible
+    };
+  });
+  React.useEffect(function () {
+    var onMouseUpListener = addEventListener(document.body, 'mouseup', onMouseUp, false);
+    var onMouseMoveListener = addEventListener(document.body, 'mousemove', onMouseMove, false);
+    checkScrollBarVisible();
+    return function () {
+      onMouseUpListener.remove();
+      onMouseMoveListener.remove();
+    };
+  }, [scrollBarWidth, isActive]);
+
+  // Loop for scroll event check
+  React.useEffect(function () {
+    if (!scrollBodyRef.current) return;
+    var scrollParents = [];
+    var parent = getDOM(scrollBodyRef.current);
+    while (parent) {
+      scrollParents.push(parent);
+      parent = parent.parentElement;
+    }
+    scrollParents.forEach(function (p) {
+      return p.addEventListener('scroll', checkScrollBarVisible, false);
+    });
+    window.addEventListener('resize', checkScrollBarVisible, false);
+    window.addEventListener('scroll', checkScrollBarVisible, false);
+    container.addEventListener('scroll', checkScrollBarVisible, false);
+    return function () {
+      scrollParents.forEach(function (p) {
+        return p.removeEventListener('scroll', checkScrollBarVisible);
+      });
+      window.removeEventListener('resize', checkScrollBarVisible);
+      window.removeEventListener('scroll', checkScrollBarVisible);
+      container.removeEventListener('scroll', checkScrollBarVisible);
+    };
+  }, [container]);
+  React.useEffect(function () {
+    if (!scrollState.isHiddenScrollBar) {
+      setScrollState(function (state) {
+        var bodyNode = scrollBodyRef.current;
+        if (!bodyNode) {
+          return state;
+        }
+        return _objectSpread(_objectSpread({}, state), {}, {
+          scrollLeft: bodyNode.scrollLeft / bodyNode.scrollWidth * bodyNode.clientWidth
+        });
+      });
+    }
+  }, [scrollState.isHiddenScrollBar]);
+  if (bodyScrollWidth <= bodyWidth || !scrollBarWidth || scrollState.isHiddenScrollBar) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    style: {
+      height: getScrollBarSize(),
+      width: bodyWidth,
+      bottom: offsetScroll
+    },
+    className: "".concat(prefixCls, "-sticky-scroll")
+  }, /*#__PURE__*/React.createElement("div", {
+    onMouseDown: onMouseDown,
+    ref: scrollBarRef,
+    className: classNames("".concat(prefixCls, "-sticky-scroll-bar"), _defineProperty({}, "".concat(prefixCls, "-sticky-scroll-bar-active"), isActive)),
+    style: {
+      width: "".concat(scrollBarWidth, "px"),
+      transform: "translate3d(".concat(scrollState.scrollLeft, "px, 0, 0)")
+    }
+  }));
+};
+export default /*#__PURE__*/React.forwardRef(StickyScrollBar);
--- a/node_modules/rc-table/es/sugar/Column.d.ts
+++ b/node_modules/rc-table/es/sugar/Column.d.ts
@@ -0,0 +1,10 @@
+import type { ColumnType } from '../interface';
+export interface ColumnProps<RecordType> extends ColumnType<RecordType> {
+    children?: null;
+}
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+declare function Column<RecordType>(_: ColumnProps<RecordType>): any;
+export default Column;
--- a/node_modules/rc-table/es/sugar/Column.js
+++ b/node_modules/rc-table/es/sugar/Column.js
@@ -0,0 +1,10 @@
+/* istanbul ignore next */
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function Column(_) {
+  return null;
+}
+export default Column;
--- a/node_modules/rc-table/es/sugar/ColumnGroup.d.ts
+++ b/node_modules/rc-table/es/sugar/ColumnGroup.d.ts
@@ -0,0 +1,12 @@
+import type * as React from 'react';
+import type { ColumnProps } from './Column';
+import type { ColumnType } from '../interface';
+export interface ColumnGroupProps<RecordType> extends Omit<ColumnType<RecordType>, 'children'> {
+    children: React.ReactElement<ColumnProps<RecordType>> | readonly React.ReactElement<ColumnProps<RecordType>>[];
+}
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+declare function ColumnGroup<RecordType>(_: ColumnGroupProps<RecordType>): any;
+export default ColumnGroup;
--- a/node_modules/rc-table/es/sugar/ColumnGroup.js
+++ b/node_modules/rc-table/es/sugar/ColumnGroup.js
@@ -0,0 +1,10 @@
+/* istanbul ignore next */
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function ColumnGroup(_) {
+  return null;
+}
+export default ColumnGroup;
--- a/node_modules/rc-table/es/utils/expandUtil.d.ts
+++ b/node_modules/rc-table/es/utils/expandUtil.d.ts
@@ -0,0 +1,5 @@
+import * as React from 'react';
+import type { RenderExpandIconProps, Key, GetRowKey, ExpandableConfig } from '../interface';
+export declare function renderExpandIcon<RecordType>({ prefixCls, record, onExpand, expanded, expandable, }: RenderExpandIconProps<RecordType>): React.JSX.Element;
+export declare function findAllChildrenKeys<RecordType>(data: readonly RecordType[], getRowKey: GetRowKey<RecordType>, childrenColumnName: string): Key[];
+export declare function computedExpandedClassName<RecordType>(cls: ExpandableConfig<RecordType>['expandedRowClassName'], record: RecordType, index: number, indent: number): string;
--- a/node_modules/rc-table/es/utils/expandUtil.js
+++ b/node_modules/rc-table/es/utils/expandUtil.js
@@ -0,0 +1,44 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import * as React from 'react';
+import classNames from 'classnames';
+export function renderExpandIcon(_ref) {
+  var prefixCls = _ref.prefixCls,
+    record = _ref.record,
+    onExpand = _ref.onExpand,
+    expanded = _ref.expanded,
+    expandable = _ref.expandable;
+  var expandClassName = "".concat(prefixCls, "-row-expand-icon");
+  if (!expandable) {
+    return /*#__PURE__*/React.createElement("span", {
+      className: classNames(expandClassName, "".concat(prefixCls, "-row-spaced"))
+    });
+  }
+  var onClick = function onClick(event) {
+    onExpand(record, event);
+    event.stopPropagation();
+  };
+  return /*#__PURE__*/React.createElement("span", {
+    className: classNames(expandClassName, _defineProperty(_defineProperty({}, "".concat(prefixCls, "-row-expanded"), expanded), "".concat(prefixCls, "-row-collapsed"), !expanded)),
+    onClick: onClick
+  });
+}
+export function findAllChildrenKeys(data, getRowKey, childrenColumnName) {
+  var keys = [];
+  function dig(list) {
+    (list || []).forEach(function (item, index) {
+      keys.push(getRowKey(item, index));
+      dig(item[childrenColumnName]);
+    });
+  }
+  dig(data);
+  return keys;
+}
+export function computedExpandedClassName(cls, record, index, indent) {
+  if (typeof cls === 'string') {
+    return cls;
+  }
+  if (typeof cls === 'function') {
+    return cls(record, index, indent);
+  }
+  return '';
+}
--- a/node_modules/rc-table/es/utils/fixUtil.d.ts
+++ b/node_modules/rc-table/es/utils/fixUtil.d.ts
@@ -0,0 +1,13 @@
+import type { Direction, FixedType, StickyOffsets } from '../interface';
+export interface FixedInfo {
+    fixLeft: number | false;
+    fixRight: number | false;
+    lastFixLeft: boolean;
+    firstFixRight: boolean;
+    lastFixRight: boolean;
+    firstFixLeft: boolean;
+    isSticky: boolean;
+}
+export declare function getCellFixedInfo(colStart: number, colEnd: number, columns: readonly {
+    fixed?: FixedType;
+}[], stickyOffsets: StickyOffsets, direction: Direction): FixedInfo;
--- a/node_modules/rc-table/es/utils/fixUtil.js
+++ b/node_modules/rc-table/es/utils/fixUtil.js
@@ -0,0 +1,46 @@
+export function getCellFixedInfo(colStart, colEnd, columns, stickyOffsets, direction) {
+  var startColumn = columns[colStart] || {};
+  var endColumn = columns[colEnd] || {};
+  var fixLeft;
+  var fixRight;
+  if (startColumn.fixed === 'left') {
+    fixLeft = stickyOffsets.left[direction === 'rtl' ? colEnd : colStart];
+  } else if (endColumn.fixed === 'right') {
+    fixRight = stickyOffsets.right[direction === 'rtl' ? colStart : colEnd];
+  }
+  var lastFixLeft = false;
+  var firstFixRight = false;
+  var lastFixRight = false;
+  var firstFixLeft = false;
+  var nextColumn = columns[colEnd + 1];
+  var prevColumn = columns[colStart - 1];
+
+  // need show shadow only when canLastFix is true
+  var canLastFix = nextColumn && !nextColumn.fixed || prevColumn && !prevColumn.fixed || columns.every(function (col) {
+    return col.fixed === 'left';
+  });
+  if (direction === 'rtl') {
+    if (fixLeft !== undefined) {
+      var prevFixLeft = prevColumn && prevColumn.fixed === 'left';
+      firstFixLeft = !prevFixLeft && canLastFix;
+    } else if (fixRight !== undefined) {
+      var nextFixRight = nextColumn && nextColumn.fixed === 'right';
+      lastFixRight = !nextFixRight && canLastFix;
+    }
+  } else if (fixLeft !== undefined) {
+    var nextFixLeft = nextColumn && nextColumn.fixed === 'left';
+    lastFixLeft = !nextFixLeft && canLastFix;
+  } else if (fixRight !== undefined) {
+    var prevFixRight = prevColumn && prevColumn.fixed === 'right';
+    firstFixRight = !prevFixRight && canLastFix;
+  }
+  return {
+    fixLeft: fixLeft,
+    fixRight: fixRight,
+    lastFixLeft: lastFixLeft,
+    firstFixRight: firstFixRight,
+    lastFixRight: lastFixRight,
+    firstFixLeft: firstFixLeft,
+    isSticky: stickyOffsets.isSticky
+  };
+}
--- a/node_modules/rc-table/es/utils/legacyUtil.d.ts
+++ b/node_modules/rc-table/es/utils/legacyUtil.d.ts
@@ -0,0 +1,5 @@
+import type { ExpandableConfig, LegacyExpandableProps } from '../interface';
+export declare const INTERNAL_COL_DEFINE = "RC_TABLE_INTERNAL_COL_DEFINE";
+export declare function getExpandableProps<RecordType>(props: LegacyExpandableProps<RecordType> & {
+    expandable?: ExpandableConfig<RecordType>;
+}): ExpandableConfig<RecordType>;
--- a/node_modules/rc-table/es/utils/legacyUtil.js
+++ b/node_modules/rc-table/es/utils/legacyUtil.js
@@ -0,0 +1,24 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["expandable"];
+import warning from "rc-util/es/warning";
+export var INTERNAL_COL_DEFINE = 'RC_TABLE_INTERNAL_COL_DEFINE';
+export function getExpandableProps(props) {
+  var expandable = props.expandable,
+    legacyExpandableConfig = _objectWithoutProperties(props, _excluded);
+  var config;
+  if ('expandable' in props) {
+    config = _objectSpread(_objectSpread({}, legacyExpandableConfig), expandable);
+  } else {
+    if (process.env.NODE_ENV !== 'production' && ['indentSize', 'expandedRowKeys', 'defaultExpandedRowKeys', 'defaultExpandAllRows', 'expandedRowRender', 'expandRowByClick', 'expandIcon', 'onExpand', 'onExpandedRowsChange', 'expandedRowClassName', 'expandIconColumnIndex', 'showExpandColumn', 'title'].some(function (prop) {
+      return prop in props;
+    })) {
+      warning(false, 'expanded related props have been moved into `expandable`.');
+    }
+    config = legacyExpandableConfig;
+  }
+  if (config.showExpandColumn === false) {
+    config.expandIconColumnIndex = -1;
+  }
+  return config;
+}
--- a/node_modules/rc-table/es/utils/offsetUtil.d.ts
+++ b/node_modules/rc-table/es/utils/offsetUtil.d.ts
@@ -0,0 +1,4 @@
+export declare function getOffset(node: HTMLElement | Window): {
+    left: number;
+    top: number;
+};
--- a/node_modules/rc-table/es/utils/offsetUtil.js
+++ b/node_modules/rc-table/es/utils/offsetUtil.js
@@ -0,0 +1,14 @@
+import { getDOM } from "rc-util/es/Dom/findDOMNode";
+
+// Copy from `rc-util/Dom/css.js`
+export function getOffset(node) {
+  var element = getDOM(node);
+  var box = element.getBoundingClientRect();
+  var docElem = document.documentElement;
+
+  // < ie8 not support win.pageXOffset, use docElem.scrollLeft instead
+  return {
+    left: box.left + (window.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || document.body.clientLeft || 0),
+    top: box.top + (window.pageYOffset || docElem.scrollTop) - (docElem.clientTop || document.body.clientTop || 0)
+  };
+}
--- a/node_modules/rc-table/es/utils/valueUtil.d.ts
+++ b/node_modules/rc-table/es/utils/valueUtil.d.ts
@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { DataIndex, Key } from '../interface';
+export interface GetColumnKeyColumn<T = any> {
+    key?: Key;
+    dataIndex?: DataIndex<T>;
+}
+export declare function getColumnsKey<T = any>(columns: readonly GetColumnKeyColumn<T>[]): import("react").Key[];
+export declare function validateValue<T>(val: T): boolean;
+export declare function validNumberValue(value: any): boolean;
--- a/Show More
+++ b/Show More