add all frontend files

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;

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);

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;

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;

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;

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')));
+}

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;

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;
+}

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;

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);

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;

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);

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];

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;
+}

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];

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];
+  });
+}

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;

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;

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;

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);

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;

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));
+}

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;

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);
+}

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;

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;

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;

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;

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;

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;

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;

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);

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;

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;

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;

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;

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;

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;

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;

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;

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;

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;

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;

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;

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>;

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);

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;

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();

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";

node_modules/rc-table/es/constant.js

@@ -0,0 +1,2 @@
+export var EXPAND_COLUMN = {};
+export var INTERNAL_HOOKS = 'rc-table-internal-hook';

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;

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;

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;

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;

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;

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;

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];

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]);
+}

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>
+];

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];
+}

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[];

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);
+  });
+}

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>[];

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;
+}

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];

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];
+}

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];

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];
+}

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>;

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';
+}

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>;
+};

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
+    })
+  });
+}

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;
+};

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]);
+}

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;

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;

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;

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;

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 {};

node_modules/rc-table/es/interface.js

@@ -0,0 +1 @@
+export {};

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 {};

node_modules/rc-table/es/namePathType.js

@@ -0,0 +1 @@
+export {};

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;

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);

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;

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;

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;

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;

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;

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 '';
+}

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;

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
+  };
+}

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>;

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;
+}

node_modules/rc-table/es/utils/offsetUtil.d.ts

@@ -0,0 +1,4 @@
+export declare function getOffset(node: HTMLElement | Window): {
+    left: number;
+    top: number;
+};

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)
+  };
+}

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;

node_modules/rc-table/es/utils/valueUtil.js

@@ -0,0 +1,29 @@
+var INTERNAL_KEY_PREFIX = 'RC_TABLE_KEY';
+function toArray(arr) {
+  if (arr === undefined || arr === null) {
+    return [];
+  }
+  return Array.isArray(arr) ? arr : [arr];
+}
+export function getColumnsKey(columns) {
+  var columnKeys = [];
+  var keys = {};
+  columns.forEach(function (column) {
+    var _ref = column || {},
+      key = _ref.key,
+      dataIndex = _ref.dataIndex;
+    var mergedKey = key || toArray(dataIndex).join('-') || INTERNAL_KEY_PREFIX;
+    while (keys[mergedKey]) {
+      mergedKey = "".concat(mergedKey, "_next");
+    }
+    keys[mergedKey] = true;
+    columnKeys.push(mergedKey);
+  });
+  return columnKeys;
+}
+export function validateValue(val) {
+  return val !== null && val !== undefined;
+}
+export function validNumberValue(value) {
+  return typeof value === 'number' && !Number.isNaN(value);
+}