add all frontend files

node_modules/rc-virtual-list/es/Context.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const WheelLockContext: React.Context<(lock: boolean) => void>;

node_modules/rc-virtual-list/es/Context.js

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export var WheelLockContext = /*#__PURE__*/React.createContext(function () {});

node_modules/rc-virtual-list/es/Filler.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+export type InnerProps = Pick<React.HTMLAttributes<HTMLDivElement>, 'role' | 'id'>;
+interface FillerProps {
+    prefixCls?: string;
+    /** Virtual filler height. Should be `count * itemMinHeight` */
+    height: number;
+    /** Set offset of visible items. Should be the top of start item position */
+    offsetY?: number;
+    offsetX?: number;
+    scrollWidth?: number;
+    children: React.ReactNode;
+    onInnerResize?: () => void;
+    innerProps?: InnerProps;
+    rtl: boolean;
+    extra?: React.ReactNode;
+}
+/**
+ * Fill component to provided the scroll content real height.
+ */
+declare const Filler: React.ForwardRefExoticComponent<FillerProps & React.RefAttributes<HTMLDivElement>>;
+export default Filler;

node_modules/rc-virtual-list/es/Filler.js

@@ -0,0 +1,52 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import * as React from 'react';
+import ResizeObserver from 'rc-resize-observer';
+import classNames from 'classnames';
+/**
+ * Fill component to provided the scroll content real height.
+ */
+var Filler = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
+  var height = _ref.height,
+    offsetY = _ref.offsetY,
+    offsetX = _ref.offsetX,
+    children = _ref.children,
+    prefixCls = _ref.prefixCls,
+    onInnerResize = _ref.onInnerResize,
+    innerProps = _ref.innerProps,
+    rtl = _ref.rtl,
+    extra = _ref.extra;
+  var outerStyle = {};
+  var innerStyle = {
+    display: 'flex',
+    flexDirection: 'column'
+  };
+  if (offsetY !== undefined) {
+    // Not set `width` since this will break `sticky: right`
+    outerStyle = {
+      height: height,
+      position: 'relative',
+      overflow: 'hidden'
+    };
+    innerStyle = _objectSpread(_objectSpread({}, innerStyle), {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
+      transform: "translateY(".concat(offsetY, "px)")
+    }, rtl ? 'marginRight' : 'marginLeft', -offsetX), "position", 'absolute'), "left", 0), "right", 0), "top", 0));
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    style: outerStyle
+  }, /*#__PURE__*/React.createElement(ResizeObserver, {
+    onResize: function onResize(_ref2) {
+      var offsetHeight = _ref2.offsetHeight;
+      if (offsetHeight && onInnerResize) {
+        onInnerResize();
+      }
+    }
+  }, /*#__PURE__*/React.createElement("div", _extends({
+    style: innerStyle,
+    className: classNames(_defineProperty({}, "".concat(prefixCls, "-holder-inner"), prefixCls)),
+    ref: ref
+  }, innerProps), children, extra)));
+});
+Filler.displayName = 'Filler';
+export default Filler;

node_modules/rc-virtual-list/es/Item.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export interface ItemProps {
+    children: React.ReactElement;
+    setRef: (element: HTMLElement) => void;
+}
+export declare function Item({ children, setRef }: ItemProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;

node_modules/rc-virtual-list/es/Item.js

@@ -0,0 +1,11 @@
+import * as React from 'react';
+export function Item(_ref) {
+  var children = _ref.children,
+    setRef = _ref.setRef;
+  var refFunc = React.useCallback(function (node) {
+    setRef(node);
+  }, []);
+  return /*#__PURE__*/React.cloneElement(children, {
+    ref: refFunc
+  });
+}

node_modules/rc-virtual-list/es/List.d.ts

@@ -0,0 +1,61 @@
+import * as React from 'react';
+import type { InnerProps } from './Filler';
+import type { ScrollPos, ScrollTarget } from './hooks/useScrollTo';
+import type { ExtraRenderInfo, RenderFunc } from './interface';
+import type { ScrollBarDirectionType } from './ScrollBar';
+export interface ScrollInfo {
+    x: number;
+    y: number;
+}
+export type ScrollConfig = ScrollTarget | ScrollPos;
+export type ScrollTo = (arg?: number | ScrollConfig | null) => void;
+export type ListRef = {
+    nativeElement: HTMLDivElement;
+    scrollTo: ScrollTo;
+    getScrollInfo: () => ScrollInfo;
+};
+export interface ListProps<T> extends Omit<React.HTMLAttributes<any>, 'children'> {
+    prefixCls?: string;
+    children: RenderFunc<T>;
+    data: T[];
+    height?: number;
+    itemHeight?: number;
+    /** If not match virtual scroll condition, Set List still use height of container. */
+    fullHeight?: boolean;
+    itemKey: React.Key | ((item: T) => React.Key);
+    component?: string | React.FC<any> | React.ComponentClass<any>;
+    /** Set `false` will always use real scroll instead of virtual one */
+    virtual?: boolean;
+    direction?: ScrollBarDirectionType;
+    /**
+     * By default `scrollWidth` is same as container.
+     * When set this, it will show the horizontal scrollbar and
+     * `scrollWidth` will be used as the real width instead of container width.
+     * When set, `virtual` will always be enabled.
+     */
+    scrollWidth?: number;
+    styles?: {
+        horizontalScrollBar?: React.CSSProperties;
+        horizontalScrollBarThumb?: React.CSSProperties;
+        verticalScrollBar?: React.CSSProperties;
+        verticalScrollBarThumb?: React.CSSProperties;
+    };
+    showScrollBar?: boolean | 'optional';
+    onScroll?: React.UIEventHandler<HTMLElement>;
+    /**
+     * Given the virtual offset value.
+     * It's the logic offset from start position.
+     */
+    onVirtualScroll?: (info: ScrollInfo) => void;
+    /** Trigger when render list item changed */
+    onVisibleChange?: (visibleList: T[], fullList: T[]) => void;
+    /** Inject to inner container props. Only use when you need pass aria related data */
+    innerProps?: InnerProps;
+    /** Render extra content into Filler */
+    extraRender?: (info: ExtraRenderInfo) => React.ReactNode;
+}
+export declare function RawList<T>(props: ListProps<T>, ref: React.Ref<ListRef>): React.JSX.Element;
+declare const _default: <Item = any>(props: ListProps<Item> & {
+    ref?: React.Ref<ListRef>;
+}) => React.ReactElement;
+export default _default;

node_modules/rc-virtual-list/es/List.js

@@ -0,0 +1,548 @@
+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 _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["prefixCls", "className", "height", "itemHeight", "fullHeight", "style", "data", "children", "itemKey", "virtual", "direction", "scrollWidth", "component", "onScroll", "onVirtualScroll", "onVisibleChange", "innerProps", "extraRender", "styles", "showScrollBar"];
+import classNames from 'classnames';
+import ResizeObserver from 'rc-resize-observer';
+import { useEvent } from 'rc-util';
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+import * as React from 'react';
+import { useRef, useState } from 'react';
+import { flushSync } from 'react-dom';
+import Filler from "./Filler";
+import useChildren from "./hooks/useChildren";
+import useDiffItem from "./hooks/useDiffItem";
+import useFrameWheel from "./hooks/useFrameWheel";
+import { useGetSize } from "./hooks/useGetSize";
+import useHeights from "./hooks/useHeights";
+import useMobileTouchMove from "./hooks/useMobileTouchMove";
+import useOriginScroll from "./hooks/useOriginScroll";
+import useScrollDrag from "./hooks/useScrollDrag";
+import useScrollTo from "./hooks/useScrollTo";
+import ScrollBar from "./ScrollBar";
+import { getSpinSize } from "./utils/scrollbarUtil";
+var EMPTY_DATA = [];
+var ScrollStyle = {
+  overflowY: 'auto',
+  overflowAnchor: 'none'
+};
+export function RawList(props, ref) {
+  var _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? 'rc-virtual-list' : _props$prefixCls,
+    className = props.className,
+    height = props.height,
+    itemHeight = props.itemHeight,
+    _props$fullHeight = props.fullHeight,
+    fullHeight = _props$fullHeight === void 0 ? true : _props$fullHeight,
+    style = props.style,
+    data = props.data,
+    children = props.children,
+    itemKey = props.itemKey,
+    virtual = props.virtual,
+    direction = props.direction,
+    scrollWidth = props.scrollWidth,
+    _props$component = props.component,
+    Component = _props$component === void 0 ? 'div' : _props$component,
+    onScroll = props.onScroll,
+    onVirtualScroll = props.onVirtualScroll,
+    onVisibleChange = props.onVisibleChange,
+    innerProps = props.innerProps,
+    extraRender = props.extraRender,
+    styles = props.styles,
+    _props$showScrollBar = props.showScrollBar,
+    showScrollBar = _props$showScrollBar === void 0 ? 'optional' : _props$showScrollBar,
+    restProps = _objectWithoutProperties(props, _excluded);
+
+  // =============================== Item Key ===============================
+  var getKey = React.useCallback(function (item) {
+    if (typeof itemKey === 'function') {
+      return itemKey(item);
+    }
+    return item === null || item === void 0 ? void 0 : item[itemKey];
+  }, [itemKey]);
+
+  // ================================ Height ================================
+  var _useHeights = useHeights(getKey, null, null),
+    _useHeights2 = _slicedToArray(_useHeights, 4),
+    setInstanceRef = _useHeights2[0],
+    collectHeight = _useHeights2[1],
+    heights = _useHeights2[2],
+    heightUpdatedMark = _useHeights2[3];
+
+  // ================================= MISC =================================
+  var useVirtual = !!(virtual !== false && height && itemHeight);
+  var containerHeight = React.useMemo(function () {
+    return Object.values(heights.maps).reduce(function (total, curr) {
+      return total + curr;
+    }, 0);
+  }, [heights.id, heights.maps]);
+  var inVirtual = useVirtual && data && (Math.max(itemHeight * data.length, containerHeight) > height || !!scrollWidth);
+  var isRTL = direction === 'rtl';
+  var mergedClassName = classNames(prefixCls, _defineProperty({}, "".concat(prefixCls, "-rtl"), isRTL), className);
+  var mergedData = data || EMPTY_DATA;
+  var componentRef = useRef();
+  var fillerInnerRef = useRef();
+  var containerRef = useRef();
+
+  // =============================== Item Key ===============================
+
+  var _useState = useState(0),
+    _useState2 = _slicedToArray(_useState, 2),
+    offsetTop = _useState2[0],
+    setOffsetTop = _useState2[1];
+  var _useState3 = useState(0),
+    _useState4 = _slicedToArray(_useState3, 2),
+    offsetLeft = _useState4[0],
+    setOffsetLeft = _useState4[1];
+  var _useState5 = useState(false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    scrollMoving = _useState6[0],
+    setScrollMoving = _useState6[1];
+  var onScrollbarStartMove = function onScrollbarStartMove() {
+    setScrollMoving(true);
+  };
+  var onScrollbarStopMove = function onScrollbarStopMove() {
+    setScrollMoving(false);
+  };
+  var sharedConfig = {
+    getKey: getKey
+  };
+
+  // ================================ Scroll ================================
+  function syncScrollTop(newTop) {
+    setOffsetTop(function (origin) {
+      var value;
+      if (typeof newTop === 'function') {
+        value = newTop(origin);
+      } else {
+        value = newTop;
+      }
+      var alignedTop = keepInRange(value);
+      componentRef.current.scrollTop = alignedTop;
+      return alignedTop;
+    });
+  }
+
+  // ================================ Legacy ================================
+  // Put ref here since the range is generate by follow
+  var rangeRef = useRef({
+    start: 0,
+    end: mergedData.length
+  });
+  var diffItemRef = useRef();
+  var _useDiffItem = useDiffItem(mergedData, getKey),
+    _useDiffItem2 = _slicedToArray(_useDiffItem, 1),
+    diffItem = _useDiffItem2[0];
+  diffItemRef.current = diffItem;
+
+  // ========================== Visible Calculation =========================
+  var _React$useMemo = React.useMemo(function () {
+      if (!useVirtual) {
+        return {
+          scrollHeight: undefined,
+          start: 0,
+          end: mergedData.length - 1,
+          offset: undefined
+        };
+      }
+
+      // Always use virtual scroll bar in avoid shaking
+      if (!inVirtual) {
+        var _fillerInnerRef$curre;
+        return {
+          scrollHeight: ((_fillerInnerRef$curre = fillerInnerRef.current) === null || _fillerInnerRef$curre === void 0 ? void 0 : _fillerInnerRef$curre.offsetHeight) || 0,
+          start: 0,
+          end: mergedData.length - 1,
+          offset: undefined
+        };
+      }
+      var itemTop = 0;
+      var startIndex;
+      var startOffset;
+      var endIndex;
+      var dataLen = mergedData.length;
+      for (var i = 0; i < dataLen; i += 1) {
+        var _item = mergedData[i];
+        var key = getKey(_item);
+        var cacheHeight = heights.get(key);
+        var currentItemBottom = itemTop + (cacheHeight === undefined ? itemHeight : cacheHeight);
+
+        // Check item top in the range
+        if (currentItemBottom >= offsetTop && startIndex === undefined) {
+          startIndex = i;
+          startOffset = itemTop;
+        }
+
+        // Check item bottom in the range. We will render additional one item for motion usage
+        if (currentItemBottom > offsetTop + height && endIndex === undefined) {
+          endIndex = i;
+        }
+        itemTop = currentItemBottom;
+      }
+
+      // When scrollTop at the end but data cut to small count will reach this
+      if (startIndex === undefined) {
+        startIndex = 0;
+        startOffset = 0;
+        endIndex = Math.ceil(height / itemHeight);
+      }
+      if (endIndex === undefined) {
+        endIndex = mergedData.length - 1;
+      }
+
+      // Give cache to improve scroll experience
+      endIndex = Math.min(endIndex + 1, mergedData.length - 1);
+      return {
+        scrollHeight: itemTop,
+        start: startIndex,
+        end: endIndex,
+        offset: startOffset
+      };
+    }, [inVirtual, useVirtual, offsetTop, mergedData, heightUpdatedMark, height]),
+    scrollHeight = _React$useMemo.scrollHeight,
+    start = _React$useMemo.start,
+    end = _React$useMemo.end,
+    fillerOffset = _React$useMemo.offset;
+  rangeRef.current.start = start;
+  rangeRef.current.end = end;
+
+  // When scroll up, first visible item get real height may not same as `itemHeight`,
+  // Which will make scroll jump.
+  // Let's sync scroll top to avoid jump
+  React.useLayoutEffect(function () {
+    var changedRecord = heights.getRecord();
+    if (changedRecord.size === 1) {
+      var recordKey = Array.from(changedRecord.keys())[0];
+      var prevCacheHeight = changedRecord.get(recordKey);
+
+      // Quick switch data may cause `start` not in `mergedData` anymore
+      var startItem = mergedData[start];
+      if (startItem && prevCacheHeight === undefined) {
+        var startIndexKey = getKey(startItem);
+        if (startIndexKey === recordKey) {
+          var realStartHeight = heights.get(recordKey);
+          var diffHeight = realStartHeight - itemHeight;
+          syncScrollTop(function (ori) {
+            return ori + diffHeight;
+          });
+        }
+      }
+    }
+    heights.resetRecord();
+  }, [scrollHeight]);
+
+  // ================================= Size =================================
+  var _React$useState = React.useState({
+      width: 0,
+      height: height
+    }),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    size = _React$useState2[0],
+    setSize = _React$useState2[1];
+  var onHolderResize = function onHolderResize(sizeInfo) {
+    setSize({
+      width: sizeInfo.offsetWidth,
+      height: sizeInfo.offsetHeight
+    });
+  };
+
+  // Hack on scrollbar to enable flash call
+  var verticalScrollBarRef = useRef();
+  var horizontalScrollBarRef = useRef();
+  var horizontalScrollBarSpinSize = React.useMemo(function () {
+    return getSpinSize(size.width, scrollWidth);
+  }, [size.width, scrollWidth]);
+  var verticalScrollBarSpinSize = React.useMemo(function () {
+    return getSpinSize(size.height, scrollHeight);
+  }, [size.height, scrollHeight]);
+
+  // =============================== In Range ===============================
+  var maxScrollHeight = scrollHeight - height;
+  var maxScrollHeightRef = useRef(maxScrollHeight);
+  maxScrollHeightRef.current = maxScrollHeight;
+  function keepInRange(newScrollTop) {
+    var newTop = newScrollTop;
+    if (!Number.isNaN(maxScrollHeightRef.current)) {
+      newTop = Math.min(newTop, maxScrollHeightRef.current);
+    }
+    newTop = Math.max(newTop, 0);
+    return newTop;
+  }
+  var isScrollAtTop = offsetTop <= 0;
+  var isScrollAtBottom = offsetTop >= maxScrollHeight;
+  var isScrollAtLeft = offsetLeft <= 0;
+  var isScrollAtRight = offsetLeft >= scrollWidth;
+  var originScroll = useOriginScroll(isScrollAtTop, isScrollAtBottom, isScrollAtLeft, isScrollAtRight);
+
+  // ================================ Scroll ================================
+  var getVirtualScrollInfo = function getVirtualScrollInfo() {
+    return {
+      x: isRTL ? -offsetLeft : offsetLeft,
+      y: offsetTop
+    };
+  };
+  var lastVirtualScrollInfoRef = useRef(getVirtualScrollInfo());
+  var triggerScroll = useEvent(function (params) {
+    if (onVirtualScroll) {
+      var nextInfo = _objectSpread(_objectSpread({}, getVirtualScrollInfo()), params);
+
+      // Trigger when offset changed
+      if (lastVirtualScrollInfoRef.current.x !== nextInfo.x || lastVirtualScrollInfoRef.current.y !== nextInfo.y) {
+        onVirtualScroll(nextInfo);
+        lastVirtualScrollInfoRef.current = nextInfo;
+      }
+    }
+  });
+  function onScrollBar(newScrollOffset, horizontal) {
+    var newOffset = newScrollOffset;
+    if (horizontal) {
+      flushSync(function () {
+        setOffsetLeft(newOffset);
+      });
+      triggerScroll();
+    } else {
+      syncScrollTop(newOffset);
+    }
+  }
+
+  // When data size reduce. It may trigger native scroll event back to fit scroll position
+  function onFallbackScroll(e) {
+    var newScrollTop = e.currentTarget.scrollTop;
+    if (newScrollTop !== offsetTop) {
+      syncScrollTop(newScrollTop);
+    }
+
+    // Trigger origin onScroll
+    onScroll === null || onScroll === void 0 || onScroll(e);
+    triggerScroll();
+  }
+  var keepInHorizontalRange = function keepInHorizontalRange(nextOffsetLeft) {
+    var tmpOffsetLeft = nextOffsetLeft;
+    var max = !!scrollWidth ? scrollWidth - size.width : 0;
+    tmpOffsetLeft = Math.max(tmpOffsetLeft, 0);
+    tmpOffsetLeft = Math.min(tmpOffsetLeft, max);
+    return tmpOffsetLeft;
+  };
+  var onWheelDelta = useEvent(function (offsetXY, fromHorizontal) {
+    if (fromHorizontal) {
+      flushSync(function () {
+        setOffsetLeft(function (left) {
+          var nextOffsetLeft = left + (isRTL ? -offsetXY : offsetXY);
+          return keepInHorizontalRange(nextOffsetLeft);
+        });
+      });
+      triggerScroll();
+    } else {
+      syncScrollTop(function (top) {
+        var newTop = top + offsetXY;
+        return newTop;
+      });
+    }
+  });
+
+  // Since this added in global,should use ref to keep update
+  var _useFrameWheel = useFrameWheel(useVirtual, isScrollAtTop, isScrollAtBottom, isScrollAtLeft, isScrollAtRight, !!scrollWidth, onWheelDelta),
+    _useFrameWheel2 = _slicedToArray(_useFrameWheel, 2),
+    onRawWheel = _useFrameWheel2[0],
+    onFireFoxScroll = _useFrameWheel2[1];
+
+  // Mobile touch move
+  useMobileTouchMove(useVirtual, componentRef, function (isHorizontal, delta, smoothOffset, e) {
+    var event = e;
+    if (originScroll(isHorizontal, delta, smoothOffset)) {
+      return false;
+    }
+
+    // Fix nest List trigger TouchMove event
+    if (!event || !event._virtualHandled) {
+      if (event) {
+        event._virtualHandled = true;
+      }
+      onRawWheel({
+        preventDefault: function preventDefault() {},
+        deltaX: isHorizontal ? delta : 0,
+        deltaY: isHorizontal ? 0 : delta
+      });
+      return true;
+    }
+    return false;
+  });
+
+  // MouseDown drag for scroll
+  useScrollDrag(inVirtual, componentRef, function (offset) {
+    syncScrollTop(function (top) {
+      return top + offset;
+    });
+  });
+  useLayoutEffect(function () {
+    // Firefox only
+    function onMozMousePixelScroll(e) {
+      // scrolling at top/bottom limit
+      var scrollingUpAtTop = isScrollAtTop && e.detail < 0;
+      var scrollingDownAtBottom = isScrollAtBottom && e.detail > 0;
+      if (useVirtual && !scrollingUpAtTop && !scrollingDownAtBottom) {
+        e.preventDefault();
+      }
+    }
+    var componentEle = componentRef.current;
+    componentEle.addEventListener('wheel', onRawWheel, {
+      passive: false
+    });
+    componentEle.addEventListener('DOMMouseScroll', onFireFoxScroll, {
+      passive: true
+    });
+    componentEle.addEventListener('MozMousePixelScroll', onMozMousePixelScroll, {
+      passive: false
+    });
+    return function () {
+      componentEle.removeEventListener('wheel', onRawWheel);
+      componentEle.removeEventListener('DOMMouseScroll', onFireFoxScroll);
+      componentEle.removeEventListener('MozMousePixelScroll', onMozMousePixelScroll);
+    };
+  }, [useVirtual, isScrollAtTop, isScrollAtBottom]);
+
+  // Sync scroll left
+  useLayoutEffect(function () {
+    if (scrollWidth) {
+      var newOffsetLeft = keepInHorizontalRange(offsetLeft);
+      setOffsetLeft(newOffsetLeft);
+      triggerScroll({
+        x: newOffsetLeft
+      });
+    }
+  }, [size.width, scrollWidth]);
+
+  // ================================= Ref ==================================
+  var delayHideScrollBar = function delayHideScrollBar() {
+    var _verticalScrollBarRef, _horizontalScrollBarR;
+    (_verticalScrollBarRef = verticalScrollBarRef.current) === null || _verticalScrollBarRef === void 0 || _verticalScrollBarRef.delayHidden();
+    (_horizontalScrollBarR = horizontalScrollBarRef.current) === null || _horizontalScrollBarR === void 0 || _horizontalScrollBarR.delayHidden();
+  };
+  var _scrollTo = useScrollTo(componentRef, mergedData, heights, itemHeight, getKey, function () {
+    return collectHeight(true);
+  }, syncScrollTop, delayHideScrollBar);
+  React.useImperativeHandle(ref, function () {
+    return {
+      nativeElement: containerRef.current,
+      getScrollInfo: getVirtualScrollInfo,
+      scrollTo: function scrollTo(config) {
+        function isPosScroll(arg) {
+          return arg && _typeof(arg) === 'object' && ('left' in arg || 'top' in arg);
+        }
+        if (isPosScroll(config)) {
+          // Scroll X
+          if (config.left !== undefined) {
+            setOffsetLeft(keepInHorizontalRange(config.left));
+          }
+
+          // Scroll Y
+          _scrollTo(config.top);
+        } else {
+          _scrollTo(config);
+        }
+      }
+    };
+  });
+
+  // ================================ Effect ================================
+  /** We need told outside that some list not rendered */
+  useLayoutEffect(function () {
+    if (onVisibleChange) {
+      var renderList = mergedData.slice(start, end + 1);
+      onVisibleChange(renderList, mergedData);
+    }
+  }, [start, end, mergedData]);
+
+  // ================================ Extra =================================
+  var getSize = useGetSize(mergedData, getKey, heights, itemHeight);
+  var extraContent = extraRender === null || extraRender === void 0 ? void 0 : extraRender({
+    start: start,
+    end: end,
+    virtual: inVirtual,
+    offsetX: offsetLeft,
+    offsetY: fillerOffset,
+    rtl: isRTL,
+    getSize: getSize
+  });
+
+  // ================================ Render ================================
+  var listChildren = useChildren(mergedData, start, end, scrollWidth, offsetLeft, setInstanceRef, children, sharedConfig);
+  var componentStyle = null;
+  if (height) {
+    componentStyle = _objectSpread(_defineProperty({}, fullHeight ? 'height' : 'maxHeight', height), ScrollStyle);
+    if (useVirtual) {
+      componentStyle.overflowY = 'hidden';
+      if (scrollWidth) {
+        componentStyle.overflowX = 'hidden';
+      }
+      if (scrollMoving) {
+        componentStyle.pointerEvents = 'none';
+      }
+    }
+  }
+  var containerProps = {};
+  if (isRTL) {
+    containerProps.dir = 'rtl';
+  }
+  return /*#__PURE__*/React.createElement("div", _extends({
+    ref: containerRef,
+    style: _objectSpread(_objectSpread({}, style), {}, {
+      position: 'relative'
+    }),
+    className: mergedClassName
+  }, containerProps, restProps), /*#__PURE__*/React.createElement(ResizeObserver, {
+    onResize: onHolderResize
+  }, /*#__PURE__*/React.createElement(Component, {
+    className: "".concat(prefixCls, "-holder"),
+    style: componentStyle,
+    ref: componentRef,
+    onScroll: onFallbackScroll,
+    onMouseEnter: delayHideScrollBar
+  }, /*#__PURE__*/React.createElement(Filler, {
+    prefixCls: prefixCls,
+    height: scrollHeight,
+    offsetX: offsetLeft,
+    offsetY: fillerOffset,
+    scrollWidth: scrollWidth,
+    onInnerResize: collectHeight,
+    ref: fillerInnerRef,
+    innerProps: innerProps,
+    rtl: isRTL,
+    extra: extraContent
+  }, listChildren))), inVirtual && scrollHeight > height && /*#__PURE__*/React.createElement(ScrollBar, {
+    ref: verticalScrollBarRef,
+    prefixCls: prefixCls,
+    scrollOffset: offsetTop,
+    scrollRange: scrollHeight,
+    rtl: isRTL,
+    onScroll: onScrollBar,
+    onStartMove: onScrollbarStartMove,
+    onStopMove: onScrollbarStopMove,
+    spinSize: verticalScrollBarSpinSize,
+    containerSize: size.height,
+    style: styles === null || styles === void 0 ? void 0 : styles.verticalScrollBar,
+    thumbStyle: styles === null || styles === void 0 ? void 0 : styles.verticalScrollBarThumb,
+    showScrollBar: showScrollBar
+  }), inVirtual && scrollWidth > size.width && /*#__PURE__*/React.createElement(ScrollBar, {
+    ref: horizontalScrollBarRef,
+    prefixCls: prefixCls,
+    scrollOffset: offsetLeft,
+    scrollRange: scrollWidth,
+    rtl: isRTL,
+    onScroll: onScrollBar,
+    onStartMove: onScrollbarStartMove,
+    onStopMove: onScrollbarStopMove,
+    spinSize: horizontalScrollBarSpinSize,
+    containerSize: size.width,
+    horizontal: true,
+    style: styles === null || styles === void 0 ? void 0 : styles.horizontalScrollBar,
+    thumbStyle: styles === null || styles === void 0 ? void 0 : styles.horizontalScrollBarThumb,
+    showScrollBar: showScrollBar
+  }));
+}
+var List = /*#__PURE__*/React.forwardRef(RawList);
+List.displayName = 'List';
+export default List;

node_modules/rc-virtual-list/es/ScrollBar.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+export type ScrollBarDirectionType = 'ltr' | 'rtl';
+export interface ScrollBarProps {
+    prefixCls: string;
+    scrollOffset: number;
+    scrollRange: number;
+    rtl: boolean;
+    onScroll: (scrollOffset: number, horizontal?: boolean) => void;
+    onStartMove: () => void;
+    onStopMove: () => void;
+    horizontal?: boolean;
+    style?: React.CSSProperties;
+    thumbStyle?: React.CSSProperties;
+    spinSize: number;
+    containerSize: number;
+    showScrollBar?: boolean | 'optional';
+}
+export interface ScrollBarRef {
+    delayHidden: () => void;
+}
+declare const ScrollBar: React.ForwardRefExoticComponent<ScrollBarProps & React.RefAttributes<ScrollBarRef>>;
+export default ScrollBar;

node_modules/rc-virtual-list/es/ScrollBar.js

@@ -0,0 +1,245 @@
+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 classNames from 'classnames';
+import raf from "rc-util/es/raf";
+import * as React from 'react';
+import { getPageXY } from "./hooks/useScrollDrag";
+var ScrollBar = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var prefixCls = props.prefixCls,
+    rtl = props.rtl,
+    scrollOffset = props.scrollOffset,
+    scrollRange = props.scrollRange,
+    onStartMove = props.onStartMove,
+    onStopMove = props.onStopMove,
+    onScroll = props.onScroll,
+    horizontal = props.horizontal,
+    spinSize = props.spinSize,
+    containerSize = props.containerSize,
+    style = props.style,
+    propsThumbStyle = props.thumbStyle,
+    showScrollBar = props.showScrollBar;
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    dragging = _React$useState2[0],
+    setDragging = _React$useState2[1];
+  var _React$useState3 = React.useState(null),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    pageXY = _React$useState4[0],
+    setPageXY = _React$useState4[1];
+  var _React$useState5 = React.useState(null),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    startTop = _React$useState6[0],
+    setStartTop = _React$useState6[1];
+  var isLTR = !rtl;
+
+  // ========================= Refs =========================
+  var scrollbarRef = React.useRef();
+  var thumbRef = React.useRef();
+
+  // ======================= Visible ========================
+  var _React$useState7 = React.useState(showScrollBar),
+    _React$useState8 = _slicedToArray(_React$useState7, 2),
+    visible = _React$useState8[0],
+    setVisible = _React$useState8[1];
+  var visibleTimeoutRef = React.useRef();
+  var delayHidden = function delayHidden() {
+    if (showScrollBar === true || showScrollBar === false) return;
+    clearTimeout(visibleTimeoutRef.current);
+    setVisible(true);
+    visibleTimeoutRef.current = setTimeout(function () {
+      setVisible(false);
+    }, 3000);
+  };
+
+  // ======================== Range =========================
+  var enableScrollRange = scrollRange - containerSize || 0;
+  var enableOffsetRange = containerSize - spinSize || 0;
+
+  // ========================= Top ==========================
+  var top = React.useMemo(function () {
+    if (scrollOffset === 0 || enableScrollRange === 0) {
+      return 0;
+    }
+    var ptg = scrollOffset / enableScrollRange;
+    return ptg * enableOffsetRange;
+  }, [scrollOffset, enableScrollRange, enableOffsetRange]);
+
+  // ====================== Container =======================
+  var onContainerMouseDown = function onContainerMouseDown(e) {
+    e.stopPropagation();
+    e.preventDefault();
+  };
+
+  // ======================== Thumb =========================
+  var stateRef = React.useRef({
+    top: top,
+    dragging: dragging,
+    pageY: pageXY,
+    startTop: startTop
+  });
+  stateRef.current = {
+    top: top,
+    dragging: dragging,
+    pageY: pageXY,
+    startTop: startTop
+  };
+  var onThumbMouseDown = function onThumbMouseDown(e) {
+    setDragging(true);
+    setPageXY(getPageXY(e, horizontal));
+    setStartTop(stateRef.current.top);
+    onStartMove();
+    e.stopPropagation();
+    e.preventDefault();
+  };
+
+  // ======================== Effect ========================
+
+  // React make event as passive, but we need to preventDefault
+  // Add event on dom directly instead.
+  // ref: https://github.com/facebook/react/issues/9809
+  React.useEffect(function () {
+    var onScrollbarTouchStart = function onScrollbarTouchStart(e) {
+      e.preventDefault();
+    };
+    var scrollbarEle = scrollbarRef.current;
+    var thumbEle = thumbRef.current;
+    scrollbarEle.addEventListener('touchstart', onScrollbarTouchStart, {
+      passive: false
+    });
+    thumbEle.addEventListener('touchstart', onThumbMouseDown, {
+      passive: false
+    });
+    return function () {
+      scrollbarEle.removeEventListener('touchstart', onScrollbarTouchStart);
+      thumbEle.removeEventListener('touchstart', onThumbMouseDown);
+    };
+  }, []);
+
+  // Pass to effect
+  var enableScrollRangeRef = React.useRef();
+  enableScrollRangeRef.current = enableScrollRange;
+  var enableOffsetRangeRef = React.useRef();
+  enableOffsetRangeRef.current = enableOffsetRange;
+  React.useEffect(function () {
+    if (dragging) {
+      var moveRafId;
+      var onMouseMove = function onMouseMove(e) {
+        var _stateRef$current = stateRef.current,
+          stateDragging = _stateRef$current.dragging,
+          statePageY = _stateRef$current.pageY,
+          stateStartTop = _stateRef$current.startTop;
+        raf.cancel(moveRafId);
+        var rect = scrollbarRef.current.getBoundingClientRect();
+        var scale = containerSize / (horizontal ? rect.width : rect.height);
+        if (stateDragging) {
+          var offset = (getPageXY(e, horizontal) - statePageY) * scale;
+          var newTop = stateStartTop;
+          if (!isLTR && horizontal) {
+            newTop -= offset;
+          } else {
+            newTop += offset;
+          }
+          var tmpEnableScrollRange = enableScrollRangeRef.current;
+          var tmpEnableOffsetRange = enableOffsetRangeRef.current;
+          var ptg = tmpEnableOffsetRange ? newTop / tmpEnableOffsetRange : 0;
+          var newScrollTop = Math.ceil(ptg * tmpEnableScrollRange);
+          newScrollTop = Math.max(newScrollTop, 0);
+          newScrollTop = Math.min(newScrollTop, tmpEnableScrollRange);
+          moveRafId = raf(function () {
+            onScroll(newScrollTop, horizontal);
+          });
+        }
+      };
+      var onMouseUp = function onMouseUp() {
+        setDragging(false);
+        onStopMove();
+      };
+      window.addEventListener('mousemove', onMouseMove, {
+        passive: true
+      });
+      window.addEventListener('touchmove', onMouseMove, {
+        passive: true
+      });
+      window.addEventListener('mouseup', onMouseUp, {
+        passive: true
+      });
+      window.addEventListener('touchend', onMouseUp, {
+        passive: true
+      });
+      return function () {
+        window.removeEventListener('mousemove', onMouseMove);
+        window.removeEventListener('touchmove', onMouseMove);
+        window.removeEventListener('mouseup', onMouseUp);
+        window.removeEventListener('touchend', onMouseUp);
+        raf.cancel(moveRafId);
+      };
+    }
+  }, [dragging]);
+  React.useEffect(function () {
+    delayHidden();
+    return function () {
+      clearTimeout(visibleTimeoutRef.current);
+    };
+  }, [scrollOffset]);
+
+  // ====================== Imperative ======================
+  React.useImperativeHandle(ref, function () {
+    return {
+      delayHidden: delayHidden
+    };
+  });
+
+  // ======================== Render ========================
+  var scrollbarPrefixCls = "".concat(prefixCls, "-scrollbar");
+  var containerStyle = {
+    position: 'absolute',
+    visibility: visible ? null : 'hidden'
+  };
+  var thumbStyle = {
+    position: 'absolute',
+    borderRadius: 99,
+    background: 'var(--rc-virtual-list-scrollbar-bg, rgba(0, 0, 0, 0.5))',
+    cursor: 'pointer',
+    userSelect: 'none'
+  };
+  if (horizontal) {
+    Object.assign(containerStyle, {
+      height: 8,
+      left: 0,
+      right: 0,
+      bottom: 0
+    });
+    Object.assign(thumbStyle, _defineProperty({
+      height: '100%',
+      width: spinSize
+    }, isLTR ? 'left' : 'right', top));
+  } else {
+    Object.assign(containerStyle, _defineProperty({
+      width: 8,
+      top: 0,
+      bottom: 0
+    }, isLTR ? 'right' : 'left', 0));
+    Object.assign(thumbStyle, {
+      width: '100%',
+      height: spinSize,
+      top: top
+    });
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    ref: scrollbarRef,
+    className: classNames(scrollbarPrefixCls, _defineProperty(_defineProperty(_defineProperty({}, "".concat(scrollbarPrefixCls, "-horizontal"), horizontal), "".concat(scrollbarPrefixCls, "-vertical"), !horizontal), "".concat(scrollbarPrefixCls, "-visible"), visible)),
+    style: _objectSpread(_objectSpread({}, containerStyle), style),
+    onMouseDown: onContainerMouseDown,
+    onMouseMove: delayHidden
+  }, /*#__PURE__*/React.createElement("div", {
+    ref: thumbRef,
+    className: classNames("".concat(scrollbarPrefixCls, "-thumb"), _defineProperty({}, "".concat(scrollbarPrefixCls, "-thumb-moving"), dragging)),
+    style: _objectSpread(_objectSpread({}, thumbStyle), propsThumbStyle),
+    onMouseDown: onThumbMouseDown
+  }));
+});
+if (process.env.NODE_ENV !== 'production') {
+  ScrollBar.displayName = 'ScrollBar';
+}
+export default ScrollBar;

node_modules/rc-virtual-list/es/hooks/useChildren.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import type { RenderFunc, SharedConfig } from '../interface';
+export default function useChildren<T>(list: T[], startIndex: number, endIndex: number, scrollWidth: number, offsetX: number, setNodeRef: (item: T, element: HTMLElement) => void, renderFunc: RenderFunc<T>, { getKey }: SharedConfig<T>): React.JSX.Element[];

node_modules/rc-virtual-list/es/hooks/useChildren.js

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { Item } from "../Item";
+export default function useChildren(list, startIndex, endIndex, scrollWidth, offsetX, setNodeRef, renderFunc, _ref) {
+  var getKey = _ref.getKey;
+  return list.slice(startIndex, endIndex + 1).map(function (item, index) {
+    var eleIndex = startIndex + index;
+    var node = renderFunc(item, eleIndex, {
+      style: {
+        width: scrollWidth
+      },
+      offsetX: offsetX
+    });
+    var key = getKey(item);
+    return /*#__PURE__*/React.createElement(Item, {
+      key: key,
+      setRef: function setRef(ele) {
+        return setNodeRef(item, ele);
+      }
+    }, node);
+  });
+}

node_modules/rc-virtual-list/es/hooks/useDiffItem.d.ts

@@ -0,0 +1,2 @@
+import type { GetKey } from '../interface';
+export default function useDiffItem<T>(data: T[], getKey: GetKey<T>, onDiff?: (diffIndex: number) => void): [T];

node_modules/rc-virtual-list/es/hooks/useDiffItem.js

@@ -0,0 +1,22 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import { findListDiffIndex } from "../utils/algorithmUtil";
+export default function useDiffItem(data, getKey, onDiff) {
+  var _React$useState = React.useState(data),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    prevData = _React$useState2[0],
+    setPrevData = _React$useState2[1];
+  var _React$useState3 = React.useState(null),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    diffItem = _React$useState4[0],
+    setDiffItem = _React$useState4[1];
+  React.useEffect(function () {
+    var diff = findListDiffIndex(prevData || [], data || [], getKey);
+    if ((diff === null || diff === void 0 ? void 0 : diff.index) !== undefined) {
+      onDiff === null || onDiff === void 0 || onDiff(diff.index);
+      setDiffItem(data[diff.index]);
+    }
+    setPrevData(data);
+  }, [data]);
+  return [diffItem];
+}

node_modules/rc-virtual-list/es/hooks/useFrameWheel.d.ts

@@ -0,0 +1,10 @@
+interface FireFoxDOMMouseScrollEvent {
+    detail: number;
+    preventDefault: VoidFunction;
+}
+export default function useFrameWheel(inVirtual: boolean, isScrollAtTop: boolean, isScrollAtBottom: boolean, isScrollAtLeft: boolean, isScrollAtRight: boolean, horizontalScroll: boolean, 
+/***
+ * Return `true` when you need to prevent default event
+ */
+onWheelDelta: (offset: number, horizontal: boolean) => void): [(e: WheelEvent) => void, (e: FireFoxDOMMouseScrollEvent) => void];
+export {};

node_modules/rc-virtual-list/es/hooks/useFrameWheel.js

@@ -0,0 +1,93 @@
+import raf from "rc-util/es/raf";
+import { useRef } from 'react';
+import isFF from "../utils/isFirefox";
+import useOriginScroll from "./useOriginScroll";
+export default function useFrameWheel(inVirtual, isScrollAtTop, isScrollAtBottom, isScrollAtLeft, isScrollAtRight, horizontalScroll,
+/***
+ * Return `true` when you need to prevent default event
+ */
+onWheelDelta) {
+  var offsetRef = useRef(0);
+  var nextFrameRef = useRef(null);
+
+  // Firefox patch
+  var wheelValueRef = useRef(null);
+  var isMouseScrollRef = useRef(false);
+
+  // Scroll status sync
+  var originScroll = useOriginScroll(isScrollAtTop, isScrollAtBottom, isScrollAtLeft, isScrollAtRight);
+  function onWheelY(e, deltaY) {
+    raf.cancel(nextFrameRef.current);
+
+    // Do nothing when scroll at the edge, Skip check when is in scroll
+    if (originScroll(false, deltaY)) return;
+
+    // Skip if nest List has handled this event
+    var event = e;
+    if (!event._virtualHandled) {
+      event._virtualHandled = true;
+    } else {
+      return;
+    }
+    offsetRef.current += deltaY;
+    wheelValueRef.current = deltaY;
+
+    // Proxy of scroll events
+    if (!isFF) {
+      event.preventDefault();
+    }
+    nextFrameRef.current = raf(function () {
+      // Patch a multiple for Firefox to fix wheel number too small
+      // ref: https://github.com/ant-design/ant-design/issues/26372#issuecomment-679460266
+      var patchMultiple = isMouseScrollRef.current ? 10 : 1;
+      onWheelDelta(offsetRef.current * patchMultiple, false);
+      offsetRef.current = 0;
+    });
+  }
+  function onWheelX(event, deltaX) {
+    onWheelDelta(deltaX, true);
+    if (!isFF) {
+      event.preventDefault();
+    }
+  }
+
+  // Check for which direction does wheel do. `sx` means `shift + wheel`
+  var wheelDirectionRef = useRef(null);
+  var wheelDirectionCleanRef = useRef(null);
+  function onWheel(event) {
+    if (!inVirtual) return;
+
+    // Wait for 2 frame to clean direction
+    raf.cancel(wheelDirectionCleanRef.current);
+    wheelDirectionCleanRef.current = raf(function () {
+      wheelDirectionRef.current = null;
+    }, 2);
+    var deltaX = event.deltaX,
+      deltaY = event.deltaY,
+      shiftKey = event.shiftKey;
+    var mergedDeltaX = deltaX;
+    var mergedDeltaY = deltaY;
+    if (wheelDirectionRef.current === 'sx' || !wheelDirectionRef.current && (shiftKey || false) && deltaY && !deltaX) {
+      mergedDeltaX = deltaY;
+      mergedDeltaY = 0;
+      wheelDirectionRef.current = 'sx';
+    }
+    var absX = Math.abs(mergedDeltaX);
+    var absY = Math.abs(mergedDeltaY);
+    if (wheelDirectionRef.current === null) {
+      wheelDirectionRef.current = horizontalScroll && absX > absY ? 'x' : 'y';
+    }
+    if (wheelDirectionRef.current === 'y') {
+      onWheelY(event, mergedDeltaY);
+    } else {
+      onWheelX(event, mergedDeltaX);
+    }
+  }
+
+  // A patch for firefox
+  function onFireFoxScroll(event) {
+    if (!inVirtual) return;
+    isMouseScrollRef.current = event.detail === wheelValueRef.current;
+  }
+  return [onWheel, onFireFoxScroll];
+}

node_modules/rc-virtual-list/es/hooks/useGetSize.d.ts

@@ -0,0 +1,7 @@
+import type CacheMap from '../utils/CacheMap';
+import type { GetKey, GetSize } from '../interface';
+/**
+ * Size info need loop query for the `heights` which will has the perf issue.
+ * Let cache result for each render phase.
+ */
+export declare function useGetSize<T>(mergedData: T[], getKey: GetKey<T>, heights: CacheMap, itemHeight: number): GetSize;

node_modules/rc-virtual-list/es/hooks/useGetSize.js

@@ -0,0 +1,48 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+
+/**
+ * Size info need loop query for the `heights` which will has the perf issue.
+ * Let cache result for each render phase.
+ */
+export function useGetSize(mergedData, getKey, heights, itemHeight) {
+  var _React$useMemo = React.useMemo(function () {
+      return [new Map(), []];
+    }, [mergedData, heights.id, itemHeight]),
+    _React$useMemo2 = _slicedToArray(_React$useMemo, 2),
+    key2Index = _React$useMemo2[0],
+    bottomList = _React$useMemo2[1];
+  var getSize = function getSize(startKey) {
+    var endKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startKey;
+    // Get from cache first
+    var startIndex = key2Index.get(startKey);
+    var endIndex = key2Index.get(endKey);
+
+    // Loop to fill the cache
+    if (startIndex === undefined || endIndex === undefined) {
+      var dataLen = mergedData.length;
+      for (var i = bottomList.length; i < dataLen; i += 1) {
+        var _heights$get;
+        var item = mergedData[i];
+        var key = getKey(item);
+        key2Index.set(key, i);
+        var cacheHeight = (_heights$get = heights.get(key)) !== null && _heights$get !== void 0 ? _heights$get : itemHeight;
+        bottomList[i] = (bottomList[i - 1] || 0) + cacheHeight;
+        if (key === startKey) {
+          startIndex = i;
+        }
+        if (key === endKey) {
+          endIndex = i;
+        }
+        if (startIndex !== undefined && endIndex !== undefined) {
+          break;
+        }
+      }
+    }
+    return {
+      top: bottomList[startIndex - 1] || 0,
+      bottom: bottomList[endIndex]
+    };
+  };
+  return getSize;
+}

node_modules/rc-virtual-list/es/hooks/useHeights.d.ts

@@ -0,0 +1,8 @@
+import type { GetKey } from '../interface';
+import CacheMap from '../utils/CacheMap';
+export default function useHeights<T>(getKey: GetKey<T>, onItemAdd?: (item: T) => void, onItemRemove?: (item: T) => void): [
+    setInstanceRef: (item: T, instance: HTMLElement) => void,
+    collectHeight: (sync?: boolean) => void,
+    cacheMap: CacheMap,
+    updatedMark: number
+];

node_modules/rc-virtual-list/es/hooks/useHeights.js

@@ -0,0 +1,83 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import { useEffect, useRef } from 'react';
+import CacheMap from "../utils/CacheMap";
+function parseNumber(value) {
+  var num = parseFloat(value);
+  return isNaN(num) ? 0 : num;
+}
+export default function useHeights(getKey, onItemAdd, onItemRemove) {
+  var _React$useState = React.useState(0),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    updatedMark = _React$useState2[0],
+    setUpdatedMark = _React$useState2[1];
+  var instanceRef = useRef(new Map());
+  var heightsRef = useRef(new CacheMap());
+  var promiseIdRef = useRef(0);
+  function cancelRaf() {
+    promiseIdRef.current += 1;
+  }
+  function collectHeight() {
+    var sync = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    cancelRaf();
+    var doCollect = function doCollect() {
+      var changed = false;
+      instanceRef.current.forEach(function (element, key) {
+        if (element && element.offsetParent) {
+          var offsetHeight = element.offsetHeight;
+          var _getComputedStyle = getComputedStyle(element),
+            marginTop = _getComputedStyle.marginTop,
+            marginBottom = _getComputedStyle.marginBottom;
+          var marginTopNum = parseNumber(marginTop);
+          var marginBottomNum = parseNumber(marginBottom);
+          var totalHeight = offsetHeight + marginTopNum + marginBottomNum;
+          if (heightsRef.current.get(key) !== totalHeight) {
+            heightsRef.current.set(key, totalHeight);
+            changed = true;
+          }
+        }
+      });
+
+      // Always trigger update mark to tell parent that should re-calculate heights when resized
+      if (changed) {
+        setUpdatedMark(function (c) {
+          return c + 1;
+        });
+      }
+    };
+    if (sync) {
+      doCollect();
+    } else {
+      promiseIdRef.current += 1;
+      var id = promiseIdRef.current;
+      Promise.resolve().then(function () {
+        if (id === promiseIdRef.current) {
+          doCollect();
+        }
+      });
+    }
+  }
+  function setInstanceRef(item, instance) {
+    var key = getKey(item);
+    var origin = instanceRef.current.get(key);
+    if (instance) {
+      instanceRef.current.set(key, instance);
+      collectHeight();
+    } else {
+      instanceRef.current.delete(key);
+    }
+
+    // Instance changed
+    if (!origin !== !instance) {
+      if (instance) {
+        onItemAdd === null || onItemAdd === void 0 || onItemAdd(item);
+      } else {
+        onItemRemove === null || onItemRemove === void 0 || onItemRemove(item);
+      }
+    }
+  }
+  useEffect(function () {
+    return cancelRaf;
+  }, []);
+  return [setInstanceRef, collectHeight, heightsRef.current, updatedMark];
+}

node_modules/rc-virtual-list/es/hooks/useMobileTouchMove.d.ts

@@ -0,0 +1,2 @@
+import type * as React from 'react';
+export default function useMobileTouchMove(inVirtual: boolean, listRef: React.RefObject<HTMLDivElement>, callback: (isHorizontal: boolean, offset: number, smoothOffset: boolean, e?: TouchEvent) => boolean): void;

node_modules/rc-virtual-list/es/hooks/useMobileTouchMove.js

@@ -0,0 +1,87 @@
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+import { useRef } from 'react';
+var SMOOTH_PTG = 14 / 15;
+export default function useMobileTouchMove(inVirtual, listRef, callback) {
+  var touchedRef = useRef(false);
+  var touchXRef = useRef(0);
+  var touchYRef = useRef(0);
+  var elementRef = useRef(null);
+
+  // Smooth scroll
+  var intervalRef = useRef(null);
+
+  /* eslint-disable prefer-const */
+  var cleanUpEvents;
+  var onTouchMove = function onTouchMove(e) {
+    if (touchedRef.current) {
+      var currentX = Math.ceil(e.touches[0].pageX);
+      var currentY = Math.ceil(e.touches[0].pageY);
+      var offsetX = touchXRef.current - currentX;
+      var offsetY = touchYRef.current - currentY;
+      var _isHorizontal = Math.abs(offsetX) > Math.abs(offsetY);
+      if (_isHorizontal) {
+        touchXRef.current = currentX;
+      } else {
+        touchYRef.current = currentY;
+      }
+      var scrollHandled = callback(_isHorizontal, _isHorizontal ? offsetX : offsetY, false, e);
+      if (scrollHandled) {
+        e.preventDefault();
+      }
+
+      // Smooth interval
+      clearInterval(intervalRef.current);
+      if (scrollHandled) {
+        intervalRef.current = setInterval(function () {
+          if (_isHorizontal) {
+            offsetX *= SMOOTH_PTG;
+          } else {
+            offsetY *= SMOOTH_PTG;
+          }
+          var offset = Math.floor(_isHorizontal ? offsetX : offsetY);
+          if (!callback(_isHorizontal, offset, true) || Math.abs(offset) <= 0.1) {
+            clearInterval(intervalRef.current);
+          }
+        }, 16);
+      }
+    }
+  };
+  var onTouchEnd = function onTouchEnd() {
+    touchedRef.current = false;
+    cleanUpEvents();
+  };
+  var onTouchStart = function onTouchStart(e) {
+    cleanUpEvents();
+    if (e.touches.length === 1 && !touchedRef.current) {
+      touchedRef.current = true;
+      touchXRef.current = Math.ceil(e.touches[0].pageX);
+      touchYRef.current = Math.ceil(e.touches[0].pageY);
+      elementRef.current = e.target;
+      elementRef.current.addEventListener('touchmove', onTouchMove, {
+        passive: false
+      });
+      elementRef.current.addEventListener('touchend', onTouchEnd, {
+        passive: true
+      });
+    }
+  };
+  cleanUpEvents = function cleanUpEvents() {
+    if (elementRef.current) {
+      elementRef.current.removeEventListener('touchmove', onTouchMove);
+      elementRef.current.removeEventListener('touchend', onTouchEnd);
+    }
+  };
+  useLayoutEffect(function () {
+    if (inVirtual) {
+      listRef.current.addEventListener('touchstart', onTouchStart, {
+        passive: true
+      });
+    }
+    return function () {
+      var _listRef$current;
+      (_listRef$current = listRef.current) === null || _listRef$current === void 0 || _listRef$current.removeEventListener('touchstart', onTouchStart);
+      cleanUpEvents();
+      clearInterval(intervalRef.current);
+    };
+  }, [inVirtual]);
+}

node_modules/rc-virtual-list/es/hooks/useOriginScroll.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (isScrollAtTop: boolean, isScrollAtBottom: boolean, isScrollAtLeft: boolean, isScrollAtRight: boolean) => (isHorizontal: boolean, delta: number, smoothOffset?: boolean) => boolean;
+export default _default;

node_modules/rc-virtual-list/es/hooks/useOriginScroll.js

@@ -0,0 +1,44 @@
+import { useRef } from 'react';
+export default (function (isScrollAtTop, isScrollAtBottom, isScrollAtLeft, isScrollAtRight) {
+  // Do lock for a wheel when scrolling
+  var lockRef = useRef(false);
+  var lockTimeoutRef = useRef(null);
+  function lockScroll() {
+    clearTimeout(lockTimeoutRef.current);
+    lockRef.current = true;
+    lockTimeoutRef.current = setTimeout(function () {
+      lockRef.current = false;
+    }, 50);
+  }
+
+  // Pass to ref since global add is in closure
+  var scrollPingRef = useRef({
+    top: isScrollAtTop,
+    bottom: isScrollAtBottom,
+    left: isScrollAtLeft,
+    right: isScrollAtRight
+  });
+  scrollPingRef.current.top = isScrollAtTop;
+  scrollPingRef.current.bottom = isScrollAtBottom;
+  scrollPingRef.current.left = isScrollAtLeft;
+  scrollPingRef.current.right = isScrollAtRight;
+  return function (isHorizontal, delta) {
+    var smoothOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var originScroll = isHorizontal ?
+    // Pass origin wheel when on the left
+    delta < 0 && scrollPingRef.current.left ||
+    // Pass origin wheel when on the right
+    delta > 0 && scrollPingRef.current.right // Pass origin wheel when on the top
+    : delta < 0 && scrollPingRef.current.top ||
+    // Pass origin wheel when on the bottom
+    delta > 0 && scrollPingRef.current.bottom;
+    if (smoothOffset && originScroll) {
+      // No need lock anymore when it's smooth offset from touchMove interval
+      clearTimeout(lockTimeoutRef.current);
+      lockRef.current = false;
+    } else if (!originScroll || lockRef.current) {
+      lockScroll();
+    }
+    return !lockRef.current && originScroll;
+  };
+});

node_modules/rc-virtual-list/es/hooks/useScrollDrag.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+export declare function getPageXY(e: React.MouseEvent | React.TouchEvent | MouseEvent | TouchEvent, horizontal: boolean): number;
+export default function useScrollDrag(inVirtual: boolean, componentRef: React.RefObject<HTMLElement>, onScrollOffset: (offset: number) => void): void;

node_modules/rc-virtual-list/es/hooks/useScrollDrag.js

@@ -0,0 +1,75 @@
+import raf from "rc-util/es/raf";
+import * as React from 'react';
+function smoothScrollOffset(offset) {
+  return Math.floor(Math.pow(offset, 0.5));
+}
+export function getPageXY(e, horizontal) {
+  var obj = 'touches' in e ? e.touches[0] : e;
+  return obj[horizontal ? 'pageX' : 'pageY'] - window[horizontal ? 'scrollX' : 'scrollY'];
+}
+export default function useScrollDrag(inVirtual, componentRef, onScrollOffset) {
+  React.useEffect(function () {
+    var ele = componentRef.current;
+    if (inVirtual && ele) {
+      var mouseDownLock = false;
+      var rafId;
+      var _offset;
+      var stopScroll = function stopScroll() {
+        raf.cancel(rafId);
+      };
+      var continueScroll = function continueScroll() {
+        stopScroll();
+        rafId = raf(function () {
+          onScrollOffset(_offset);
+          continueScroll();
+        });
+      };
+      var clearDragState = function clearDragState() {
+        mouseDownLock = false;
+        stopScroll();
+      };
+      var onMouseDown = function onMouseDown(e) {
+        // Skip if element set draggable
+        if (e.target.draggable || e.button !== 0) {
+          return;
+        }
+        // Skip if nest List has handled this event
+        var event = e;
+        if (!event._virtualHandled) {
+          event._virtualHandled = true;
+          mouseDownLock = true;
+        }
+      };
+      var onMouseMove = function onMouseMove(e) {
+        if (mouseDownLock) {
+          var mouseY = getPageXY(e, false);
+          var _ele$getBoundingClien = ele.getBoundingClientRect(),
+            top = _ele$getBoundingClien.top,
+            bottom = _ele$getBoundingClien.bottom;
+          if (mouseY <= top) {
+            var diff = top - mouseY;
+            _offset = -smoothScrollOffset(diff);
+            continueScroll();
+          } else if (mouseY >= bottom) {
+            var _diff = mouseY - bottom;
+            _offset = smoothScrollOffset(_diff);
+            continueScroll();
+          } else {
+            stopScroll();
+          }
+        }
+      };
+      ele.addEventListener('mousedown', onMouseDown);
+      ele.ownerDocument.addEventListener('mouseup', clearDragState);
+      ele.ownerDocument.addEventListener('mousemove', onMouseMove);
+      ele.ownerDocument.addEventListener('dragend', clearDragState);
+      return function () {
+        ele.removeEventListener('mousedown', onMouseDown);
+        ele.ownerDocument.removeEventListener('mouseup', clearDragState);
+        ele.ownerDocument.removeEventListener('mousemove', onMouseMove);
+        ele.ownerDocument.removeEventListener('dragend', clearDragState);
+        stopScroll();
+      };
+    }
+  }, [inVirtual]);
+}

node_modules/rc-virtual-list/es/hooks/useScrollTo.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import type { GetKey } from '../interface';
+import type CacheMap from '../utils/CacheMap';
+export type ScrollAlign = 'top' | 'bottom' | 'auto';
+export type ScrollPos = {
+    left?: number;
+    top?: number;
+};
+export type ScrollTarget = {
+    index: number;
+    align?: ScrollAlign;
+    offset?: number;
+} | {
+    key: React.Key;
+    align?: ScrollAlign;
+    offset?: number;
+};
+export default function useScrollTo<T>(containerRef: React.RefObject<HTMLDivElement>, data: T[], heights: CacheMap, itemHeight: number, getKey: GetKey<T>, collectHeight: () => void, syncScrollTop: (newTop: number) => void, triggerFlash: () => void): (arg: number | ScrollTarget) => void;

node_modules/rc-virtual-list/es/hooks/useScrollTo.js

@@ -0,0 +1,143 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+/* eslint-disable no-param-reassign */
+import * as React from 'react';
+import raf from "rc-util/es/raf";
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+import { warning } from 'rc-util';
+var MAX_TIMES = 10;
+export default function useScrollTo(containerRef, data, heights, itemHeight, getKey, collectHeight, syncScrollTop, triggerFlash) {
+  var scrollRef = React.useRef();
+  var _React$useState = React.useState(null),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    syncState = _React$useState2[0],
+    setSyncState = _React$useState2[1];
+
+  // ========================== Sync Scroll ==========================
+  useLayoutEffect(function () {
+    if (syncState && syncState.times < MAX_TIMES) {
+      // Never reach
+      if (!containerRef.current) {
+        setSyncState(function (ori) {
+          return _objectSpread({}, ori);
+        });
+        return;
+      }
+      collectHeight();
+      var targetAlign = syncState.targetAlign,
+        originAlign = syncState.originAlign,
+        index = syncState.index,
+        offset = syncState.offset;
+      var height = containerRef.current.clientHeight;
+      var needCollectHeight = false;
+      var newTargetAlign = targetAlign;
+      var targetTop = null;
+
+      // Go to next frame if height not exist
+      if (height) {
+        var mergedAlign = targetAlign || originAlign;
+
+        // Get top & bottom
+        var stackTop = 0;
+        var itemTop = 0;
+        var itemBottom = 0;
+        var maxLen = Math.min(data.length - 1, index);
+        for (var i = 0; i <= maxLen; i += 1) {
+          var key = getKey(data[i]);
+          itemTop = stackTop;
+          var cacheHeight = heights.get(key);
+          itemBottom = itemTop + (cacheHeight === undefined ? itemHeight : cacheHeight);
+          stackTop = itemBottom;
+        }
+
+        // Check if need sync height (visible range has item not record height)
+        var leftHeight = mergedAlign === 'top' ? offset : height - offset;
+        for (var _i = maxLen; _i >= 0; _i -= 1) {
+          var _key = getKey(data[_i]);
+          var _cacheHeight = heights.get(_key);
+          if (_cacheHeight === undefined) {
+            needCollectHeight = true;
+            break;
+          }
+          leftHeight -= _cacheHeight;
+          if (leftHeight <= 0) {
+            break;
+          }
+        }
+
+        // Scroll to
+        switch (mergedAlign) {
+          case 'top':
+            targetTop = itemTop - offset;
+            break;
+          case 'bottom':
+            targetTop = itemBottom - height + offset;
+            break;
+          default:
+            {
+              var scrollTop = containerRef.current.scrollTop;
+              var scrollBottom = scrollTop + height;
+              if (itemTop < scrollTop) {
+                newTargetAlign = 'top';
+              } else if (itemBottom > scrollBottom) {
+                newTargetAlign = 'bottom';
+              }
+            }
+        }
+        if (targetTop !== null) {
+          syncScrollTop(targetTop);
+        }
+
+        // One more time for sync
+        if (targetTop !== syncState.lastTop) {
+          needCollectHeight = true;
+        }
+      }
+
+      // Trigger next effect
+      if (needCollectHeight) {
+        setSyncState(_objectSpread(_objectSpread({}, syncState), {}, {
+          times: syncState.times + 1,
+          targetAlign: newTargetAlign,
+          lastTop: targetTop
+        }));
+      }
+    } else if (process.env.NODE_ENV !== 'production' && (syncState === null || syncState === void 0 ? void 0 : syncState.times) === MAX_TIMES) {
+      warning(false, 'Seems `scrollTo` with `rc-virtual-list` reach the max limitation. Please fire issue for us. Thanks.');
+    }
+  }, [syncState, containerRef.current]);
+
+  // =========================== Scroll To ===========================
+  return function (arg) {
+    // When not argument provided, we think dev may want to show the scrollbar
+    if (arg === null || arg === undefined) {
+      triggerFlash();
+      return;
+    }
+
+    // Normal scroll logic
+    raf.cancel(scrollRef.current);
+    if (typeof arg === 'number') {
+      syncScrollTop(arg);
+    } else if (arg && _typeof(arg) === 'object') {
+      var index;
+      var align = arg.align;
+      if ('index' in arg) {
+        index = arg.index;
+      } else {
+        index = data.findIndex(function (item) {
+          return getKey(item) === arg.key;
+        });
+      }
+      var _arg$offset = arg.offset,
+        offset = _arg$offset === void 0 ? 0 : _arg$offset;
+      setSyncState({
+        times: 0,
+        index: index,
+        offset: offset,
+        originAlign: align
+      });
+    }
+  };
+}

node_modules/rc-virtual-list/es/index.d.ts

@@ -0,0 +1,3 @@
+import List from './List';
+export type { ListRef, ListProps } from './List';
+export default List;

node_modules/rc-virtual-list/es/index.js

@@ -0,0 +1,2 @@
+import List from "./List";
+export default List;

node_modules/rc-virtual-list/es/interface.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+export type RenderFunc<T> = (item: T, index: number, props: {
+    style: React.CSSProperties;
+    offsetX: number;
+}) => React.ReactNode;
+export interface SharedConfig<T> {
+    getKey: (item: T) => React.Key;
+}
+export type GetKey<T> = (item: T) => React.Key;
+export type GetSize = (startKey: React.Key, endKey?: React.Key) => {
+    top: number;
+    bottom: number;
+};
+export interface ExtraRenderInfo {
+    /** Virtual list start line */
+    start: number;
+    /** Virtual list end line */
+    end: number;
+    /** Is current in virtual render */
+    virtual: boolean;
+    /** Used for `scrollWidth` tell the horizontal offset */
+    offsetX: number;
+    offsetY: number;
+    rtl: boolean;
+    getSize: GetSize;
+}

node_modules/rc-virtual-list/es/interface.js

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

node_modules/rc-virtual-list/es/mock.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import type { ListProps, ListRef } from './List';
+declare const List: <Item = any>(props: React.PropsWithChildren<ListProps<Item>> & {
+    ref?: React.Ref<ListRef>;
+}) => React.ReactElement;
+export default List;

node_modules/rc-virtual-list/es/mock.js

@@ -0,0 +1,10 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import * as React from 'react';
+import { RawList } from "./List";
+var List = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  return RawList(_objectSpread(_objectSpread({}, props), {}, {
+    virtual: false
+  }), ref);
+});
+List.displayName = 'List';
+export default List;

node_modules/rc-virtual-list/es/utils/CacheMap.d.ts

@@ -0,0 +1,16 @@
+import type React from 'react';
+declare class CacheMap {
+    maps: Record<string, number>;
+    id: number;
+    diffRecords: Map<React.Key, number>;
+    constructor();
+    set(key: React.Key, value: number): void;
+    get(key: React.Key): number;
+    /**
+     * CacheMap will record the key changed.
+     * To help to know what's update in the next render.
+     */
+    resetRecord(): void;
+    getRecord(): Map<React.Key, number>;
+}
+export default CacheMap;

node_modules/rc-virtual-list/es/utils/CacheMap.js

@@ -0,0 +1,46 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// Firefox has low performance of map.
+var CacheMap = /*#__PURE__*/function () {
+  function CacheMap() {
+    _classCallCheck(this, CacheMap);
+    _defineProperty(this, "maps", void 0);
+    // Used for cache key
+    // `useMemo` no need to update if `id` not change
+    _defineProperty(this, "id", 0);
+    _defineProperty(this, "diffRecords", new Map());
+    this.maps = Object.create(null);
+  }
+  _createClass(CacheMap, [{
+    key: "set",
+    value: function set(key, value) {
+      // Record prev value
+      this.diffRecords.set(key, this.maps[key]);
+      this.maps[key] = value;
+      this.id += 1;
+    }
+  }, {
+    key: "get",
+    value: function get(key) {
+      return this.maps[key];
+    }
+
+    /**
+     * CacheMap will record the key changed.
+     * To help to know what's update in the next render.
+     */
+  }, {
+    key: "resetRecord",
+    value: function resetRecord() {
+      this.diffRecords.clear();
+    }
+  }, {
+    key: "getRecord",
+    value: function getRecord() {
+      return this.diffRecords;
+    }
+  }]);
+  return CacheMap;
+}();
+export default CacheMap;

node_modules/rc-virtual-list/es/utils/algorithmUtil.d.ts

@@ -0,0 +1,23 @@
+import type * as React from 'react';
+/**
+ * Get index with specific start index one by one. e.g.
+ * min: 3, max: 9, start: 6
+ *
+ * Return index is:
+ * [0]: 6
+ * [1]: 7
+ * [2]: 5
+ * [3]: 8
+ * [4]: 4
+ * [5]: 9
+ * [6]: 3
+ */
+export declare function getIndexByStartLoc(min: number, max: number, start: number, index: number): number;
+/**
+ * We assume that 2 list has only 1 item diff and others keeping the order.
+ * So we can use dichotomy algorithm to find changed one.
+ */
+export declare function findListDiffIndex<T>(originList: T[], targetList: T[], getKey: (item: T) => React.Key): {
+    index: number;
+    multiple: boolean;
+} | null;

node_modules/rc-virtual-list/es/utils/algorithmUtil.js

@@ -0,0 +1,80 @@
+/**
+ * Get index with specific start index one by one. e.g.
+ * min: 3, max: 9, start: 6
+ *
+ * Return index is:
+ * [0]: 6
+ * [1]: 7
+ * [2]: 5
+ * [3]: 8
+ * [4]: 4
+ * [5]: 9
+ * [6]: 3
+ */
+export function getIndexByStartLoc(min, max, start, index) {
+  var beforeCount = start - min;
+  var afterCount = max - start;
+  var balanceCount = Math.min(beforeCount, afterCount) * 2;
+
+  // Balance
+  if (index <= balanceCount) {
+    var stepIndex = Math.floor(index / 2);
+    if (index % 2) {
+      return start + stepIndex + 1;
+    }
+    return start - stepIndex;
+  }
+
+  // One is out of range
+  if (beforeCount > afterCount) {
+    return start - (index - afterCount);
+  }
+  return start + (index - beforeCount);
+}
+
+/**
+ * We assume that 2 list has only 1 item diff and others keeping the order.
+ * So we can use dichotomy algorithm to find changed one.
+ */
+export function findListDiffIndex(originList, targetList, getKey) {
+  var originLen = originList.length;
+  var targetLen = targetList.length;
+  var shortList;
+  var longList;
+  if (originLen === 0 && targetLen === 0) {
+    return null;
+  }
+  if (originLen < targetLen) {
+    shortList = originList;
+    longList = targetList;
+  } else {
+    shortList = targetList;
+    longList = originList;
+  }
+  var notExistKey = {
+    __EMPTY_ITEM__: true
+  };
+  function getItemKey(item) {
+    if (item !== undefined) {
+      return getKey(item);
+    }
+    return notExistKey;
+  }
+
+  // Loop to find diff one
+  var diffIndex = null;
+  var multiple = Math.abs(originLen - targetLen) !== 1;
+  for (var i = 0; i < longList.length; i += 1) {
+    var shortKey = getItemKey(shortList[i]);
+    var longKey = getItemKey(longList[i]);
+    if (shortKey !== longKey) {
+      diffIndex = i;
+      multiple = multiple || shortKey !== getItemKey(longList[i + 1]);
+      break;
+    }
+  }
+  return diffIndex === null ? null : {
+    index: diffIndex,
+    multiple: multiple
+  };
+}

node_modules/rc-virtual-list/es/utils/isFirefox.d.ts

@@ -0,0 +1,2 @@
+declare const isFF: boolean;
+export default isFF;

node_modules/rc-virtual-list/es/utils/isFirefox.js

@@ -0,0 +1,3 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+var isFF = (typeof navigator === "undefined" ? "undefined" : _typeof(navigator)) === 'object' && /Firefox/i.test(navigator.userAgent);
+export default isFF;

node_modules/rc-virtual-list/es/utils/scrollbarUtil.d.ts

@@ -0,0 +1 @@
+export declare function getSpinSize(containerSize?: number, scrollRange?: number): number;

node_modules/rc-virtual-list/es/utils/scrollbarUtil.js

@@ -0,0 +1,11 @@
+var MIN_SIZE = 20;
+export function getSpinSize() {
+  var containerSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  var scrollRange = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var baseSize = containerSize / scrollRange * containerSize;
+  if (isNaN(baseSize)) {
+    baseSize = 0;
+  }
+  baseSize = Math.max(baseSize, MIN_SIZE);
+  return Math.floor(baseSize);
+}