add all frontend files

node_modules/rc-menu/es/Divider.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import type { MenuDividerType } from './interface';
+export type DividerProps = Omit<MenuDividerType, 'type'>;
+export default function Divider({ className, style }: DividerProps): React.JSX.Element;

node_modules/rc-menu/es/Divider.js

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import classNames from 'classnames';
+import { MenuContext } from "./context/MenuContext";
+import { useMeasure } from "./context/PathContext";
+export default function Divider(_ref) {
+  var className = _ref.className,
+    style = _ref.style;
+  var _React$useContext = React.useContext(MenuContext),
+    prefixCls = _React$useContext.prefixCls;
+  var measure = useMeasure();
+  if (measure) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement("li", {
+    role: "separator",
+    className: classNames("".concat(prefixCls, "-item-divider"), className),
+    style: style
+  });
+}

node_modules/rc-menu/es/Icon.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { RenderIconInfo, RenderIconType } from './interface';
+export interface IconProps {
+    icon?: RenderIconType;
+    props: RenderIconInfo;
+    /** Fallback of icon if provided */
+    children?: React.ReactElement;
+}
+export default function Icon({ icon, props, children }: IconProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;

node_modules/rc-menu/es/Icon.js

@@ -0,0 +1,18 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import * as React from 'react';
+export default function Icon(_ref) {
+  var icon = _ref.icon,
+    props = _ref.props,
+    children = _ref.children;
+  var iconNode;
+  if (icon === null || icon === false) {
+    return null;
+  }
+  if (typeof icon === 'function') {
+    iconNode = /*#__PURE__*/React.createElement(icon, _objectSpread({}, props));
+  } else if (typeof icon !== "boolean") {
+    // Compatible for origin definition
+    iconNode = icon;
+  }
+  return iconNode || children || null;
+}

node_modules/rc-menu/es/Menu.d.ts

@@ -0,0 +1,73 @@
+import type { CSSMotionProps } from 'rc-motion';
+import * as React from 'react';
+import type { BuiltinPlacements, Components, ItemType, MenuClickEventHandler, MenuMode, MenuRef, RenderIconType, SelectEventHandler, TriggerSubMenuAction } from './interface';
+export interface MenuProps extends Omit<React.HTMLAttributes<HTMLUListElement>, 'onClick' | 'onSelect' | 'dir'> {
+    prefixCls?: string;
+    rootClassName?: string;
+    items?: ItemType[];
+    /** @deprecated Please use `items` instead */
+    children?: React.ReactNode;
+    disabled?: boolean;
+    /** @private Disable auto overflow. Pls note the prop name may refactor since we do not final decided. */
+    disabledOverflow?: boolean;
+    /** direction of menu */
+    direction?: 'ltr' | 'rtl';
+    mode?: MenuMode;
+    inlineCollapsed?: boolean;
+    defaultOpenKeys?: string[];
+    openKeys?: string[];
+    activeKey?: string;
+    defaultActiveFirst?: boolean;
+    selectable?: boolean;
+    multiple?: boolean;
+    defaultSelectedKeys?: string[];
+    selectedKeys?: string[];
+    onSelect?: SelectEventHandler;
+    onDeselect?: SelectEventHandler;
+    inlineIndent?: number;
+    /** Menu motion define. Use `defaultMotions` if you need config motion of each mode */
+    motion?: CSSMotionProps;
+    /** Default menu motion of each mode */
+    defaultMotions?: Partial<{
+        [key in MenuMode | 'other']: CSSMotionProps;
+    }>;
+    subMenuOpenDelay?: number;
+    subMenuCloseDelay?: number;
+    forceSubMenuRender?: boolean;
+    triggerSubMenuAction?: TriggerSubMenuAction;
+    builtinPlacements?: BuiltinPlacements;
+    itemIcon?: RenderIconType;
+    expandIcon?: RenderIconType;
+    overflowedIndicator?: React.ReactNode;
+    /** @private Internal usage. Do not use in your production. */
+    overflowedIndicatorPopupClassName?: string;
+    getPopupContainer?: (node: HTMLElement) => HTMLElement;
+    onClick?: MenuClickEventHandler;
+    onOpenChange?: (openKeys: string[]) => void;
+    /***
+     * @private Only used for `pro-layout`. Do not use in your prod directly
+     * and we do not promise any compatibility for this.
+     */
+    _internalRenderMenuItem?: (originNode: React.ReactElement, menuItemProps: any, stateProps: {
+        selected: boolean;
+    }) => React.ReactElement;
+    /***
+     * @private Only used for `pro-layout`. Do not use in your prod directly
+     * and we do not promise any compatibility for this.
+     */
+    _internalRenderSubMenuItem?: (originNode: React.ReactElement, subMenuItemProps: any, stateProps: {
+        selected: boolean;
+        open: boolean;
+        active: boolean;
+        disabled: boolean;
+    }) => React.ReactElement;
+    /**
+     * @private NEVER! EVER! USE IN PRODUCTION!!!
+     * This is a hack API for `antd` to fix `findDOMNode` issue.
+     * Not use it! Not accept any PR try to make it as normal API.
+     * By zombieJ
+     */
+    _internalComponents?: Components;
+}
+declare const Menu: React.ForwardRefExoticComponent<MenuProps & React.RefAttributes<MenuRef>>;
+export default Menu;

node_modules/rc-menu/es/Menu.js

@@ -0,0 +1,481 @@
+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 _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["prefixCls", "rootClassName", "style", "className", "tabIndex", "items", "children", "direction", "id", "mode", "inlineCollapsed", "disabled", "disabledOverflow", "subMenuOpenDelay", "subMenuCloseDelay", "forceSubMenuRender", "defaultOpenKeys", "openKeys", "activeKey", "defaultActiveFirst", "selectable", "multiple", "defaultSelectedKeys", "selectedKeys", "onSelect", "onDeselect", "inlineIndent", "motion", "defaultMotions", "triggerSubMenuAction", "builtinPlacements", "itemIcon", "expandIcon", "overflowedIndicator", "overflowedIndicatorPopupClassName", "getPopupContainer", "onClick", "onOpenChange", "onKeyDown", "openAnimation", "openTransitionName", "_internalRenderMenuItem", "_internalRenderSubMenuItem", "_internalComponents"];
+import classNames from 'classnames';
+import Overflow from 'rc-overflow';
+import useMergedState from "rc-util/es/hooks/useMergedState";
+import isEqual from "rc-util/es/isEqual";
+import warning from "rc-util/es/warning";
+import * as React from 'react';
+import { useImperativeHandle } from 'react';
+import { flushSync } from 'react-dom';
+import { IdContext } from "./context/IdContext";
+import MenuContextProvider from "./context/MenuContext";
+import { PathRegisterContext, PathUserContext } from "./context/PathContext";
+import PrivateContext from "./context/PrivateContext";
+import { getFocusableElements, refreshElements, useAccessibility } from "./hooks/useAccessibility";
+import useKeyRecords, { OVERFLOW_KEY } from "./hooks/useKeyRecords";
+import useMemoCallback from "./hooks/useMemoCallback";
+import useUUID from "./hooks/useUUID";
+import MenuItem from "./MenuItem";
+import SubMenu from "./SubMenu";
+import { parseItems } from "./utils/nodeUtil";
+import { warnItemProp } from "./utils/warnUtil";
+
+/**
+ * Menu modify after refactor:
+ * ## Add
+ * - disabled
+ *
+ * ## Remove
+ * - openTransitionName
+ * - openAnimation
+ * - onDestroy
+ * - siderCollapsed: Seems antd do not use this prop (Need test in antd)
+ * - collapsedWidth: Seems this logic should be handle by antd Layout.Sider
+ */
+
+// optimize for render
+var EMPTY_LIST = [];
+var Menu = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var _childList$;
+  var _ref = props,
+    _ref$prefixCls = _ref.prefixCls,
+    prefixCls = _ref$prefixCls === void 0 ? 'rc-menu' : _ref$prefixCls,
+    rootClassName = _ref.rootClassName,
+    style = _ref.style,
+    className = _ref.className,
+    _ref$tabIndex = _ref.tabIndex,
+    tabIndex = _ref$tabIndex === void 0 ? 0 : _ref$tabIndex,
+    items = _ref.items,
+    children = _ref.children,
+    direction = _ref.direction,
+    id = _ref.id,
+    _ref$mode = _ref.mode,
+    mode = _ref$mode === void 0 ? 'vertical' : _ref$mode,
+    inlineCollapsed = _ref.inlineCollapsed,
+    disabled = _ref.disabled,
+    disabledOverflow = _ref.disabledOverflow,
+    _ref$subMenuOpenDelay = _ref.subMenuOpenDelay,
+    subMenuOpenDelay = _ref$subMenuOpenDelay === void 0 ? 0.1 : _ref$subMenuOpenDelay,
+    _ref$subMenuCloseDela = _ref.subMenuCloseDelay,
+    subMenuCloseDelay = _ref$subMenuCloseDela === void 0 ? 0.1 : _ref$subMenuCloseDela,
+    forceSubMenuRender = _ref.forceSubMenuRender,
+    defaultOpenKeys = _ref.defaultOpenKeys,
+    openKeys = _ref.openKeys,
+    activeKey = _ref.activeKey,
+    defaultActiveFirst = _ref.defaultActiveFirst,
+    _ref$selectable = _ref.selectable,
+    selectable = _ref$selectable === void 0 ? true : _ref$selectable,
+    _ref$multiple = _ref.multiple,
+    multiple = _ref$multiple === void 0 ? false : _ref$multiple,
+    defaultSelectedKeys = _ref.defaultSelectedKeys,
+    selectedKeys = _ref.selectedKeys,
+    onSelect = _ref.onSelect,
+    onDeselect = _ref.onDeselect,
+    _ref$inlineIndent = _ref.inlineIndent,
+    inlineIndent = _ref$inlineIndent === void 0 ? 24 : _ref$inlineIndent,
+    motion = _ref.motion,
+    defaultMotions = _ref.defaultMotions,
+    _ref$triggerSubMenuAc = _ref.triggerSubMenuAction,
+    triggerSubMenuAction = _ref$triggerSubMenuAc === void 0 ? 'hover' : _ref$triggerSubMenuAc,
+    builtinPlacements = _ref.builtinPlacements,
+    itemIcon = _ref.itemIcon,
+    expandIcon = _ref.expandIcon,
+    _ref$overflowedIndica = _ref.overflowedIndicator,
+    overflowedIndicator = _ref$overflowedIndica === void 0 ? '...' : _ref$overflowedIndica,
+    overflowedIndicatorPopupClassName = _ref.overflowedIndicatorPopupClassName,
+    getPopupContainer = _ref.getPopupContainer,
+    onClick = _ref.onClick,
+    onOpenChange = _ref.onOpenChange,
+    onKeyDown = _ref.onKeyDown,
+    openAnimation = _ref.openAnimation,
+    openTransitionName = _ref.openTransitionName,
+    _internalRenderMenuItem = _ref._internalRenderMenuItem,
+    _internalRenderSubMenuItem = _ref._internalRenderSubMenuItem,
+    _internalComponents = _ref._internalComponents,
+    restProps = _objectWithoutProperties(_ref, _excluded);
+  var _React$useMemo = React.useMemo(function () {
+      return [parseItems(children, items, EMPTY_LIST, _internalComponents, prefixCls), parseItems(children, items, EMPTY_LIST, {}, prefixCls)];
+    }, [children, items, _internalComponents]),
+    _React$useMemo2 = _slicedToArray(_React$useMemo, 2),
+    childList = _React$useMemo2[0],
+    measureChildList = _React$useMemo2[1];
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    mounted = _React$useState2[0],
+    setMounted = _React$useState2[1];
+  var containerRef = React.useRef();
+  var uuid = useUUID(id);
+  var isRtl = direction === 'rtl';
+
+  // ========================= Warn =========================
+  if (process.env.NODE_ENV !== 'production') {
+    warning(!openAnimation && !openTransitionName, '`openAnimation` and `openTransitionName` is removed. Please use `motion` or `defaultMotion` instead.');
+  }
+
+  // ========================= Open =========================
+  var _useMergedState = useMergedState(defaultOpenKeys, {
+      value: openKeys,
+      postState: function postState(keys) {
+        return keys || EMPTY_LIST;
+      }
+    }),
+    _useMergedState2 = _slicedToArray(_useMergedState, 2),
+    mergedOpenKeys = _useMergedState2[0],
+    setMergedOpenKeys = _useMergedState2[1];
+
+  // React 18 will merge mouse event which means we open key will not sync
+  // ref: https://github.com/ant-design/ant-design/issues/38818
+  var triggerOpenKeys = function triggerOpenKeys(keys) {
+    var forceFlush = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    function doUpdate() {
+      setMergedOpenKeys(keys);
+      onOpenChange === null || onOpenChange === void 0 || onOpenChange(keys);
+    }
+    if (forceFlush) {
+      flushSync(doUpdate);
+    } else {
+      doUpdate();
+    }
+  };
+
+  // >>>>> Cache & Reset open keys when inlineCollapsed changed
+  var _React$useState3 = React.useState(mergedOpenKeys),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    inlineCacheOpenKeys = _React$useState4[0],
+    setInlineCacheOpenKeys = _React$useState4[1];
+  var mountRef = React.useRef(false);
+
+  // ========================= Mode =========================
+  var _React$useMemo3 = React.useMemo(function () {
+      if ((mode === 'inline' || mode === 'vertical') && inlineCollapsed) {
+        return ['vertical', inlineCollapsed];
+      }
+      return [mode, false];
+    }, [mode, inlineCollapsed]),
+    _React$useMemo4 = _slicedToArray(_React$useMemo3, 2),
+    mergedMode = _React$useMemo4[0],
+    mergedInlineCollapsed = _React$useMemo4[1];
+  var isInlineMode = mergedMode === 'inline';
+  var _React$useState5 = React.useState(mergedMode),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    internalMode = _React$useState6[0],
+    setInternalMode = _React$useState6[1];
+  var _React$useState7 = React.useState(mergedInlineCollapsed),
+    _React$useState8 = _slicedToArray(_React$useState7, 2),
+    internalInlineCollapsed = _React$useState8[0],
+    setInternalInlineCollapsed = _React$useState8[1];
+  React.useEffect(function () {
+    setInternalMode(mergedMode);
+    setInternalInlineCollapsed(mergedInlineCollapsed);
+    if (!mountRef.current) {
+      return;
+    }
+    // Synchronously update MergedOpenKeys
+    if (isInlineMode) {
+      setMergedOpenKeys(inlineCacheOpenKeys);
+    } else {
+      // Trigger open event in case its in control
+      triggerOpenKeys(EMPTY_LIST);
+    }
+  }, [mergedMode, mergedInlineCollapsed]);
+
+  // ====================== Responsive ======================
+  var _React$useState9 = React.useState(0),
+    _React$useState10 = _slicedToArray(_React$useState9, 2),
+    lastVisibleIndex = _React$useState10[0],
+    setLastVisibleIndex = _React$useState10[1];
+  var allVisible = lastVisibleIndex >= childList.length - 1 || internalMode !== 'horizontal' || disabledOverflow;
+
+  // Cache
+  React.useEffect(function () {
+    if (isInlineMode) {
+      setInlineCacheOpenKeys(mergedOpenKeys);
+    }
+  }, [mergedOpenKeys]);
+  React.useEffect(function () {
+    mountRef.current = true;
+    return function () {
+      mountRef.current = false;
+    };
+  }, []);
+
+  // ========================= Path =========================
+  var _useKeyRecords = useKeyRecords(),
+    registerPath = _useKeyRecords.registerPath,
+    unregisterPath = _useKeyRecords.unregisterPath,
+    refreshOverflowKeys = _useKeyRecords.refreshOverflowKeys,
+    isSubPathKey = _useKeyRecords.isSubPathKey,
+    getKeyPath = _useKeyRecords.getKeyPath,
+    getKeys = _useKeyRecords.getKeys,
+    getSubPathKeys = _useKeyRecords.getSubPathKeys;
+  var registerPathContext = React.useMemo(function () {
+    return {
+      registerPath: registerPath,
+      unregisterPath: unregisterPath
+    };
+  }, [registerPath, unregisterPath]);
+  var pathUserContext = React.useMemo(function () {
+    return {
+      isSubPathKey: isSubPathKey
+    };
+  }, [isSubPathKey]);
+  React.useEffect(function () {
+    refreshOverflowKeys(allVisible ? EMPTY_LIST : childList.slice(lastVisibleIndex + 1).map(function (child) {
+      return child.key;
+    }));
+  }, [lastVisibleIndex, allVisible]);
+
+  // ======================== Active ========================
+  var _useMergedState3 = useMergedState(activeKey || defaultActiveFirst && ((_childList$ = childList[0]) === null || _childList$ === void 0 ? void 0 : _childList$.key), {
+      value: activeKey
+    }),
+    _useMergedState4 = _slicedToArray(_useMergedState3, 2),
+    mergedActiveKey = _useMergedState4[0],
+    setMergedActiveKey = _useMergedState4[1];
+  var onActive = useMemoCallback(function (key) {
+    setMergedActiveKey(key);
+  });
+  var onInactive = useMemoCallback(function () {
+    setMergedActiveKey(undefined);
+  });
+  useImperativeHandle(ref, function () {
+    return {
+      list: containerRef.current,
+      focus: function focus(options) {
+        var _childList$find;
+        var keys = getKeys();
+        var _refreshElements = refreshElements(keys, uuid),
+          elements = _refreshElements.elements,
+          key2element = _refreshElements.key2element,
+          element2key = _refreshElements.element2key;
+        var focusableElements = getFocusableElements(containerRef.current, elements);
+        var shouldFocusKey = mergedActiveKey !== null && mergedActiveKey !== void 0 ? mergedActiveKey : focusableElements[0] ? element2key.get(focusableElements[0]) : (_childList$find = childList.find(function (node) {
+          return !node.props.disabled;
+        })) === null || _childList$find === void 0 ? void 0 : _childList$find.key;
+        var elementToFocus = key2element.get(shouldFocusKey);
+        if (shouldFocusKey && elementToFocus) {
+          var _elementToFocus$focus;
+          elementToFocus === null || elementToFocus === void 0 || (_elementToFocus$focus = elementToFocus.focus) === null || _elementToFocus$focus === void 0 || _elementToFocus$focus.call(elementToFocus, options);
+        }
+      }
+    };
+  });
+
+  // ======================== Select ========================
+  // >>>>> Select keys
+  var _useMergedState5 = useMergedState(defaultSelectedKeys || [], {
+      value: selectedKeys,
+      // Legacy convert key to array
+      postState: function postState(keys) {
+        if (Array.isArray(keys)) {
+          return keys;
+        }
+        if (keys === null || keys === undefined) {
+          return EMPTY_LIST;
+        }
+        return [keys];
+      }
+    }),
+    _useMergedState6 = _slicedToArray(_useMergedState5, 2),
+    mergedSelectKeys = _useMergedState6[0],
+    setMergedSelectKeys = _useMergedState6[1];
+
+  // >>>>> Trigger select
+  var triggerSelection = function triggerSelection(info) {
+    if (selectable) {
+      // Insert or Remove
+      var targetKey = info.key;
+      var exist = mergedSelectKeys.includes(targetKey);
+      var newSelectKeys;
+      if (multiple) {
+        if (exist) {
+          newSelectKeys = mergedSelectKeys.filter(function (key) {
+            return key !== targetKey;
+          });
+        } else {
+          newSelectKeys = [].concat(_toConsumableArray(mergedSelectKeys), [targetKey]);
+        }
+      } else {
+        newSelectKeys = [targetKey];
+      }
+      setMergedSelectKeys(newSelectKeys);
+
+      // Trigger event
+      var selectInfo = _objectSpread(_objectSpread({}, info), {}, {
+        selectedKeys: newSelectKeys
+      });
+      if (exist) {
+        onDeselect === null || onDeselect === void 0 || onDeselect(selectInfo);
+      } else {
+        onSelect === null || onSelect === void 0 || onSelect(selectInfo);
+      }
+    }
+
+    // Whatever selectable, always close it
+    if (!multiple && mergedOpenKeys.length && internalMode !== 'inline') {
+      triggerOpenKeys(EMPTY_LIST);
+    }
+  };
+
+  // ========================= Open =========================
+  /**
+   * Click for item. SubMenu do not have selection status
+   */
+  var onInternalClick = useMemoCallback(function (info) {
+    onClick === null || onClick === void 0 || onClick(warnItemProp(info));
+    triggerSelection(info);
+  });
+  var onInternalOpenChange = useMemoCallback(function (key, open) {
+    var newOpenKeys = mergedOpenKeys.filter(function (k) {
+      return k !== key;
+    });
+    if (open) {
+      newOpenKeys.push(key);
+    } else if (internalMode !== 'inline') {
+      // We need find all related popup to close
+      var subPathKeys = getSubPathKeys(key);
+      newOpenKeys = newOpenKeys.filter(function (k) {
+        return !subPathKeys.has(k);
+      });
+    }
+    if (!isEqual(mergedOpenKeys, newOpenKeys, true)) {
+      triggerOpenKeys(newOpenKeys, true);
+    }
+  });
+
+  // ==================== Accessibility =====================
+  var triggerAccessibilityOpen = function triggerAccessibilityOpen(key, open) {
+    var nextOpen = open !== null && open !== void 0 ? open : !mergedOpenKeys.includes(key);
+    onInternalOpenChange(key, nextOpen);
+  };
+  var onInternalKeyDown = useAccessibility(internalMode, mergedActiveKey, isRtl, uuid, containerRef, getKeys, getKeyPath, setMergedActiveKey, triggerAccessibilityOpen, onKeyDown);
+
+  // ======================== Effect ========================
+  React.useEffect(function () {
+    setMounted(true);
+  }, []);
+
+  // ======================= Context ========================
+  var privateContext = React.useMemo(function () {
+    return {
+      _internalRenderMenuItem: _internalRenderMenuItem,
+      _internalRenderSubMenuItem: _internalRenderSubMenuItem
+    };
+  }, [_internalRenderMenuItem, _internalRenderSubMenuItem]);
+
+  // ======================== Render ========================
+
+  // >>>>> Children
+  var wrappedChildList = internalMode !== 'horizontal' || disabledOverflow ? childList :
+  // Need wrap for overflow dropdown that do not response for open
+  childList.map(function (child, index) {
+    return (
+      /*#__PURE__*/
+      // Always wrap provider to avoid sub node re-mount
+      React.createElement(MenuContextProvider, {
+        key: child.key,
+        overflowDisabled: index > lastVisibleIndex
+      }, child)
+    );
+  });
+
+  // >>>>> Container
+  var container = /*#__PURE__*/React.createElement(Overflow, _extends({
+    id: id,
+    ref: containerRef,
+    prefixCls: "".concat(prefixCls, "-overflow"),
+    component: "ul",
+    itemComponent: MenuItem,
+    className: classNames(prefixCls, "".concat(prefixCls, "-root"), "".concat(prefixCls, "-").concat(internalMode), className, _defineProperty(_defineProperty({}, "".concat(prefixCls, "-inline-collapsed"), internalInlineCollapsed), "".concat(prefixCls, "-rtl"), isRtl), rootClassName),
+    dir: direction,
+    style: style,
+    role: "menu",
+    tabIndex: tabIndex,
+    data: wrappedChildList,
+    renderRawItem: function renderRawItem(node) {
+      return node;
+    },
+    renderRawRest: function renderRawRest(omitItems) {
+      // We use origin list since wrapped list use context to prevent open
+      var len = omitItems.length;
+      var originOmitItems = len ? childList.slice(-len) : null;
+      return /*#__PURE__*/React.createElement(SubMenu, {
+        eventKey: OVERFLOW_KEY,
+        title: overflowedIndicator,
+        disabled: allVisible,
+        internalPopupClose: len === 0,
+        popupClassName: overflowedIndicatorPopupClassName
+      }, originOmitItems);
+    },
+    maxCount: internalMode !== 'horizontal' || disabledOverflow ? Overflow.INVALIDATE : Overflow.RESPONSIVE,
+    ssr: "full",
+    "data-menu-list": true,
+    onVisibleChange: function onVisibleChange(newLastIndex) {
+      setLastVisibleIndex(newLastIndex);
+    },
+    onKeyDown: onInternalKeyDown
+  }, restProps));
+
+  // >>>>> Render
+  return /*#__PURE__*/React.createElement(PrivateContext.Provider, {
+    value: privateContext
+  }, /*#__PURE__*/React.createElement(IdContext.Provider, {
+    value: uuid
+  }, /*#__PURE__*/React.createElement(MenuContextProvider, {
+    prefixCls: prefixCls,
+    rootClassName: rootClassName,
+    mode: internalMode,
+    openKeys: mergedOpenKeys,
+    rtl: isRtl
+    // Disabled
+    ,
+    disabled: disabled
+    // Motion
+    ,
+    motion: mounted ? motion : null,
+    defaultMotions: mounted ? defaultMotions : null
+    // Active
+    ,
+    activeKey: mergedActiveKey,
+    onActive: onActive,
+    onInactive: onInactive
+    // Selection
+    ,
+    selectedKeys: mergedSelectKeys
+    // Level
+    ,
+    inlineIndent: inlineIndent
+    // Popup
+    ,
+    subMenuOpenDelay: subMenuOpenDelay,
+    subMenuCloseDelay: subMenuCloseDelay,
+    forceSubMenuRender: forceSubMenuRender,
+    builtinPlacements: builtinPlacements,
+    triggerSubMenuAction: triggerSubMenuAction,
+    getPopupContainer: getPopupContainer
+    // Icon
+    ,
+    itemIcon: itemIcon,
+    expandIcon: expandIcon
+    // Events
+    ,
+    onItemClick: onInternalClick,
+    onOpenChange: onInternalOpenChange
+  }, /*#__PURE__*/React.createElement(PathUserContext.Provider, {
+    value: pathUserContext
+  }, container), /*#__PURE__*/React.createElement("div", {
+    style: {
+      display: 'none'
+    },
+    "aria-hidden": true
+  }, /*#__PURE__*/React.createElement(PathRegisterContext.Provider, {
+    value: registerPathContext
+  }, measureChildList)))));
+});
+export default Menu;

node_modules/rc-menu/es/MenuItem.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import type { MenuItemType } from './interface';
+export interface MenuItemProps extends Omit<MenuItemType, 'label' | 'key' | 'ref'>, Omit<React.HTMLAttributes<HTMLLIElement>, 'onClick' | 'onMouseEnter' | 'onMouseLeave' | 'onSelect'> {
+    children?: React.ReactNode;
+    /** @private Internal filled key. Do not set it directly */
+    eventKey?: string;
+    /** @private Do not use. Private warning empty usage */
+    warnKey?: boolean;
+    /** @deprecated No place to use this. Should remove */
+    attribute?: Record<string, string>;
+}
+declare const _default: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLElement>>;
+export default _default;

node_modules/rc-menu/es/MenuItem.js

@@ -0,0 +1,214 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+var _excluded = ["title", "attribute", "elementRef"],
+  _excluded2 = ["style", "className", "eventKey", "warnKey", "disabled", "itemIcon", "children", "role", "onMouseEnter", "onMouseLeave", "onClick", "onKeyDown", "onFocus"],
+  _excluded3 = ["active"];
+import classNames from 'classnames';
+import Overflow from 'rc-overflow';
+import KeyCode from "rc-util/es/KeyCode";
+import omit from "rc-util/es/omit";
+import { useComposeRef } from "rc-util/es/ref";
+import warning from "rc-util/es/warning";
+import * as React from 'react';
+import { useMenuId } from "./context/IdContext";
+import { MenuContext } from "./context/MenuContext";
+import { useFullPath, useMeasure } from "./context/PathContext";
+import PrivateContext from "./context/PrivateContext";
+import useActive from "./hooks/useActive";
+import useDirectionStyle from "./hooks/useDirectionStyle";
+import Icon from "./Icon";
+import { warnItemProp } from "./utils/warnUtil";
+// Since Menu event provide the `info.item` which point to the MenuItem node instance.
+// We have to use class component here.
+// This should be removed from doc & api in future.
+var LegacyMenuItem = /*#__PURE__*/function (_React$Component) {
+  _inherits(LegacyMenuItem, _React$Component);
+  var _super = _createSuper(LegacyMenuItem);
+  function LegacyMenuItem() {
+    _classCallCheck(this, LegacyMenuItem);
+    return _super.apply(this, arguments);
+  }
+  _createClass(LegacyMenuItem, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        title = _this$props.title,
+        attribute = _this$props.attribute,
+        elementRef = _this$props.elementRef,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+
+      // Here the props are eventually passed to the DOM element.
+      // React does not recognize non-standard attributes.
+      // Therefore, remove the props that is not used here.
+      // ref: https://github.com/ant-design/ant-design/issues/41395
+      var passedProps = omit(restProps, ['eventKey', 'popupClassName', 'popupOffset', 'onTitleClick']);
+      warning(!attribute, '`attribute` of Menu.Item is deprecated. Please pass attribute directly.');
+      return /*#__PURE__*/React.createElement(Overflow.Item, _extends({}, attribute, {
+        title: typeof title === 'string' ? title : undefined
+      }, passedProps, {
+        ref: elementRef
+      }));
+    }
+  }]);
+  return LegacyMenuItem;
+}(React.Component);
+/**
+ * Real Menu Item component
+ */
+var InternalMenuItem = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var style = props.style,
+    className = props.className,
+    eventKey = props.eventKey,
+    warnKey = props.warnKey,
+    disabled = props.disabled,
+    itemIcon = props.itemIcon,
+    children = props.children,
+    role = props.role,
+    onMouseEnter = props.onMouseEnter,
+    onMouseLeave = props.onMouseLeave,
+    onClick = props.onClick,
+    onKeyDown = props.onKeyDown,
+    onFocus = props.onFocus,
+    restProps = _objectWithoutProperties(props, _excluded2);
+  var domDataId = useMenuId(eventKey);
+  var _React$useContext = React.useContext(MenuContext),
+    prefixCls = _React$useContext.prefixCls,
+    onItemClick = _React$useContext.onItemClick,
+    contextDisabled = _React$useContext.disabled,
+    overflowDisabled = _React$useContext.overflowDisabled,
+    contextItemIcon = _React$useContext.itemIcon,
+    selectedKeys = _React$useContext.selectedKeys,
+    onActive = _React$useContext.onActive;
+  var _React$useContext2 = React.useContext(PrivateContext),
+    _internalRenderMenuItem = _React$useContext2._internalRenderMenuItem;
+  var itemCls = "".concat(prefixCls, "-item");
+  var legacyMenuItemRef = React.useRef();
+  var elementRef = React.useRef();
+  var mergedDisabled = contextDisabled || disabled;
+  var mergedEleRef = useComposeRef(ref, elementRef);
+  var connectedKeys = useFullPath(eventKey);
+
+  // ================================ Warn ================================
+  if (process.env.NODE_ENV !== 'production' && warnKey) {
+    warning(false, 'MenuItem should not leave undefined `key`.');
+  }
+
+  // ============================= Info =============================
+  var getEventInfo = function getEventInfo(e) {
+    return {
+      key: eventKey,
+      // Note: For legacy code is reversed which not like other antd component
+      keyPath: _toConsumableArray(connectedKeys).reverse(),
+      item: legacyMenuItemRef.current,
+      domEvent: e
+    };
+  };
+
+  // ============================= Icon =============================
+  var mergedItemIcon = itemIcon || contextItemIcon;
+
+  // ============================ Active ============================
+  var _useActive = useActive(eventKey, mergedDisabled, onMouseEnter, onMouseLeave),
+    active = _useActive.active,
+    activeProps = _objectWithoutProperties(_useActive, _excluded3);
+
+  // ============================ Select ============================
+  var selected = selectedKeys.includes(eventKey);
+
+  // ======================== DirectionStyle ========================
+  var directionStyle = useDirectionStyle(connectedKeys.length);
+
+  // ============================ Events ============================
+  var onInternalClick = function onInternalClick(e) {
+    if (mergedDisabled) {
+      return;
+    }
+    var info = getEventInfo(e);
+    onClick === null || onClick === void 0 || onClick(warnItemProp(info));
+    onItemClick(info);
+  };
+  var onInternalKeyDown = function onInternalKeyDown(e) {
+    onKeyDown === null || onKeyDown === void 0 || onKeyDown(e);
+    if (e.which === KeyCode.ENTER) {
+      var info = getEventInfo(e);
+
+      // Legacy. Key will also trigger click event
+      onClick === null || onClick === void 0 || onClick(warnItemProp(info));
+      onItemClick(info);
+    }
+  };
+
+  /**
+   * Used for accessibility. Helper will focus element without key board.
+   * We should manually trigger an active
+   */
+  var onInternalFocus = function onInternalFocus(e) {
+    onActive(eventKey);
+    onFocus === null || onFocus === void 0 || onFocus(e);
+  };
+
+  // ============================ Render ============================
+  var optionRoleProps = {};
+  if (props.role === 'option') {
+    optionRoleProps['aria-selected'] = selected;
+  }
+  var renderNode = /*#__PURE__*/React.createElement(LegacyMenuItem, _extends({
+    ref: legacyMenuItemRef,
+    elementRef: mergedEleRef,
+    role: role === null ? 'none' : role || 'menuitem',
+    tabIndex: disabled ? null : -1,
+    "data-menu-id": overflowDisabled && domDataId ? null : domDataId
+  }, omit(restProps, ['extra']), activeProps, optionRoleProps, {
+    component: "li",
+    "aria-disabled": disabled,
+    style: _objectSpread(_objectSpread({}, directionStyle), style),
+    className: classNames(itemCls, _defineProperty(_defineProperty(_defineProperty({}, "".concat(itemCls, "-active"), active), "".concat(itemCls, "-selected"), selected), "".concat(itemCls, "-disabled"), mergedDisabled), className),
+    onClick: onInternalClick,
+    onKeyDown: onInternalKeyDown,
+    onFocus: onInternalFocus
+  }), children, /*#__PURE__*/React.createElement(Icon, {
+    props: _objectSpread(_objectSpread({}, props), {}, {
+      isSelected: selected
+    }),
+    icon: mergedItemIcon
+  }));
+  if (_internalRenderMenuItem) {
+    renderNode = _internalRenderMenuItem(renderNode, props, {
+      selected: selected
+    });
+  }
+  return renderNode;
+});
+function MenuItem(props, ref) {
+  var eventKey = props.eventKey;
+
+  // ==================== Record KeyPath ====================
+  var measure = useMeasure();
+  var connectedKeyPath = useFullPath(eventKey);
+
+  // eslint-disable-next-line consistent-return
+  React.useEffect(function () {
+    if (measure) {
+      measure.registerPath(eventKey, connectedKeyPath);
+      return function () {
+        measure.unregisterPath(eventKey, connectedKeyPath);
+      };
+    }
+  }, [connectedKeyPath]);
+  if (measure) {
+    return null;
+  }
+
+  // ======================== Render ========================
+  return /*#__PURE__*/React.createElement(InternalMenuItem, _extends({}, props, {
+    ref: ref
+  }));
+}
+export default /*#__PURE__*/React.forwardRef(MenuItem);

node_modules/rc-menu/es/MenuItemGroup.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import type { MenuItemGroupType } from './interface';
+export interface MenuItemGroupProps extends Omit<MenuItemGroupType, 'type' | 'children' | 'label'> {
+    title?: React.ReactNode;
+    children?: React.ReactNode;
+    /** @private Internal filled key. Do not set it directly */
+    eventKey?: string;
+    /** @private Do not use. Private warning empty usage */
+    warnKey?: boolean;
+}
+declare const MenuItemGroup: React.ForwardRefExoticComponent<Omit<MenuItemGroupProps, "ref"> & React.RefAttributes<HTMLLIElement>>;
+export default MenuItemGroup;

node_modules/rc-menu/es/MenuItemGroup.js

@@ -0,0 +1,52 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["className", "title", "eventKey", "children"];
+import classNames from 'classnames';
+import omit from "rc-util/es/omit";
+import * as React from 'react';
+import { MenuContext } from "./context/MenuContext";
+import { useFullPath, useMeasure } from "./context/PathContext";
+import { parseChildren } from "./utils/commonUtil";
+var InternalMenuItemGroup = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var className = props.className,
+    title = props.title,
+    eventKey = props.eventKey,
+    children = props.children,
+    restProps = _objectWithoutProperties(props, _excluded);
+  var _React$useContext = React.useContext(MenuContext),
+    prefixCls = _React$useContext.prefixCls;
+  var groupPrefixCls = "".concat(prefixCls, "-item-group");
+  return /*#__PURE__*/React.createElement("li", _extends({
+    ref: ref,
+    role: "presentation"
+  }, restProps, {
+    onClick: function onClick(e) {
+      return e.stopPropagation();
+    },
+    className: classNames(groupPrefixCls, className)
+  }), /*#__PURE__*/React.createElement("div", {
+    role: "presentation",
+    className: "".concat(groupPrefixCls, "-title"),
+    title: typeof title === 'string' ? title : undefined
+  }, title), /*#__PURE__*/React.createElement("ul", {
+    role: "group",
+    className: "".concat(groupPrefixCls, "-list")
+  }, children));
+});
+var MenuItemGroup = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var eventKey = props.eventKey,
+    children = props.children;
+  var connectedKeyPath = useFullPath(eventKey);
+  var childList = parseChildren(children, connectedKeyPath);
+  var measure = useMeasure();
+  if (measure) {
+    return childList;
+  }
+  return /*#__PURE__*/React.createElement(InternalMenuItemGroup, _extends({
+    ref: ref
+  }, omit(props, ['warnKey'])), childList);
+});
+if (process.env.NODE_ENV !== 'production') {
+  MenuItemGroup.displayName = 'MenuItemGroup';
+}
+export default MenuItemGroup;

node_modules/rc-menu/es/SubMenu/InlineSubMenuList.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export interface InlineSubMenuListProps {
+    id?: string;
+    open: boolean;
+    keyPath: string[];
+    children: React.ReactNode;
+}
+export default function InlineSubMenuList({ id, open, keyPath, children, }: InlineSubMenuListProps): React.JSX.Element;

node_modules/rc-menu/es/SubMenu/InlineSubMenuList.js

@@ -0,0 +1,79 @@
+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 * as React from 'react';
+import CSSMotion from 'rc-motion';
+import { getMotion } from "../utils/motionUtil";
+import MenuContextProvider, { MenuContext } from "../context/MenuContext";
+import SubMenuList from "./SubMenuList";
+export default function InlineSubMenuList(_ref) {
+  var id = _ref.id,
+    open = _ref.open,
+    keyPath = _ref.keyPath,
+    children = _ref.children;
+  var fixedMode = 'inline';
+  var _React$useContext = React.useContext(MenuContext),
+    prefixCls = _React$useContext.prefixCls,
+    forceSubMenuRender = _React$useContext.forceSubMenuRender,
+    motion = _React$useContext.motion,
+    defaultMotions = _React$useContext.defaultMotions,
+    mode = _React$useContext.mode;
+
+  // Always use latest mode check
+  var sameModeRef = React.useRef(false);
+  sameModeRef.current = mode === fixedMode;
+
+  // We record `destroy` mark here since when mode change from `inline` to others.
+  // The inline list should remove when motion end.
+  var _React$useState = React.useState(!sameModeRef.current),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    destroy = _React$useState2[0],
+    setDestroy = _React$useState2[1];
+  var mergedOpen = sameModeRef.current ? open : false;
+
+  // ================================= Effect =================================
+  // Reset destroy state when mode change back
+  React.useEffect(function () {
+    if (sameModeRef.current) {
+      setDestroy(false);
+    }
+  }, [mode]);
+
+  // ================================= Render =================================
+  var mergedMotion = _objectSpread({}, getMotion(fixedMode, motion, defaultMotions));
+
+  // No need appear since nest inlineCollapse changed
+  if (keyPath.length > 1) {
+    mergedMotion.motionAppear = false;
+  }
+
+  // Hide inline list when mode changed and motion end
+  var originOnVisibleChanged = mergedMotion.onVisibleChanged;
+  mergedMotion.onVisibleChanged = function (newVisible) {
+    if (!sameModeRef.current && !newVisible) {
+      setDestroy(true);
+    }
+    return originOnVisibleChanged === null || originOnVisibleChanged === void 0 ? void 0 : originOnVisibleChanged(newVisible);
+  };
+  if (destroy) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(MenuContextProvider, {
+    mode: fixedMode,
+    locked: !sameModeRef.current
+  }, /*#__PURE__*/React.createElement(CSSMotion, _extends({
+    visible: mergedOpen
+  }, mergedMotion, {
+    forceRender: forceSubMenuRender,
+    removeOnLeave: false,
+    leavedClassName: "".concat(prefixCls, "-hidden")
+  }), function (_ref2) {
+    var motionClassName = _ref2.className,
+      motionStyle = _ref2.style;
+    return /*#__PURE__*/React.createElement(SubMenuList, {
+      id: id,
+      className: motionClassName,
+      style: motionStyle
+    }, children);
+  }));
+}

node_modules/rc-menu/es/SubMenu/PopupTrigger.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { MenuMode } from '../interface';
+export interface PopupTriggerProps {
+    prefixCls: string;
+    mode: MenuMode;
+    visible: boolean;
+    children: React.ReactElement;
+    popup: React.ReactNode;
+    popupStyle?: React.CSSProperties;
+    popupClassName?: string;
+    popupOffset?: number[];
+    disabled: boolean;
+    onVisibleChange: (visible: boolean) => void;
+}
+export default function PopupTrigger({ prefixCls, visible, children, popup, popupStyle, popupClassName, popupOffset, disabled, mode, onVisibleChange, }: PopupTriggerProps): React.JSX.Element;

node_modules/rc-menu/es/SubMenu/PopupTrigger.js

@@ -0,0 +1,91 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import Trigger from '@rc-component/trigger';
+import classNames from 'classnames';
+import raf from "rc-util/es/raf";
+import { MenuContext } from "../context/MenuContext";
+import { placements, placementsRtl } from "../placements";
+import { getMotion } from "../utils/motionUtil";
+var popupPlacementMap = {
+  horizontal: 'bottomLeft',
+  vertical: 'rightTop',
+  'vertical-left': 'rightTop',
+  'vertical-right': 'leftTop'
+};
+export default function PopupTrigger(_ref) {
+  var prefixCls = _ref.prefixCls,
+    visible = _ref.visible,
+    children = _ref.children,
+    popup = _ref.popup,
+    popupStyle = _ref.popupStyle,
+    popupClassName = _ref.popupClassName,
+    popupOffset = _ref.popupOffset,
+    disabled = _ref.disabled,
+    mode = _ref.mode,
+    onVisibleChange = _ref.onVisibleChange;
+  var _React$useContext = React.useContext(MenuContext),
+    getPopupContainer = _React$useContext.getPopupContainer,
+    rtl = _React$useContext.rtl,
+    subMenuOpenDelay = _React$useContext.subMenuOpenDelay,
+    subMenuCloseDelay = _React$useContext.subMenuCloseDelay,
+    builtinPlacements = _React$useContext.builtinPlacements,
+    triggerSubMenuAction = _React$useContext.triggerSubMenuAction,
+    forceSubMenuRender = _React$useContext.forceSubMenuRender,
+    rootClassName = _React$useContext.rootClassName,
+    motion = _React$useContext.motion,
+    defaultMotions = _React$useContext.defaultMotions;
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    innerVisible = _React$useState2[0],
+    setInnerVisible = _React$useState2[1];
+  var placement = rtl ? _objectSpread(_objectSpread({}, placementsRtl), builtinPlacements) : _objectSpread(_objectSpread({}, placements), builtinPlacements);
+  var popupPlacement = popupPlacementMap[mode];
+  var targetMotion = getMotion(mode, motion, defaultMotions);
+  var targetMotionRef = React.useRef(targetMotion);
+  if (mode !== 'inline') {
+    /**
+     * PopupTrigger is only used for vertical and horizontal types.
+     * When collapsed is unfolded, the inline animation will destroy the vertical animation.
+     */
+    targetMotionRef.current = targetMotion;
+  }
+  var mergedMotion = _objectSpread(_objectSpread({}, targetMotionRef.current), {}, {
+    leavedClassName: "".concat(prefixCls, "-hidden"),
+    removeOnLeave: false,
+    motionAppear: true
+  });
+
+  // Delay to change visible
+  var visibleRef = React.useRef();
+  React.useEffect(function () {
+    visibleRef.current = raf(function () {
+      setInnerVisible(visible);
+    });
+    return function () {
+      raf.cancel(visibleRef.current);
+    };
+  }, [visible]);
+  return /*#__PURE__*/React.createElement(Trigger, {
+    prefixCls: prefixCls,
+    popupClassName: classNames("".concat(prefixCls, "-popup"), _defineProperty({}, "".concat(prefixCls, "-rtl"), rtl), popupClassName, rootClassName),
+    stretch: mode === 'horizontal' ? 'minWidth' : null,
+    getPopupContainer: getPopupContainer,
+    builtinPlacements: placement,
+    popupPlacement: popupPlacement,
+    popupVisible: innerVisible,
+    popup: popup,
+    popupStyle: popupStyle,
+    popupAlign: popupOffset && {
+      offset: popupOffset
+    },
+    action: disabled ? [] : [triggerSubMenuAction],
+    mouseEnterDelay: subMenuOpenDelay,
+    mouseLeaveDelay: subMenuCloseDelay,
+    onPopupVisibleChange: onVisibleChange,
+    forceRender: forceSubMenuRender,
+    popupMotion: mergedMotion,
+    fresh: true
+  }, children);
+}

node_modules/rc-menu/es/SubMenu/SubMenuList.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export interface SubMenuListProps extends React.HTMLAttributes<HTMLUListElement> {
+    children?: React.ReactNode;
+}
+declare const SubMenuList: React.ForwardRefExoticComponent<SubMenuListProps & React.RefAttributes<HTMLUListElement>>;
+export default SubMenuList;

node_modules/rc-menu/es/SubMenu/SubMenuList.js

@@ -0,0 +1,25 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["className", "children"];
+import * as React from 'react';
+import classNames from 'classnames';
+import { MenuContext } from "../context/MenuContext";
+var InternalSubMenuList = function InternalSubMenuList(_ref, ref) {
+  var className = _ref.className,
+    children = _ref.children,
+    restProps = _objectWithoutProperties(_ref, _excluded);
+  var _React$useContext = React.useContext(MenuContext),
+    prefixCls = _React$useContext.prefixCls,
+    mode = _React$useContext.mode,
+    rtl = _React$useContext.rtl;
+  return /*#__PURE__*/React.createElement("ul", _extends({
+    className: classNames(prefixCls, rtl && "".concat(prefixCls, "-rtl"), "".concat(prefixCls, "-sub"), "".concat(prefixCls, "-").concat(mode === 'inline' ? 'inline' : 'vertical'), className),
+    role: "menu"
+  }, restProps, {
+    "data-menu-list": true,
+    ref: ref
+  }), children);
+};
+var SubMenuList = /*#__PURE__*/React.forwardRef(InternalSubMenuList);
+SubMenuList.displayName = 'SubMenuList';
+export default SubMenuList;

node_modules/rc-menu/es/SubMenu/index.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import type { SubMenuType } from '../interface';
+export interface SubMenuProps extends Omit<SubMenuType, 'key' | 'children' | 'label'> {
+    title?: React.ReactNode;
+    children?: React.ReactNode;
+    /** @private Used for rest popup. Do not use in your prod */
+    internalPopupClose?: boolean;
+    /** @private Internal filled key. Do not set it directly */
+    eventKey?: string;
+    /** @private Do not use. Private warning empty usage */
+    warnKey?: boolean;
+}
+declare const SubMenu: React.ForwardRefExoticComponent<Omit<SubMenuProps, "ref"> & React.RefAttributes<HTMLLIElement>>;
+export default SubMenu;

node_modules/rc-menu/es/SubMenu/index.js

@@ -0,0 +1,298 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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 = ["style", "className", "title", "eventKey", "warnKey", "disabled", "internalPopupClose", "children", "itemIcon", "expandIcon", "popupClassName", "popupOffset", "popupStyle", "onClick", "onMouseEnter", "onMouseLeave", "onTitleClick", "onTitleMouseEnter", "onTitleMouseLeave"],
+  _excluded2 = ["active"];
+import * as React from 'react';
+import classNames from 'classnames';
+import Overflow from 'rc-overflow';
+import warning from "rc-util/es/warning";
+import SubMenuList from "./SubMenuList";
+import { parseChildren } from "../utils/commonUtil";
+import MenuContextProvider, { MenuContext } from "../context/MenuContext";
+import useMemoCallback from "../hooks/useMemoCallback";
+import PopupTrigger from "./PopupTrigger";
+import Icon from "../Icon";
+import useActive from "../hooks/useActive";
+import { warnItemProp } from "../utils/warnUtil";
+import useDirectionStyle from "../hooks/useDirectionStyle";
+import InlineSubMenuList from "./InlineSubMenuList";
+import { PathTrackerContext, PathUserContext, useFullPath, useMeasure } from "../context/PathContext";
+import { useMenuId } from "../context/IdContext";
+import PrivateContext from "../context/PrivateContext";
+var InternalSubMenu = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var style = props.style,
+    className = props.className,
+    title = props.title,
+    eventKey = props.eventKey,
+    warnKey = props.warnKey,
+    disabled = props.disabled,
+    internalPopupClose = props.internalPopupClose,
+    children = props.children,
+    itemIcon = props.itemIcon,
+    expandIcon = props.expandIcon,
+    popupClassName = props.popupClassName,
+    popupOffset = props.popupOffset,
+    popupStyle = props.popupStyle,
+    onClick = props.onClick,
+    onMouseEnter = props.onMouseEnter,
+    onMouseLeave = props.onMouseLeave,
+    onTitleClick = props.onTitleClick,
+    onTitleMouseEnter = props.onTitleMouseEnter,
+    onTitleMouseLeave = props.onTitleMouseLeave,
+    restProps = _objectWithoutProperties(props, _excluded);
+  var domDataId = useMenuId(eventKey);
+  var _React$useContext = React.useContext(MenuContext),
+    prefixCls = _React$useContext.prefixCls,
+    mode = _React$useContext.mode,
+    openKeys = _React$useContext.openKeys,
+    contextDisabled = _React$useContext.disabled,
+    overflowDisabled = _React$useContext.overflowDisabled,
+    activeKey = _React$useContext.activeKey,
+    selectedKeys = _React$useContext.selectedKeys,
+    contextItemIcon = _React$useContext.itemIcon,
+    contextExpandIcon = _React$useContext.expandIcon,
+    onItemClick = _React$useContext.onItemClick,
+    onOpenChange = _React$useContext.onOpenChange,
+    onActive = _React$useContext.onActive;
+  var _React$useContext2 = React.useContext(PrivateContext),
+    _internalRenderSubMenuItem = _React$useContext2._internalRenderSubMenuItem;
+  var _React$useContext3 = React.useContext(PathUserContext),
+    isSubPathKey = _React$useContext3.isSubPathKey;
+  var connectedPath = useFullPath();
+  var subMenuPrefixCls = "".concat(prefixCls, "-submenu");
+  var mergedDisabled = contextDisabled || disabled;
+  var elementRef = React.useRef();
+  var popupRef = React.useRef();
+
+  // ================================ Warn ================================
+  if (process.env.NODE_ENV !== 'production' && warnKey) {
+    warning(false, 'SubMenu should not leave undefined `key`.');
+  }
+
+  // ================================ Icon ================================
+  var mergedItemIcon = itemIcon !== null && itemIcon !== void 0 ? itemIcon : contextItemIcon;
+  var mergedExpandIcon = expandIcon !== null && expandIcon !== void 0 ? expandIcon : contextExpandIcon;
+
+  // ================================ Open ================================
+  var originOpen = openKeys.includes(eventKey);
+  var open = !overflowDisabled && originOpen;
+
+  // =============================== Select ===============================
+  var childrenSelected = isSubPathKey(selectedKeys, eventKey);
+
+  // =============================== Active ===============================
+  var _useActive = useActive(eventKey, mergedDisabled, onTitleMouseEnter, onTitleMouseLeave),
+    active = _useActive.active,
+    activeProps = _objectWithoutProperties(_useActive, _excluded2);
+
+  // Fallback of active check to avoid hover on menu title or disabled item
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    childrenActive = _React$useState2[0],
+    setChildrenActive = _React$useState2[1];
+  var triggerChildrenActive = function triggerChildrenActive(newActive) {
+    if (!mergedDisabled) {
+      setChildrenActive(newActive);
+    }
+  };
+  var onInternalMouseEnter = function onInternalMouseEnter(domEvent) {
+    triggerChildrenActive(true);
+    onMouseEnter === null || onMouseEnter === void 0 || onMouseEnter({
+      key: eventKey,
+      domEvent: domEvent
+    });
+  };
+  var onInternalMouseLeave = function onInternalMouseLeave(domEvent) {
+    triggerChildrenActive(false);
+    onMouseLeave === null || onMouseLeave === void 0 || onMouseLeave({
+      key: eventKey,
+      domEvent: domEvent
+    });
+  };
+  var mergedActive = React.useMemo(function () {
+    if (active) {
+      return active;
+    }
+    if (mode !== 'inline') {
+      return childrenActive || isSubPathKey([activeKey], eventKey);
+    }
+    return false;
+  }, [mode, active, activeKey, childrenActive, eventKey, isSubPathKey]);
+
+  // ========================== DirectionStyle ==========================
+  var directionStyle = useDirectionStyle(connectedPath.length);
+
+  // =============================== Events ===============================
+  // >>>> Title click
+  var onInternalTitleClick = function onInternalTitleClick(e) {
+    // Skip if disabled
+    if (mergedDisabled) {
+      return;
+    }
+    onTitleClick === null || onTitleClick === void 0 || onTitleClick({
+      key: eventKey,
+      domEvent: e
+    });
+
+    // Trigger open by click when mode is `inline`
+    if (mode === 'inline') {
+      onOpenChange(eventKey, !originOpen);
+    }
+  };
+
+  // >>>> Context for children click
+  var onMergedItemClick = useMemoCallback(function (info) {
+    onClick === null || onClick === void 0 || onClick(warnItemProp(info));
+    onItemClick(info);
+  });
+
+  // >>>>> Visible change
+  var onPopupVisibleChange = function onPopupVisibleChange(newVisible) {
+    if (mode !== 'inline') {
+      onOpenChange(eventKey, newVisible);
+    }
+  };
+
+  /**
+   * Used for accessibility. Helper will focus element without key board.
+   * We should manually trigger an active
+   */
+  var onInternalFocus = function onInternalFocus() {
+    onActive(eventKey);
+  };
+
+  // =============================== Render ===============================
+  var popupId = domDataId && "".concat(domDataId, "-popup");
+  var expandIconNode = React.useMemo(function () {
+    return /*#__PURE__*/React.createElement(Icon, {
+      icon: mode !== 'horizontal' ? mergedExpandIcon : undefined,
+      props: _objectSpread(_objectSpread({}, props), {}, {
+        isOpen: open,
+        // [Legacy] Not sure why need this mark
+        isSubMenu: true
+      })
+    }, /*#__PURE__*/React.createElement("i", {
+      className: "".concat(subMenuPrefixCls, "-arrow")
+    }));
+  }, [mode, mergedExpandIcon, props, open, subMenuPrefixCls]);
+
+  // >>>>> Title
+  var titleNode = /*#__PURE__*/React.createElement("div", _extends({
+    role: "menuitem",
+    style: directionStyle,
+    className: "".concat(subMenuPrefixCls, "-title"),
+    tabIndex: mergedDisabled ? null : -1,
+    ref: elementRef,
+    title: typeof title === 'string' ? title : null,
+    "data-menu-id": overflowDisabled && domDataId ? null : domDataId,
+    "aria-expanded": open,
+    "aria-haspopup": true,
+    "aria-controls": popupId,
+    "aria-disabled": mergedDisabled,
+    onClick: onInternalTitleClick,
+    onFocus: onInternalFocus
+  }, activeProps), title, expandIconNode);
+
+  // Cache mode if it change to `inline` which do not have popup motion
+  var triggerModeRef = React.useRef(mode);
+  if (mode !== 'inline' && connectedPath.length > 1) {
+    triggerModeRef.current = 'vertical';
+  } else {
+    triggerModeRef.current = mode;
+  }
+  if (!overflowDisabled) {
+    var triggerMode = triggerModeRef.current;
+
+    // Still wrap with Trigger here since we need avoid react re-mount dom node
+    // Which makes motion failed
+    titleNode = /*#__PURE__*/React.createElement(PopupTrigger, {
+      mode: triggerMode,
+      prefixCls: subMenuPrefixCls,
+      visible: !internalPopupClose && open && mode !== 'inline',
+      popupClassName: popupClassName,
+      popupOffset: popupOffset,
+      popupStyle: popupStyle,
+      popup: /*#__PURE__*/React.createElement(MenuContextProvider
+      // Special handle of horizontal mode
+      , {
+        mode: triggerMode === 'horizontal' ? 'vertical' : triggerMode
+      }, /*#__PURE__*/React.createElement(SubMenuList, {
+        id: popupId,
+        ref: popupRef
+      }, children)),
+      disabled: mergedDisabled,
+      onVisibleChange: onPopupVisibleChange
+    }, titleNode);
+  }
+
+  // >>>>> List node
+  var listNode = /*#__PURE__*/React.createElement(Overflow.Item, _extends({
+    ref: ref,
+    role: "none"
+  }, restProps, {
+    component: "li",
+    style: style,
+    className: classNames(subMenuPrefixCls, "".concat(subMenuPrefixCls, "-").concat(mode), className, _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, "".concat(subMenuPrefixCls, "-open"), open), "".concat(subMenuPrefixCls, "-active"), mergedActive), "".concat(subMenuPrefixCls, "-selected"), childrenSelected), "".concat(subMenuPrefixCls, "-disabled"), mergedDisabled)),
+    onMouseEnter: onInternalMouseEnter,
+    onMouseLeave: onInternalMouseLeave
+  }), titleNode, !overflowDisabled && /*#__PURE__*/React.createElement(InlineSubMenuList, {
+    id: popupId,
+    open: open,
+    keyPath: connectedPath
+  }, children));
+  if (_internalRenderSubMenuItem) {
+    listNode = _internalRenderSubMenuItem(listNode, props, {
+      selected: childrenSelected,
+      active: mergedActive,
+      open: open,
+      disabled: mergedDisabled
+    });
+  }
+
+  // >>>>> Render
+  return /*#__PURE__*/React.createElement(MenuContextProvider, {
+    onItemClick: onMergedItemClick,
+    mode: mode === 'horizontal' ? 'vertical' : mode,
+    itemIcon: mergedItemIcon,
+    expandIcon: mergedExpandIcon
+  }, listNode);
+});
+var SubMenu = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var eventKey = props.eventKey,
+    children = props.children;
+  var connectedKeyPath = useFullPath(eventKey);
+  var childList = parseChildren(children, connectedKeyPath);
+
+  // ==================== Record KeyPath ====================
+  var measure = useMeasure();
+
+  // eslint-disable-next-line consistent-return
+  React.useEffect(function () {
+    if (measure) {
+      measure.registerPath(eventKey, connectedKeyPath);
+      return function () {
+        measure.unregisterPath(eventKey, connectedKeyPath);
+      };
+    }
+  }, [connectedKeyPath]);
+  var renderNode;
+
+  // ======================== Render ========================
+  if (measure) {
+    renderNode = childList;
+  } else {
+    renderNode = /*#__PURE__*/React.createElement(InternalSubMenu, _extends({
+      ref: ref
+    }, props), childList);
+  }
+  return /*#__PURE__*/React.createElement(PathTrackerContext.Provider, {
+    value: connectedKeyPath
+  }, renderNode);
+});
+if (process.env.NODE_ENV !== 'production') {
+  SubMenu.displayName = 'SubMenu';
+}
+export default SubMenu;

node_modules/rc-menu/es/context/IdContext.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export declare const IdContext: React.Context<string>;
+export declare function getMenuId(uuid: string, eventKey: string): string;
+/**
+ * Get `data-menu-id`
+ */
+export declare function useMenuId(eventKey: string): string;

node_modules/rc-menu/es/context/IdContext.js

@@ -0,0 +1,16 @@
+import * as React from 'react';
+export var IdContext = /*#__PURE__*/React.createContext(null);
+export function getMenuId(uuid, eventKey) {
+  if (uuid === undefined) {
+    return null;
+  }
+  return "".concat(uuid, "-").concat(eventKey);
+}
+
+/**
+ * Get `data-menu-id`
+ */
+export function useMenuId(eventKey) {
+  var id = React.useContext(IdContext);
+  return getMenuId(id, eventKey);
+}

node_modules/rc-menu/es/context/MenuContext.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import type { CSSMotionProps } from 'rc-motion';
+import type { BuiltinPlacements, MenuClickEventHandler, MenuMode, RenderIconType, TriggerSubMenuAction } from '../interface';
+export interface MenuContextProps {
+    prefixCls: string;
+    rootClassName?: string;
+    openKeys: string[];
+    rtl?: boolean;
+    mode: MenuMode;
+    disabled?: boolean;
+    overflowDisabled?: boolean;
+    activeKey: string;
+    onActive: (key: string) => void;
+    onInactive: (key: string) => void;
+    selectedKeys: string[];
+    inlineIndent: number;
+    motion?: CSSMotionProps;
+    defaultMotions?: Partial<{
+        [key in MenuMode | 'other']: CSSMotionProps;
+    }>;
+    subMenuOpenDelay: number;
+    subMenuCloseDelay: number;
+    forceSubMenuRender?: boolean;
+    builtinPlacements?: BuiltinPlacements;
+    triggerSubMenuAction?: TriggerSubMenuAction;
+    itemIcon?: RenderIconType;
+    expandIcon?: RenderIconType;
+    onItemClick: MenuClickEventHandler;
+    onOpenChange: (key: string, open: boolean) => void;
+    getPopupContainer: (node: HTMLElement) => HTMLElement;
+}
+export declare const MenuContext: React.Context<MenuContextProps>;
+export interface InheritableContextProps extends Partial<MenuContextProps> {
+    children?: React.ReactNode;
+    locked?: boolean;
+}
+export default function InheritableContextProvider({ children, locked, ...restProps }: InheritableContextProps): React.JSX.Element;

node_modules/rc-menu/es/context/MenuContext.js

@@ -0,0 +1,31 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+var _excluded = ["children", "locked"];
+import * as React from 'react';
+import useMemo from "rc-util/es/hooks/useMemo";
+import isEqual from "rc-util/es/isEqual";
+export var MenuContext = /*#__PURE__*/React.createContext(null);
+function mergeProps(origin, target) {
+  var clone = _objectSpread({}, origin);
+  Object.keys(target).forEach(function (key) {
+    var value = target[key];
+    if (value !== undefined) {
+      clone[key] = value;
+    }
+  });
+  return clone;
+}
+export default function InheritableContextProvider(_ref) {
+  var children = _ref.children,
+    locked = _ref.locked,
+    restProps = _objectWithoutProperties(_ref, _excluded);
+  var context = React.useContext(MenuContext);
+  var inheritableContext = useMemo(function () {
+    return mergeProps(context, restProps);
+  }, [context, restProps], function (prev, next) {
+    return !locked && (prev[0] !== next[0] || !isEqual(prev[1], next[1], true));
+  });
+  return /*#__PURE__*/React.createElement(MenuContext.Provider, {
+    value: inheritableContext
+  }, children);
+}

node_modules/rc-menu/es/context/PathContext.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+export interface PathRegisterContextProps {
+    registerPath: (key: string, keyPath: string[]) => void;
+    unregisterPath: (key: string, keyPath: string[]) => void;
+}
+export declare const PathRegisterContext: React.Context<PathRegisterContextProps>;
+export declare function useMeasure(): PathRegisterContextProps;
+export declare const PathTrackerContext: React.Context<string[]>;
+export declare function useFullPath(eventKey?: string): string[];
+export interface PathUserContextProps {
+    isSubPathKey: (pathKeys: string[], eventKey: string) => boolean;
+}
+export declare const PathUserContext: React.Context<PathUserContextProps>;

node_modules/rc-menu/es/context/PathContext.js

@@ -0,0 +1,23 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+var EmptyList = [];
+
+// ========================= Path Register =========================
+
+export var PathRegisterContext = /*#__PURE__*/React.createContext(null);
+export function useMeasure() {
+  return React.useContext(PathRegisterContext);
+}
+
+// ========================= Path Tracker ==========================
+export var PathTrackerContext = /*#__PURE__*/React.createContext(EmptyList);
+export function useFullPath(eventKey) {
+  var parentKeyPath = React.useContext(PathTrackerContext);
+  return React.useMemo(function () {
+    return eventKey !== undefined ? [].concat(_toConsumableArray(parentKeyPath), [eventKey]) : parentKeyPath;
+  }, [parentKeyPath, eventKey]);
+}
+
+// =========================== Path User ===========================
+
+export var PathUserContext = /*#__PURE__*/React.createContext(null);

node_modules/rc-menu/es/context/PrivateContext.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import type { MenuProps } from '../Menu';
+export interface PrivateContextProps {
+    _internalRenderMenuItem?: MenuProps['_internalRenderMenuItem'];
+    _internalRenderSubMenuItem?: MenuProps['_internalRenderSubMenuItem'];
+}
+declare const PrivateContext: React.Context<PrivateContextProps>;
+export default PrivateContext;

node_modules/rc-menu/es/context/PrivateContext.js

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

node_modules/rc-menu/es/hooks/useAccessibility.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import type { MenuMode } from '../interface';
+/**
+ * Get focusable elements from the element set under provided container
+ */
+export declare function getFocusableElements(container: HTMLElement, elements: Set<HTMLElement>): HTMLElement[];
+export declare const refreshElements: (keys: string[], id: string) => {
+    elements: Set<HTMLElement>;
+    key2element: Map<string, HTMLElement>;
+    element2key: Map<HTMLElement, string>;
+};
+export declare function useAccessibility<T extends HTMLElement>(mode: MenuMode, activeKey: string, isRtl: boolean, id: string, containerRef: React.RefObject<HTMLUListElement>, getKeys: () => string[], getKeyPath: (key: string, includeOverflow?: boolean) => string[], triggerActiveKey: (key: string) => void, triggerAccessibilityOpen: (key: string, open?: boolean) => void, originOnKeyDown?: React.KeyboardEventHandler<T>): React.KeyboardEventHandler<T>;

node_modules/rc-menu/es/hooks/useAccessibility.js

@@ -0,0 +1,270 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { getFocusNodeList } from "rc-util/es/Dom/focus";
+import KeyCode from "rc-util/es/KeyCode";
+import raf from "rc-util/es/raf";
+import * as React from 'react';
+import { getMenuId } from "../context/IdContext";
+// destruct to reduce minify size
+var LEFT = KeyCode.LEFT,
+  RIGHT = KeyCode.RIGHT,
+  UP = KeyCode.UP,
+  DOWN = KeyCode.DOWN,
+  ENTER = KeyCode.ENTER,
+  ESC = KeyCode.ESC,
+  HOME = KeyCode.HOME,
+  END = KeyCode.END;
+var ArrowKeys = [UP, DOWN, LEFT, RIGHT];
+function getOffset(mode, isRootLevel, isRtl, which) {
+  var _offsets;
+  var prev = 'prev';
+  var next = 'next';
+  var children = 'children';
+  var parent = 'parent';
+
+  // Inline enter is special that we use unique operation
+  if (mode === 'inline' && which === ENTER) {
+    return {
+      inlineTrigger: true
+    };
+  }
+  var inline = _defineProperty(_defineProperty({}, UP, prev), DOWN, next);
+  var horizontal = _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, LEFT, isRtl ? next : prev), RIGHT, isRtl ? prev : next), DOWN, children), ENTER, children);
+  var vertical = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, UP, prev), DOWN, next), ENTER, children), ESC, parent), LEFT, isRtl ? children : parent), RIGHT, isRtl ? parent : children);
+  var offsets = {
+    inline: inline,
+    horizontal: horizontal,
+    vertical: vertical,
+    inlineSub: inline,
+    horizontalSub: vertical,
+    verticalSub: vertical
+  };
+  var type = (_offsets = offsets["".concat(mode).concat(isRootLevel ? '' : 'Sub')]) === null || _offsets === void 0 ? void 0 : _offsets[which];
+  switch (type) {
+    case prev:
+      return {
+        offset: -1,
+        sibling: true
+      };
+    case next:
+      return {
+        offset: 1,
+        sibling: true
+      };
+    case parent:
+      return {
+        offset: -1,
+        sibling: false
+      };
+    case children:
+      return {
+        offset: 1,
+        sibling: false
+      };
+    default:
+      return null;
+  }
+}
+function findContainerUL(element) {
+  var current = element;
+  while (current) {
+    if (current.getAttribute('data-menu-list')) {
+      return current;
+    }
+    current = current.parentElement;
+  }
+
+  // Normally should not reach this line
+  /* istanbul ignore next */
+  return null;
+}
+
+/**
+ * Find focused element within element set provided
+ */
+function getFocusElement(activeElement, elements) {
+  var current = activeElement || document.activeElement;
+  while (current) {
+    if (elements.has(current)) {
+      return current;
+    }
+    current = current.parentElement;
+  }
+  return null;
+}
+
+/**
+ * Get focusable elements from the element set under provided container
+ */
+export function getFocusableElements(container, elements) {
+  var list = getFocusNodeList(container, true);
+  return list.filter(function (ele) {
+    return elements.has(ele);
+  });
+}
+function getNextFocusElement(parentQueryContainer, elements, focusMenuElement) {
+  var offset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+  // Key on the menu item will not get validate parent container
+  if (!parentQueryContainer) {
+    return null;
+  }
+
+  // List current level menu item elements
+  var sameLevelFocusableMenuElementList = getFocusableElements(parentQueryContainer, elements);
+
+  // Find next focus index
+  var count = sameLevelFocusableMenuElementList.length;
+  var focusIndex = sameLevelFocusableMenuElementList.findIndex(function (ele) {
+    return focusMenuElement === ele;
+  });
+  if (offset < 0) {
+    if (focusIndex === -1) {
+      focusIndex = count - 1;
+    } else {
+      focusIndex -= 1;
+    }
+  } else if (offset > 0) {
+    focusIndex += 1;
+  }
+  focusIndex = (focusIndex + count) % count;
+
+  // Focus menu item
+  return sameLevelFocusableMenuElementList[focusIndex];
+}
+export var refreshElements = function refreshElements(keys, id) {
+  var elements = new Set();
+  var key2element = new Map();
+  var element2key = new Map();
+  keys.forEach(function (key) {
+    var element = document.querySelector("[data-menu-id='".concat(getMenuId(id, key), "']"));
+    if (element) {
+      elements.add(element);
+      element2key.set(element, key);
+      key2element.set(key, element);
+    }
+  });
+  return {
+    elements: elements,
+    key2element: key2element,
+    element2key: element2key
+  };
+};
+export function useAccessibility(mode, activeKey, isRtl, id, containerRef, getKeys, getKeyPath, triggerActiveKey, triggerAccessibilityOpen, originOnKeyDown) {
+  var rafRef = React.useRef();
+  var activeRef = React.useRef();
+  activeRef.current = activeKey;
+  var cleanRaf = function cleanRaf() {
+    raf.cancel(rafRef.current);
+  };
+  React.useEffect(function () {
+    return function () {
+      cleanRaf();
+    };
+  }, []);
+  return function (e) {
+    var which = e.which;
+    if ([].concat(ArrowKeys, [ENTER, ESC, HOME, END]).includes(which)) {
+      var keys = getKeys();
+      var refreshedElements = refreshElements(keys, id);
+      var _refreshedElements = refreshedElements,
+        elements = _refreshedElements.elements,
+        key2element = _refreshedElements.key2element,
+        element2key = _refreshedElements.element2key;
+
+      // First we should find current focused MenuItem/SubMenu element
+      var activeElement = key2element.get(activeKey);
+      var focusMenuElement = getFocusElement(activeElement, elements);
+      var focusMenuKey = element2key.get(focusMenuElement);
+      var offsetObj = getOffset(mode, getKeyPath(focusMenuKey, true).length === 1, isRtl, which);
+
+      // Some mode do not have fully arrow operation like inline
+      if (!offsetObj && which !== HOME && which !== END) {
+        return;
+      }
+
+      // Arrow prevent default to avoid page scroll
+      if (ArrowKeys.includes(which) || [HOME, END].includes(which)) {
+        e.preventDefault();
+      }
+      var tryFocus = function tryFocus(menuElement) {
+        if (menuElement) {
+          var focusTargetElement = menuElement;
+
+          // Focus to link instead of menu item if possible
+          var link = menuElement.querySelector('a');
+          if (link !== null && link !== void 0 && link.getAttribute('href')) {
+            focusTargetElement = link;
+          }
+          var targetKey = element2key.get(menuElement);
+          triggerActiveKey(targetKey);
+
+          /**
+           * Do not `useEffect` here since `tryFocus` may trigger async
+           * which makes React sync update the `activeKey`
+           * that force render before `useRef` set the next activeKey
+           */
+          cleanRaf();
+          rafRef.current = raf(function () {
+            if (activeRef.current === targetKey) {
+              focusTargetElement.focus();
+            }
+          });
+        }
+      };
+      if ([HOME, END].includes(which) || offsetObj.sibling || !focusMenuElement) {
+        // ========================== Sibling ==========================
+        // Find walkable focus menu element container
+        var parentQueryContainer;
+        if (!focusMenuElement || mode === 'inline') {
+          parentQueryContainer = containerRef.current;
+        } else {
+          parentQueryContainer = findContainerUL(focusMenuElement);
+        }
+
+        // Get next focus element
+        var targetElement;
+        var focusableElements = getFocusableElements(parentQueryContainer, elements);
+        if (which === HOME) {
+          targetElement = focusableElements[0];
+        } else if (which === END) {
+          targetElement = focusableElements[focusableElements.length - 1];
+        } else {
+          targetElement = getNextFocusElement(parentQueryContainer, elements, focusMenuElement, offsetObj.offset);
+        }
+        // Focus menu item
+        tryFocus(targetElement);
+
+        // ======================= InlineTrigger =======================
+      } else if (offsetObj.inlineTrigger) {
+        // Inline trigger no need switch to sub menu item
+        triggerAccessibilityOpen(focusMenuKey);
+        // =========================== Level ===========================
+      } else if (offsetObj.offset > 0) {
+        triggerAccessibilityOpen(focusMenuKey, true);
+        cleanRaf();
+        rafRef.current = raf(function () {
+          // Async should resync elements
+          refreshedElements = refreshElements(keys, id);
+          var controlId = focusMenuElement.getAttribute('aria-controls');
+          var subQueryContainer = document.getElementById(controlId);
+
+          // Get sub focusable menu item
+          var targetElement = getNextFocusElement(subQueryContainer, refreshedElements.elements);
+
+          // Focus menu item
+          tryFocus(targetElement);
+        }, 5);
+      } else if (offsetObj.offset < 0) {
+        var keyPath = getKeyPath(focusMenuKey, true);
+        var parentKey = keyPath[keyPath.length - 2];
+        var parentMenuElement = key2element.get(parentKey);
+
+        // Focus menu item
+        triggerAccessibilityOpen(parentKey, false);
+        tryFocus(parentMenuElement);
+      }
+    }
+
+    // Pass origin key down event
+    originOnKeyDown === null || originOnKeyDown === void 0 || originOnKeyDown(e);
+  };
+}

node_modules/rc-menu/es/hooks/useActive.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { MenuHoverEventHandler } from '../interface';
+interface ActiveObj {
+    active: boolean;
+    onMouseEnter?: React.MouseEventHandler<HTMLElement>;
+    onMouseLeave?: React.MouseEventHandler<HTMLElement>;
+}
+export default function useActive(eventKey: string, disabled: boolean, onMouseEnter?: MenuHoverEventHandler, onMouseLeave?: MenuHoverEventHandler): ActiveObj;
+export {};

node_modules/rc-menu/es/hooks/useActive.js

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import { MenuContext } from "../context/MenuContext";
+export default function useActive(eventKey, disabled, onMouseEnter, onMouseLeave) {
+  var _React$useContext = React.useContext(MenuContext),
+    activeKey = _React$useContext.activeKey,
+    onActive = _React$useContext.onActive,
+    onInactive = _React$useContext.onInactive;
+  var ret = {
+    active: activeKey === eventKey
+  };
+
+  // Skip when disabled
+  if (!disabled) {
+    ret.onMouseEnter = function (domEvent) {
+      onMouseEnter === null || onMouseEnter === void 0 || onMouseEnter({
+        key: eventKey,
+        domEvent: domEvent
+      });
+      onActive(eventKey);
+    };
+    ret.onMouseLeave = function (domEvent) {
+      onMouseLeave === null || onMouseLeave === void 0 || onMouseLeave({
+        key: eventKey,
+        domEvent: domEvent
+      });
+      onInactive(eventKey);
+    };
+  }
+  return ret;
+}

node_modules/rc-menu/es/hooks/useDirectionStyle.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export default function useDirectionStyle(level: number): React.CSSProperties;

node_modules/rc-menu/es/hooks/useDirectionStyle.js

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { MenuContext } from "../context/MenuContext";
+export default function useDirectionStyle(level) {
+  var _React$useContext = React.useContext(MenuContext),
+    mode = _React$useContext.mode,
+    rtl = _React$useContext.rtl,
+    inlineIndent = _React$useContext.inlineIndent;
+  if (mode !== 'inline') {
+    return null;
+  }
+  var len = level;
+  return rtl ? {
+    paddingRight: len * inlineIndent
+  } : {
+    paddingLeft: len * inlineIndent
+  };
+}

node_modules/rc-menu/es/hooks/useKeyRecords.d.ts

@@ -0,0 +1,10 @@
+export declare const OVERFLOW_KEY = "rc-menu-more";
+export default function useKeyRecords(): {
+    registerPath: (key: string, keyPath: string[]) => void;
+    unregisterPath: (key: string, keyPath: string[]) => void;
+    refreshOverflowKeys: (keys: string[]) => void;
+    isSubPathKey: (pathKeys: string[], eventKey: string) => boolean;
+    getKeyPath: (eventKey: string, includeOverflow?: boolean) => string[];
+    getKeys: () => string[];
+    getSubPathKeys: (key: string) => Set<string>;
+};

node_modules/rc-menu/es/hooks/useKeyRecords.js

@@ -0,0 +1,111 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import { useRef, useCallback } from 'react';
+import warning from "rc-util/es/warning";
+import { nextSlice } from "../utils/timeUtil";
+var PATH_SPLIT = '__RC_UTIL_PATH_SPLIT__';
+var getPathStr = function getPathStr(keyPath) {
+  return keyPath.join(PATH_SPLIT);
+};
+var getPathKeys = function getPathKeys(keyPathStr) {
+  return keyPathStr.split(PATH_SPLIT);
+};
+export var OVERFLOW_KEY = 'rc-menu-more';
+export default function useKeyRecords() {
+  var _React$useState = React.useState({}),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    internalForceUpdate = _React$useState2[1];
+  var key2pathRef = useRef(new Map());
+  var path2keyRef = useRef(new Map());
+  var _React$useState3 = React.useState([]),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    overflowKeys = _React$useState4[0],
+    setOverflowKeys = _React$useState4[1];
+  var updateRef = useRef(0);
+  var destroyRef = useRef(false);
+  var forceUpdate = function forceUpdate() {
+    if (!destroyRef.current) {
+      internalForceUpdate({});
+    }
+  };
+  var registerPath = useCallback(function (key, keyPath) {
+    // Warning for invalidate or duplicated `key`
+    if (process.env.NODE_ENV !== 'production') {
+      warning(!key2pathRef.current.has(key), "Duplicated key '".concat(key, "' used in Menu by path [").concat(keyPath.join(' > '), "]"));
+    }
+
+    // Fill map
+    var connectedPath = getPathStr(keyPath);
+    path2keyRef.current.set(connectedPath, key);
+    key2pathRef.current.set(key, connectedPath);
+    updateRef.current += 1;
+    var id = updateRef.current;
+    nextSlice(function () {
+      if (id === updateRef.current) {
+        forceUpdate();
+      }
+    });
+  }, []);
+  var unregisterPath = useCallback(function (key, keyPath) {
+    var connectedPath = getPathStr(keyPath);
+    path2keyRef.current.delete(connectedPath);
+    key2pathRef.current.delete(key);
+  }, []);
+  var refreshOverflowKeys = useCallback(function (keys) {
+    setOverflowKeys(keys);
+  }, []);
+  var getKeyPath = useCallback(function (eventKey, includeOverflow) {
+    var fullPath = key2pathRef.current.get(eventKey) || '';
+    var keys = getPathKeys(fullPath);
+    if (includeOverflow && overflowKeys.includes(keys[0])) {
+      keys.unshift(OVERFLOW_KEY);
+    }
+    return keys;
+  }, [overflowKeys]);
+  var isSubPathKey = useCallback(function (pathKeys, eventKey) {
+    return pathKeys.filter(function (item) {
+      return item !== undefined;
+    }).some(function (pathKey) {
+      var pathKeyList = getKeyPath(pathKey, true);
+      return pathKeyList.includes(eventKey);
+    });
+  }, [getKeyPath]);
+  var getKeys = function getKeys() {
+    var keys = _toConsumableArray(key2pathRef.current.keys());
+    if (overflowKeys.length) {
+      keys.push(OVERFLOW_KEY);
+    }
+    return keys;
+  };
+
+  /**
+   * Find current key related child path keys
+   */
+  var getSubPathKeys = useCallback(function (key) {
+    var connectedPath = "".concat(key2pathRef.current.get(key)).concat(PATH_SPLIT);
+    var pathKeys = new Set();
+    _toConsumableArray(path2keyRef.current.keys()).forEach(function (pathKey) {
+      if (pathKey.startsWith(connectedPath)) {
+        pathKeys.add(path2keyRef.current.get(pathKey));
+      }
+    });
+    return pathKeys;
+  }, []);
+  React.useEffect(function () {
+    return function () {
+      destroyRef.current = true;
+    };
+  }, []);
+  return {
+    // Register
+    registerPath: registerPath,
+    unregisterPath: unregisterPath,
+    refreshOverflowKeys: refreshOverflowKeys,
+    // Util
+    isSubPathKey: isSubPathKey,
+    getKeyPath: getKeyPath,
+    getKeys: getKeys,
+    getSubPathKeys: getSubPathKeys
+  };
+}

node_modules/rc-menu/es/hooks/useMemoCallback.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Cache callback function that always return same ref instead.
+ * This is used for context optimization.
+ */
+export default function useMemoCallback<T extends (...args: any[]) => void>(func: T): T;

node_modules/rc-menu/es/hooks/useMemoCallback.js

@@ -0,0 +1,18 @@
+import * as React from 'react';
+
+/**
+ * Cache callback function that always return same ref instead.
+ * This is used for context optimization.
+ */
+export default function useMemoCallback(func) {
+  var funRef = React.useRef(func);
+  funRef.current = func;
+  var callback = React.useCallback(function () {
+    var _funRef$current;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return (_funRef$current = funRef.current) === null || _funRef$current === void 0 ? void 0 : _funRef$current.call.apply(_funRef$current, [funRef].concat(args));
+  }, []);
+  return func ? callback : undefined;
+}

node_modules/rc-menu/es/hooks/useUUID.d.ts

@@ -0,0 +1 @@
+export default function useUUID(id?: string): string;

node_modules/rc-menu/es/hooks/useUUID.js

@@ -0,0 +1,19 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import useMergedState from "rc-util/es/hooks/useMergedState";
+var uniquePrefix = Math.random().toFixed(5).toString().slice(2);
+var internalId = 0;
+export default function useUUID(id) {
+  var _useMergedState = useMergedState(id, {
+      value: id
+    }),
+    _useMergedState2 = _slicedToArray(_useMergedState, 2),
+    uuid = _useMergedState2[0],
+    setUUID = _useMergedState2[1];
+  React.useEffect(function () {
+    internalId += 1;
+    var newId = process.env.NODE_ENV === 'test' ? 'test' : "".concat(uniquePrefix, "-").concat(internalId);
+    setUUID("rc-menu-uuid-".concat(newId));
+  }, []);
+  return uuid;
+}

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

@@ -0,0 +1,23 @@
+import Menu from './Menu';
+import MenuItem from './MenuItem';
+import SubMenu from './SubMenu';
+import MenuItemGroup from './MenuItemGroup';
+import { useFullPath } from './context/PathContext';
+import Divider from './Divider';
+import type { MenuProps } from './Menu';
+import type { MenuItemProps } from './MenuItem';
+import type { SubMenuProps } from './SubMenu';
+import type { MenuItemGroupProps } from './MenuItemGroup';
+import type { MenuRef } from './interface';
+export { SubMenu, MenuItem as Item, MenuItem, MenuItemGroup, MenuItemGroup as ItemGroup, Divider, 
+/** @private Only used for antd internal. Do not use in your production. */
+useFullPath, };
+export type { MenuProps, SubMenuProps, MenuItemProps, MenuItemGroupProps, MenuRef, };
+type MenuType = typeof Menu & {
+    Item: typeof MenuItem;
+    SubMenu: typeof SubMenu;
+    ItemGroup: typeof MenuItemGroup;
+    Divider: typeof Divider;
+};
+declare const ExportMenu: MenuType;
+export default ExportMenu;

node_modules/rc-menu/es/index.js

@@ -0,0 +1,14 @@
+import Menu from "./Menu";
+import MenuItem from "./MenuItem";
+import SubMenu from "./SubMenu";
+import MenuItemGroup from "./MenuItemGroup";
+import { useFullPath } from "./context/PathContext";
+import Divider from "./Divider";
+export { SubMenu, MenuItem as Item, MenuItem, MenuItemGroup, MenuItemGroup as ItemGroup, Divider, /** @private Only used for antd internal. Do not use in your production. */
+useFullPath };
+var ExportMenu = Menu;
+ExportMenu.Item = MenuItem;
+ExportMenu.SubMenu = SubMenu;
+ExportMenu.ItemGroup = MenuItemGroup;
+ExportMenu.Divider = Divider;
+export default ExportMenu;

node_modules/rc-menu/es/interface.d.ts

@@ -0,0 +1,86 @@
+import type * as React from 'react';
+interface ItemSharedProps {
+    ref?: React.Ref<HTMLLIElement | null>;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export interface SubMenuType extends ItemSharedProps {
+    type?: 'submenu';
+    label?: React.ReactNode;
+    children: ItemType[];
+    disabled?: boolean;
+    key: string;
+    rootClassName?: string;
+    itemIcon?: RenderIconType;
+    expandIcon?: RenderIconType;
+    onMouseEnter?: MenuHoverEventHandler;
+    onMouseLeave?: MenuHoverEventHandler;
+    popupClassName?: string;
+    popupOffset?: number[];
+    popupStyle?: React.CSSProperties;
+    onClick?: MenuClickEventHandler;
+    onTitleClick?: (info: MenuTitleInfo) => void;
+    onTitleMouseEnter?: MenuHoverEventHandler;
+    onTitleMouseLeave?: MenuHoverEventHandler;
+}
+export interface MenuItemType extends ItemSharedProps {
+    type?: 'item';
+    label?: React.ReactNode;
+    disabled?: boolean;
+    itemIcon?: RenderIconType;
+    extra?: React.ReactNode;
+    key: React.Key;
+    onMouseEnter?: MenuHoverEventHandler;
+    onMouseLeave?: MenuHoverEventHandler;
+    onClick?: MenuClickEventHandler;
+}
+export interface MenuItemGroupType extends ItemSharedProps {
+    type: 'group';
+    label?: React.ReactNode;
+    children?: ItemType[];
+}
+export interface MenuDividerType extends Omit<ItemSharedProps, 'ref'> {
+    type: 'divider';
+}
+export type ItemType = SubMenuType | MenuItemType | MenuItemGroupType | MenuDividerType | null;
+export type MenuMode = 'horizontal' | 'vertical' | 'inline';
+export type BuiltinPlacements = Record<string, any>;
+export type TriggerSubMenuAction = 'click' | 'hover';
+export interface RenderIconInfo {
+    isSelected?: boolean;
+    isOpen?: boolean;
+    isSubMenu?: boolean;
+    disabled?: boolean;
+}
+export type RenderIconType = React.ReactNode | ((props: RenderIconInfo) => React.ReactNode);
+export interface MenuInfo {
+    key: string;
+    keyPath: string[];
+    /** @deprecated This will not support in future. You should avoid to use this */
+    item: React.ReactInstance;
+    domEvent: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>;
+}
+export interface MenuTitleInfo {
+    key: string;
+    domEvent: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>;
+}
+export type MenuHoverEventHandler = (info: {
+    key: string;
+    domEvent: React.MouseEvent<HTMLElement>;
+}) => void;
+export interface SelectInfo extends MenuInfo {
+    selectedKeys: string[];
+}
+export type SelectEventHandler = (info: SelectInfo) => void;
+export type MenuClickEventHandler = (info: MenuInfo) => void;
+export type MenuRef = {
+    /**
+     * Focus active child if any, or the first child which is not disabled will be focused.
+     * @param options
+     */
+    focus: (options?: FocusOptions) => void;
+    list: HTMLUListElement;
+};
+export type ComponentType = 'submenu' | 'item' | 'group' | 'divider';
+export type Components = Partial<Record<ComponentType, React.ComponentType<any>>>;
+export {};

node_modules/rc-menu/es/interface.js

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

node_modules/rc-menu/es/placements.d.ts

@@ -0,0 +1,117 @@
+export declare const placements: {
+    topLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    topRight: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    bottomLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    bottomRight: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    leftTop: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    leftBottom: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    rightTop: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    rightBottom: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+};
+export declare const placementsRtl: {
+    topLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    topRight: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    bottomLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    bottomRight: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    rightTop: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    rightBottom: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    leftTop: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+    leftBottom: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+    };
+};
+export default placements;

node_modules/rc-menu/es/placements.js

@@ -0,0 +1,73 @@
+var autoAdjustOverflow = {
+  adjustX: 1,
+  adjustY: 1
+};
+export var placements = {
+  topLeft: {
+    points: ['bl', 'tl'],
+    overflow: autoAdjustOverflow
+  },
+  topRight: {
+    points: ['br', 'tr'],
+    overflow: autoAdjustOverflow
+  },
+  bottomLeft: {
+    points: ['tl', 'bl'],
+    overflow: autoAdjustOverflow
+  },
+  bottomRight: {
+    points: ['tr', 'br'],
+    overflow: autoAdjustOverflow
+  },
+  leftTop: {
+    points: ['tr', 'tl'],
+    overflow: autoAdjustOverflow
+  },
+  leftBottom: {
+    points: ['br', 'bl'],
+    overflow: autoAdjustOverflow
+  },
+  rightTop: {
+    points: ['tl', 'tr'],
+    overflow: autoAdjustOverflow
+  },
+  rightBottom: {
+    points: ['bl', 'br'],
+    overflow: autoAdjustOverflow
+  }
+};
+export var placementsRtl = {
+  topLeft: {
+    points: ['bl', 'tl'],
+    overflow: autoAdjustOverflow
+  },
+  topRight: {
+    points: ['br', 'tr'],
+    overflow: autoAdjustOverflow
+  },
+  bottomLeft: {
+    points: ['tl', 'bl'],
+    overflow: autoAdjustOverflow
+  },
+  bottomRight: {
+    points: ['tr', 'br'],
+    overflow: autoAdjustOverflow
+  },
+  rightTop: {
+    points: ['tr', 'tl'],
+    overflow: autoAdjustOverflow
+  },
+  rightBottom: {
+    points: ['br', 'bl'],
+    overflow: autoAdjustOverflow
+  },
+  leftTop: {
+    points: ['tl', 'tr'],
+    overflow: autoAdjustOverflow
+  },
+  leftBottom: {
+    points: ['bl', 'br'],
+    overflow: autoAdjustOverflow
+  }
+};
+export default placements;

node_modules/rc-menu/es/utils/commonUtil.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare function parseChildren(children: React.ReactNode | undefined, keyPath: string[]): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];

node_modules/rc-menu/es/utils/commonUtil.js

@@ -0,0 +1,25 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import toArray from "rc-util/es/Children/toArray";
+import * as React from 'react';
+export function parseChildren(children, keyPath) {
+  return toArray(children).map(function (child, index) {
+    if ( /*#__PURE__*/React.isValidElement(child)) {
+      var _eventKey, _child$props;
+      var key = child.key;
+      var eventKey = (_eventKey = (_child$props = child.props) === null || _child$props === void 0 ? void 0 : _child$props.eventKey) !== null && _eventKey !== void 0 ? _eventKey : key;
+      var emptyKey = eventKey === null || eventKey === undefined;
+      if (emptyKey) {
+        eventKey = "tmp_key-".concat([].concat(_toConsumableArray(keyPath), [index]).join('-'));
+      }
+      var cloneProps = {
+        key: eventKey,
+        eventKey: eventKey
+      };
+      if (process.env.NODE_ENV !== 'production' && emptyKey) {
+        cloneProps.warnKey = true;
+      }
+      return /*#__PURE__*/React.cloneElement(child, cloneProps);
+    }
+    return child;
+  });
+}

node_modules/rc-menu/es/utils/motionUtil.d.ts

@@ -0,0 +1,2 @@
+import type { CSSMotionProps } from 'rc-motion';
+export declare function getMotion(mode: string, motion?: CSSMotionProps, defaultMotions?: Record<string, CSSMotionProps>): CSSMotionProps;

node_modules/rc-menu/es/utils/motionUtil.js

@@ -0,0 +1,9 @@
+export function getMotion(mode, motion, defaultMotions) {
+  if (motion) {
+    return motion;
+  }
+  if (defaultMotions) {
+    return defaultMotions[mode] || defaultMotions.other;
+  }
+  return undefined;
+}

node_modules/rc-menu/es/utils/nodeUtil.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import type { Components, ItemType } from '../interface';
+export declare function parseItems(children: React.ReactNode | undefined, items: ItemType[] | undefined, keyPath: string[], components: Components, prefixCls?: string): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];

node_modules/rc-menu/es/utils/nodeUtil.js

@@ -0,0 +1,78 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+var _excluded = ["label", "children", "key", "type", "extra"];
+import * as React from 'react';
+import Divider from "../Divider";
+import MenuItem from "../MenuItem";
+import MenuItemGroup from "../MenuItemGroup";
+import SubMenu from "../SubMenu";
+import { parseChildren } from "./commonUtil";
+function convertItemsToNodes(list, components, prefixCls) {
+  var MergedMenuItem = components.item,
+    MergedMenuItemGroup = components.group,
+    MergedSubMenu = components.submenu,
+    MergedDivider = components.divider;
+  return (list || []).map(function (opt, index) {
+    if (opt && _typeof(opt) === 'object') {
+      var _ref = opt,
+        label = _ref.label,
+        children = _ref.children,
+        key = _ref.key,
+        type = _ref.type,
+        extra = _ref.extra,
+        restProps = _objectWithoutProperties(_ref, _excluded);
+      var mergedKey = key !== null && key !== void 0 ? key : "tmp-".concat(index);
+
+      // MenuItemGroup & SubMenuItem
+      if (children || type === 'group') {
+        if (type === 'group') {
+          // Group
+          return /*#__PURE__*/React.createElement(MergedMenuItemGroup, _extends({
+            key: mergedKey
+          }, restProps, {
+            title: label
+          }), convertItemsToNodes(children, components, prefixCls));
+        }
+
+        // Sub Menu
+        return /*#__PURE__*/React.createElement(MergedSubMenu, _extends({
+          key: mergedKey
+        }, restProps, {
+          title: label
+        }), convertItemsToNodes(children, components, prefixCls));
+      }
+
+      // MenuItem & Divider
+      if (type === 'divider') {
+        return /*#__PURE__*/React.createElement(MergedDivider, _extends({
+          key: mergedKey
+        }, restProps));
+      }
+      return /*#__PURE__*/React.createElement(MergedMenuItem, _extends({
+        key: mergedKey
+      }, restProps, {
+        extra: extra
+      }), label, (!!extra || extra === 0) && /*#__PURE__*/React.createElement("span", {
+        className: "".concat(prefixCls, "-item-extra")
+      }, extra));
+    }
+    return null;
+  }).filter(function (opt) {
+    return opt;
+  });
+}
+export function parseItems(children, items, keyPath, components, prefixCls) {
+  var childNodes = children;
+  var mergedComponents = _objectSpread({
+    divider: Divider,
+    item: MenuItem,
+    group: MenuItemGroup,
+    submenu: SubMenu
+  }, components);
+  if (items) {
+    childNodes = convertItemsToNodes(items, mergedComponents, prefixCls);
+  }
+  return parseChildren(childNodes, keyPath);
+}

node_modules/rc-menu/es/utils/timeUtil.d.ts

@@ -0,0 +1 @@
+export declare function nextSlice(callback: () => void): void;

node_modules/rc-menu/es/utils/timeUtil.js

@@ -0,0 +1,4 @@
+export function nextSlice(callback) {
+  /* istanbul ignore next */
+  Promise.resolve().then(callback);
+}

node_modules/rc-menu/es/utils/warnUtil.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+/**
+ * `onClick` event return `info.item` which point to react node directly.
+ * We should warning this since it will not work on FC.
+ */
+export declare function warnItemProp<T extends {
+    item: React.ReactInstance;
+}>({ item, ...restInfo }: T): T;

node_modules/rc-menu/es/utils/warnUtil.js

@@ -0,0 +1,19 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["item"];
+import warning from "rc-util/es/warning";
+
+/**
+ * `onClick` event return `info.item` which point to react node directly.
+ * We should warning this since it will not work on FC.
+ */
+export function warnItemProp(_ref) {
+  var item = _ref.item,
+    restInfo = _objectWithoutProperties(_ref, _excluded);
+  Object.defineProperty(restInfo, 'item', {
+    get: function get() {
+      warning(false, '`info.item` is deprecated since we will move to function component that not provides React Node instance in future.');
+      return item;
+    }
+  });
+  return restInfo;
+}