add all frontend files

node_modules/rc-overflow/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2019-present afc163
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/rc-overflow/README.md

@@ -0,0 +1,57 @@
+# rc-overflow 🐾
+
+[![NPM version][npm-image]][npm-url]
+[![npm download][download-image]][download-url]
+[![build status][github-actions-image]][github-actions-url]
+[![Codecov][codecov-image]][codecov-url]
+[![bundle size][bundlephobia-image]][bundlephobia-url]
+[![dumi][dumi-image]][dumi-url]
+
+[npm-image]: http://img.shields.io/npm/v/rc-overflow.svg?style=flat-square
+[npm-url]: http://npmjs.org/package/rc-overflow
+[github-actions-image]: https://github.com/react-component/overflow/workflows/CI/badge.svg
+[github-actions-url]: https://github.com/react-component/overflow/actions
+[codecov-image]: https://img.shields.io/codecov/c/github/react-component/overflow/master.svg?style=flat-square
+[codecov-url]: https://codecov.io/gh/react-component/overflow/branch/master
+[david-url]: https://david-dm.org/react-component/overflow
+[david-image]: https://david-dm.org/react-component/overflow/status.svg?style=flat-square
+[david-dev-url]: https://david-dm.org/react-component/overflow?type=dev
+[david-dev-image]: https://david-dm.org/react-component/overflow/dev-status.svg?style=flat-square
+[download-image]: https://img.shields.io/npm/dm/rc-overflow.svg?style=flat-square
+[download-url]: https://npmjs.org/package/rc-overflow
+[bundlephobia-url]: https://bundlephobia.com/result?p=rc-overflow
+[bundlephobia-image]: https://badgen.net/bundlephobia/minzip/rc-overflow
+[dumi-url]: https://github.com/umijs/dumi
+[dumi-image]: https://img.shields.io/badge/docs%20by-dumi-blue?style=flat-square
+
+Auto collapse box when overflow
+
+## Live Demo
+
+https://overflow-react-component.vercel.app/
+
+## Install
+
+[![rc-overflow](https://nodei.co/npm/rc-overflow.png)](https://npmjs.org/package/rc-overflow)
+
+## Usage
+
+```ts
+// TODO
+```
+
+## API
+
+| Property | Type | Default | Description |
+| -------- | ---- | ------- | ----------- |
+
+## Development
+
+```
+npm install
+npm start
+```
+
+## License
+
+rc-overflow is released under the MIT license.

node_modules/rc-overflow/assets/index.less

@@ -0,0 +1,15 @@
+@overflow-prefix-cls: rc-overflow;
+
+.@{overflow-prefix-cls} {
+  display: flex;
+  flex-wrap: wrap;
+  max-width: 100%;
+  position: relative;
+
+  &-item {
+    background: rgba(0, 255, 0, 0.2);
+    box-shadow: 0 0 1px black;
+    flex: none;
+    max-width: 100%;
+  }
+}

node_modules/rc-overflow/es/Item.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import type { ComponentType } from './RawItem';
+export interface ItemProps<ItemType> extends React.HTMLAttributes<any> {
+    prefixCls: string;
+    item?: ItemType;
+    className?: string;
+    style?: React.CSSProperties;
+    renderItem?: (item: ItemType, info: {
+        index: number;
+    }) => React.ReactNode;
+    responsive?: boolean;
+    /**
+     * @private To make node structure stable. We need keep wrap with ResizeObserver.
+     * But disable it when it's no need to real measure.
+     */
+    responsiveDisabled?: boolean;
+    itemKey?: React.Key;
+    registerSize: (key: React.Key, width: number | null) => void;
+    children?: React.ReactNode;
+    display: boolean;
+    order: number;
+    component?: ComponentType;
+    invalidate?: boolean;
+}
+declare const Item: React.ForwardRefExoticComponent<ItemProps<unknown> & React.RefAttributes<any>>;
+export default Item;

node_modules/rc-overflow/es/Item.js

@@ -0,0 +1,77 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["prefixCls", "invalidate", "item", "renderItem", "responsive", "responsiveDisabled", "registerSize", "itemKey", "className", "style", "children", "display", "order", "component"];
+import * as React from 'react';
+import classNames from 'classnames';
+import ResizeObserver from 'rc-resize-observer';
+// Use shared variable to save bundle size
+var UNDEFINED = undefined;
+function InternalItem(props, ref) {
+  var prefixCls = props.prefixCls,
+    invalidate = props.invalidate,
+    item = props.item,
+    renderItem = props.renderItem,
+    responsive = props.responsive,
+    responsiveDisabled = props.responsiveDisabled,
+    registerSize = props.registerSize,
+    itemKey = props.itemKey,
+    className = props.className,
+    style = props.style,
+    children = props.children,
+    display = props.display,
+    order = props.order,
+    _props$component = props.component,
+    Component = _props$component === void 0 ? 'div' : _props$component,
+    restProps = _objectWithoutProperties(props, _excluded);
+  var mergedHidden = responsive && !display;
+
+  // ================================ Effect ================================
+  function internalRegisterSize(width) {
+    registerSize(itemKey, width);
+  }
+  React.useEffect(function () {
+    return function () {
+      internalRegisterSize(null);
+    };
+  }, []);
+
+  // ================================ Render ================================
+  var childNode = renderItem && item !== UNDEFINED ? renderItem(item, {
+    index: order
+  }) : children;
+  var overflowStyle;
+  if (!invalidate) {
+    overflowStyle = {
+      opacity: mergedHidden ? 0 : 1,
+      height: mergedHidden ? 0 : UNDEFINED,
+      overflowY: mergedHidden ? 'hidden' : UNDEFINED,
+      order: responsive ? order : UNDEFINED,
+      pointerEvents: mergedHidden ? 'none' : UNDEFINED,
+      position: mergedHidden ? 'absolute' : UNDEFINED
+    };
+  }
+  var overflowProps = {};
+  if (mergedHidden) {
+    overflowProps['aria-hidden'] = true;
+  }
+  var itemNode = /*#__PURE__*/React.createElement(Component, _extends({
+    className: classNames(!invalidate && prefixCls, className),
+    style: _objectSpread(_objectSpread({}, overflowStyle), style)
+  }, overflowProps, restProps, {
+    ref: ref
+  }), childNode);
+  if (responsive) {
+    itemNode = /*#__PURE__*/React.createElement(ResizeObserver, {
+      onResize: function onResize(_ref) {
+        var offsetWidth = _ref.offsetWidth;
+        internalRegisterSize(offsetWidth);
+      },
+      disabled: responsiveDisabled
+    }, itemNode);
+  }
+  return itemNode;
+}
+var Item = /*#__PURE__*/React.forwardRef(InternalItem);
+Item.displayName = 'Item';
+export default Item;

node_modules/rc-overflow/es/Overflow.d.ts

@@ -0,0 +1,44 @@
+import * as React from 'react';
+import type { ComponentType } from './RawItem';
+import RawItem from './RawItem';
+declare const RESPONSIVE: "responsive";
+declare const INVALIDATE: "invalidate";
+export { OverflowContext } from './context';
+export type { ComponentType } from './RawItem';
+export interface OverflowProps<ItemType> extends Omit<React.HTMLAttributes<any>, 'prefix'> {
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    data?: ItemType[];
+    itemKey?: React.Key | ((item: ItemType) => React.Key);
+    /** Used for `responsive`. It will limit render node to avoid perf issue */
+    itemWidth?: number;
+    renderItem?: (item: ItemType, info: {
+        index: number;
+    }) => React.ReactNode;
+    /** @private Do not use in your production. Render raw node that need wrap Item by developer self */
+    renderRawItem?: (item: ItemType, index: number) => React.ReactElement;
+    maxCount?: number | typeof RESPONSIVE | typeof INVALIDATE;
+    renderRest?: React.ReactNode | ((omittedItems: ItemType[]) => React.ReactNode);
+    /** @private Do not use in your production. Render raw node that need wrap Item by developer self */
+    renderRawRest?: (omittedItems: ItemType[]) => React.ReactElement;
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+    component?: ComponentType;
+    itemComponent?: ComponentType;
+    /** @private This API may be refactor since not well design */
+    onVisibleChange?: (visibleCount: number) => void;
+    /** When set to `full`, ssr will render full items by default and remove at client side */
+    ssr?: 'full';
+}
+type ForwardOverflowType = <ItemType = any>(props: React.PropsWithChildren<OverflowProps<ItemType>> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => React.ReactElement;
+type FilledOverflowType = ForwardOverflowType & {
+    Item: typeof RawItem;
+    RESPONSIVE: typeof RESPONSIVE;
+    /** Will work as normal `component`. Skip patch props like `prefixCls`. */
+    INVALIDATE: typeof INVALIDATE;
+};
+declare const _default: FilledOverflowType;
+export default _default;

node_modules/rc-overflow/es/Overflow.js

@@ -0,0 +1,314 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["prefixCls", "data", "renderItem", "renderRawItem", "itemKey", "itemWidth", "ssr", "style", "className", "maxCount", "renderRest", "renderRawRest", "prefix", "suffix", "component", "itemComponent", "onVisibleChange"];
+import * as React from 'react';
+import { useState, useMemo, useCallback } from 'react';
+import classNames from 'classnames';
+import ResizeObserver from 'rc-resize-observer';
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+import Item from "./Item";
+import useEffectState, { useBatcher } from "./hooks/useEffectState";
+import RawItem from "./RawItem";
+import { OverflowContext } from "./context";
+var RESPONSIVE = 'responsive';
+var INVALIDATE = 'invalidate';
+export { OverflowContext } from "./context";
+function defaultRenderRest(omittedItems) {
+  return "+ ".concat(omittedItems.length, " ...");
+}
+function Overflow(props, ref) {
+  var _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? 'rc-overflow' : _props$prefixCls,
+    _props$data = props.data,
+    data = _props$data === void 0 ? [] : _props$data,
+    renderItem = props.renderItem,
+    renderRawItem = props.renderRawItem,
+    itemKey = props.itemKey,
+    _props$itemWidth = props.itemWidth,
+    itemWidth = _props$itemWidth === void 0 ? 10 : _props$itemWidth,
+    ssr = props.ssr,
+    style = props.style,
+    className = props.className,
+    maxCount = props.maxCount,
+    renderRest = props.renderRest,
+    renderRawRest = props.renderRawRest,
+    prefix = props.prefix,
+    suffix = props.suffix,
+    _props$component = props.component,
+    Component = _props$component === void 0 ? 'div' : _props$component,
+    itemComponent = props.itemComponent,
+    onVisibleChange = props.onVisibleChange,
+    restProps = _objectWithoutProperties(props, _excluded);
+  var fullySSR = ssr === 'full';
+  var notifyEffectUpdate = useBatcher();
+  var _useEffectState = useEffectState(notifyEffectUpdate, null),
+    _useEffectState2 = _slicedToArray(_useEffectState, 2),
+    containerWidth = _useEffectState2[0],
+    setContainerWidth = _useEffectState2[1];
+  var mergedContainerWidth = containerWidth || 0;
+  var _useEffectState3 = useEffectState(notifyEffectUpdate, new Map()),
+    _useEffectState4 = _slicedToArray(_useEffectState3, 2),
+    itemWidths = _useEffectState4[0],
+    setItemWidths = _useEffectState4[1];
+  var _useEffectState5 = useEffectState(notifyEffectUpdate, 0),
+    _useEffectState6 = _slicedToArray(_useEffectState5, 2),
+    prevRestWidth = _useEffectState6[0],
+    setPrevRestWidth = _useEffectState6[1];
+  var _useEffectState7 = useEffectState(notifyEffectUpdate, 0),
+    _useEffectState8 = _slicedToArray(_useEffectState7, 2),
+    restWidth = _useEffectState8[0],
+    setRestWidth = _useEffectState8[1];
+  var _useEffectState9 = useEffectState(notifyEffectUpdate, 0),
+    _useEffectState10 = _slicedToArray(_useEffectState9, 2),
+    prefixWidth = _useEffectState10[0],
+    setPrefixWidth = _useEffectState10[1];
+  var _useEffectState11 = useEffectState(notifyEffectUpdate, 0),
+    _useEffectState12 = _slicedToArray(_useEffectState11, 2),
+    suffixWidth = _useEffectState12[0],
+    setSuffixWidth = _useEffectState12[1];
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    suffixFixedStart = _useState2[0],
+    setSuffixFixedStart = _useState2[1];
+  var _useState3 = useState(null),
+    _useState4 = _slicedToArray(_useState3, 2),
+    displayCount = _useState4[0],
+    setDisplayCount = _useState4[1];
+  var mergedDisplayCount = React.useMemo(function () {
+    if (displayCount === null && fullySSR) {
+      return Number.MAX_SAFE_INTEGER;
+    }
+    return displayCount || 0;
+  }, [displayCount, containerWidth]);
+  var _useState5 = useState(false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    restReady = _useState6[0],
+    setRestReady = _useState6[1];
+  var itemPrefixCls = "".concat(prefixCls, "-item");
+
+  // Always use the max width to avoid blink
+  var mergedRestWidth = Math.max(prevRestWidth, restWidth);
+
+  // ================================= Data =================================
+  var isResponsive = maxCount === RESPONSIVE;
+  var shouldResponsive = data.length && isResponsive;
+  var invalidate = maxCount === INVALIDATE;
+
+  /**
+   * When is `responsive`, we will always render rest node to get the real width of it for calculation
+   */
+  var showRest = shouldResponsive || typeof maxCount === 'number' && data.length > maxCount;
+  var mergedData = useMemo(function () {
+    var items = data;
+    if (shouldResponsive) {
+      if (containerWidth === null && fullySSR) {
+        items = data;
+      } else {
+        items = data.slice(0, Math.min(data.length, mergedContainerWidth / itemWidth));
+      }
+    } else if (typeof maxCount === 'number') {
+      items = data.slice(0, maxCount);
+    }
+    return items;
+  }, [data, itemWidth, containerWidth, maxCount, shouldResponsive]);
+  var omittedItems = useMemo(function () {
+    if (shouldResponsive) {
+      return data.slice(mergedDisplayCount + 1);
+    }
+    return data.slice(mergedData.length);
+  }, [data, mergedData, shouldResponsive, mergedDisplayCount]);
+
+  // ================================= Item =================================
+  var getKey = useCallback(function (item, index) {
+    var _ref;
+    if (typeof itemKey === 'function') {
+      return itemKey(item);
+    }
+    return (_ref = itemKey && (item === null || item === void 0 ? void 0 : item[itemKey])) !== null && _ref !== void 0 ? _ref : index;
+  }, [itemKey]);
+  var mergedRenderItem = useCallback(renderItem || function (item) {
+    return item;
+  }, [renderItem]);
+  function updateDisplayCount(count, suffixFixedStartVal, notReady) {
+    // React 18 will sync render even when the value is same in some case.
+    // We take `mergedData` as deps which may cause dead loop if it's dynamic generate.
+    // ref: https://github.com/ant-design/ant-design/issues/36559
+    if (displayCount === count && (suffixFixedStartVal === undefined || suffixFixedStartVal === suffixFixedStart)) {
+      return;
+    }
+    setDisplayCount(count);
+    if (!notReady) {
+      setRestReady(count < data.length - 1);
+      onVisibleChange === null || onVisibleChange === void 0 || onVisibleChange(count);
+    }
+    if (suffixFixedStartVal !== undefined) {
+      setSuffixFixedStart(suffixFixedStartVal);
+    }
+  }
+
+  // ================================= Size =================================
+  function onOverflowResize(_, element) {
+    setContainerWidth(element.clientWidth);
+  }
+  function registerSize(key, width) {
+    setItemWidths(function (origin) {
+      var clone = new Map(origin);
+      if (width === null) {
+        clone.delete(key);
+      } else {
+        clone.set(key, width);
+      }
+      return clone;
+    });
+  }
+  function registerOverflowSize(_, width) {
+    setRestWidth(width);
+    setPrevRestWidth(restWidth);
+  }
+  function registerPrefixSize(_, width) {
+    setPrefixWidth(width);
+  }
+  function registerSuffixSize(_, width) {
+    setSuffixWidth(width);
+  }
+
+  // ================================ Effect ================================
+  function getItemWidth(index) {
+    return itemWidths.get(getKey(mergedData[index], index));
+  }
+  useLayoutEffect(function () {
+    if (mergedContainerWidth && typeof mergedRestWidth === 'number' && mergedData) {
+      var totalWidth = prefixWidth + suffixWidth;
+      var len = mergedData.length;
+      var lastIndex = len - 1;
+
+      // When data count change to 0, reset this since not loop will reach
+      if (!len) {
+        updateDisplayCount(0, null);
+        return;
+      }
+      for (var i = 0; i < len; i += 1) {
+        var currentItemWidth = getItemWidth(i);
+
+        // Fully will always render
+        if (fullySSR) {
+          currentItemWidth = currentItemWidth || 0;
+        }
+
+        // Break since data not ready
+        if (currentItemWidth === undefined) {
+          updateDisplayCount(i - 1, undefined, true);
+          break;
+        }
+
+        // Find best match
+        totalWidth += currentItemWidth;
+        if (
+        // Only one means `totalWidth` is the final width
+        lastIndex === 0 && totalWidth <= mergedContainerWidth ||
+        // Last two width will be the final width
+        i === lastIndex - 1 && totalWidth + getItemWidth(lastIndex) <= mergedContainerWidth) {
+          // Additional check if match the end
+          updateDisplayCount(lastIndex, null);
+          break;
+        } else if (totalWidth + mergedRestWidth > mergedContainerWidth) {
+          // Can not hold all the content to show rest
+          updateDisplayCount(i - 1, totalWidth - currentItemWidth - suffixWidth + restWidth);
+          break;
+        }
+      }
+      if (suffix && getItemWidth(0) + suffixWidth > mergedContainerWidth) {
+        setSuffixFixedStart(null);
+      }
+    }
+  }, [mergedContainerWidth, itemWidths, restWidth, prefixWidth, suffixWidth, getKey, mergedData]);
+
+  // ================================ Render ================================
+  var displayRest = restReady && !!omittedItems.length;
+  var suffixStyle = {};
+  if (suffixFixedStart !== null && shouldResponsive) {
+    suffixStyle = {
+      position: 'absolute',
+      left: suffixFixedStart,
+      top: 0
+    };
+  }
+  var itemSharedProps = {
+    prefixCls: itemPrefixCls,
+    responsive: shouldResponsive,
+    component: itemComponent,
+    invalidate: invalidate
+  };
+
+  // >>>>> Choice render fun by `renderRawItem`
+  var internalRenderItemNode = renderRawItem ? function (item, index) {
+    var key = getKey(item, index);
+    return /*#__PURE__*/React.createElement(OverflowContext.Provider, {
+      key: key,
+      value: _objectSpread(_objectSpread({}, itemSharedProps), {}, {
+        order: index,
+        item: item,
+        itemKey: key,
+        registerSize: registerSize,
+        display: index <= mergedDisplayCount
+      })
+    }, renderRawItem(item, index));
+  } : function (item, index) {
+    var key = getKey(item, index);
+    return /*#__PURE__*/React.createElement(Item, _extends({}, itemSharedProps, {
+      order: index,
+      key: key,
+      item: item,
+      renderItem: mergedRenderItem,
+      itemKey: key,
+      registerSize: registerSize,
+      display: index <= mergedDisplayCount
+    }));
+  };
+
+  // >>>>> Rest node
+  var restContextProps = {
+    order: displayRest ? mergedDisplayCount : Number.MAX_SAFE_INTEGER,
+    className: "".concat(itemPrefixCls, "-rest"),
+    registerSize: registerOverflowSize,
+    display: displayRest
+  };
+  var mergedRenderRest = renderRest || defaultRenderRest;
+  var restNode = renderRawRest ? /*#__PURE__*/React.createElement(OverflowContext.Provider, {
+    value: _objectSpread(_objectSpread({}, itemSharedProps), restContextProps)
+  }, renderRawRest(omittedItems)) : /*#__PURE__*/React.createElement(Item, _extends({}, itemSharedProps, restContextProps), typeof mergedRenderRest === 'function' ? mergedRenderRest(omittedItems) : mergedRenderRest);
+  var overflowNode = /*#__PURE__*/React.createElement(Component, _extends({
+    className: classNames(!invalidate && prefixCls, className),
+    style: style,
+    ref: ref
+  }, restProps), prefix && /*#__PURE__*/React.createElement(Item, _extends({}, itemSharedProps, {
+    responsive: isResponsive,
+    responsiveDisabled: !shouldResponsive,
+    order: -1,
+    className: "".concat(itemPrefixCls, "-prefix"),
+    registerSize: registerPrefixSize,
+    display: true
+  }), prefix), mergedData.map(internalRenderItemNode), showRest ? restNode : null, suffix && /*#__PURE__*/React.createElement(Item, _extends({}, itemSharedProps, {
+    responsive: isResponsive,
+    responsiveDisabled: !shouldResponsive,
+    order: mergedDisplayCount,
+    className: "".concat(itemPrefixCls, "-suffix"),
+    registerSize: registerSuffixSize,
+    display: true,
+    style: suffixStyle
+  }), suffix));
+  return isResponsive ? /*#__PURE__*/React.createElement(ResizeObserver, {
+    onResize: onOverflowResize,
+    disabled: !shouldResponsive
+  }, overflowNode) : overflowNode;
+}
+var ForwardOverflow = /*#__PURE__*/React.forwardRef(Overflow);
+ForwardOverflow.displayName = 'Overflow';
+ForwardOverflow.Item = RawItem;
+ForwardOverflow.RESPONSIVE = RESPONSIVE;
+ForwardOverflow.INVALIDATE = INVALIDATE;
+
+// Convert to generic type
+export default ForwardOverflow;

node_modules/rc-overflow/es/RawItem.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export type ComponentType = React.ComponentType<any> | React.ForwardRefExoticComponent<any> | React.FC<any> | keyof React.ReactHTML;
+export interface RawItemProps extends React.HTMLAttributes<any> {
+    component?: ComponentType;
+    children?: React.ReactNode;
+}
+declare const RawItem: React.ForwardRefExoticComponent<RawItemProps & React.RefAttributes<any>>;
+export default RawItem;

node_modules/rc-overflow/es/RawItem.js

@@ -0,0 +1,37 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["component"],
+  _excluded2 = ["className"],
+  _excluded3 = ["className"];
+import * as React from 'react';
+import classNames from 'classnames';
+import Item from "./Item";
+import { OverflowContext } from "./context";
+var InternalRawItem = function InternalRawItem(props, ref) {
+  var context = React.useContext(OverflowContext);
+
+  // Render directly when context not provided
+  if (!context) {
+    var _props$component = props.component,
+      Component = _props$component === void 0 ? 'div' : _props$component,
+      _restProps = _objectWithoutProperties(props, _excluded);
+    return /*#__PURE__*/React.createElement(Component, _extends({}, _restProps, {
+      ref: ref
+    }));
+  }
+  var contextClassName = context.className,
+    restContext = _objectWithoutProperties(context, _excluded2);
+  var className = props.className,
+    restProps = _objectWithoutProperties(props, _excluded3);
+
+  // Do not pass context to sub item to avoid multiple measure
+  return /*#__PURE__*/React.createElement(OverflowContext.Provider, {
+    value: null
+  }, /*#__PURE__*/React.createElement(Item, _extends({
+    ref: ref,
+    className: classNames(contextClassName, className)
+  }, restContext, restProps)));
+};
+var RawItem = /*#__PURE__*/React.forwardRef(InternalRawItem);
+RawItem.displayName = 'RawItem';
+export default RawItem;

node_modules/rc-overflow/es/context.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export declare const OverflowContext: React.Context<{
+    prefixCls: string;
+    responsive: boolean;
+    order: number;
+    registerSize: (key: React.Key, width: number | null) => void;
+    display: boolean;
+    invalidate: boolean;
+    item?: any;
+    itemKey?: React.Key;
+    className?: string;
+}>;

node_modules/rc-overflow/es/context.js

@@ -0,0 +1,2 @@
+import React from 'react';
+export var OverflowContext = /*#__PURE__*/React.createContext(null);

node_modules/rc-overflow/es/hooks/channelUpdate.d.ts

@@ -0,0 +1 @@
+export default function channelUpdate(callback: VoidFunction): void;

node_modules/rc-overflow/es/hooks/channelUpdate.js

@@ -0,0 +1,12 @@
+import raf from "rc-util/es/raf";
+export default function channelUpdate(callback) {
+  if (typeof MessageChannel === 'undefined') {
+    raf(callback);
+  } else {
+    var channel = new MessageChannel();
+    channel.port1.onmessage = function () {
+      return callback();
+    };
+    channel.port2.postMessage(undefined);
+  }
+}

node_modules/rc-overflow/es/hooks/useEffectState.d.ts

@@ -0,0 +1,12 @@
+type Updater<T> = T | ((origin: T) => T);
+type UpdateCallbackFunc = VoidFunction;
+type NotifyEffectUpdate = (callback: UpdateCallbackFunc) => void;
+/**
+ * Batcher for record any `useEffectState` need update.
+ */
+export declare function useBatcher(): NotifyEffectUpdate;
+/**
+ * Trigger state update by `useLayoutEffect` to save perf.
+ */
+export default function useEffectState<T extends string | number | object>(notifyEffectUpdate: NotifyEffectUpdate, defaultValue?: T): [T, (value: Updater<T>) => void];
+export {};

node_modules/rc-overflow/es/hooks/useEffectState.js

@@ -0,0 +1,48 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import useEvent from "rc-util/es/hooks/useEvent";
+import * as React from 'react';
+import { unstable_batchedUpdates } from 'react-dom';
+import channelUpdate from "./channelUpdate";
+/**
+ * Batcher for record any `useEffectState` need update.
+ */
+export function useBatcher() {
+  // Updater Trigger
+  var updateFuncRef = React.useRef(null);
+
+  // Notify update
+  var notifyEffectUpdate = function notifyEffectUpdate(callback) {
+    if (!updateFuncRef.current) {
+      updateFuncRef.current = [];
+      channelUpdate(function () {
+        unstable_batchedUpdates(function () {
+          updateFuncRef.current.forEach(function (fn) {
+            fn();
+          });
+          updateFuncRef.current = null;
+        });
+      });
+    }
+    updateFuncRef.current.push(callback);
+  };
+  return notifyEffectUpdate;
+}
+
+/**
+ * Trigger state update by `useLayoutEffect` to save perf.
+ */
+export default function useEffectState(notifyEffectUpdate, defaultValue) {
+  // Value
+  var _React$useState = React.useState(defaultValue),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    stateValue = _React$useState2[0],
+    setStateValue = _React$useState2[1];
+
+  // Set State
+  var setEffectVal = useEvent(function (nextValue) {
+    notifyEffectUpdate(function () {
+      setStateValue(nextValue);
+    });
+  });
+  return [stateValue, setEffectVal];
+}

node_modules/rc-overflow/es/index.d.ts

@@ -0,0 +1,4 @@
+import Overflow from './Overflow';
+import type { OverflowProps } from './Overflow';
+export type { OverflowProps };
+export default Overflow;

node_modules/rc-overflow/es/index.js

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

node_modules/rc-overflow/lib/Item.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import type { ComponentType } from './RawItem';
+export interface ItemProps<ItemType> extends React.HTMLAttributes<any> {
+    prefixCls: string;
+    item?: ItemType;
+    className?: string;
+    style?: React.CSSProperties;
+    renderItem?: (item: ItemType, info: {
+        index: number;
+    }) => React.ReactNode;
+    responsive?: boolean;
+    /**
+     * @private To make node structure stable. We need keep wrap with ResizeObserver.
+     * But disable it when it's no need to real measure.
+     */
+    responsiveDisabled?: boolean;
+    itemKey?: React.Key;
+    registerSize: (key: React.Key, width: number | null) => void;
+    children?: React.ReactNode;
+    display: boolean;
+    order: number;
+    component?: ComponentType;
+    invalidate?: boolean;
+}
+declare const Item: React.ForwardRefExoticComponent<ItemProps<unknown> & React.RefAttributes<any>>;
+export default Item;

node_modules/rc-overflow/lib/Item.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var React = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _rcResizeObserver = _interopRequireDefault(require("rc-resize-observer"));
+var _excluded = ["prefixCls", "invalidate", "item", "renderItem", "responsive", "responsiveDisabled", "registerSize", "itemKey", "className", "style", "children", "display", "order", "component"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+// Use shared variable to save bundle size
+var UNDEFINED = undefined;
+function InternalItem(props, ref) {
+  var prefixCls = props.prefixCls,
+    invalidate = props.invalidate,
+    item = props.item,
+    renderItem = props.renderItem,
+    responsive = props.responsive,
+    responsiveDisabled = props.responsiveDisabled,
+    registerSize = props.registerSize,
+    itemKey = props.itemKey,
+    className = props.className,
+    style = props.style,
+    children = props.children,
+    display = props.display,
+    order = props.order,
+    _props$component = props.component,
+    Component = _props$component === void 0 ? 'div' : _props$component,
+    restProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+  var mergedHidden = responsive && !display;
+
+  // ================================ Effect ================================
+  function internalRegisterSize(width) {
+    registerSize(itemKey, width);
+  }
+  React.useEffect(function () {
+    return function () {
+      internalRegisterSize(null);
+    };
+  }, []);
+
+  // ================================ Render ================================
+  var childNode = renderItem && item !== UNDEFINED ? renderItem(item, {
+    index: order
+  }) : children;
+  var overflowStyle;
+  if (!invalidate) {
+    overflowStyle = {
+      opacity: mergedHidden ? 0 : 1,
+      height: mergedHidden ? 0 : UNDEFINED,
+      overflowY: mergedHidden ? 'hidden' : UNDEFINED,
+      order: responsive ? order : UNDEFINED,
+      pointerEvents: mergedHidden ? 'none' : UNDEFINED,
+      position: mergedHidden ? 'absolute' : UNDEFINED
+    };
+  }
+  var overflowProps = {};
+  if (mergedHidden) {
+    overflowProps['aria-hidden'] = true;
+  }
+  var itemNode = /*#__PURE__*/React.createElement(Component, (0, _extends2.default)({
+    className: (0, _classnames.default)(!invalidate && prefixCls, className),
+    style: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, overflowStyle), style)
+  }, overflowProps, restProps, {
+    ref: ref
+  }), childNode);
+  if (responsive) {
+    itemNode = /*#__PURE__*/React.createElement(_rcResizeObserver.default, {
+      onResize: function onResize(_ref) {
+        var offsetWidth = _ref.offsetWidth;
+        internalRegisterSize(offsetWidth);
+      },
+      disabled: responsiveDisabled
+    }, itemNode);
+  }
+  return itemNode;
+}
+var Item = /*#__PURE__*/React.forwardRef(InternalItem);
+Item.displayName = 'Item';
+var _default = exports.default = Item;

node_modules/rc-overflow/lib/Overflow.d.ts

@@ -0,0 +1,44 @@
+import * as React from 'react';
+import type { ComponentType } from './RawItem';
+import RawItem from './RawItem';
+declare const RESPONSIVE: "responsive";
+declare const INVALIDATE: "invalidate";
+export { OverflowContext } from './context';
+export type { ComponentType } from './RawItem';
+export interface OverflowProps<ItemType> extends Omit<React.HTMLAttributes<any>, 'prefix'> {
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    data?: ItemType[];
+    itemKey?: React.Key | ((item: ItemType) => React.Key);
+    /** Used for `responsive`. It will limit render node to avoid perf issue */
+    itemWidth?: number;
+    renderItem?: (item: ItemType, info: {
+        index: number;
+    }) => React.ReactNode;
+    /** @private Do not use in your production. Render raw node that need wrap Item by developer self */
+    renderRawItem?: (item: ItemType, index: number) => React.ReactElement;
+    maxCount?: number | typeof RESPONSIVE | typeof INVALIDATE;
+    renderRest?: React.ReactNode | ((omittedItems: ItemType[]) => React.ReactNode);
+    /** @private Do not use in your production. Render raw node that need wrap Item by developer self */
+    renderRawRest?: (omittedItems: ItemType[]) => React.ReactElement;
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+    component?: ComponentType;
+    itemComponent?: ComponentType;
+    /** @private This API may be refactor since not well design */
+    onVisibleChange?: (visibleCount: number) => void;
+    /** When set to `full`, ssr will render full items by default and remove at client side */
+    ssr?: 'full';
+}
+type ForwardOverflowType = <ItemType = any>(props: React.PropsWithChildren<OverflowProps<ItemType>> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => React.ReactElement;
+type FilledOverflowType = ForwardOverflowType & {
+    Item: typeof RawItem;
+    RESPONSIVE: typeof RESPONSIVE;
+    /** Will work as normal `component`. Skip patch props like `prefixCls`. */
+    INVALIDATE: typeof INVALIDATE;
+};
+declare const _default: FilledOverflowType;
+export default _default;

node_modules/rc-overflow/lib/Overflow.js

@@ -0,0 +1,329 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "OverflowContext", {
+  enumerable: true,
+  get: function get() {
+    return _context.OverflowContext;
+  }
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _react = _interopRequireWildcard(require("react"));
+var React = _react;
+var _classnames = _interopRequireDefault(require("classnames"));
+var _rcResizeObserver = _interopRequireDefault(require("rc-resize-observer"));
+var _useLayoutEffect = _interopRequireDefault(require("rc-util/lib/hooks/useLayoutEffect"));
+var _Item = _interopRequireDefault(require("./Item"));
+var _useEffectState13 = _interopRequireWildcard(require("./hooks/useEffectState"));
+var _RawItem = _interopRequireDefault(require("./RawItem"));
+var _context = require("./context");
+var _excluded = ["prefixCls", "data", "renderItem", "renderRawItem", "itemKey", "itemWidth", "ssr", "style", "className", "maxCount", "renderRest", "renderRawRest", "prefix", "suffix", "component", "itemComponent", "onVisibleChange"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var RESPONSIVE = 'responsive';
+var INVALIDATE = 'invalidate';
+function defaultRenderRest(omittedItems) {
+  return "+ ".concat(omittedItems.length, " ...");
+}
+function Overflow(props, ref) {
+  var _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? 'rc-overflow' : _props$prefixCls,
+    _props$data = props.data,
+    data = _props$data === void 0 ? [] : _props$data,
+    renderItem = props.renderItem,
+    renderRawItem = props.renderRawItem,
+    itemKey = props.itemKey,
+    _props$itemWidth = props.itemWidth,
+    itemWidth = _props$itemWidth === void 0 ? 10 : _props$itemWidth,
+    ssr = props.ssr,
+    style = props.style,
+    className = props.className,
+    maxCount = props.maxCount,
+    renderRest = props.renderRest,
+    renderRawRest = props.renderRawRest,
+    prefix = props.prefix,
+    suffix = props.suffix,
+    _props$component = props.component,
+    Component = _props$component === void 0 ? 'div' : _props$component,
+    itemComponent = props.itemComponent,
+    onVisibleChange = props.onVisibleChange,
+    restProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+  var fullySSR = ssr === 'full';
+  var notifyEffectUpdate = (0, _useEffectState13.useBatcher)();
+  var _useEffectState = (0, _useEffectState13.default)(notifyEffectUpdate, null),
+    _useEffectState2 = (0, _slicedToArray2.default)(_useEffectState, 2),
+    containerWidth = _useEffectState2[0],
+    setContainerWidth = _useEffectState2[1];
+  var mergedContainerWidth = containerWidth || 0;
+  var _useEffectState3 = (0, _useEffectState13.default)(notifyEffectUpdate, new Map()),
+    _useEffectState4 = (0, _slicedToArray2.default)(_useEffectState3, 2),
+    itemWidths = _useEffectState4[0],
+    setItemWidths = _useEffectState4[1];
+  var _useEffectState5 = (0, _useEffectState13.default)(notifyEffectUpdate, 0),
+    _useEffectState6 = (0, _slicedToArray2.default)(_useEffectState5, 2),
+    prevRestWidth = _useEffectState6[0],
+    setPrevRestWidth = _useEffectState6[1];
+  var _useEffectState7 = (0, _useEffectState13.default)(notifyEffectUpdate, 0),
+    _useEffectState8 = (0, _slicedToArray2.default)(_useEffectState7, 2),
+    restWidth = _useEffectState8[0],
+    setRestWidth = _useEffectState8[1];
+  var _useEffectState9 = (0, _useEffectState13.default)(notifyEffectUpdate, 0),
+    _useEffectState10 = (0, _slicedToArray2.default)(_useEffectState9, 2),
+    prefixWidth = _useEffectState10[0],
+    setPrefixWidth = _useEffectState10[1];
+  var _useEffectState11 = (0, _useEffectState13.default)(notifyEffectUpdate, 0),
+    _useEffectState12 = (0, _slicedToArray2.default)(_useEffectState11, 2),
+    suffixWidth = _useEffectState12[0],
+    setSuffixWidth = _useEffectState12[1];
+  var _useState = (0, _react.useState)(null),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    suffixFixedStart = _useState2[0],
+    setSuffixFixedStart = _useState2[1];
+  var _useState3 = (0, _react.useState)(null),
+    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+    displayCount = _useState4[0],
+    setDisplayCount = _useState4[1];
+  var mergedDisplayCount = React.useMemo(function () {
+    if (displayCount === null && fullySSR) {
+      return Number.MAX_SAFE_INTEGER;
+    }
+    return displayCount || 0;
+  }, [displayCount, containerWidth]);
+  var _useState5 = (0, _react.useState)(false),
+    _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+    restReady = _useState6[0],
+    setRestReady = _useState6[1];
+  var itemPrefixCls = "".concat(prefixCls, "-item");
+
+  // Always use the max width to avoid blink
+  var mergedRestWidth = Math.max(prevRestWidth, restWidth);
+
+  // ================================= Data =================================
+  var isResponsive = maxCount === RESPONSIVE;
+  var shouldResponsive = data.length && isResponsive;
+  var invalidate = maxCount === INVALIDATE;
+
+  /**
+   * When is `responsive`, we will always render rest node to get the real width of it for calculation
+   */
+  var showRest = shouldResponsive || typeof maxCount === 'number' && data.length > maxCount;
+  var mergedData = (0, _react.useMemo)(function () {
+    var items = data;
+    if (shouldResponsive) {
+      if (containerWidth === null && fullySSR) {
+        items = data;
+      } else {
+        items = data.slice(0, Math.min(data.length, mergedContainerWidth / itemWidth));
+      }
+    } else if (typeof maxCount === 'number') {
+      items = data.slice(0, maxCount);
+    }
+    return items;
+  }, [data, itemWidth, containerWidth, maxCount, shouldResponsive]);
+  var omittedItems = (0, _react.useMemo)(function () {
+    if (shouldResponsive) {
+      return data.slice(mergedDisplayCount + 1);
+    }
+    return data.slice(mergedData.length);
+  }, [data, mergedData, shouldResponsive, mergedDisplayCount]);
+
+  // ================================= Item =================================
+  var getKey = (0, _react.useCallback)(function (item, index) {
+    var _ref;
+    if (typeof itemKey === 'function') {
+      return itemKey(item);
+    }
+    return (_ref = itemKey && (item === null || item === void 0 ? void 0 : item[itemKey])) !== null && _ref !== void 0 ? _ref : index;
+  }, [itemKey]);
+  var mergedRenderItem = (0, _react.useCallback)(renderItem || function (item) {
+    return item;
+  }, [renderItem]);
+  function updateDisplayCount(count, suffixFixedStartVal, notReady) {
+    // React 18 will sync render even when the value is same in some case.
+    // We take `mergedData` as deps which may cause dead loop if it's dynamic generate.
+    // ref: https://github.com/ant-design/ant-design/issues/36559
+    if (displayCount === count && (suffixFixedStartVal === undefined || suffixFixedStartVal === suffixFixedStart)) {
+      return;
+    }
+    setDisplayCount(count);
+    if (!notReady) {
+      setRestReady(count < data.length - 1);
+      onVisibleChange === null || onVisibleChange === void 0 || onVisibleChange(count);
+    }
+    if (suffixFixedStartVal !== undefined) {
+      setSuffixFixedStart(suffixFixedStartVal);
+    }
+  }
+
+  // ================================= Size =================================
+  function onOverflowResize(_, element) {
+    setContainerWidth(element.clientWidth);
+  }
+  function registerSize(key, width) {
+    setItemWidths(function (origin) {
+      var clone = new Map(origin);
+      if (width === null) {
+        clone.delete(key);
+      } else {
+        clone.set(key, width);
+      }
+      return clone;
+    });
+  }
+  function registerOverflowSize(_, width) {
+    setRestWidth(width);
+    setPrevRestWidth(restWidth);
+  }
+  function registerPrefixSize(_, width) {
+    setPrefixWidth(width);
+  }
+  function registerSuffixSize(_, width) {
+    setSuffixWidth(width);
+  }
+
+  // ================================ Effect ================================
+  function getItemWidth(index) {
+    return itemWidths.get(getKey(mergedData[index], index));
+  }
+  (0, _useLayoutEffect.default)(function () {
+    if (mergedContainerWidth && typeof mergedRestWidth === 'number' && mergedData) {
+      var totalWidth = prefixWidth + suffixWidth;
+      var len = mergedData.length;
+      var lastIndex = len - 1;
+
+      // When data count change to 0, reset this since not loop will reach
+      if (!len) {
+        updateDisplayCount(0, null);
+        return;
+      }
+      for (var i = 0; i < len; i += 1) {
+        var currentItemWidth = getItemWidth(i);
+
+        // Fully will always render
+        if (fullySSR) {
+          currentItemWidth = currentItemWidth || 0;
+        }
+
+        // Break since data not ready
+        if (currentItemWidth === undefined) {
+          updateDisplayCount(i - 1, undefined, true);
+          break;
+        }
+
+        // Find best match
+        totalWidth += currentItemWidth;
+        if (
+        // Only one means `totalWidth` is the final width
+        lastIndex === 0 && totalWidth <= mergedContainerWidth ||
+        // Last two width will be the final width
+        i === lastIndex - 1 && totalWidth + getItemWidth(lastIndex) <= mergedContainerWidth) {
+          // Additional check if match the end
+          updateDisplayCount(lastIndex, null);
+          break;
+        } else if (totalWidth + mergedRestWidth > mergedContainerWidth) {
+          // Can not hold all the content to show rest
+          updateDisplayCount(i - 1, totalWidth - currentItemWidth - suffixWidth + restWidth);
+          break;
+        }
+      }
+      if (suffix && getItemWidth(0) + suffixWidth > mergedContainerWidth) {
+        setSuffixFixedStart(null);
+      }
+    }
+  }, [mergedContainerWidth, itemWidths, restWidth, prefixWidth, suffixWidth, getKey, mergedData]);
+
+  // ================================ Render ================================
+  var displayRest = restReady && !!omittedItems.length;
+  var suffixStyle = {};
+  if (suffixFixedStart !== null && shouldResponsive) {
+    suffixStyle = {
+      position: 'absolute',
+      left: suffixFixedStart,
+      top: 0
+    };
+  }
+  var itemSharedProps = {
+    prefixCls: itemPrefixCls,
+    responsive: shouldResponsive,
+    component: itemComponent,
+    invalidate: invalidate
+  };
+
+  // >>>>> Choice render fun by `renderRawItem`
+  var internalRenderItemNode = renderRawItem ? function (item, index) {
+    var key = getKey(item, index);
+    return /*#__PURE__*/React.createElement(_context.OverflowContext.Provider, {
+      key: key,
+      value: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, itemSharedProps), {}, {
+        order: index,
+        item: item,
+        itemKey: key,
+        registerSize: registerSize,
+        display: index <= mergedDisplayCount
+      })
+    }, renderRawItem(item, index));
+  } : function (item, index) {
+    var key = getKey(item, index);
+    return /*#__PURE__*/React.createElement(_Item.default, (0, _extends2.default)({}, itemSharedProps, {
+      order: index,
+      key: key,
+      item: item,
+      renderItem: mergedRenderItem,
+      itemKey: key,
+      registerSize: registerSize,
+      display: index <= mergedDisplayCount
+    }));
+  };
+
+  // >>>>> Rest node
+  var restContextProps = {
+    order: displayRest ? mergedDisplayCount : Number.MAX_SAFE_INTEGER,
+    className: "".concat(itemPrefixCls, "-rest"),
+    registerSize: registerOverflowSize,
+    display: displayRest
+  };
+  var mergedRenderRest = renderRest || defaultRenderRest;
+  var restNode = renderRawRest ? /*#__PURE__*/React.createElement(_context.OverflowContext.Provider, {
+    value: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, itemSharedProps), restContextProps)
+  }, renderRawRest(omittedItems)) : /*#__PURE__*/React.createElement(_Item.default, (0, _extends2.default)({}, itemSharedProps, restContextProps), typeof mergedRenderRest === 'function' ? mergedRenderRest(omittedItems) : mergedRenderRest);
+  var overflowNode = /*#__PURE__*/React.createElement(Component, (0, _extends2.default)({
+    className: (0, _classnames.default)(!invalidate && prefixCls, className),
+    style: style,
+    ref: ref
+  }, restProps), prefix && /*#__PURE__*/React.createElement(_Item.default, (0, _extends2.default)({}, itemSharedProps, {
+    responsive: isResponsive,
+    responsiveDisabled: !shouldResponsive,
+    order: -1,
+    className: "".concat(itemPrefixCls, "-prefix"),
+    registerSize: registerPrefixSize,
+    display: true
+  }), prefix), mergedData.map(internalRenderItemNode), showRest ? restNode : null, suffix && /*#__PURE__*/React.createElement(_Item.default, (0, _extends2.default)({}, itemSharedProps, {
+    responsive: isResponsive,
+    responsiveDisabled: !shouldResponsive,
+    order: mergedDisplayCount,
+    className: "".concat(itemPrefixCls, "-suffix"),
+    registerSize: registerSuffixSize,
+    display: true,
+    style: suffixStyle
+  }), suffix));
+  return isResponsive ? /*#__PURE__*/React.createElement(_rcResizeObserver.default, {
+    onResize: onOverflowResize,
+    disabled: !shouldResponsive
+  }, overflowNode) : overflowNode;
+}
+var ForwardOverflow = /*#__PURE__*/React.forwardRef(Overflow);
+ForwardOverflow.displayName = 'Overflow';
+ForwardOverflow.Item = _RawItem.default;
+ForwardOverflow.RESPONSIVE = RESPONSIVE;
+ForwardOverflow.INVALIDATE = INVALIDATE;
+
+// Convert to generic type
+var _default = exports.default = ForwardOverflow;

node_modules/rc-overflow/lib/RawItem.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export type ComponentType = React.ComponentType<any> | React.ForwardRefExoticComponent<any> | React.FC<any> | keyof React.ReactHTML;
+export interface RawItemProps extends React.HTMLAttributes<any> {
+    component?: ComponentType;
+    children?: React.ReactNode;
+}
+declare const RawItem: React.ForwardRefExoticComponent<RawItemProps & React.RefAttributes<any>>;
+export default RawItem;

node_modules/rc-overflow/lib/RawItem.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var React = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _Item = _interopRequireDefault(require("./Item"));
+var _context = require("./context");
+var _excluded = ["component"],
+  _excluded2 = ["className"],
+  _excluded3 = ["className"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var InternalRawItem = function InternalRawItem(props, ref) {
+  var context = React.useContext(_context.OverflowContext);
+
+  // Render directly when context not provided
+  if (!context) {
+    var _props$component = props.component,
+      Component = _props$component === void 0 ? 'div' : _props$component,
+      _restProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+    return /*#__PURE__*/React.createElement(Component, (0, _extends2.default)({}, _restProps, {
+      ref: ref
+    }));
+  }
+  var contextClassName = context.className,
+    restContext = (0, _objectWithoutProperties2.default)(context, _excluded2);
+  var className = props.className,
+    restProps = (0, _objectWithoutProperties2.default)(props, _excluded3);
+
+  // Do not pass context to sub item to avoid multiple measure
+  return /*#__PURE__*/React.createElement(_context.OverflowContext.Provider, {
+    value: null
+  }, /*#__PURE__*/React.createElement(_Item.default, (0, _extends2.default)({
+    ref: ref,
+    className: (0, _classnames.default)(contextClassName, className)
+  }, restContext, restProps)));
+};
+var RawItem = /*#__PURE__*/React.forwardRef(InternalRawItem);
+RawItem.displayName = 'RawItem';
+var _default = exports.default = RawItem;

node_modules/rc-overflow/lib/context.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export declare const OverflowContext: React.Context<{
+    prefixCls: string;
+    responsive: boolean;
+    order: number;
+    registerSize: (key: React.Key, width: number | null) => void;
+    display: boolean;
+    invalidate: boolean;
+    item?: any;
+    itemKey?: React.Key;
+    className?: string;
+}>;

node_modules/rc-overflow/lib/context.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OverflowContext = void 0;
+var _react = _interopRequireDefault(require("react"));
+var OverflowContext = exports.OverflowContext = /*#__PURE__*/_react.default.createContext(null);

node_modules/rc-overflow/lib/hooks/channelUpdate.d.ts

@@ -0,0 +1 @@
+export default function channelUpdate(callback: VoidFunction): void;

node_modules/rc-overflow/lib/hooks/channelUpdate.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = channelUpdate;
+var _raf = _interopRequireDefault(require("rc-util/lib/raf"));
+function channelUpdate(callback) {
+  if (typeof MessageChannel === 'undefined') {
+    (0, _raf.default)(callback);
+  } else {
+    var channel = new MessageChannel();
+    channel.port1.onmessage = function () {
+      return callback();
+    };
+    channel.port2.postMessage(undefined);
+  }
+}

node_modules/rc-overflow/lib/hooks/useEffectState.d.ts

@@ -0,0 +1,12 @@
+type Updater<T> = T | ((origin: T) => T);
+type UpdateCallbackFunc = VoidFunction;
+type NotifyEffectUpdate = (callback: UpdateCallbackFunc) => void;
+/**
+ * Batcher for record any `useEffectState` need update.
+ */
+export declare function useBatcher(): NotifyEffectUpdate;
+/**
+ * Trigger state update by `useLayoutEffect` to save perf.
+ */
+export default function useEffectState<T extends string | number | object>(notifyEffectUpdate: NotifyEffectUpdate, defaultValue?: T): [T, (value: Updater<T>) => void];
+export {};

node_modules/rc-overflow/lib/hooks/useEffectState.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useEffectState;
+exports.useBatcher = useBatcher;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _useEvent = _interopRequireDefault(require("rc-util/lib/hooks/useEvent"));
+var React = _interopRequireWildcard(require("react"));
+var _reactDom = require("react-dom");
+var _channelUpdate = _interopRequireDefault(require("./channelUpdate"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Batcher for record any `useEffectState` need update.
+ */
+function useBatcher() {
+  // Updater Trigger
+  var updateFuncRef = React.useRef(null);
+
+  // Notify update
+  var notifyEffectUpdate = function notifyEffectUpdate(callback) {
+    if (!updateFuncRef.current) {
+      updateFuncRef.current = [];
+      (0, _channelUpdate.default)(function () {
+        (0, _reactDom.unstable_batchedUpdates)(function () {
+          updateFuncRef.current.forEach(function (fn) {
+            fn();
+          });
+          updateFuncRef.current = null;
+        });
+      });
+    }
+    updateFuncRef.current.push(callback);
+  };
+  return notifyEffectUpdate;
+}
+
+/**
+ * Trigger state update by `useLayoutEffect` to save perf.
+ */
+function useEffectState(notifyEffectUpdate, defaultValue) {
+  // Value
+  var _React$useState = React.useState(defaultValue),
+    _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+    stateValue = _React$useState2[0],
+    setStateValue = _React$useState2[1];
+
+  // Set State
+  var setEffectVal = (0, _useEvent.default)(function (nextValue) {
+    notifyEffectUpdate(function () {
+      setStateValue(nextValue);
+    });
+  });
+  return [stateValue, setEffectVal];
+}

node_modules/rc-overflow/lib/index.d.ts

@@ -0,0 +1,4 @@
+import Overflow from './Overflow';
+import type { OverflowProps } from './Overflow';
+export type { OverflowProps };
+export default Overflow;

node_modules/rc-overflow/lib/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Overflow = _interopRequireDefault(require("./Overflow"));
+var _default = exports.default = _Overflow.default;

node_modules/rc-overflow/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "rc-overflow",
+  "version": "1.5.0",
+  "description": "Auto collapse box when overflow",
+  "keywords": [
+    "react",
+    "react-component",
+    "react-overflow",
+    "overflow",
+    "antd",
+    "ant-design"
+  ],
+  "main": "./lib/index",
+  "module": "./es/index",
+  "files": [
+    "assets/*.css",
+    "assets/*.less",
+    "es",
+    "lib",
+    "dist"
+  ],
+  "homepage": "https://react-component.github.io/overflow",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:react-component/overflow.git"
+  },
+  "bugs": {
+    "url": "http://github.com/react-component/overflow/issues"
+  },
+  "license": "MIT",
+  "scripts": {
+    "start": "dumi dev",
+    "docs:build": "dumi build",
+    "docs:deploy": "gh-pages -d docs-dist",
+    "compile": "father build",
+    "prepare": "dumi setup",
+    "deploy": "npm run docs:build && npm run docs:deploy",
+    "prettier": "prettier --write \"**/*.{js,jsx,tsx,ts,less,md,json}\"",
+    "test": "rc-test",
+    "test:coverage": "rc-test --coverage",
+    "prepublishOnly": "npm run compile && np --no-cleanup --yolo --no-publish",
+    "lint": "eslint src/ --ext .tsx,.ts",
+    "lint:tsc": "tsc -p tsconfig.json --noEmit",
+    "now-build": "npm run docs:build"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.11.1",
+    "classnames": "^2.2.1",
+    "rc-resize-observer": "^1.0.0",
+    "rc-util": "^5.37.0"
+  },
+  "devDependencies": {
+    "@rc-component/father-plugin": "^1.0.0",
+    "@testing-library/jest-dom": "^5.16.4",
+    "@testing-library/react": "^12.0.0",
+    "@types/classnames": "^2.2.9",
+    "@types/enzyme": "^3.10.8",
+    "@types/jest": "^26.0.23",
+    "@types/react": "^16.14.2",
+    "@types/react-dom": "^16.9.10",
+    "@umijs/fabric": "^3.0.0",
+    "glob": "^10.0.0",
+    "cross-env": "^7.0.2",
+    "dumi": "^2.0.0",
+    "enzyme": "^3.0.0",
+    "enzyme-adapter-react-16": "^1.0.1",
+    "enzyme-to-json": "^3.4.0",
+    "eslint": "^8.57.0",
+    "father": "^4.0.0",
+    "less": "^3.10.3",
+    "np": "^7.0.0",
+    "prettier": "^2.0.5",
+    "rc-test": "^7.0",
+    "react": "^16.0.0",
+    "react-dom": "^16.0.0",
+    "regenerator-runtime": "^0.13.7",
+    "typescript": "~5.3.3",
+    "@typescript-eslint/parser": "^5.59.0",
+    "@typescript-eslint/eslint-plugin": "^5.59.0",
+    "eslint-plugin-jest": "^27.5.1",
+    "eslint-plugin-unicorn": "^51.0.1"
+  },
+  "peerDependencies": {
+    "react": ">=16.9.0",
+    "react-dom": ">=16.9.0"
+  },
+  "overrides": {
+    "cheerio": "1.0.0-rc.12"
+  },
+  "cnpm": {
+    "mode": "npm"
+  },
+  "tnpm": {
+    "mode": "npm"
+  }
+}