add all frontend files

node_modules/antd/es/_util/ActionButton.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import type { ButtonProps, LegacyButtonType } from '../button/button';
+export interface ActionButtonProps {
+    type?: LegacyButtonType;
+    actionFn?: (...args: any[]) => any | PromiseLike<any>;
+    close?: (...args: any[]) => void;
+    autoFocus?: boolean;
+    prefixCls: string;
+    buttonProps?: ButtonProps;
+    emitEvent?: boolean;
+    quitOnNullishReturnValue?: boolean;
+    children?: React.ReactNode;
+    /**
+     * Do not throw if is await mode
+     */
+    isSilent?: () => boolean;
+}
+declare const ActionButton: React.FC<ActionButtonProps>;
+export default ActionButton;

node_modules/antd/es/_util/ActionButton.js

@@ -0,0 +1,103 @@
+"use client";
+
+import * as React from 'react';
+import useState from "rc-util/es/hooks/useState";
+import Button from '../button';
+import { convertLegacyProps } from '../button/buttonHelpers';
+const isThenable = thing => {
+  return typeof (thing === null || thing === void 0 ? void 0 : thing.then) === 'function';
+};
+const ActionButton = props => {
+  const {
+    type,
+    children,
+    prefixCls,
+    buttonProps,
+    close,
+    autoFocus,
+    emitEvent,
+    isSilent,
+    quitOnNullishReturnValue,
+    actionFn
+  } = props;
+  const clickedRef = React.useRef(false);
+  const buttonRef = React.useRef(null);
+  const [loading, setLoading] = useState(false);
+  const onInternalClose = (...args) => {
+    close === null || close === void 0 ? void 0 : close.apply(void 0, args);
+  };
+  React.useEffect(() => {
+    let timeoutId = null;
+    if (autoFocus) {
+      timeoutId = setTimeout(() => {
+        var _a;
+        (_a = buttonRef.current) === null || _a === void 0 ? void 0 : _a.focus({
+          preventScroll: true
+        });
+      });
+    }
+    return () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, [autoFocus]);
+  const handlePromiseOnOk = returnValueOfOnOk => {
+    if (!isThenable(returnValueOfOnOk)) {
+      return;
+    }
+    setLoading(true);
+    returnValueOfOnOk.then((...args) => {
+      setLoading(false, true);
+      onInternalClose.apply(void 0, args);
+      clickedRef.current = false;
+    }, e => {
+      // See: https://github.com/ant-design/ant-design/issues/6183
+      setLoading(false, true);
+      clickedRef.current = false;
+      // Do not throw if is `await` mode
+      if (isSilent === null || isSilent === void 0 ? void 0 : isSilent()) {
+        return;
+      }
+      return Promise.reject(e);
+    });
+  };
+  const onClick = e => {
+    if (clickedRef.current) {
+      return;
+    }
+    clickedRef.current = true;
+    if (!actionFn) {
+      onInternalClose();
+      return;
+    }
+    let returnValueOfOnOk;
+    if (emitEvent) {
+      returnValueOfOnOk = actionFn(e);
+      if (quitOnNullishReturnValue && !isThenable(returnValueOfOnOk)) {
+        clickedRef.current = false;
+        onInternalClose(e);
+        return;
+      }
+    } else if (actionFn.length) {
+      returnValueOfOnOk = actionFn(close);
+      // https://github.com/ant-design/ant-design/issues/23358
+      clickedRef.current = false;
+    } else {
+      returnValueOfOnOk = actionFn();
+      if (!isThenable(returnValueOfOnOk)) {
+        onInternalClose();
+        return;
+      }
+    }
+    handlePromiseOnOk(returnValueOfOnOk);
+  };
+  return /*#__PURE__*/React.createElement(Button, Object.assign({}, convertLegacyProps(type), {
+    onClick: onClick,
+    loading: loading,
+    prefixCls: prefixCls
+  }, buttonProps, {
+    ref: buttonRef
+  }), children);
+};
+export default ActionButton;

node_modules/antd/es/_util/ContextIsolator.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const ContextIsolator: React.FC<Readonly<React.PropsWithChildren<Partial<Record<'space' | 'form', boolean>>>>>;
+export default ContextIsolator;

node_modules/antd/es/_util/ContextIsolator.js

@@ -0,0 +1,27 @@
+"use client";
+
+import React from 'react';
+import { NoFormStyle } from '../form/context';
+import { NoCompactStyle } from '../space/Compact';
+const ContextIsolator = props => {
+  const {
+    space,
+    form,
+    children
+  } = props;
+  if (children === undefined || children === null) {
+    return null;
+  }
+  let result = children;
+  if (form) {
+    result = /*#__PURE__*/React.createElement(NoFormStyle, {
+      override: true,
+      status: true
+    }, result);
+  }
+  if (space) {
+    result = /*#__PURE__*/React.createElement(NoCompactStyle, null, result);
+  }
+  return result;
+};
+export default ContextIsolator;

node_modules/antd/es/_util/PurePanel.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { AnyObject } from './type';
+export declare function withPureRenderTheme<T extends AnyObject = AnyObject>(Component: React.FC<T>): (props: T) => React.JSX.Element;
+export interface BaseProps {
+    prefixCls?: string;
+    style?: React.CSSProperties;
+}
+declare const genPurePanel: <ComponentProps extends BaseProps = BaseProps>(Component: React.ComponentType<Readonly<ComponentProps>>, alignPropName?: "align" | "dropdownAlign" | "popupAlign", postProps?: (props: ComponentProps) => ComponentProps, defaultPrefixCls?: string, getDropdownCls?: (prefixCls: string) => string) => (props: AnyObject) => React.JSX.Element;
+export default genPurePanel;

node_modules/antd/es/_util/PurePanel.js

@@ -0,0 +1,90 @@
+"use client";
+
+import * as React from 'react';
+import useMergedState from "rc-util/es/hooks/useMergedState";
+import ConfigProvider, { ConfigContext } from '../config-provider';
+export function withPureRenderTheme(Component) {
+  return props => (/*#__PURE__*/React.createElement(ConfigProvider, {
+    theme: {
+      token: {
+        motion: false,
+        zIndexPopupBase: 0
+      }
+    }
+  }, /*#__PURE__*/React.createElement(Component, Object.assign({}, props))));
+}
+/* istanbul ignore next */
+const genPurePanel = (Component, alignPropName, postProps, defaultPrefixCls, getDropdownCls) => {
+  const PurePanel = props => {
+    const {
+      prefixCls: customizePrefixCls,
+      style
+    } = props;
+    const holderRef = React.useRef(null);
+    const [popupHeight, setPopupHeight] = React.useState(0);
+    const [popupWidth, setPopupWidth] = React.useState(0);
+    const [open, setOpen] = useMergedState(false, {
+      value: props.open
+    });
+    const {
+      getPrefixCls
+    } = React.useContext(ConfigContext);
+    const prefixCls = getPrefixCls(defaultPrefixCls || 'select', customizePrefixCls);
+    React.useEffect(() => {
+      // We do not care about ssr
+      setOpen(true);
+      if (typeof ResizeObserver !== 'undefined') {
+        const resizeObserver = new ResizeObserver(entries => {
+          const element = entries[0].target;
+          setPopupHeight(element.offsetHeight + 8);
+          setPopupWidth(element.offsetWidth);
+        });
+        const interval = setInterval(() => {
+          var _a;
+          const dropdownCls = getDropdownCls ? `.${getDropdownCls(prefixCls)}` : `.${prefixCls}-dropdown`;
+          const popup = (_a = holderRef.current) === null || _a === void 0 ? void 0 : _a.querySelector(dropdownCls);
+          if (popup) {
+            clearInterval(interval);
+            resizeObserver.observe(popup);
+          }
+        }, 10);
+        return () => {
+          clearInterval(interval);
+          resizeObserver.disconnect();
+        };
+      }
+    }, [prefixCls]);
+    let mergedProps = Object.assign(Object.assign({}, props), {
+      style: Object.assign(Object.assign({}, style), {
+        margin: 0
+      }),
+      open,
+      visible: open,
+      getPopupContainer: () => holderRef.current
+    });
+    if (postProps) {
+      mergedProps = postProps(mergedProps);
+    }
+    if (alignPropName) {
+      Object.assign(mergedProps, {
+        [alignPropName]: {
+          overflow: {
+            adjustX: false,
+            adjustY: false
+          }
+        }
+      });
+    }
+    const mergedStyle = {
+      paddingBottom: popupHeight,
+      position: 'relative',
+      minWidth: popupWidth
+    };
+    return /*#__PURE__*/React.createElement("div", {
+      ref: holderRef,
+      style: mergedStyle
+    }, /*#__PURE__*/React.createElement(Component, Object.assign({}, mergedProps)));
+  };
+  return withPureRenderTheme(PurePanel);
+};
+export default genPurePanel;

node_modules/antd/es/_util/aria-data-attrs.d.ts

@@ -0,0 +1,4 @@
+import type * as React from 'react';
+export type HTMLAriaDataAttributes = React.AriaAttributes & {
+    [key: `data-${string}`]: unknown;
+} & Pick<React.HTMLAttributes<HTMLDivElement>, 'role'>;

node_modules/antd/es/_util/aria-data-attrs.js

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

node_modules/antd/es/_util/capitalize.d.ts

@@ -0,0 +1 @@
+export default function capitalize<T extends string>(str: T): Capitalize<T>;

node_modules/antd/es/_util/capitalize.js

@@ -0,0 +1,7 @@
+export default function capitalize(str) {
+  if (typeof str !== 'string') {
+    return str;
+  }
+  const ret = str.charAt(0).toUpperCase() + str.slice(1);
+  return ret;
+}

node_modules/antd/es/_util/colors.d.ts

@@ -0,0 +1,13 @@
+import type { PresetColorKey } from '../theme/interface';
+type InverseColor = `${PresetColorKey}-inverse`;
+export declare const PresetStatusColorTypes: readonly ["success", "processing", "error", "default", "warning"];
+export type PresetColorType = PresetColorKey | InverseColor;
+export type PresetStatusColorType = (typeof PresetStatusColorTypes)[number];
+/**
+ * determine if the color keyword belongs to the `Ant Design` {@link PresetColors}.
+ * @param color color to be judged
+ * @param includeInverse whether to include reversed colors
+ */
+export declare function isPresetColor(color?: any, includeInverse?: boolean): boolean;
+export declare function isPresetStatusColor(color?: any): color is PresetStatusColorType;
+export {};

node_modules/antd/es/_util/colors.js

@@ -0,0 +1,18 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { PresetColors } from '../theme/interface';
+const inverseColors = PresetColors.map(color => `${color}-inverse`);
+export const PresetStatusColorTypes = ['success', 'processing', 'error', 'default', 'warning'];
+/**
+ * determine if the color keyword belongs to the `Ant Design` {@link PresetColors}.
+ * @param color color to be judged
+ * @param includeInverse whether to include reversed colors
+ */
+export function isPresetColor(color, includeInverse = true) {
+  if (includeInverse) {
+    return [].concat(_toConsumableArray(inverseColors), _toConsumableArray(PresetColors)).includes(color);
+  }
+  return PresetColors.includes(color);
+}
+export function isPresetStatusColor(color) {
+  return PresetStatusColorTypes.includes(color);
+}

node_modules/antd/es/_util/convertToTooltipProps.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from 'react';
+import type { TooltipProps } from '../tooltip';
+declare function convertToTooltipProps<P extends TooltipProps>(tooltip: P | ReactNode): P | null;
+export default convertToTooltipProps;

node_modules/antd/es/_util/convertToTooltipProps.js

@@ -0,0 +1,14 @@
+import { isValidElement } from 'react';
+function convertToTooltipProps(tooltip) {
+  // isNil
+  if (tooltip === undefined || tooltip === null) {
+    return null;
+  }
+  if (typeof tooltip === 'object' && ! /*#__PURE__*/isValidElement(tooltip)) {
+    return tooltip;
+  }
+  return {
+    title: tooltip
+  };
+}
+export default convertToTooltipProps;

node_modules/antd/es/_util/easings.d.ts

@@ -0,0 +1 @@
+export declare function easeInOutCubic(t: number, b: number, c: number, d: number): number;

node_modules/antd/es/_util/easings.js

@@ -0,0 +1,9 @@
+export function easeInOutCubic(t, b, c, d) {
+  const cc = c - b;
+  t /= d / 2;
+  if (t < 1) {
+    return cc / 2 * t * t * t + b;
+  }
+  // biome-ignore lint: it is a common easing function
+  return cc / 2 * ((t -= 2) * t * t + 2) + b;
+}

node_modules/antd/es/_util/extendsObject.d.ts

@@ -0,0 +1,4 @@
+declare function mergeProps<A, B>(a: A, b: B): B & A;
+declare function mergeProps<A, B, C>(a: A, b: B, c: C): C & B & A;
+declare function mergeProps<A, B, C, D>(a: A, b: B, c: C, d: D): D & C & B & A;
+export default mergeProps;

node_modules/antd/es/_util/extendsObject.js

@@ -0,0 +1,14 @@
+function mergeProps(...items) {
+  const ret = {};
+  items.forEach(item => {
+    if (item) {
+      Object.keys(item).forEach(key => {
+        if (item[key] !== undefined) {
+          ret[key] = item[key];
+        }
+      });
+    }
+  });
+  return ret;
+}
+export default mergeProps;

node_modules/antd/es/_util/gapSize.d.ts

@@ -0,0 +1,3 @@
+import type { SizeType } from '../config-provider/SizeContext';
+export declare function isPresetSize(size?: SizeType | string | number): size is SizeType;
+export declare function isValidGapNumber(size?: SizeType | string | number): size is number;

node_modules/antd/es/_util/gapSize.js

@@ -0,0 +1,10 @@
+export function isPresetSize(size) {
+  return ['small', 'middle', 'large'].includes(size);
+}
+export function isValidGapNumber(size) {
+  if (!size) {
+    // The case of size = 0 is deliberately excluded here, because the default value of the gap attribute in CSS is 0, so if the user passes 0 in, we can directly ignore it.
+    return false;
+  }
+  return typeof size === 'number' && !Number.isNaN(size);
+}

node_modules/antd/es/_util/getAllowClear.d.ts

@@ -0,0 +1,4 @@
+import type { BaseInputProps } from 'rc-input/lib/interface';
+export type AllowClear = BaseInputProps['allowClear'];
+declare const getAllowClear: (allowClear: AllowClear) => AllowClear;
+export default getAllowClear;

node_modules/antd/es/_util/getAllowClear.js

@@ -0,0 +1,16 @@
+"use client";
+
+import React from 'react';
+import CloseCircleFilled from "@ant-design/icons/es/icons/CloseCircleFilled";
+const getAllowClear = allowClear => {
+  let mergedAllowClear;
+  if (typeof allowClear === 'object' && (allowClear === null || allowClear === void 0 ? void 0 : allowClear.clearIcon)) {
+    mergedAllowClear = allowClear;
+  } else if (allowClear) {
+    mergedAllowClear = {
+      clearIcon: /*#__PURE__*/React.createElement(CloseCircleFilled, null)
+    };
+  }
+  return mergedAllowClear;
+};
+export default getAllowClear;

node_modules/antd/es/_util/getRenderPropValue.d.ts

@@ -0,0 +1,3 @@
+import type * as React from 'react';
+export type RenderFunction = () => React.ReactNode;
+export declare const getRenderPropValue: (propValue?: React.ReactNode | RenderFunction) => React.ReactNode;

node_modules/antd/es/_util/getRenderPropValue.js

@@ -0,0 +1,6 @@
+export const getRenderPropValue = propValue => {
+  if (!propValue) {
+    return null;
+  }
+  return typeof propValue === 'function' ? propValue() : propValue;
+};

node_modules/antd/es/_util/getScroll.d.ts

@@ -0,0 +1,3 @@
+export declare function isWindow(obj: any): obj is Window;
+declare const getScroll: (target: HTMLElement | Window | Document | null) => number;
+export default getScroll;

node_modules/antd/es/_util/getScroll.js

@@ -0,0 +1,31 @@
+export function isWindow(obj) {
+  return obj !== null && obj !== undefined && obj === obj.window;
+}
+const getScroll = target => {
+  var _a, _b;
+  if (typeof window === 'undefined') {
+    /* istanbul ignore next */
+    return 0;
+  }
+  let result = 0;
+  if (isWindow(target)) {
+    result = target.pageYOffset;
+  } else if (target instanceof Document) {
+    result = target.documentElement.scrollTop;
+  } else if (target instanceof HTMLElement) {
+    result = target.scrollTop;
+  } else if (target) {
+    // According to the type inference, the `target` is `never` type.
+    // Since we configured the loose mode type checking, and supports mocking the target with such shape below::
+    //    `{ documentElement: { scrollLeft: 200, scrollTop: 400 } }`,
+    //    the program may falls into this branch.
+    // Check the corresponding tests for details. Don't sure what is the real scenario this happens.
+    /* biome-ignore lint/complexity/useLiteralKeys: target is a never type */ /* eslint-disable-next-line dot-notation */
+    result = target['scrollTop'];
+  }
+  if (target && !isWindow(target) && typeof result !== 'number') {
+    result = (_b = ((_a = target.ownerDocument) !== null && _a !== void 0 ? _a : target).documentElement) === null || _b === void 0 ? void 0 : _b.scrollTop;
+  }
+  return result;
+};
+export default getScroll;

node_modules/antd/es/_util/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export * from './useClosable';
+export * from './useForceUpdate';
+export * from './useMergeSemantic';
+export * from './useMultipleSelect';
+export * from './usePatchElement';
+export * from './useProxyImperativeHandle';
+export * from './useSyncState';
+export * from './useZIndex';

node_modules/antd/es/_util/hooks/index.js

@@ -0,0 +1,8 @@
+export * from './useClosable';
+export * from './useForceUpdate';
+export * from './useMergeSemantic';
+export * from './useMultipleSelect';
+export * from './usePatchElement';
+export * from './useProxyImperativeHandle';
+export * from './useSyncState';
+export * from './useZIndex';

node_modules/antd/es/_util/hooks/useClosable.d.ts

@@ -0,0 +1,33 @@
+import type { ReactNode } from 'react';
+import React from 'react';
+import type { DialogProps } from 'rc-dialog';
+import type { HTMLAriaDataAttributes } from '../aria-data-attrs';
+export type ClosableType = DialogProps['closable'];
+export type BaseContextClosable = {
+    closable?: ClosableType;
+    closeIcon?: ReactNode;
+};
+export type ContextClosable<T extends BaseContextClosable = any> = Partial<Pick<T, 'closable' | 'closeIcon'>>;
+export declare function pickClosable<T extends BaseContextClosable>(context?: ContextClosable<T>): ContextClosable<T> | undefined;
+export type UseClosableParams = {
+    closable?: ClosableType;
+    closeIcon?: ReactNode;
+    defaultClosable?: boolean;
+    defaultCloseIcon?: ReactNode;
+    customCloseIconRender?: (closeIcon: ReactNode) => ReactNode;
+    context?: ContextClosable;
+};
+/** Collection contains the all the props related with closable. e.g. `closable`, `closeIcon` */
+interface ClosableCollection {
+    closable?: ClosableType;
+    closeIcon?: ReactNode;
+}
+interface FallbackCloseCollection extends ClosableCollection {
+    /**
+     * Some components need to wrap CloseIcon twice,
+     * this method will be executed once after the final CloseIcon is calculated
+     */
+    closeIconRender?: (closeIcon: ReactNode) => ReactNode;
+}
+export declare const useClosable: (propCloseCollection?: ClosableCollection, contextCloseCollection?: ClosableCollection | null, fallbackCloseCollection?: FallbackCloseCollection) => [closable: boolean, closeIcon: React.ReactNode, closeBtnIsDisabled: boolean, ariaOrDataProps?: HTMLAriaDataAttributes];
+export {};

node_modules/antd/es/_util/hooks/useClosable.js

@@ -0,0 +1,106 @@
+"use client";
+
+import React from 'react';
+import CloseOutlined from "@ant-design/icons/es/icons/CloseOutlined";
+import pickAttrs from "rc-util/es/pickAttrs";
+import { useLocale } from '../../locale';
+import defaultLocale from '../../locale/en_US';
+import extendsObject from '../extendsObject';
+export function pickClosable(context) {
+  if (!context) {
+    return undefined;
+  }
+  const {
+    closable,
+    closeIcon
+  } = context;
+  return {
+    closable,
+    closeIcon
+  };
+}
+/** Convert `closable` and `closeIcon` to config object */
+function useClosableConfig(closableCollection) {
+  const {
+    closable,
+    closeIcon
+  } = closableCollection || {};
+  return React.useMemo(() => {
+    if (
+    // If `closable`, whatever rest be should be true
+    !closable && (closable === false || closeIcon === false || closeIcon === null)) {
+      return false;
+    }
+    if (closable === undefined && closeIcon === undefined) {
+      return null;
+    }
+    let closableConfig = {
+      closeIcon: typeof closeIcon !== 'boolean' && closeIcon !== null ? closeIcon : undefined
+    };
+    if (closable && typeof closable === 'object') {
+      closableConfig = Object.assign(Object.assign({}, closableConfig), closable);
+    }
+    return closableConfig;
+  }, [closable, closeIcon]);
+}
+/** Use same object to support `useMemo` optimization */
+const EmptyFallbackCloseCollection = {};
+export const useClosable = (propCloseCollection, contextCloseCollection, fallbackCloseCollection = EmptyFallbackCloseCollection) => {
+  // Align the `props`, `context` `fallback` to config object first
+  const propCloseConfig = useClosableConfig(propCloseCollection);
+  const contextCloseConfig = useClosableConfig(contextCloseCollection);
+  const [contextLocale] = useLocale('global', defaultLocale.global);
+  const closeBtnIsDisabled = typeof propCloseConfig !== 'boolean' ? !!(propCloseConfig === null || propCloseConfig === void 0 ? void 0 : propCloseConfig.disabled) : false;
+  const mergedFallbackCloseCollection = React.useMemo(() => Object.assign({
+    closeIcon: /*#__PURE__*/React.createElement(CloseOutlined, null)
+  }, fallbackCloseCollection), [fallbackCloseCollection]);
+  // Use fallback logic to fill the config
+  const mergedClosableConfig = React.useMemo(() => {
+    // ================ Props First ================
+    // Skip if prop is disabled
+    if (propCloseConfig === false) {
+      return false;
+    }
+    if (propCloseConfig) {
+      return extendsObject(mergedFallbackCloseCollection, contextCloseConfig, propCloseConfig);
+    }
+    // =============== Context Second ==============
+    // Skip if context is disabled
+    if (contextCloseConfig === false) {
+      return false;
+    }
+    if (contextCloseConfig) {
+      return extendsObject(mergedFallbackCloseCollection, contextCloseConfig);
+    }
+    // ============= Fallback Default ==============
+    return !mergedFallbackCloseCollection.closable ? false : mergedFallbackCloseCollection;
+  }, [propCloseConfig, contextCloseConfig, mergedFallbackCloseCollection]);
+  // Calculate the final closeIcon
+  return React.useMemo(() => {
+    var _a, _b;
+    if (mergedClosableConfig === false) {
+      return [false, null, closeBtnIsDisabled, {}];
+    }
+    const {
+      closeIconRender
+    } = mergedFallbackCloseCollection;
+    const {
+      closeIcon
+    } = mergedClosableConfig;
+    let mergedCloseIcon = closeIcon;
+    // Wrap the closeIcon with aria props
+    const ariaOrDataProps = pickAttrs(mergedClosableConfig, true);
+    if (mergedCloseIcon !== null && mergedCloseIcon !== undefined) {
+      // Wrap the closeIcon if needed
+      if (closeIconRender) {
+        mergedCloseIcon = closeIconRender(closeIcon);
+      }
+      mergedCloseIcon = /*#__PURE__*/React.isValidElement(mergedCloseIcon) ? (/*#__PURE__*/React.cloneElement(mergedCloseIcon, Object.assign(Object.assign(Object.assign({}, mergedCloseIcon.props), {
+        'aria-label': (_b = (_a = mergedCloseIcon.props) === null || _a === void 0 ? void 0 : _a['aria-label']) !== null && _b !== void 0 ? _b : contextLocale.close
+      }), ariaOrDataProps))) : (/*#__PURE__*/React.createElement("span", Object.assign({
+        "aria-label": contextLocale.close
+      }, ariaOrDataProps), mergedCloseIcon));
+    }
+    return [true, mergedCloseIcon, closeBtnIsDisabled, ariaOrDataProps];
+  }, [closeBtnIsDisabled, contextLocale.close, mergedClosableConfig, mergedFallbackCloseCollection]);
+};

node_modules/antd/es/_util/hooks/useForceUpdate.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const useForceUpdate: () => [number, React.ActionDispatch<[]>];

node_modules/antd/es/_util/hooks/useForceUpdate.js

@@ -0,0 +1,4 @@
+import React from 'react';
+export const useForceUpdate = () => {
+  return React.useReducer(ori => ori + 1, 0);
+};

node_modules/antd/es/_util/hooks/useMergeSemantic.d.ts

@@ -0,0 +1,14 @@
+import type { ValidChar } from '../type';
+type TemplateSemanticClassNames<T extends string> = Partial<Record<T, string>>;
+export type SemanticSchema = {
+    _default?: string;
+} & {
+    [key: `${ValidChar}${string}`]: SemanticSchema;
+};
+export declare function mergeClassNames<T extends string, SemanticClassNames extends Partial<Record<T, any>> = TemplateSemanticClassNames<T>>(schema?: SemanticSchema, ...classNames: (SemanticClassNames | undefined)[]): any;
+/**
+ * Merge classNames and styles from multiple sources.
+ * When `schema` is provided, it will **must** provide the nest object structure.
+ */
+export declare const useMergeSemantic: <ClassNamesType extends object, StylesType extends object>(classNamesList: (ClassNamesType | undefined)[], stylesList: (StylesType | undefined)[], schema?: SemanticSchema) => readonly [ClassNamesType, StylesType];
+export {};

node_modules/antd/es/_util/hooks/useMergeSemantic.js

@@ -0,0 +1,70 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import classnames from 'classnames';
+// ========================= ClassNames =========================
+export function mergeClassNames(schema, ...classNames) {
+  const mergedSchema = schema || {};
+  return classNames.reduce((acc, cur) => {
+    // Loop keys of the current classNames
+    Object.keys(cur || {}).forEach(key => {
+      const keySchema = mergedSchema[key];
+      const curVal = cur[key];
+      if (keySchema && typeof keySchema === 'object') {
+        if (curVal && typeof curVal === 'object') {
+          // Loop fill
+          acc[key] = mergeClassNames(keySchema, acc[key], curVal);
+        } else {
+          // Covert string to object structure
+          const {
+            _default: defaultField
+          } = keySchema;
+          if (defaultField) {
+            acc[key] = acc[key] || {};
+            acc[key][defaultField] = classnames(acc[key][defaultField], curVal);
+          }
+        }
+      } else {
+        // Flatten fill
+        acc[key] = classnames(acc[key], curVal);
+      }
+    });
+    return acc;
+  }, {});
+}
+function useSemanticClassNames(schema, ...classNames) {
+  return React.useMemo(() => mergeClassNames.apply(void 0, [schema].concat(classNames)), [classNames, schema]);
+}
+// =========================== Styles ===========================
+function useSemanticStyles(...styles) {
+  return React.useMemo(() => {
+    return styles.reduce((acc, cur = {}) => {
+      Object.keys(cur).forEach(key => {
+        acc[key] = Object.assign(Object.assign({}, acc[key]), cur[key]);
+      });
+      return acc;
+    }, {});
+  }, [styles]);
+}
+// =========================== Export ===========================
+function fillObjectBySchema(obj, schema) {
+  const newObj = Object.assign({}, obj);
+  Object.keys(schema).forEach(key => {
+    if (key !== '_default') {
+      const nestSchema = schema[key];
+      const nextValue = newObj[key] || {};
+      newObj[key] = nestSchema ? fillObjectBySchema(nextValue, nestSchema) : nextValue;
+    }
+  });
+  return newObj;
+}
+/**
+ * Merge classNames and styles from multiple sources.
+ * When `schema` is provided, it will **must** provide the nest object structure.
+ */
+export const useMergeSemantic = (classNamesList, stylesList, schema) => {
+  const mergedClassNames = useSemanticClassNames.apply(void 0, [schema].concat(_toConsumableArray(classNamesList)));
+  const mergedStyles = useSemanticStyles.apply(void 0, _toConsumableArray(stylesList));
+  return React.useMemo(() => {
+    return [fillObjectBySchema(mergedClassNames, schema), fillObjectBySchema(mergedStyles, schema)];
+  }, [mergedClassNames, mergedStyles, schema]);
+};

node_modules/antd/es/_util/hooks/useMultipleSelect.d.ts

@@ -0,0 +1,6 @@
+export type PrevSelectedIndex = null | number;
+/**
+ * @title multipleSelect hooks
+ * @description multipleSelect by hold down shift key
+ */
+export declare const useMultipleSelect: <T, K>(getKey: (item: T, index: number, array: T[]) => K) => readonly [(currentSelectedIndex: number, data: T[], selectedKeys: Set<K>) => K[], import("react").Dispatch<import("react").SetStateAction<PrevSelectedIndex>>];

node_modules/antd/es/_util/hooks/useMultipleSelect.js

@@ -0,0 +1,31 @@
+import { useCallback, useState } from 'react';
+/**
+ * @title multipleSelect hooks
+ * @description multipleSelect by hold down shift key
+ */
+export const useMultipleSelect = getKey => {
+  const [prevSelectedIndex, setPrevSelectedIndex] = useState(null);
+  const multipleSelect = useCallback((currentSelectedIndex, data, selectedKeys) => {
+    const configPrevSelectedIndex = prevSelectedIndex !== null && prevSelectedIndex !== void 0 ? prevSelectedIndex : currentSelectedIndex;
+    // add/delete the selected range
+    const startIndex = Math.min(configPrevSelectedIndex || 0, currentSelectedIndex);
+    const endIndex = Math.max(configPrevSelectedIndex || 0, currentSelectedIndex);
+    const rangeKeys = data.slice(startIndex, endIndex + 1).map(getKey);
+    const shouldSelected = rangeKeys.some(rangeKey => !selectedKeys.has(rangeKey));
+    const changedKeys = [];
+    rangeKeys.forEach(item => {
+      if (shouldSelected) {
+        if (!selectedKeys.has(item)) {
+          changedKeys.push(item);
+        }
+        selectedKeys.add(item);
+      } else {
+        selectedKeys.delete(item);
+        changedKeys.push(item);
+      }
+    });
+    setPrevSelectedIndex(shouldSelected ? endIndex : null);
+    return changedKeys;
+  }, [prevSelectedIndex]);
+  return [multipleSelect, setPrevSelectedIndex];
+};

node_modules/antd/es/_util/hooks/usePatchElement.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const usePatchElement: () => [React.ReactElement[], (element: React.ReactElement) => () => void];

node_modules/antd/es/_util/hooks/usePatchElement.js

@@ -0,0 +1,15 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+export const usePatchElement = () => {
+  const [elements, setElements] = React.useState([]);
+  const patchElement = React.useCallback(element => {
+    // append a new element to elements (and create a new ref)
+    setElements(originElements => [].concat(_toConsumableArray(originElements), [element]));
+    // return a function that removes the new element out of elements (and create a new ref)
+    // it works a little like useEffect
+    return () => {
+      setElements(originElements => originElements.filter(ele => ele !== element));
+    };
+  }, []);
+  return [elements, patchElement];
+};

node_modules/antd/es/_util/hooks/useProxyImperativeHandle.d.ts

@@ -0,0 +1,4 @@
+import type { Ref } from 'react';
+export declare const useProxyImperativeHandle: <NativeELementType extends HTMLElement, ReturnRefType extends {
+    nativeElement: NativeELementType;
+}>(ref: Ref<any> | undefined, init: () => ReturnRefType) => void;

node_modules/antd/es/_util/hooks/useProxyImperativeHandle.js

@@ -0,0 +1,34 @@
+// Proxy the dom ref with `{ nativeElement, otherFn }` type
+// ref: https://github.com/ant-design/ant-design/discussions/45242
+import { useImperativeHandle } from 'react';
+function fillProxy(element, handler) {
+  element._antProxy = element._antProxy || {};
+  Object.keys(handler).forEach(key => {
+    if (!(key in element._antProxy)) {
+      const ori = element[key];
+      element._antProxy[key] = ori;
+      element[key] = handler[key];
+    }
+  });
+  return element;
+}
+export const useProxyImperativeHandle = (ref, init) => {
+  return useImperativeHandle(ref, () => {
+    const refObj = init();
+    const {
+      nativeElement
+    } = refObj;
+    if (typeof Proxy !== 'undefined') {
+      return new Proxy(nativeElement, {
+        get(obj, prop) {
+          if (refObj[prop]) {
+            return refObj[prop];
+          }
+          return Reflect.get(obj, prop);
+        }
+      });
+    }
+    // Fallback of IE
+    return fillProxy(nativeElement, refObj);
+  });
+};

node_modules/antd/es/_util/hooks/useSyncState.d.ts

@@ -0,0 +1,3 @@
+type UseSyncStateProps<T> = readonly [() => T, (newValue: T) => void];
+export declare const useSyncState: <T>(initialValue: T) => UseSyncStateProps<T>;
+export {};

node_modules/antd/es/_util/hooks/useSyncState.js

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { useForceUpdate } from './useForceUpdate';
+export const useSyncState = initialValue => {
+  const ref = React.useRef(initialValue);
+  const [, forceUpdate] = useForceUpdate();
+  return [() => ref.current, newValue => {
+    ref.current = newValue;
+    // re-render
+    forceUpdate();
+  }];
+};

node_modules/antd/es/_util/hooks/useZIndex.d.ts

@@ -0,0 +1,8 @@
+export type ZIndexContainer = 'Modal' | 'Drawer' | 'Popover' | 'Popconfirm' | 'Tooltip' | 'Tour' | 'FloatButton';
+export type ZIndexConsumer = 'SelectLike' | 'Dropdown' | 'DatePicker' | 'Menu' | 'ImagePreview';
+export declare const CONTAINER_MAX_OFFSET: number;
+export declare const containerBaseZIndexOffset: Record<ZIndexContainer, number>;
+export declare const consumerBaseZIndexOffset: Record<ZIndexConsumer, number>;
+type ReturnResult = [zIndex: number | undefined, contextZIndex: number];
+export declare const useZIndex: (componentType: ZIndexContainer | ZIndexConsumer, customZIndex?: number) => ReturnResult;
+export {};

node_modules/antd/es/_util/hooks/useZIndex.js

@@ -0,0 +1,64 @@
+import React from 'react';
+import useToken from '../../theme/useToken';
+import { devUseWarning } from '../warning';
+import zIndexContext from '../zindexContext';
+// Z-Index control range
+// Container: 1000 + offset 100 (max base + 10 * offset = 2000)
+// Popover: offset 50
+// Notification: Container Max zIndex + componentOffset
+const CONTAINER_OFFSET = 100;
+const CONTAINER_OFFSET_MAX_COUNT = 10;
+export const CONTAINER_MAX_OFFSET = CONTAINER_OFFSET * CONTAINER_OFFSET_MAX_COUNT;
+/**
+ * Static function will default be the `CONTAINER_MAX_OFFSET`.
+ * But it still may have children component like Select, Dropdown.
+ * So the warning zIndex should exceed the `CONTAINER_MAX_OFFSET`.
+ */
+const CONTAINER_MAX_OFFSET_WITH_CHILDREN = CONTAINER_MAX_OFFSET + CONTAINER_OFFSET;
+export const containerBaseZIndexOffset = {
+  Modal: CONTAINER_OFFSET,
+  Drawer: CONTAINER_OFFSET,
+  Popover: CONTAINER_OFFSET,
+  Popconfirm: CONTAINER_OFFSET,
+  Tooltip: CONTAINER_OFFSET,
+  Tour: CONTAINER_OFFSET,
+  FloatButton: CONTAINER_OFFSET
+};
+export const consumerBaseZIndexOffset = {
+  SelectLike: 50,
+  Dropdown: 50,
+  DatePicker: 50,
+  Menu: 50,
+  ImagePreview: 1
+};
+function isContainerType(type) {
+  return type in containerBaseZIndexOffset;
+}
+export const useZIndex = (componentType, customZIndex) => {
+  const [, token] = useToken();
+  const parentZIndex = React.useContext(zIndexContext);
+  const isContainer = isContainerType(componentType);
+  let result;
+  if (customZIndex !== undefined) {
+    result = [customZIndex, customZIndex];
+  } else {
+    let zIndex = parentZIndex !== null && parentZIndex !== void 0 ? parentZIndex : 0;
+    if (isContainer) {
+      zIndex +=
+      // Use preset token zIndex by default but not stack when has parent container
+      (parentZIndex ? 0 : token.zIndexPopupBase) +
+      // Container offset
+      containerBaseZIndexOffset[componentType];
+    } else {
+      zIndex += consumerBaseZIndexOffset[componentType];
+    }
+    result = [parentZIndex === undefined ? customZIndex : zIndex, zIndex];
+  }
+  if (process.env.NODE_ENV !== 'production') {
+    const warning = devUseWarning(componentType);
+    const maxZIndex = token.zIndexPopupBase + CONTAINER_MAX_OFFSET_WITH_CHILDREN;
+    const currentZIndex = result[0] || 0;
+    process.env.NODE_ENV !== "production" ? warning(customZIndex !== undefined || currentZIndex <= maxZIndex, 'usage', '`zIndex` is over design token `zIndexPopupBase` too much. It may cause unexpected override.') : void 0;
+  }
+  return result;
+};

node_modules/antd/es/_util/isPrimitive.d.ts

@@ -0,0 +1,2 @@
+declare const isPrimitive: (value: unknown) => boolean;
+export default isPrimitive;

node_modules/antd/es/_util/isPrimitive.js

@@ -0,0 +1,2 @@
+const isPrimitive = value => typeof value !== 'object' && typeof value !== 'function' || value === null;
+export default isPrimitive;

node_modules/antd/es/_util/mediaQueryUtil.d.ts

@@ -0,0 +1,4 @@
+type MQListenerHandler = (mql: MediaQueryList, handler: (e: MediaQueryListEvent) => void) => void;
+export declare const addMediaQueryListener: MQListenerHandler;
+export declare const removeMediaQueryListener: MQListenerHandler;
+export {};

node_modules/antd/es/_util/mediaQueryUtil.js

@@ -0,0 +1,16 @@
+export const addMediaQueryListener = (mql, handler) => {
+  // Don't delete here, please keep the code compatible
+  if (typeof (mql === null || mql === void 0 ? void 0 : mql.addEventListener) !== 'undefined') {
+    mql.addEventListener('change', handler);
+  } else if (typeof (mql === null || mql === void 0 ? void 0 : mql.addListener) !== 'undefined') {
+    mql.addListener(handler);
+  }
+};
+export const removeMediaQueryListener = (mql, handler) => {
+  // Don't delete here, please keep the code compatible
+  if (typeof (mql === null || mql === void 0 ? void 0 : mql.removeEventListener) !== 'undefined') {
+    mql.removeEventListener('change', handler);
+  } else if (typeof (mql === null || mql === void 0 ? void 0 : mql.removeListener) !== 'undefined') {
+    mql.removeListener(handler);
+  }
+};

node_modules/antd/es/_util/motion.d.ts

@@ -0,0 +1,7 @@
+import type { CSSMotionProps } from 'rc-motion';
+declare const initCollapseMotion: (rootCls?: string) => CSSMotionProps;
+declare const _SelectPlacements: readonly ["bottomLeft", "bottomRight", "topLeft", "topRight"];
+export type SelectCommonPlacement = (typeof _SelectPlacements)[number];
+declare const getTransitionName: (rootPrefixCls: string, motion: string, transitionName?: string) => string;
+export { getTransitionName };
+export default initCollapseMotion;

node_modules/antd/es/_util/motion.js

@@ -0,0 +1,41 @@
+import { defaultPrefixCls } from '../config-provider';
+// ================== Collapse Motion ==================
+const getCollapsedHeight = () => ({
+  height: 0,
+  opacity: 0
+});
+const getRealHeight = node => {
+  const {
+    scrollHeight
+  } = node;
+  return {
+    height: scrollHeight,
+    opacity: 1
+  };
+};
+const getCurrentHeight = node => ({
+  height: node ? node.offsetHeight : 0
+});
+const skipOpacityTransition = (_, event) => (event === null || event === void 0 ? void 0 : event.deadline) === true || event.propertyName === 'height';
+const initCollapseMotion = (rootCls = defaultPrefixCls) => ({
+  motionName: `${rootCls}-motion-collapse`,
+  onAppearStart: getCollapsedHeight,
+  onEnterStart: getCollapsedHeight,
+  onAppearActive: getRealHeight,
+  onEnterActive: getRealHeight,
+  onLeaveStart: getCurrentHeight,
+  onLeaveActive: getCollapsedHeight,
+  onAppearEnd: skipOpacityTransition,
+  onEnterEnd: skipOpacityTransition,
+  onLeaveEnd: skipOpacityTransition,
+  motionDeadline: 500
+});
+const _SelectPlacements = ['bottomLeft', 'bottomRight', 'topLeft', 'topRight'];
+const getTransitionName = (rootPrefixCls, motion, transitionName) => {
+  if (transitionName !== undefined) {
+    return transitionName;
+  }
+  return `${rootPrefixCls}-${motion}`;
+};
+export { getTransitionName };
+export default initCollapseMotion;

node_modules/antd/es/_util/placements.d.ts

@@ -0,0 +1,21 @@
+import type { BuildInPlacements } from '@rc-component/trigger';
+import { getArrowOffsetToken } from '../style/placementArrow';
+export interface AdjustOverflow {
+    adjustX?: 0 | 1;
+    adjustY?: 0 | 1;
+}
+export interface PlacementsConfig {
+    arrowWidth: number;
+    arrowPointAtCenter?: boolean;
+    autoAdjustOverflow?: boolean | AdjustOverflow;
+    offset: number;
+    borderRadius: number;
+    visibleFirst?: boolean;
+}
+export declare function getOverflowOptions(placement: string, arrowOffset: ReturnType<typeof getArrowOffsetToken>, arrowWidth: number, autoAdjustOverflow?: boolean | AdjustOverflow): {
+    adjustX?: boolean | number;
+    adjustY?: boolean | number;
+    shiftX?: boolean | number;
+    shiftY?: boolean | number;
+};
+export default function getPlacements(config: PlacementsConfig): BuildInPlacements;

node_modules/antd/es/_util/placements.js

@@ -0,0 +1,178 @@
+import { getArrowOffsetToken } from '../style/placementArrow';
+export function getOverflowOptions(placement, arrowOffset, arrowWidth, autoAdjustOverflow) {
+  if (autoAdjustOverflow === false) {
+    return {
+      adjustX: false,
+      adjustY: false
+    };
+  }
+  const overflow = autoAdjustOverflow && typeof autoAdjustOverflow === 'object' ? autoAdjustOverflow : {};
+  const baseOverflow = {};
+  switch (placement) {
+    case 'top':
+    case 'bottom':
+      baseOverflow.shiftX = arrowOffset.arrowOffsetHorizontal * 2 + arrowWidth;
+      baseOverflow.shiftY = true;
+      baseOverflow.adjustY = true;
+      break;
+    case 'left':
+    case 'right':
+      baseOverflow.shiftY = arrowOffset.arrowOffsetVertical * 2 + arrowWidth;
+      baseOverflow.shiftX = true;
+      baseOverflow.adjustX = true;
+      break;
+  }
+  const mergedOverflow = Object.assign(Object.assign({}, baseOverflow), overflow);
+  // Support auto shift
+  if (!mergedOverflow.shiftX) {
+    mergedOverflow.adjustX = true;
+  }
+  if (!mergedOverflow.shiftY) {
+    mergedOverflow.adjustY = true;
+  }
+  return mergedOverflow;
+}
+const PlacementAlignMap = {
+  left: {
+    points: ['cr', 'cl']
+  },
+  right: {
+    points: ['cl', 'cr']
+  },
+  top: {
+    points: ['bc', 'tc']
+  },
+  bottom: {
+    points: ['tc', 'bc']
+  },
+  topLeft: {
+    points: ['bl', 'tl']
+  },
+  leftTop: {
+    points: ['tr', 'tl']
+  },
+  topRight: {
+    points: ['br', 'tr']
+  },
+  rightTop: {
+    points: ['tl', 'tr']
+  },
+  bottomRight: {
+    points: ['tr', 'br']
+  },
+  rightBottom: {
+    points: ['bl', 'br']
+  },
+  bottomLeft: {
+    points: ['tl', 'bl']
+  },
+  leftBottom: {
+    points: ['br', 'bl']
+  }
+};
+const ArrowCenterPlacementAlignMap = {
+  topLeft: {
+    points: ['bl', 'tc']
+  },
+  leftTop: {
+    points: ['tr', 'cl']
+  },
+  topRight: {
+    points: ['br', 'tc']
+  },
+  rightTop: {
+    points: ['tl', 'cr']
+  },
+  bottomRight: {
+    points: ['tr', 'bc']
+  },
+  rightBottom: {
+    points: ['bl', 'cr']
+  },
+  bottomLeft: {
+    points: ['tl', 'bc']
+  },
+  leftBottom: {
+    points: ['br', 'cl']
+  }
+};
+const DisableAutoArrowList = new Set(['topLeft', 'topRight', 'bottomLeft', 'bottomRight', 'leftTop', 'leftBottom', 'rightTop', 'rightBottom']);
+export default function getPlacements(config) {
+  const {
+    arrowWidth,
+    autoAdjustOverflow,
+    arrowPointAtCenter,
+    offset,
+    borderRadius,
+    visibleFirst
+  } = config;
+  const halfArrowWidth = arrowWidth / 2;
+  const placementMap = {};
+  // Dynamic offset
+  const arrowOffset = getArrowOffsetToken({
+    contentRadius: borderRadius,
+    limitVerticalRadius: true
+  });
+  Object.keys(PlacementAlignMap).forEach(key => {
+    const template = arrowPointAtCenter && ArrowCenterPlacementAlignMap[key] || PlacementAlignMap[key];
+    const placementInfo = Object.assign(Object.assign({}, template), {
+      offset: [0, 0],
+      dynamicInset: true
+    });
+    placementMap[key] = placementInfo;
+    // Disable autoArrow since design is fixed position
+    if (DisableAutoArrowList.has(key)) {
+      placementInfo.autoArrow = false;
+    }
+    // Static offset
+    switch (key) {
+      case 'top':
+      case 'topLeft':
+      case 'topRight':
+        placementInfo.offset[1] = -halfArrowWidth - offset;
+        break;
+      case 'bottom':
+      case 'bottomLeft':
+      case 'bottomRight':
+        placementInfo.offset[1] = halfArrowWidth + offset;
+        break;
+      case 'left':
+      case 'leftTop':
+      case 'leftBottom':
+        placementInfo.offset[0] = -halfArrowWidth - offset;
+        break;
+      case 'right':
+      case 'rightTop':
+      case 'rightBottom':
+        placementInfo.offset[0] = halfArrowWidth + offset;
+        break;
+    }
+    if (arrowPointAtCenter) {
+      switch (key) {
+        case 'topLeft':
+        case 'bottomLeft':
+          placementInfo.offset[0] = -arrowOffset.arrowOffsetHorizontal - halfArrowWidth;
+          break;
+        case 'topRight':
+        case 'bottomRight':
+          placementInfo.offset[0] = arrowOffset.arrowOffsetHorizontal + halfArrowWidth;
+          break;
+        case 'leftTop':
+        case 'rightTop':
+          placementInfo.offset[1] = -arrowOffset.arrowOffsetHorizontal * 2 + halfArrowWidth;
+          break;
+        case 'leftBottom':
+        case 'rightBottom':
+          placementInfo.offset[1] = arrowOffset.arrowOffsetHorizontal * 2 - halfArrowWidth;
+          break;
+      }
+    }
+    // Overflow
+    placementInfo.overflow = getOverflowOptions(key, arrowOffset, arrowWidth, autoAdjustOverflow);
+    // VisibleFirst
+    if (visibleFirst) {
+      placementInfo.htmlRegion = 'visibleFirst';
+    }
+  });
+  return placementMap;
+}

node_modules/antd/es/_util/reactNode.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { AnyObject } from './type';
+export declare function isFragment(child: any): boolean;
+type RenderProps = AnyObject | ((originProps: AnyObject) => AnyObject | undefined);
+export declare const replaceElement: <P>(element: React.ReactNode, replacement: React.ReactNode, props?: RenderProps) => React.ReactNode;
+export declare function cloneElement<P>(element: React.ReactNode, props?: RenderProps): React.ReactElement<P>;
+export {};

node_modules/antd/es/_util/reactNode.js

@@ -0,0 +1,13 @@
+import React from 'react';
+export function isFragment(child) {
+  return child && /*#__PURE__*/React.isValidElement(child) && child.type === React.Fragment;
+}
+export const replaceElement = (element, replacement, props) => {
+  if (! /*#__PURE__*/React.isValidElement(element)) {
+    return replacement;
+  }
+  return /*#__PURE__*/React.cloneElement(element, typeof props === 'function' ? props(element.props || {}) : props);
+};
+export function cloneElement(element, props) {
+  return replaceElement(element, element, props);
+}

node_modules/antd/es/_util/responsiveObserver.d.ts

@@ -0,0 +1,21 @@
+export type Breakpoint = 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs';
+export type BreakpointMap = Record<Breakpoint, string>;
+export type ScreenMap = Partial<Record<Breakpoint, boolean>>;
+export type ScreenSizeMap = Partial<Record<Breakpoint, number>>;
+export declare const responsiveArray: Breakpoint[];
+type SubscribeFunc = (screens: ScreenMap) => void;
+export declare const matchScreen: (screens: ScreenMap, screenSizes?: ScreenSizeMap) => number | undefined;
+interface ResponsiveObserverType {
+    responsiveMap: BreakpointMap;
+    dispatch: (map: ScreenMap) => boolean;
+    subscribe: (func: SubscribeFunc) => number;
+    unsubscribe: (token: number) => void;
+    register: () => void;
+    unregister: () => void;
+    matchHandlers: Record<PropertyKey, {
+        mql: MediaQueryList;
+        listener: (this: MediaQueryList, ev: MediaQueryListEvent) => void;
+    }>;
+}
+declare const useResponsiveObserver: () => ResponsiveObserverType;
+export default useResponsiveObserver;

node_modules/antd/es/_util/responsiveObserver.js

@@ -0,0 +1,110 @@
+import React from 'react';
+import { useToken } from '../theme/internal';
+import { addMediaQueryListener, removeMediaQueryListener } from './mediaQueryUtil';
+export const responsiveArray = ['xxl', 'xl', 'lg', 'md', 'sm', 'xs'];
+const getResponsiveMap = token => ({
+  xs: `(max-width: ${token.screenXSMax}px)`,
+  sm: `(min-width: ${token.screenSM}px)`,
+  md: `(min-width: ${token.screenMD}px)`,
+  lg: `(min-width: ${token.screenLG}px)`,
+  xl: `(min-width: ${token.screenXL}px)`,
+  xxl: `(min-width: ${token.screenXXL}px)`
+});
+/**
+ * Ensures that the breakpoints token are valid, in good order
+ * For each breakpoint : screenMin <= screen <= screenMax and screenMax <= nextScreenMin
+ */
+const validateBreakpoints = token => {
+  const indexableToken = token;
+  const revBreakpoints = [].concat(responsiveArray).reverse();
+  revBreakpoints.forEach((breakpoint, i) => {
+    const breakpointUpper = breakpoint.toUpperCase();
+    const screenMin = `screen${breakpointUpper}Min`;
+    const screen = `screen${breakpointUpper}`;
+    if (!(indexableToken[screenMin] <= indexableToken[screen])) {
+      throw new Error(`${screenMin}<=${screen} fails : !(${indexableToken[screenMin]}<=${indexableToken[screen]})`);
+    }
+    if (i < revBreakpoints.length - 1) {
+      const screenMax = `screen${breakpointUpper}Max`;
+      if (!(indexableToken[screen] <= indexableToken[screenMax])) {
+        throw new Error(`${screen}<=${screenMax} fails : !(${indexableToken[screen]}<=${indexableToken[screenMax]})`);
+      }
+      const nextBreakpointUpperMin = revBreakpoints[i + 1].toUpperCase();
+      const nextScreenMin = `screen${nextBreakpointUpperMin}Min`;
+      if (!(indexableToken[screenMax] <= indexableToken[nextScreenMin])) {
+        throw new Error(`${screenMax}<=${nextScreenMin} fails : !(${indexableToken[screenMax]}<=${indexableToken[nextScreenMin]})`);
+      }
+    }
+  });
+  return token;
+};
+export const matchScreen = (screens, screenSizes) => {
+  if (!screenSizes) {
+    return;
+  }
+  for (const breakpoint of responsiveArray) {
+    if (screens[breakpoint] && (screenSizes === null || screenSizes === void 0 ? void 0 : screenSizes[breakpoint]) !== undefined) {
+      return screenSizes[breakpoint];
+    }
+  }
+};
+const useResponsiveObserver = () => {
+  const [, token] = useToken();
+  const responsiveMap = getResponsiveMap(validateBreakpoints(token));
+  // To avoid repeat create instance, we add `useMemo` here.
+  return React.useMemo(() => {
+    const subscribers = new Map();
+    let subUid = -1;
+    let screens = {};
+    return {
+      responsiveMap,
+      matchHandlers: {},
+      dispatch(pointMap) {
+        screens = pointMap;
+        subscribers.forEach(func => func(screens));
+        return subscribers.size >= 1;
+      },
+      subscribe(func) {
+        if (!subscribers.size) {
+          this.register();
+        }
+        subUid += 1;
+        subscribers.set(subUid, func);
+        func(screens);
+        return subUid;
+      },
+      unsubscribe(paramToken) {
+        subscribers.delete(paramToken);
+        if (!subscribers.size) {
+          this.unregister();
+        }
+      },
+      register() {
+        Object.entries(responsiveMap).forEach(([screen, mediaQuery]) => {
+          const listener = ({
+            matches
+          }) => {
+            this.dispatch(Object.assign(Object.assign({}, screens), {
+              [screen]: matches
+            }));
+          };
+          const mql = window.matchMedia(mediaQuery);
+          addMediaQueryListener(mql, listener);
+          this.matchHandlers[mediaQuery] = {
+            mql,
+            listener
+          };
+          listener(mql);
+        });
+      },
+      unregister() {
+        Object.values(responsiveMap).forEach(mediaQuery => {
+          const handler = this.matchHandlers[mediaQuery];
+          removeMediaQueryListener(handler === null || handler === void 0 ? void 0 : handler.mql, handler === null || handler === void 0 ? void 0 : handler.listener);
+        });
+        subscribers.clear();
+      }
+    };
+  }, [responsiveMap]);
+};
+export default useResponsiveObserver;

node_modules/antd/es/_util/scrollTo.d.ts

@@ -0,0 +1,10 @@
+interface ScrollToOptions {
+    /** Scroll container, default as window */
+    getContainer?: () => HTMLElement | Window | Document;
+    /** Scroll end callback */
+    callback?: () => void;
+    /** Animation duration, default as 450 */
+    duration?: number;
+}
+export default function scrollTo(y: number, options?: ScrollToOptions): void;
+export {};

node_modules/antd/es/_util/scrollTo.js

@@ -0,0 +1,31 @@
+import raf from "rc-util/es/raf";
+import { easeInOutCubic } from './easings';
+import getScroll, { isWindow } from './getScroll';
+export default function scrollTo(y, options = {}) {
+  const {
+    getContainer = () => window,
+    callback,
+    duration = 450
+  } = options;
+  const container = getContainer();
+  const scrollTop = getScroll(container);
+  const startTime = Date.now();
+  const frameFunc = () => {
+    const timestamp = Date.now();
+    const time = timestamp - startTime;
+    const nextScrollTop = easeInOutCubic(time > duration ? duration : time, scrollTop, y, duration);
+    if (isWindow(container)) {
+      container.scrollTo(window.pageXOffset, nextScrollTop);
+    } else if (container instanceof Document || container.constructor.name === 'HTMLDocument') {
+      container.documentElement.scrollTop = nextScrollTop;
+    } else {
+      container.scrollTop = nextScrollTop;
+    }
+    if (time < duration) {
+      raf(frameFunc);
+    } else if (typeof callback === 'function') {
+      callback();
+    }
+  };
+  raf(frameFunc);
+}

node_modules/antd/es/_util/statusUtils.d.ts

@@ -0,0 +1,6 @@
+import type { ValidateStatus } from '../form/FormItem';
+declare const _InputStatuses: readonly ["warning", "error", ""];
+export type InputStatus = (typeof _InputStatuses)[number];
+export declare function getStatusClassNames(prefixCls: string, status?: ValidateStatus, hasFeedback?: boolean): string;
+export declare const getMergedStatus: (contextStatus?: ValidateStatus, customStatus?: InputStatus) => "" | "success" | "warning" | "error" | "validating" | undefined;
+export {};

node_modules/antd/es/_util/statusUtils.js

@@ -0,0 +1,12 @@
+import classNames from 'classnames';
+const _InputStatuses = ['warning', 'error', ''];
+export function getStatusClassNames(prefixCls, status, hasFeedback) {
+  return classNames({
+    [`${prefixCls}-status-success`]: status === 'success',
+    [`${prefixCls}-status-warning`]: status === 'warning',
+    [`${prefixCls}-status-error`]: status === 'error',
+    [`${prefixCls}-status-validating`]: status === 'validating',
+    [`${prefixCls}-has-feedback`]: hasFeedback
+  });
+}
+export const getMergedStatus = (contextStatus, customStatus) => customStatus || contextStatus;

node_modules/antd/es/_util/styleChecker.d.ts

@@ -0,0 +1,3 @@
+import { isStyleSupport } from 'rc-util/lib/Dom/styleChecker';
+export declare const canUseDocElement: () => false | HTMLElement;
+export { isStyleSupport };

node_modules/antd/es/_util/styleChecker.js

@@ -0,0 +1,4 @@
+import canUseDom from "rc-util/es/Dom/canUseDom";
+import { isStyleSupport } from "rc-util/es/Dom/styleChecker";
+export const canUseDocElement = () => canUseDom() && window.document.documentElement;
+export { isStyleSupport };

node_modules/antd/es/_util/throttleByAnimationFrame.d.ts

@@ -0,0 +1,5 @@
+declare function throttleByAnimationFrame<T extends any[]>(fn: (...args: T) => void): {
+    (...args: T): void;
+    cancel(): void;
+};
+export default throttleByAnimationFrame;

node_modules/antd/es/_util/throttleByAnimationFrame.js

@@ -0,0 +1,20 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import raf from "rc-util/es/raf";
+function throttleByAnimationFrame(fn) {
+  let requestId = null;
+  const later = args => () => {
+    requestId = null;
+    fn.apply(void 0, _toConsumableArray(args));
+  };
+  const throttled = (...args) => {
+    if (requestId === null) {
+      requestId = raf(later(args));
+    }
+  };
+  throttled.cancel = () => {
+    raf.cancel(requestId);
+    requestId = null;
+  };
+  return throttled;
+}
+export default throttleByAnimationFrame;

node_modules/antd/es/_util/toList.d.ts

@@ -0,0 +1,2 @@
+declare const toList: <T>(candidate: T | T[], skipEmpty?: boolean) => T[];
+export default toList;

node_modules/antd/es/_util/toList.js

@@ -0,0 +1,7 @@
+const toList = (candidate, skipEmpty = false) => {
+  if (skipEmpty && (candidate === undefined || candidate === null)) {
+    return [];
+  }
+  return Array.isArray(candidate) ? candidate : [candidate];
+};
+export default toList;

node_modules/antd/es/_util/transKeys.d.ts

@@ -0,0 +1,3 @@
+import type { TransferKey } from '../transfer/interface';
+export declare const groupKeysMap: (keys: TransferKey[]) => Map<import("react").Key, number>;
+export declare const groupDisabledKeysMap: <RecordType extends any[]>(dataSource: RecordType) => Map<import("react").Key, number>;

node_modules/antd/es/_util/transKeys.js

@@ -0,0 +1,19 @@
+export const groupKeysMap = keys => {
+  const map = new Map();
+  keys.forEach((key, index) => {
+    map.set(key, index);
+  });
+  return map;
+};
+export const groupDisabledKeysMap = dataSource => {
+  const map = new Map();
+  dataSource.forEach(({
+    disabled,
+    key
+  }, index) => {
+    if (disabled) {
+      map.set(key, index);
+    }
+  });
+  return map;
+};

node_modules/antd/es/_util/type.d.ts

@@ -0,0 +1,57 @@
+import type React from 'react';
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/** https://github.com/Microsoft/TypeScript/issues/29729 */
+export type LiteralUnion<T, U extends Primitive = string> = T | (U & Record<never, never>);
+export type AnyObject = Record<PropertyKey, any>;
+export type EmptyObject = Record<never, never>;
+export type CustomComponent<P = AnyObject> = React.ComponentType<P> | string;
+/**
+ * Get component props
+ * @example
+ * ```ts
+ * import { Checkbox } from 'antd'
+ * import type { GetProps } from 'antd';
+ *
+ * type CheckboxGroupProps = GetProps<typeof Checkbox.Group>
+ * ```
+ * @since 5.13.0
+ */
+export type GetProps<T extends React.ComponentType<any> | object> = T extends React.ComponentType<infer P> ? P : T extends object ? T : never;
+/**
+ * Get component props by component name
+ * @example
+ * ```ts
+ * import { Select } from 'antd';
+ * import type { GetProp, SelectProps } from 'antd';
+ *
+ * type SelectOption1 = GetProp<SelectProps, 'options'>[number];
+ * // or
+ * type SelectOption2 = GetProp<typeof Select, 'options'>[number];
+ *
+ * const onChange: GetProp<typeof Select, 'onChange'> = (value, option) => {
+ *  // Do something
+ * };
+ * ```
+ * @since 5.13.0
+ */
+export type GetProp<T extends React.ComponentType<any> | object, PropName extends keyof GetProps<T>> = NonNullable<GetProps<T>[PropName]>;
+type ReactRefComponent<Props extends {
+    ref?: React.Ref<any> | string;
+}> = (props: Props) => React.ReactNode;
+type ExtractRefAttributesRef<T> = T extends React.RefAttributes<infer P> ? P : never;
+/**
+ * Get component ref
+ * @example
+ * ```ts
+ * import { Input } from 'antd';
+ * import type { GetRef } from 'antd';
+ *
+ * type InputRef = GetRef<typeof Input>;
+ * ```
+ * @since 5.13.0
+ */
+export type GetRef<T extends ReactRefComponent<any> | React.Component<any>> = T extends React.Component<any> ? T : T extends React.ComponentType<infer P> ? ExtractRefAttributesRef<P> : never;
+export type GetContextProps<T> = T extends React.Context<infer P> ? P : never;
+export type GetContextProp<T extends React.Context<any>, PropName extends keyof GetContextProps<T>> = NonNullable<GetContextProps<T>[PropName]>;
+export type ValidChar = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+export {};

node_modules/antd/es/_util/type.js

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

node_modules/antd/es/_util/warning.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+export declare function noop(): void;
+export declare function resetWarned(): void;
+type Warning = (valid: boolean, component: string, message?: string) => void;
+declare const warning: Warning;
+type BaseTypeWarning = (valid: boolean, 
+/**
+ * - deprecated: Some API will be removed in future but still support now.
+ * - usage: Some API usage is not correct.
+ * - breaking: Breaking change like API is removed.
+ */
+type: 'deprecated' | 'usage' | 'breaking', message?: string) => void;
+type TypeWarning = BaseTypeWarning & {
+    deprecated: (valid: boolean, oldProp: string, newProp: string, message?: string) => void;
+};
+export interface WarningContextProps {
+    /**
+     * @descCN 设置警告等级，设置 `false` 时会将废弃相关信息聚合为单条信息。
+     * @descEN Set the warning level. When set to `false`, discard related information will be aggregated into a single message.
+     * @since 5.10.0
+     */
+    strict?: boolean;
+}
+export declare const WarningContext: React.Context<WarningContextProps>;
+/**
+ * This is a hook but we not named as `useWarning`
+ * since this is only used in development.
+ * We should always wrap this in `if (process.env.NODE_ENV !== 'production')` condition
+ */
+export declare const devUseWarning: (component: string) => TypeWarning;
+export default warning;

node_modules/antd/es/_util/warning.js

@@ -0,0 +1,59 @@
+import * as React from 'react';
+import rcWarning, { resetWarned as rcResetWarned } from "rc-util/es/warning";
+export function noop() {}
+let deprecatedWarnList = null;
+export function resetWarned() {
+  deprecatedWarnList = null;
+  rcResetWarned();
+}
+let _warning = noop;
+if (process.env.NODE_ENV !== 'production') {
+  _warning = (valid, component, message) => {
+    rcWarning(valid, `[antd: ${component}] ${message}`);
+    // StrictMode will inject console which will not throw warning in React 17.
+    if (process.env.NODE_ENV === 'test') {
+      resetWarned();
+    }
+  };
+}
+const warning = _warning;
+export const WarningContext = /*#__PURE__*/React.createContext({});
+/**
+ * This is a hook but we not named as `useWarning`
+ * since this is only used in development.
+ * We should always wrap this in `if (process.env.NODE_ENV !== 'production')` condition
+ */
+export const devUseWarning = process.env.NODE_ENV !== 'production' ? component => {
+  const {
+    strict
+  } = React.useContext(WarningContext);
+  const typeWarning = (valid, type, message) => {
+    if (!valid) {
+      if (strict === false && type === 'deprecated') {
+        const existWarning = deprecatedWarnList;
+        if (!deprecatedWarnList) {
+          deprecatedWarnList = {};
+        }
+        deprecatedWarnList[component] = deprecatedWarnList[component] || [];
+        if (!deprecatedWarnList[component].includes(message || '')) {
+          deprecatedWarnList[component].push(message || '');
+        }
+        // Warning for the first time
+        if (!existWarning) {
+          console.warn('[antd] There exists deprecated usage in your code:', deprecatedWarnList);
+        }
+      } else {
+        process.env.NODE_ENV !== "production" ? warning(valid, component, message) : void 0;
+      }
+    }
+  };
+  typeWarning.deprecated = (valid, oldProp, newProp, message) => {
+    typeWarning(valid, 'deprecated', `\`${oldProp}\` is deprecated. Please use \`${newProp}\` instead.${message ? ` ${message}` : ''}`);
+  };
+  return typeWarning;
+} : () => {
+  const noopWarning = () => {};
+  noopWarning.deprecated = noop;
+  return noopWarning;
+};
+export default warning;

node_modules/antd/es/_util/wave/WaveEffect.d.ts

@@ -0,0 +1,10 @@
+import type { UnmountType } from '../../config-provider/UnstableContext';
+import type { ShowWaveEffect } from './interface';
+export interface WaveEffectProps {
+    className: string;
+    target: HTMLElement;
+    component?: string;
+    registerUnmount: () => UnmountType | null;
+}
+declare const showWaveEffect: ShowWaveEffect;
+export default showWaveEffect;

node_modules/antd/es/_util/wave/WaveEffect.js

@@ -0,0 +1,142 @@
+"use client";
+
+import * as React from 'react';
+import classNames from 'classnames';
+import CSSMotion from 'rc-motion';
+import raf from "rc-util/es/raf";
+import { composeRef } from "rc-util/es/ref";
+import { unstableSetRender } from '../../config-provider/UnstableContext';
+import { TARGET_CLS } from './interface';
+import { getTargetWaveColor } from './util';
+function validateNum(value) {
+  return Number.isNaN(value) ? 0 : value;
+}
+const WaveEffect = props => {
+  const {
+    className,
+    target,
+    component,
+    registerUnmount
+  } = props;
+  const divRef = React.useRef(null);
+  // ====================== Refs ======================
+  const unmountRef = React.useRef(null);
+  React.useEffect(() => {
+    unmountRef.current = registerUnmount();
+  }, []);
+  // ===================== Effect =====================
+  const [color, setWaveColor] = React.useState(null);
+  const [borderRadius, setBorderRadius] = React.useState([]);
+  const [left, setLeft] = React.useState(0);
+  const [top, setTop] = React.useState(0);
+  const [width, setWidth] = React.useState(0);
+  const [height, setHeight] = React.useState(0);
+  const [enabled, setEnabled] = React.useState(false);
+  const waveStyle = {
+    left,
+    top,
+    width,
+    height,
+    borderRadius: borderRadius.map(radius => `${radius}px`).join(' ')
+  };
+  if (color) {
+    waveStyle['--wave-color'] = color;
+  }
+  function syncPos() {
+    const nodeStyle = getComputedStyle(target);
+    // Get wave color from target
+    setWaveColor(getTargetWaveColor(target));
+    const isStatic = nodeStyle.position === 'static';
+    // Rect
+    const {
+      borderLeftWidth,
+      borderTopWidth
+    } = nodeStyle;
+    setLeft(isStatic ? target.offsetLeft : validateNum(-Number.parseFloat(borderLeftWidth)));
+    setTop(isStatic ? target.offsetTop : validateNum(-Number.parseFloat(borderTopWidth)));
+    setWidth(target.offsetWidth);
+    setHeight(target.offsetHeight);
+    // Get border radius
+    const {
+      borderTopLeftRadius,
+      borderTopRightRadius,
+      borderBottomLeftRadius,
+      borderBottomRightRadius
+    } = nodeStyle;
+    setBorderRadius([borderTopLeftRadius, borderTopRightRadius, borderBottomRightRadius, borderBottomLeftRadius].map(radius => validateNum(Number.parseFloat(radius))));
+  }
+  React.useEffect(() => {
+    if (target) {
+      // We need delay to check position here
+      // since UI may change after click
+      const id = raf(() => {
+        syncPos();
+        setEnabled(true);
+      });
+      // Add resize observer to follow size
+      let resizeObserver;
+      if (typeof ResizeObserver !== 'undefined') {
+        resizeObserver = new ResizeObserver(syncPos);
+        resizeObserver.observe(target);
+      }
+      return () => {
+        raf.cancel(id);
+        resizeObserver === null || resizeObserver === void 0 ? void 0 : resizeObserver.disconnect();
+      };
+    }
+  }, [target]);
+  if (!enabled) {
+    return null;
+  }
+  const isSmallComponent = (component === 'Checkbox' || component === 'Radio') && (target === null || target === void 0 ? void 0 : target.classList.contains(TARGET_CLS));
+  return /*#__PURE__*/React.createElement(CSSMotion, {
+    visible: true,
+    motionAppear: true,
+    motionName: "wave-motion",
+    motionDeadline: 5000,
+    onAppearEnd: (_, event) => {
+      var _a, _b;
+      if (event.deadline || event.propertyName === 'opacity') {
+        const holder = (_a = divRef.current) === null || _a === void 0 ? void 0 : _a.parentElement;
+        (_b = unmountRef.current) === null || _b === void 0 ? void 0 : _b.call(unmountRef).then(() => {
+          holder === null || holder === void 0 ? void 0 : holder.remove();
+        });
+      }
+      return false;
+    }
+  }, ({
+    className: motionClassName
+  }, ref) => (/*#__PURE__*/React.createElement("div", {
+    ref: composeRef(divRef, ref),
+    className: classNames(className, motionClassName, {
+      'wave-quick': isSmallComponent
+    }),
+    style: waveStyle
+  })));
+};
+const showWaveEffect = (target, info) => {
+  var _a;
+  const {
+    component
+  } = info;
+  // Skip for unchecked checkbox
+  if (component === 'Checkbox' && !((_a = target.querySelector('input')) === null || _a === void 0 ? void 0 : _a.checked)) {
+    return;
+  }
+  // Create holder
+  const holder = document.createElement('div');
+  holder.style.position = 'absolute';
+  holder.style.left = '0px';
+  holder.style.top = '0px';
+  target === null || target === void 0 ? void 0 : target.insertBefore(holder, target === null || target === void 0 ? void 0 : target.firstChild);
+  const reactRender = unstableSetRender();
+  let unmountCallback = null;
+  function registerUnmount() {
+    return unmountCallback;
+  }
+  unmountCallback = reactRender(/*#__PURE__*/React.createElement(WaveEffect, Object.assign({}, info, {
+    target: target,
+    registerUnmount: registerUnmount
+  })), holder);
+};
+export default showWaveEffect;

node_modules/antd/es/_util/wave/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { WaveComponent } from './interface';
+export interface WaveProps {
+    disabled?: boolean;
+    children?: React.ReactNode;
+    component?: WaveComponent;
+}
+declare const Wave: React.FC<WaveProps>;
+export default Wave;

node_modules/antd/es/_util/wave/index.js

@@ -0,0 +1,58 @@
+import React, { useContext, useRef } from 'react';
+import classNames from 'classnames';
+import isVisible from "rc-util/es/Dom/isVisible";
+import { composeRef, getNodeRef, supportRef } from "rc-util/es/ref";
+import { ConfigContext } from '../../config-provider';
+import { cloneElement } from '../reactNode';
+import useStyle from './style';
+import useWave from './useWave';
+const Wave = props => {
+  const {
+    children,
+    disabled,
+    component
+  } = props;
+  const {
+    getPrefixCls
+  } = useContext(ConfigContext);
+  const containerRef = useRef(null);
+  // ============================== Style ===============================
+  const prefixCls = getPrefixCls('wave');
+  const [, hashId] = useStyle(prefixCls);
+  // =============================== Wave ===============================
+  const showWave = useWave(containerRef, classNames(prefixCls, hashId), component);
+  // ============================== Effect ==============================
+  React.useEffect(() => {
+    const node = containerRef.current;
+    if (!node || node.nodeType !== window.Node.ELEMENT_NODE || disabled) {
+      return;
+    }
+    // Click handler
+    const onClick = e => {
+      // Fix radio button click twice
+      if (!isVisible(e.target) ||
+      // No need wave
+      !node.getAttribute || node.getAttribute('disabled') || node.disabled || node.className.includes('disabled') && !node.className.includes('disabled:') || node.getAttribute('aria-disabled') === 'true' || node.className.includes('-leave')) {
+        return;
+      }
+      showWave(e);
+    };
+    // Bind events
+    node.addEventListener('click', onClick, true);
+    return () => {
+      node.removeEventListener('click', onClick, true);
+    };
+  }, [disabled]);
+  // ============================== Render ==============================
+  if (! /*#__PURE__*/React.isValidElement(children)) {
+    return children !== null && children !== void 0 ? children : null;
+  }
+  const ref = supportRef(children) ? composeRef(getNodeRef(children), containerRef) : containerRef;
+  return cloneElement(children, {
+    ref
+  });
+};
+if (process.env.NODE_ENV !== 'production') {
+  Wave.displayName = 'Wave';
+}
+export default Wave;

node_modules/antd/es/_util/wave/interface.d.ts

@@ -0,0 +1,11 @@
+import type { GlobalToken } from '../../theme/internal';
+export declare const TARGET_CLS = "ant-wave-target";
+export type ShowWaveEffect = (element: HTMLElement, info: {
+    className: string;
+    token: GlobalToken;
+    component?: WaveComponent;
+    event: MouseEvent;
+    hashId: string;
+}) => void;
+export type ShowWave = (event: MouseEvent) => void;
+export type WaveComponent = 'Tag' | 'Button' | 'Checkbox' | 'Radio' | 'Switch';

node_modules/antd/es/_util/wave/interface.js

@@ -0,0 +1,2 @@
+import { defaultPrefixCls } from '../../config-provider';
+export const TARGET_CLS = `${defaultPrefixCls}-wave-target`;

node_modules/antd/es/_util/wave/style.d.ts

@@ -0,0 +1,7 @@
+import type { FullToken } from '../../theme/internal';
+export interface ComponentToken {
+}
+export interface WaveToken extends FullToken<'Wave'> {
+}
+declare const _default: (prefixCls: string, rootCls?: string) => import("@ant-design/cssinjs-utils/lib/interface").UseComponentStyleResult;
+export default _default;

node_modules/antd/es/_util/wave/style.js

@@ -0,0 +1,30 @@
+import { genComponentStyleHook } from '../../theme/internal';
+const genWaveStyle = token => {
+  const {
+    componentCls,
+    colorPrimary
+  } = token;
+  return {
+    [componentCls]: {
+      position: 'absolute',
+      background: 'transparent',
+      pointerEvents: 'none',
+      boxSizing: 'border-box',
+      color: `var(--wave-color, ${colorPrimary})`,
+      boxShadow: `0 0 0 0 currentcolor`,
+      opacity: 0.2,
+      // =================== Motion ===================
+      '&.wave-motion-appear': {
+        transition: [`box-shadow 0.4s ${token.motionEaseOutCirc}`, `opacity 2s ${token.motionEaseOutCirc}`].join(','),
+        '&-active': {
+          boxShadow: `0 0 0 6px currentcolor`,
+          opacity: 0
+        },
+        '&.wave-quick': {
+          transition: [`box-shadow ${token.motionDurationSlow} ${token.motionEaseInOut}`, `opacity ${token.motionDurationSlow} ${token.motionEaseInOut}`].join(',')
+        }
+      }
+    }
+  };
+};
+export default genComponentStyleHook('Wave', genWaveStyle);

node_modules/antd/es/_util/wave/useWave.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import type { ShowWave, WaveComponent } from './interface';
+declare const useWave: (nodeRef: React.RefObject<HTMLElement | null>, className: string, component?: WaveComponent) => ShowWave;
+export default useWave;

node_modules/antd/es/_util/wave/useWave.js

@@ -0,0 +1,41 @@
+import * as React from 'react';
+import useEvent from "rc-util/es/hooks/useEvent";
+import raf from "rc-util/es/raf";
+import { ConfigContext } from '../../config-provider';
+import useToken from '../../theme/useToken';
+import { TARGET_CLS } from './interface';
+import showWaveEffect from './WaveEffect';
+const useWave = (nodeRef, className, component) => {
+  const {
+    wave
+  } = React.useContext(ConfigContext);
+  const [, token, hashId] = useToken();
+  const showWave = useEvent(event => {
+    const node = nodeRef.current;
+    if ((wave === null || wave === void 0 ? void 0 : wave.disabled) || !node) {
+      return;
+    }
+    const targetNode = node.querySelector(`.${TARGET_CLS}`) || node;
+    const {
+      showEffect
+    } = wave || {};
+    // Customize wave effect
+    (showEffect || showWaveEffect)(targetNode, {
+      className,
+      token,
+      component,
+      event,
+      hashId
+    });
+  });
+  const rafId = React.useRef(null);
+  // Merge trigger event into one for each frame
+  const showDebounceWave = event => {
+    raf.cancel(rafId.current);
+    rafId.current = raf(() => {
+      showWave(event);
+    });
+  };
+  return showDebounceWave;
+};
+export default useWave;

node_modules/antd/es/_util/wave/util.d.ts

@@ -0,0 +1,2 @@
+export declare function isValidWaveColor(color: string): boolean | "";
+export declare function getTargetWaveColor(node: HTMLElement): string | null;

node_modules/antd/es/_util/wave/util.js

@@ -0,0 +1,14 @@
+export function isValidWaveColor(color) {
+  return color && color !== '#fff' && color !== '#ffffff' && color !== 'rgb(255, 255, 255)' && color !== 'rgba(255, 255, 255, 1)' && !/rgba\((?:\d*, ){3}0\)/.test(color) &&
+  // any transparent rgba color
+  color !== 'transparent' && color !== 'canvastext';
+}
+export function getTargetWaveColor(node) {
+  var _a;
+  const {
+    borderTopColor,
+    borderColor,
+    backgroundColor
+  } = getComputedStyle(node);
+  return (_a = [borderTopColor, borderColor, backgroundColor].find(isValidWaveColor)) !== null && _a !== void 0 ? _a : null;
+}

node_modules/antd/es/_util/zindexContext.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const zIndexContext: React.Context<number | undefined>;
+export default zIndexContext;

node_modules/antd/es/_util/zindexContext.js

@@ -0,0 +1,6 @@
+import React from 'react';
+const zIndexContext = /*#__PURE__*/React.createContext(undefined);
+if (process.env.NODE_ENV !== 'production') {
+  zIndexContext.displayName = 'zIndexContext';
+}
+export default zIndexContext;