add all frontend files

node_modules/antd/es/form/ErrorList.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import type { ValidateStatus } from './FormItem';
+export interface ErrorListProps {
+    fieldId?: string;
+    help?: React.ReactNode;
+    helpStatus?: ValidateStatus;
+    errors?: React.ReactNode[];
+    warnings?: React.ReactNode[];
+    className?: string;
+    onVisibleChanged?: (visible: boolean) => void;
+}
+declare const ErrorList: React.FC<ErrorListProps>;
+export default ErrorList;

node_modules/antd/es/form/ErrorList.js

@@ -0,0 +1,97 @@
+"use client";
+
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import classNames from 'classnames';
+import CSSMotion, { CSSMotionList } from 'rc-motion';
+import initCollapseMotion from '../_util/motion';
+import useCSSVarCls from '../config-provider/hooks/useCSSVarCls';
+import { FormItemPrefixContext } from './context';
+import useDebounce from './hooks/useDebounce';
+import useStyle from './style';
+const EMPTY_LIST = [];
+function toErrorEntity(error, prefix, errorStatus, index = 0) {
+  return {
+    key: typeof error === 'string' ? error : `${prefix}-${index}`,
+    error,
+    errorStatus
+  };
+}
+const ErrorList = ({
+  help,
+  helpStatus,
+  errors = EMPTY_LIST,
+  warnings = EMPTY_LIST,
+  className: rootClassName,
+  fieldId,
+  onVisibleChanged
+}) => {
+  const {
+    prefixCls
+  } = React.useContext(FormItemPrefixContext);
+  const baseClassName = `${prefixCls}-item-explain`;
+  const rootCls = useCSSVarCls(prefixCls);
+  const [wrapCSSVar, hashId, cssVarCls] = useStyle(prefixCls, rootCls);
+  const collapseMotion = React.useMemo(() => initCollapseMotion(prefixCls), [prefixCls]);
+  // We have to debounce here again since somewhere use ErrorList directly still need no shaking
+  // ref: https://github.com/ant-design/ant-design/issues/36336
+  const debounceErrors = useDebounce(errors);
+  const debounceWarnings = useDebounce(warnings);
+  const fullKeyList = React.useMemo(() => {
+    if (help !== undefined && help !== null) {
+      return [toErrorEntity(help, 'help', helpStatus)];
+    }
+    return [].concat(_toConsumableArray(debounceErrors.map((error, index) => toErrorEntity(error, 'error', 'error', index))), _toConsumableArray(debounceWarnings.map((warning, index) => toErrorEntity(warning, 'warning', 'warning', index))));
+  }, [help, helpStatus, debounceErrors, debounceWarnings]);
+  const filledKeyFullKeyList = React.useMemo(() => {
+    const keysCount = {};
+    fullKeyList.forEach(({
+      key
+    }) => {
+      keysCount[key] = (keysCount[key] || 0) + 1;
+    });
+    return fullKeyList.map((entity, index) => Object.assign(Object.assign({}, entity), {
+      key: keysCount[entity.key] > 1 ? `${entity.key}-fallback-${index}` : entity.key
+    }));
+  }, [fullKeyList]);
+  const helpProps = {};
+  if (fieldId) {
+    helpProps.id = `${fieldId}_help`;
+  }
+  return wrapCSSVar(/*#__PURE__*/React.createElement(CSSMotion, {
+    motionDeadline: collapseMotion.motionDeadline,
+    motionName: `${prefixCls}-show-help`,
+    visible: !!filledKeyFullKeyList.length,
+    onVisibleChanged: onVisibleChanged
+  }, holderProps => {
+    const {
+      className: holderClassName,
+      style: holderStyle
+    } = holderProps;
+    return /*#__PURE__*/React.createElement("div", Object.assign({}, helpProps, {
+      className: classNames(baseClassName, holderClassName, cssVarCls, rootCls, rootClassName, hashId),
+      style: holderStyle
+    }), /*#__PURE__*/React.createElement(CSSMotionList, Object.assign({
+      keys: filledKeyFullKeyList
+    }, initCollapseMotion(prefixCls), {
+      motionName: `${prefixCls}-show-help-item`,
+      component: false
+    }), itemProps => {
+      const {
+        key,
+        error,
+        errorStatus,
+        className: itemClassName,
+        style: itemStyle
+      } = itemProps;
+      return /*#__PURE__*/React.createElement("div", {
+        key: key,
+        className: classNames(itemClassName, {
+          [`${baseClassName}-${errorStatus}`]: errorStatus
+        }),
+        style: itemStyle
+      }, error);
+    }));
+  }));
+};
+export default ErrorList;

node_modules/antd/es/form/Form.d.ts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+import { List, useWatch } from 'rc-field-form';
+import type { FormProps as RcFormProps } from 'rc-field-form/lib/Form';
+import type { FormRef } from 'rc-field-form/lib/interface';
+import type { Variant } from '../config-provider';
+import type { SizeType } from '../config-provider/SizeContext';
+import type { ColProps } from '../grid/col';
+import type { FeedbackIcons } from './FormItem';
+import useForm from './hooks/useForm';
+import type { FormInstance } from './hooks/useForm';
+import type { FormLabelAlign, ScrollFocusOptions } from './interface';
+export type RequiredMark = boolean | 'optional' | ((labelNode: React.ReactNode, info: {
+    required: boolean;
+}) => React.ReactNode);
+export type FormLayout = 'horizontal' | 'inline' | 'vertical';
+export type FormItemLayout = 'horizontal' | 'vertical';
+export type { ScrollFocusOptions };
+export interface FormProps<Values = any> extends Omit<RcFormProps<Values>, 'form'> {
+    prefixCls?: string;
+    colon?: boolean;
+    name?: string;
+    layout?: FormLayout;
+    labelAlign?: FormLabelAlign;
+    labelWrap?: boolean;
+    labelCol?: ColProps;
+    wrapperCol?: ColProps;
+    form?: FormInstance<Values>;
+    feedbackIcons?: FeedbackIcons;
+    size?: SizeType;
+    disabled?: boolean;
+    scrollToFirstError?: ScrollFocusOptions | boolean;
+    requiredMark?: RequiredMark;
+    /** @deprecated Will warning in future branch. Pls use `requiredMark` instead. */
+    hideRequiredMark?: boolean;
+    rootClassName?: string;
+    variant?: Variant;
+}
+declare const Form: (<Values = any>(props: React.PropsWithChildren<FormProps<Values>> & React.RefAttributes<FormRef<Values>>) => React.ReactElement) & Pick<React.FC, "displayName">;
+export { List, useForm, useWatch, type FormInstance };
+export default Form;

node_modules/antd/es/form/Form.js

@@ -0,0 +1,167 @@
+"use client";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import * as React from 'react';
+import classNames from 'classnames';
+import FieldForm, { List, useWatch } from 'rc-field-form';
+import { useComponentConfig } from '../config-provider/context';
+import DisabledContext, { DisabledContextProvider } from '../config-provider/DisabledContext';
+import useCSSVarCls from '../config-provider/hooks/useCSSVarCls';
+import useSize from '../config-provider/hooks/useSize';
+import SizeContext from '../config-provider/SizeContext';
+import { FormContext, FormProvider, NoFormStyle, VariantContext } from './context';
+import useForm from './hooks/useForm';
+import useFormWarning from './hooks/useFormWarning';
+import useStyle from './style';
+import ValidateMessagesContext from './validateMessagesContext';
+const InternalForm = (props, ref) => {
+  const contextDisabled = React.useContext(DisabledContext);
+  const {
+    getPrefixCls,
+    direction,
+    requiredMark: contextRequiredMark,
+    colon: contextColon,
+    scrollToFirstError: contextScrollToFirstError,
+    className: contextClassName,
+    style: contextStyle
+  } = useComponentConfig('form');
+  const {
+      prefixCls: customizePrefixCls,
+      className,
+      rootClassName,
+      size,
+      disabled = contextDisabled,
+      form,
+      colon,
+      labelAlign,
+      labelWrap,
+      labelCol,
+      wrapperCol,
+      hideRequiredMark,
+      layout = 'horizontal',
+      scrollToFirstError,
+      requiredMark,
+      onFinishFailed,
+      name,
+      style,
+      feedbackIcons,
+      variant
+    } = props,
+    restFormProps = __rest(props, ["prefixCls", "className", "rootClassName", "size", "disabled", "form", "colon", "labelAlign", "labelWrap", "labelCol", "wrapperCol", "hideRequiredMark", "layout", "scrollToFirstError", "requiredMark", "onFinishFailed", "name", "style", "feedbackIcons", "variant"]);
+  const mergedSize = useSize(size);
+  const contextValidateMessages = React.useContext(ValidateMessagesContext);
+  /* eslint-disable react-hooks/rules-of-hooks */
+  if (process.env.NODE_ENV !== 'production') {
+    // biome-ignore lint/correctness/useHookAtTopLevel: Development-only warning hook called conditionally
+    useFormWarning(props);
+  }
+  /* eslint-enable */
+  const mergedRequiredMark = React.useMemo(() => {
+    if (requiredMark !== undefined) {
+      return requiredMark;
+    }
+    if (hideRequiredMark) {
+      return false;
+    }
+    if (contextRequiredMark !== undefined) {
+      return contextRequiredMark;
+    }
+    return true;
+  }, [hideRequiredMark, requiredMark, contextRequiredMark]);
+  const mergedColon = colon !== null && colon !== void 0 ? colon : contextColon;
+  const prefixCls = getPrefixCls('form', customizePrefixCls);
+  // Style
+  const rootCls = useCSSVarCls(prefixCls);
+  const [wrapCSSVar, hashId, cssVarCls] = useStyle(prefixCls, rootCls);
+  const formClassName = classNames(prefixCls, `${prefixCls}-${layout}`, {
+    [`${prefixCls}-hide-required-mark`]: mergedRequiredMark === false,
+    // todo: remove in next major version
+    [`${prefixCls}-rtl`]: direction === 'rtl',
+    [`${prefixCls}-${mergedSize}`]: mergedSize
+  }, cssVarCls, rootCls, hashId, contextClassName, className, rootClassName);
+  const [wrapForm] = useForm(form);
+  const {
+    __INTERNAL__
+  } = wrapForm;
+  __INTERNAL__.name = name;
+  const formContextValue = React.useMemo(() => ({
+    name,
+    labelAlign,
+    labelCol,
+    labelWrap,
+    wrapperCol,
+    layout,
+    colon: mergedColon,
+    requiredMark: mergedRequiredMark,
+    itemRef: __INTERNAL__.itemRef,
+    form: wrapForm,
+    feedbackIcons
+  }), [name, labelAlign, labelCol, wrapperCol, layout, mergedColon, mergedRequiredMark, wrapForm, feedbackIcons]);
+  const nativeElementRef = React.useRef(null);
+  React.useImperativeHandle(ref, () => {
+    var _a;
+    return Object.assign(Object.assign({}, wrapForm), {
+      nativeElement: (_a = nativeElementRef.current) === null || _a === void 0 ? void 0 : _a.nativeElement
+    });
+  });
+  const scrollToField = (options, fieldName) => {
+    if (options) {
+      let defaultScrollToFirstError = {
+        block: 'nearest'
+      };
+      if (typeof options === 'object') {
+        defaultScrollToFirstError = Object.assign(Object.assign({}, defaultScrollToFirstError), options);
+      }
+      wrapForm.scrollToField(fieldName, defaultScrollToFirstError);
+    }
+  };
+  const onInternalFinishFailed = errorInfo => {
+    onFinishFailed === null || onFinishFailed === void 0 ? void 0 : onFinishFailed(errorInfo);
+    if (errorInfo.errorFields.length) {
+      const fieldName = errorInfo.errorFields[0].name;
+      if (scrollToFirstError !== undefined) {
+        scrollToField(scrollToFirstError, fieldName);
+        return;
+      }
+      if (contextScrollToFirstError !== undefined) {
+        scrollToField(contextScrollToFirstError, fieldName);
+      }
+    }
+  };
+  return wrapCSSVar(/*#__PURE__*/React.createElement(VariantContext.Provider, {
+    value: variant
+  }, /*#__PURE__*/React.createElement(DisabledContextProvider, {
+    disabled: disabled
+  }, /*#__PURE__*/React.createElement(SizeContext.Provider, {
+    value: mergedSize
+  }, /*#__PURE__*/React.createElement(FormProvider, {
+    // This is not list in API, we pass with spread
+    validateMessages: contextValidateMessages
+  }, /*#__PURE__*/React.createElement(FormContext.Provider, {
+    value: formContextValue
+  }, /*#__PURE__*/React.createElement(NoFormStyle, {
+    status: true
+  }, /*#__PURE__*/React.createElement(FieldForm, Object.assign({
+    id: name
+  }, restFormProps, {
+    name: name,
+    onFinishFailed: onInternalFinishFailed,
+    form: wrapForm,
+    ref: nativeElementRef,
+    style: Object.assign(Object.assign({}, contextStyle), style),
+    className: formClassName
+  })))))))));
+};
+const Form = /*#__PURE__*/React.forwardRef(InternalForm);
+if (process.env.NODE_ENV !== 'production') {
+  Form.displayName = 'Form';
+}
+export { List, useForm, useWatch };
+export default Form;

node_modules/antd/es/form/FormItem/ItemHolder.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import type { Meta } from 'rc-field-form/lib/interface';
+import type { FormItemProps } from '.';
+import type { ReportMetaChange } from '../context';
+export interface ItemHolderProps extends FormItemProps {
+    prefixCls: string;
+    className?: string;
+    rootClassName?: string;
+    style?: React.CSSProperties;
+    errors: React.ReactNode[];
+    warnings: React.ReactNode[];
+    meta: Meta;
+    children?: React.ReactNode;
+    fieldId?: string;
+    isRequired?: boolean;
+    onSubItemMetaChange: ReportMetaChange;
+}
+export default function ItemHolder(props: ItemHolderProps): React.JSX.Element;

node_modules/antd/es/form/FormItem/ItemHolder.js

@@ -0,0 +1,133 @@
+"use client";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import * as React from 'react';
+import classNames from 'classnames';
+import isVisible from "rc-util/es/Dom/isVisible";
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+import omit from "rc-util/es/omit";
+import { Row } from '../../grid';
+import { FormContext, NoStyleItemContext } from '../context';
+import FormItemInput from '../FormItemInput';
+import FormItemLabel from '../FormItemLabel';
+import useDebounce from '../hooks/useDebounce';
+import { getStatus } from '../util';
+import StatusProvider from './StatusProvider';
+export default function ItemHolder(props) {
+  const {
+      prefixCls,
+      className,
+      rootClassName,
+      style,
+      help,
+      errors,
+      warnings,
+      validateStatus,
+      meta,
+      hasFeedback,
+      hidden,
+      children,
+      fieldId,
+      required,
+      isRequired,
+      onSubItemMetaChange,
+      layout: propsLayout,
+      name
+    } = props,
+    restProps = __rest(props, ["prefixCls", "className", "rootClassName", "style", "help", "errors", "warnings", "validateStatus", "meta", "hasFeedback", "hidden", "children", "fieldId", "required", "isRequired", "onSubItemMetaChange", "layout", "name"]);
+  const itemPrefixCls = `${prefixCls}-item`;
+  const {
+    requiredMark,
+    layout: formLayout
+  } = React.useContext(FormContext);
+  const layout = propsLayout || formLayout;
+  const vertical = layout === 'vertical';
+  // ======================== Margin ========================
+  const itemRef = React.useRef(null);
+  const debounceErrors = useDebounce(errors);
+  const debounceWarnings = useDebounce(warnings);
+  const hasHelp = help !== undefined && help !== null;
+  const hasError = !!(hasHelp || errors.length || warnings.length);
+  const isOnScreen = !!itemRef.current && isVisible(itemRef.current);
+  const [marginBottom, setMarginBottom] = React.useState(null);
+  useLayoutEffect(() => {
+    if (hasError && itemRef.current) {
+      // The element must be part of the DOMTree to use getComputedStyle
+      // https://stackoverflow.com/questions/35360711/getcomputedstyle-returns-a-cssstyledeclaration-but-all-properties-are-empty-on-a
+      const itemStyle = getComputedStyle(itemRef.current);
+      setMarginBottom(Number.parseInt(itemStyle.marginBottom, 10));
+    }
+  }, [hasError, isOnScreen]);
+  const onErrorVisibleChanged = nextVisible => {
+    if (!nextVisible) {
+      setMarginBottom(null);
+    }
+  };
+  // ======================== Status ========================
+  const getValidateState = (isDebounce = false) => {
+    const _errors = isDebounce ? debounceErrors : meta.errors;
+    const _warnings = isDebounce ? debounceWarnings : meta.warnings;
+    return getStatus(_errors, _warnings, meta, '', !!hasFeedback, validateStatus);
+  };
+  const mergedValidateStatus = getValidateState();
+  // ======================== Render ========================
+  const itemClassName = classNames(itemPrefixCls, className, rootClassName, {
+    [`${itemPrefixCls}-with-help`]: hasHelp || debounceErrors.length || debounceWarnings.length,
+    // Status
+    [`${itemPrefixCls}-has-feedback`]: mergedValidateStatus && hasFeedback,
+    [`${itemPrefixCls}-has-success`]: mergedValidateStatus === 'success',
+    [`${itemPrefixCls}-has-warning`]: mergedValidateStatus === 'warning',
+    [`${itemPrefixCls}-has-error`]: mergedValidateStatus === 'error',
+    [`${itemPrefixCls}-is-validating`]: mergedValidateStatus === 'validating',
+    [`${itemPrefixCls}-hidden`]: hidden,
+    // Layout
+    [`${itemPrefixCls}-${layout}`]: layout
+  });
+  return /*#__PURE__*/React.createElement("div", {
+    className: itemClassName,
+    style: style,
+    ref: itemRef
+  }, /*#__PURE__*/React.createElement(Row, Object.assign({
+    className: `${itemPrefixCls}-row`
+  }, omit(restProps, ['_internalItemRender', 'colon', 'dependencies', 'extra', 'fieldKey', 'getValueFromEvent', 'getValueProps', 'htmlFor', 'id',
+  // It is deprecated because `htmlFor` is its replacement.
+  'initialValue', 'isListField', 'label', 'labelAlign', 'labelCol', 'labelWrap', 'messageVariables', 'name', 'normalize', 'noStyle', 'preserve', 'requiredMark', 'rules', 'shouldUpdate', 'trigger', 'tooltip', 'validateFirst', 'validateTrigger', 'valuePropName', 'wrapperCol', 'validateDebounce'])), /*#__PURE__*/React.createElement(FormItemLabel, Object.assign({
+    htmlFor: fieldId
+  }, props, {
+    requiredMark: requiredMark,
+    required: required !== null && required !== void 0 ? required : isRequired,
+    prefixCls: prefixCls,
+    vertical: vertical
+  })), /*#__PURE__*/React.createElement(FormItemInput, Object.assign({}, props, meta, {
+    errors: debounceErrors,
+    warnings: debounceWarnings,
+    prefixCls: prefixCls,
+    status: mergedValidateStatus,
+    help: help,
+    marginBottom: marginBottom,
+    onErrorVisibleChanged: onErrorVisibleChanged
+  }), /*#__PURE__*/React.createElement(NoStyleItemContext.Provider, {
+    value: onSubItemMetaChange
+  }, /*#__PURE__*/React.createElement(StatusProvider, {
+    prefixCls: prefixCls,
+    meta: meta,
+    errors: meta.errors,
+    warnings: meta.warnings,
+    hasFeedback: hasFeedback,
+    // Already calculated
+    validateStatus: mergedValidateStatus,
+    name: name
+  }, children)))), !!marginBottom && (/*#__PURE__*/React.createElement("div", {
+    className: `${itemPrefixCls}-margin-offset`,
+    style: {
+      marginBottom: -marginBottom
+    }
+  })));
+}

node_modules/antd/es/form/FormItem/StatusProvider.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import type { Meta, NamePath } from 'rc-field-form/lib/interface';
+import type { FeedbackIcons, ValidateStatus } from '.';
+export interface StatusProviderProps {
+    children?: React.ReactNode;
+    validateStatus?: ValidateStatus;
+    prefixCls: string;
+    meta: Meta;
+    errors: React.ReactNode[];
+    warnings: React.ReactNode[];
+    hasFeedback?: boolean | {
+        icons?: FeedbackIcons;
+    };
+    noStyle?: boolean;
+    name?: NamePath;
+}
+export default function StatusProvider({ children, errors, warnings, hasFeedback, validateStatus, prefixCls, meta, noStyle, name, }: StatusProviderProps): React.JSX.Element;

node_modules/antd/es/form/FormItem/StatusProvider.js

@@ -0,0 +1,79 @@
+"use client";
+
+import * as React from 'react';
+import CheckCircleFilled from "@ant-design/icons/es/icons/CheckCircleFilled";
+import CloseCircleFilled from "@ant-design/icons/es/icons/CloseCircleFilled";
+import ExclamationCircleFilled from "@ant-design/icons/es/icons/ExclamationCircleFilled";
+import LoadingOutlined from "@ant-design/icons/es/icons/LoadingOutlined";
+import classNames from 'classnames';
+import { FormContext, FormItemInputContext } from '../context';
+import { getStatus } from '../util';
+const iconMap = {
+  success: CheckCircleFilled,
+  warning: ExclamationCircleFilled,
+  error: CloseCircleFilled,
+  validating: LoadingOutlined
+};
+export default function StatusProvider({
+  children,
+  errors,
+  warnings,
+  hasFeedback,
+  validateStatus,
+  prefixCls,
+  meta,
+  noStyle,
+  name
+}) {
+  const itemPrefixCls = `${prefixCls}-item`;
+  const {
+    feedbackIcons
+  } = React.useContext(FormContext);
+  const mergedValidateStatus = getStatus(errors, warnings, meta, null, !!hasFeedback, validateStatus);
+  const {
+    isFormItemInput: parentIsFormItemInput,
+    status: parentStatus,
+    hasFeedback: parentHasFeedback,
+    feedbackIcon: parentFeedbackIcon,
+    name: parentName
+  } = React.useContext(FormItemInputContext);
+  // ====================== Context =======================
+  const formItemStatusContext = React.useMemo(() => {
+    var _a;
+    let feedbackIcon;
+    if (hasFeedback) {
+      const customIcons = hasFeedback !== true && hasFeedback.icons || feedbackIcons;
+      const customIconNode = mergedValidateStatus && ((_a = customIcons === null || customIcons === void 0 ? void 0 : customIcons({
+        status: mergedValidateStatus,
+        errors,
+        warnings
+      })) === null || _a === void 0 ? void 0 : _a[mergedValidateStatus]);
+      const IconNode = mergedValidateStatus ? iconMap[mergedValidateStatus] : null;
+      feedbackIcon = customIconNode !== false && IconNode ? (/*#__PURE__*/React.createElement("span", {
+        className: classNames(`${itemPrefixCls}-feedback-icon`, `${itemPrefixCls}-feedback-icon-${mergedValidateStatus}`)
+      }, customIconNode || /*#__PURE__*/React.createElement(IconNode, null))) : null;
+    }
+    const context = {
+      status: mergedValidateStatus || '',
+      errors,
+      warnings,
+      hasFeedback: !!hasFeedback,
+      feedbackIcon,
+      isFormItemInput: true,
+      name
+    };
+    // No style will follow parent context
+    if (noStyle) {
+      context.status = (mergedValidateStatus !== null && mergedValidateStatus !== void 0 ? mergedValidateStatus : parentStatus) || '';
+      context.isFormItemInput = parentIsFormItemInput;
+      context.hasFeedback = !!(hasFeedback !== null && hasFeedback !== void 0 ? hasFeedback : parentHasFeedback);
+      context.feedbackIcon = hasFeedback !== undefined ? context.feedbackIcon : parentFeedbackIcon;
+      context.name = name !== null && name !== void 0 ? name : parentName;
+    }
+    return context;
+  }, [mergedValidateStatus, hasFeedback, noStyle, parentIsFormItemInput, parentStatus]);
+  // ======================= Render =======================
+  return /*#__PURE__*/React.createElement(FormItemInputContext.Provider, {
+    value: formItemStatusContext
+  }, children);
+}

node_modules/antd/es/form/FormItem/index.d.ts

@@ -0,0 +1,46 @@
+import * as React from 'react';
+import type { FieldProps } from 'rc-field-form/lib/Field';
+import type { FormInstance, FormItemLayout } from '../Form';
+import type { FormItemInputProps } from '../FormItemInput';
+import type { FormItemLabelProps, LabelTooltipType } from '../FormItemLabel';
+import useFormItemStatus from '../hooks/useFormItemStatus';
+declare const _ValidateStatuses: readonly ["success", "warning", "error", "validating", ""];
+export type ValidateStatus = (typeof _ValidateStatuses)[number];
+type RenderChildren<Values = any> = (form: FormInstance<Values>) => React.ReactNode;
+type RcFieldProps<Values = any> = Omit<FieldProps<Values>, 'children'>;
+type ChildrenType<Values = any> = RenderChildren<Values> | React.ReactNode;
+export type FeedbackIcons = (itemStatus: {
+    status: ValidateStatus;
+    errors?: React.ReactNode[];
+    warnings?: React.ReactNode[];
+}) => {
+    [key in ValidateStatus]?: React.ReactNode;
+};
+export interface FormItemProps<Values = any> extends Omit<FormItemLabelProps, 'requiredMark'>, FormItemInputProps, RcFieldProps<Values> {
+    prefixCls?: string;
+    noStyle?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+    rootClassName?: string;
+    children?: ChildrenType<Values>;
+    id?: string;
+    hasFeedback?: boolean | {
+        icons: FeedbackIcons;
+    };
+    validateStatus?: ValidateStatus;
+    required?: boolean;
+    hidden?: boolean;
+    initialValue?: any;
+    messageVariables?: Record<string, string>;
+    tooltip?: LabelTooltipType;
+    /** @deprecated No need anymore */
+    fieldKey?: React.Key | React.Key[];
+    layout?: FormItemLayout;
+}
+declare function InternalFormItem<Values = any>(props: FormItemProps<Values>): React.ReactElement;
+type InternalFormItemType = typeof InternalFormItem;
+type CompoundedComponent = InternalFormItemType & {
+    useStatus: typeof useFormItemStatus;
+};
+declare const FormItem: CompoundedComponent;
+export default FormItem;

node_modules/antd/es/form/FormItem/index.js

@@ -0,0 +1,278 @@
+"use client";
+
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import classNames from 'classnames';
+import { Field, FieldContext, ListContext } from 'rc-field-form';
+import useState from "rc-util/es/hooks/useState";
+import { supportRef } from "rc-util/es/ref";
+import { cloneElement } from '../../_util/reactNode';
+import { devUseWarning } from '../../_util/warning';
+import { ConfigContext } from '../../config-provider';
+import useCSSVarCls from '../../config-provider/hooks/useCSSVarCls';
+import { FormContext, NoStyleItemContext } from '../context';
+import useChildren from '../hooks/useChildren';
+import useFormItemStatus from '../hooks/useFormItemStatus';
+import useFrameState from '../hooks/useFrameState';
+import useItemRef from '../hooks/useItemRef';
+import useStyle from '../style';
+import { getFieldId, toArray } from '../util';
+import ItemHolder from './ItemHolder';
+import StatusProvider from './StatusProvider';
+const NAME_SPLIT = '__SPLIT__';
+const _ValidateStatuses = ['success', 'warning', 'error', 'validating', ''];
+// https://github.com/ant-design/ant-design/issues/46417
+// `getValueProps` may modify the value props name,
+// we should check if the control is similar.
+function isSimilarControl(a, b) {
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  return keysA.length === keysB.length && keysA.every(key => {
+    const propValueA = a[key];
+    const propValueB = b[key];
+    return propValueA === propValueB || typeof propValueA === 'function' || typeof propValueB === 'function';
+  });
+}
+const MemoInput = /*#__PURE__*/React.memo(({
+  children
+}) => children, (prev, next) => isSimilarControl(prev.control, next.control) && prev.update === next.update && prev.childProps.length === next.childProps.length && prev.childProps.every((value, index) => value === next.childProps[index]));
+function genEmptyMeta() {
+  return {
+    errors: [],
+    warnings: [],
+    touched: false,
+    validating: false,
+    name: [],
+    validated: false
+  };
+}
+function InternalFormItem(props) {
+  const {
+    name,
+    noStyle,
+    className,
+    dependencies,
+    prefixCls: customizePrefixCls,
+    shouldUpdate,
+    rules,
+    children,
+    required,
+    label,
+    messageVariables,
+    trigger = 'onChange',
+    validateTrigger,
+    hidden,
+    help,
+    layout
+  } = props;
+  const {
+    getPrefixCls
+  } = React.useContext(ConfigContext);
+  const {
+    name: formName
+  } = React.useContext(FormContext);
+  const mergedChildren = useChildren(children);
+  const isRenderProps = typeof mergedChildren === 'function';
+  const notifyParentMetaChange = React.useContext(NoStyleItemContext);
+  const {
+    validateTrigger: contextValidateTrigger
+  } = React.useContext(FieldContext);
+  const mergedValidateTrigger = validateTrigger !== undefined ? validateTrigger : contextValidateTrigger;
+  const hasName = !(name === undefined || name === null);
+  const prefixCls = getPrefixCls('form', customizePrefixCls);
+  // Style
+  const rootCls = useCSSVarCls(prefixCls);
+  const [wrapCSSVar, hashId, cssVarCls] = useStyle(prefixCls, rootCls);
+  // ========================= Warn =========================
+  const warning = devUseWarning('Form.Item');
+  if (process.env.NODE_ENV !== 'production') {
+    process.env.NODE_ENV !== "production" ? warning(name !== null, 'usage', '`null` is passed as `name` property') : void 0;
+  }
+  // ========================= MISC =========================
+  // Get `noStyle` required info
+  const listContext = React.useContext(ListContext);
+  const fieldKeyPathRef = React.useRef(null);
+  // ======================== Errors ========================
+  // >>>>> Collect sub field errors
+  const [subFieldErrors, setSubFieldErrors] = useFrameState({});
+  // >>>>> Current field errors
+  const [meta, setMeta] = useState(() => genEmptyMeta());
+  const onMetaChange = nextMeta => {
+    // This keyInfo is not correct when field is removed
+    // Since origin keyManager no longer keep the origin key anymore
+    // Which means we need cache origin one and reuse when removed
+    const keyInfo = listContext === null || listContext === void 0 ? void 0 : listContext.getKey(nextMeta.name);
+    // Destroy will reset all the meta
+    setMeta(nextMeta.destroy ? genEmptyMeta() : nextMeta, true);
+    // Bump to parent since noStyle
+    if (noStyle && help !== false && notifyParentMetaChange) {
+      let namePath = nextMeta.name;
+      if (!nextMeta.destroy) {
+        if (keyInfo !== undefined) {
+          const [fieldKey, restPath] = keyInfo;
+          namePath = [fieldKey].concat(_toConsumableArray(restPath));
+          fieldKeyPathRef.current = namePath;
+        }
+      } else {
+        // Use origin cache data
+        namePath = fieldKeyPathRef.current || namePath;
+      }
+      notifyParentMetaChange(nextMeta, namePath);
+    }
+  };
+  // >>>>> Collect noStyle Field error to the top FormItem
+  const onSubItemMetaChange = (subMeta, uniqueKeys) => {
+    // Only `noStyle` sub item will trigger
+    setSubFieldErrors(prevSubFieldErrors => {
+      const clone = Object.assign({}, prevSubFieldErrors);
+      // name: ['user', 1] + key: [4] = ['user', 4]
+      const mergedNamePath = [].concat(_toConsumableArray(subMeta.name.slice(0, -1)), _toConsumableArray(uniqueKeys));
+      const mergedNameKey = mergedNamePath.join(NAME_SPLIT);
+      if (subMeta.destroy) {
+        // Remove
+        delete clone[mergedNameKey];
+      } else {
+        // Update
+        clone[mergedNameKey] = subMeta;
+      }
+      return clone;
+    });
+  };
+  // >>>>> Get merged errors
+  const [mergedErrors, mergedWarnings] = React.useMemo(() => {
+    const errorList = _toConsumableArray(meta.errors);
+    const warningList = _toConsumableArray(meta.warnings);
+    Object.values(subFieldErrors).forEach(subFieldError => {
+      errorList.push.apply(errorList, _toConsumableArray(subFieldError.errors || []));
+      warningList.push.apply(warningList, _toConsumableArray(subFieldError.warnings || []));
+    });
+    return [errorList, warningList];
+  }, [subFieldErrors, meta.errors, meta.warnings]);
+  // ===================== Children Ref =====================
+  const getItemRef = useItemRef();
+  // ======================== Render ========================
+  function renderLayout(baseChildren, fieldId, isRequired) {
+    if (noStyle && !hidden) {
+      return /*#__PURE__*/React.createElement(StatusProvider, {
+        prefixCls: prefixCls,
+        hasFeedback: props.hasFeedback,
+        validateStatus: props.validateStatus,
+        meta: meta,
+        errors: mergedErrors,
+        warnings: mergedWarnings,
+        noStyle: true,
+        name: name
+      }, baseChildren);
+    }
+    return /*#__PURE__*/React.createElement(ItemHolder, Object.assign({
+      key: "row"
+    }, props, {
+      className: classNames(className, cssVarCls, rootCls, hashId),
+      prefixCls: prefixCls,
+      fieldId: fieldId,
+      isRequired: isRequired,
+      errors: mergedErrors,
+      warnings: mergedWarnings,
+      meta: meta,
+      onSubItemMetaChange: onSubItemMetaChange,
+      layout: layout,
+      name: name
+    }), baseChildren);
+  }
+  if (!hasName && !isRenderProps && !dependencies) {
+    return wrapCSSVar(renderLayout(mergedChildren));
+  }
+  let variables = {};
+  if (typeof label === 'string') {
+    variables.label = label;
+  } else if (name) {
+    variables.label = String(name);
+  }
+  if (messageVariables) {
+    variables = Object.assign(Object.assign({}, variables), messageVariables);
+  }
+  // >>>>> With Field
+  return wrapCSSVar(/*#__PURE__*/React.createElement(Field, Object.assign({}, props, {
+    messageVariables: variables,
+    trigger: trigger,
+    validateTrigger: mergedValidateTrigger,
+    onMetaChange: onMetaChange
+  }), (control, renderMeta, context) => {
+    const mergedName = toArray(name).length && renderMeta ? renderMeta.name : [];
+    const fieldId = getFieldId(mergedName, formName);
+    const isRequired = required !== undefined ? required : !!(rules === null || rules === void 0 ? void 0 : rules.some(rule => {
+      if (rule && typeof rule === 'object' && rule.required && !rule.warningOnly) {
+        return true;
+      }
+      if (typeof rule === 'function') {
+        const ruleEntity = rule(context);
+        return (ruleEntity === null || ruleEntity === void 0 ? void 0 : ruleEntity.required) && !(ruleEntity === null || ruleEntity === void 0 ? void 0 : ruleEntity.warningOnly);
+      }
+      return false;
+    }));
+    // ======================= Children =======================
+    const mergedControl = Object.assign({}, control);
+    let childNode = null;
+    process.env.NODE_ENV !== "production" ? warning(!(shouldUpdate && dependencies), 'usage', "`shouldUpdate` and `dependencies` shouldn't be used together. See https://u.ant.design/form-deps.") : void 0;
+    if (Array.isArray(mergedChildren) && hasName) {
+      process.env.NODE_ENV !== "production" ? warning(false, 'usage', 'A `Form.Item` with a `name` prop must have a single child element. For information on how to render more complex form items, see https://u.ant.design/complex-form-item.') : void 0;
+      childNode = mergedChildren;
+    } else if (isRenderProps && (!(shouldUpdate || dependencies) || hasName)) {
+      process.env.NODE_ENV !== "production" ? warning(!!(shouldUpdate || dependencies), 'usage', 'A `Form.Item` with a render function must have either `shouldUpdate` or `dependencies`.') : void 0;
+      process.env.NODE_ENV !== "production" ? warning(!hasName, 'usage', 'A `Form.Item` with a render function cannot be a field, and thus cannot have a `name` prop.') : void 0;
+    } else if (dependencies && !isRenderProps && !hasName) {
+      process.env.NODE_ENV !== "production" ? warning(false, 'usage', 'Must set `name` or use a render function when `dependencies` is set.') : void 0;
+    } else if (/*#__PURE__*/React.isValidElement(mergedChildren)) {
+      process.env.NODE_ENV !== "production" ? warning(mergedChildren.props.defaultValue === undefined, 'usage', '`defaultValue` will not work on controlled Field. You should use `initialValues` of Form instead.') : void 0;
+      const childProps = Object.assign(Object.assign({}, mergedChildren.props), mergedControl);
+      if (!childProps.id) {
+        childProps.id = fieldId;
+      }
+      if (help || mergedErrors.length > 0 || mergedWarnings.length > 0 || props.extra) {
+        const describedbyArr = [];
+        if (help || mergedErrors.length > 0) {
+          describedbyArr.push(`${fieldId}_help`);
+        }
+        if (props.extra) {
+          describedbyArr.push(`${fieldId}_extra`);
+        }
+        childProps['aria-describedby'] = describedbyArr.join(' ');
+      }
+      if (mergedErrors.length > 0) {
+        childProps['aria-invalid'] = 'true';
+      }
+      if (isRequired) {
+        childProps['aria-required'] = 'true';
+      }
+      if (supportRef(mergedChildren)) {
+        childProps.ref = getItemRef(mergedName, mergedChildren);
+      }
+      // We should keep user origin event handler
+      const triggers = new Set([].concat(_toConsumableArray(toArray(trigger)), _toConsumableArray(toArray(mergedValidateTrigger))));
+      triggers.forEach(eventName => {
+        childProps[eventName] = (...args) => {
+          var _a2, _c2;
+          var _a, _b, _c;
+          (_a = mergedControl[eventName]) === null || _a === void 0 ? void 0 : (_a2 = _a).call.apply(_a2, [mergedControl].concat(args));
+          (_c = (_b = mergedChildren.props)[eventName]) === null || _c === void 0 ? void 0 : (_c2 = _c).call.apply(_c2, [_b].concat(args));
+        };
+      });
+      // List of props that need to be watched for changes -> if changes are detected in MemoInput -> rerender
+      const watchingChildProps = [childProps['aria-required'], childProps['aria-invalid'], childProps['aria-describedby']];
+      childNode = /*#__PURE__*/React.createElement(MemoInput, {
+        control: mergedControl,
+        update: mergedChildren,
+        childProps: watchingChildProps
+      }, cloneElement(mergedChildren, childProps));
+    } else if (isRenderProps && (shouldUpdate || dependencies) && !hasName) {
+      childNode = mergedChildren(context);
+    } else {
+      process.env.NODE_ENV !== "production" ? warning(!mergedName.length || !!noStyle, 'usage', '`name` is only used for validate React element. If you are using Form.Item as layout display, please remove `name` instead.') : void 0;
+      childNode = mergedChildren;
+    }
+    return renderLayout(childNode, fieldId, isRequired);
+  }));
+}
+const FormItem = InternalFormItem;
+FormItem.useStatus = useFormItemStatus;
+export default FormItem;

node_modules/antd/es/form/FormItemInput.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import type { ColProps } from '../grid/col';
+import type { ValidateStatus } from './FormItem';
+interface FormItemInputMiscProps {
+    prefixCls: string;
+    children: React.ReactNode;
+    errors: React.ReactNode[];
+    warnings: React.ReactNode[];
+    marginBottom?: number | null;
+    onErrorVisibleChanged?: (visible: boolean) => void;
+}
+export interface FormItemInputProps {
+    labelCol?: ColProps;
+    wrapperCol?: ColProps;
+    extra?: React.ReactNode;
+    status?: ValidateStatus;
+    help?: React.ReactNode;
+    fieldId?: string;
+    label?: React.ReactNode;
+}
+declare const FormItemInput: React.FC<FormItemInputProps & FormItemInputMiscProps>;
+export default FormItemInput;

node_modules/antd/es/form/FormItemInput.js

@@ -0,0 +1,124 @@
+"use client";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import * as React from 'react';
+import classNames from 'classnames';
+import { get, set } from 'rc-util';
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+import Col from '../grid/col';
+import { FormContext, FormItemPrefixContext } from './context';
+import ErrorList from './ErrorList';
+import FallbackCmp from './style/fallbackCmp';
+const GRID_MAX = 24;
+const FormItemInput = props => {
+  const {
+    prefixCls,
+    status,
+    labelCol,
+    wrapperCol,
+    children,
+    errors,
+    warnings,
+    _internalItemRender: formItemRender,
+    extra,
+    help,
+    fieldId,
+    marginBottom,
+    onErrorVisibleChanged,
+    label
+  } = props;
+  const baseClassName = `${prefixCls}-item`;
+  const formContext = React.useContext(FormContext);
+  const mergedWrapperCol = React.useMemo(() => {
+    let mergedWrapper = Object.assign({}, wrapperCol || formContext.wrapperCol || {});
+    if (label === null && !labelCol && !wrapperCol && formContext.labelCol) {
+      const list = [undefined, 'xs', 'sm', 'md', 'lg', 'xl', 'xxl'];
+      list.forEach(size => {
+        const _size = size ? [size] : [];
+        const formLabel = get(formContext.labelCol, _size);
+        const formLabelObj = typeof formLabel === 'object' ? formLabel : {};
+        const wrapper = get(mergedWrapper, _size);
+        const wrapperObj = typeof wrapper === 'object' ? wrapper : {};
+        if ('span' in formLabelObj && !('offset' in wrapperObj) && formLabelObj.span < GRID_MAX) {
+          mergedWrapper = set(mergedWrapper, [].concat(_size, ['offset']), formLabelObj.span);
+        }
+      });
+    }
+    return mergedWrapper;
+  }, [wrapperCol, formContext.wrapperCol, formContext.labelCol, label, labelCol]);
+  const className = classNames(`${baseClassName}-control`, mergedWrapperCol.className);
+  // Pass to sub FormItem should not with col info
+  const subFormContext = React.useMemo(() => {
+    const {
+        labelCol: _labelCol,
+        wrapperCol: _wrapperCol
+      } = formContext,
+      rest = __rest(formContext, ["labelCol", "wrapperCol"]);
+    return rest;
+  }, [formContext]);
+  const extraRef = React.useRef(null);
+  const [extraHeight, setExtraHeight] = React.useState(0);
+  useLayoutEffect(() => {
+    if (extra && extraRef.current) {
+      setExtraHeight(extraRef.current.clientHeight);
+    } else {
+      setExtraHeight(0);
+    }
+  }, [extra]);
+  const inputDom = /*#__PURE__*/React.createElement("div", {
+    className: `${baseClassName}-control-input`
+  }, /*#__PURE__*/React.createElement("div", {
+    className: `${baseClassName}-control-input-content`
+  }, children));
+  const formItemContext = React.useMemo(() => ({
+    prefixCls,
+    status
+  }), [prefixCls, status]);
+  const errorListDom = marginBottom !== null || errors.length || warnings.length ? (/*#__PURE__*/React.createElement(FormItemPrefixContext.Provider, {
+    value: formItemContext
+  }, /*#__PURE__*/React.createElement(ErrorList, {
+    fieldId: fieldId,
+    errors: errors,
+    warnings: warnings,
+    help: help,
+    helpStatus: status,
+    className: `${baseClassName}-explain-connected`,
+    onVisibleChanged: onErrorVisibleChanged
+  }))) : null;
+  const extraProps = {};
+  if (fieldId) {
+    extraProps.id = `${fieldId}_extra`;
+  }
+  // If extra = 0, && will goes wrong
+  // 0&&error -> 0
+  const extraDom = extra ? (/*#__PURE__*/React.createElement("div", Object.assign({}, extraProps, {
+    className: `${baseClassName}-extra`,
+    ref: extraRef
+  }), extra)) : null;
+  const additionalDom = errorListDom || extraDom ? (/*#__PURE__*/React.createElement("div", {
+    className: `${baseClassName}-additional`,
+    style: marginBottom ? {
+      minHeight: marginBottom + extraHeight
+    } : {}
+  }, errorListDom, extraDom)) : null;
+  const dom = formItemRender && formItemRender.mark === 'pro_table_render' && formItemRender.render ? formItemRender.render(props, {
+    input: inputDom,
+    errorList: errorListDom,
+    extra: extraDom
+  }) : (/*#__PURE__*/React.createElement(React.Fragment, null, inputDom, additionalDom));
+  return /*#__PURE__*/React.createElement(FormContext.Provider, {
+    value: subFormContext
+  }, /*#__PURE__*/React.createElement(Col, Object.assign({}, mergedWrapperCol, {
+    className: className
+  }), dom), /*#__PURE__*/React.createElement(FallbackCmp, {
+    prefixCls: prefixCls
+  }));
+};
+export default FormItemInput;

node_modules/antd/es/form/FormItemLabel.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import type { ColProps } from '../grid/col';
+import type { TooltipProps } from '../tooltip';
+import type { FormLabelAlign } from './interface';
+export type WrapperTooltipProps = TooltipProps & {
+    icon?: React.ReactElement;
+};
+export type LabelTooltipType = WrapperTooltipProps | React.ReactNode;
+export interface FormItemLabelProps {
+    colon?: boolean;
+    htmlFor?: string;
+    label?: React.ReactNode;
+    labelAlign?: FormLabelAlign;
+    labelCol?: ColProps;
+    tooltip?: LabelTooltipType;
+    vertical?: boolean;
+}
+declare const FormItemLabel: React.FC<FormItemLabelProps & {
+    required?: boolean;
+    prefixCls: string;
+}>;
+export default FormItemLabel;

node_modules/antd/es/form/FormItemLabel.js

@@ -0,0 +1,110 @@
+"use client";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import * as React from 'react';
+import QuestionCircleOutlined from "@ant-design/icons/es/icons/QuestionCircleOutlined";
+import classNames from 'classnames';
+import convertToTooltipProps from '../_util/convertToTooltipProps';
+import Col from '../grid/col';
+import { useLocale } from '../locale';
+import defaultLocale from '../locale/en_US';
+import Tooltip from '../tooltip';
+import { FormContext } from './context';
+const FormItemLabel = ({
+  prefixCls,
+  label,
+  htmlFor,
+  labelCol,
+  labelAlign,
+  colon,
+  required,
+  requiredMark,
+  tooltip,
+  vertical
+}) => {
+  var _a;
+  const [formLocale] = useLocale('Form');
+  const {
+    labelAlign: contextLabelAlign,
+    labelCol: contextLabelCol,
+    labelWrap,
+    colon: contextColon
+  } = React.useContext(FormContext);
+  if (!label) {
+    return null;
+  }
+  const mergedLabelCol = labelCol || contextLabelCol || {};
+  const mergedLabelAlign = labelAlign || contextLabelAlign;
+  const labelClsBasic = `${prefixCls}-item-label`;
+  const labelColClassName = classNames(labelClsBasic, mergedLabelAlign === 'left' && `${labelClsBasic}-left`, mergedLabelCol.className, {
+    [`${labelClsBasic}-wrap`]: !!labelWrap
+  });
+  let labelChildren = label;
+  // Keep label is original where there should have no colon
+  const computedColon = colon === true || contextColon !== false && colon !== false;
+  const haveColon = computedColon && !vertical;
+  // Remove duplicated user input colon
+  if (haveColon && typeof label === 'string' && label.trim()) {
+    labelChildren = label.replace(/[:|：]\s*$/, '');
+  }
+  // Tooltip
+  const tooltipProps = convertToTooltipProps(tooltip);
+  if (tooltipProps) {
+    const {
+        icon = /*#__PURE__*/React.createElement(QuestionCircleOutlined, null)
+      } = tooltipProps,
+      restTooltipProps = __rest(tooltipProps, ["icon"]);
+    const tooltipNode = /*#__PURE__*/React.createElement(Tooltip, Object.assign({}, restTooltipProps), /*#__PURE__*/React.cloneElement(icon, {
+      className: `${prefixCls}-item-tooltip`,
+      title: '',
+      onClick: e => {
+        // Prevent label behavior in tooltip icon
+        // https://github.com/ant-design/ant-design/issues/46154
+        e.preventDefault();
+      },
+      tabIndex: null
+    }));
+    labelChildren = /*#__PURE__*/React.createElement(React.Fragment, null, labelChildren, tooltipNode);
+  }
+  // Required Mark
+  const isOptionalMark = requiredMark === 'optional';
+  const isRenderMark = typeof requiredMark === 'function';
+  const hideRequiredMark = requiredMark === false;
+  if (isRenderMark) {
+    labelChildren = requiredMark(labelChildren, {
+      required: !!required
+    });
+  } else if (isOptionalMark && !required) {
+    labelChildren = /*#__PURE__*/React.createElement(React.Fragment, null, labelChildren, /*#__PURE__*/React.createElement("span", {
+      className: `${prefixCls}-item-optional`,
+      title: ""
+    }, (formLocale === null || formLocale === void 0 ? void 0 : formLocale.optional) || ((_a = defaultLocale.Form) === null || _a === void 0 ? void 0 : _a.optional)));
+  }
+  // https://github.com/ant-design/ant-design/pull/52950#discussion_r1980880316
+  let markType;
+  if (hideRequiredMark) {
+    markType = 'hidden';
+  } else if (isOptionalMark || isRenderMark) {
+    markType = 'optional';
+  }
+  const labelClassName = classNames({
+    [`${prefixCls}-item-required`]: required,
+    [`${prefixCls}-item-required-mark-${markType}`]: markType,
+    [`${prefixCls}-item-no-colon`]: !computedColon
+  });
+  return /*#__PURE__*/React.createElement(Col, Object.assign({}, mergedLabelCol, {
+    className: labelColClassName
+  }), /*#__PURE__*/React.createElement("label", {
+    htmlFor: htmlFor,
+    className: labelClassName,
+    title: typeof label === 'string' ? label : ''
+  }, labelChildren));
+};
+export default FormItemLabel;

node_modules/antd/es/form/FormList.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import type { StoreValue, ValidatorRule } from 'rc-field-form/lib/interface';
+export interface FormListFieldData {
+    name: number;
+    key: number;
+    /** @deprecated No need anymore Use key instead */
+    fieldKey?: number;
+}
+export interface FormListOperation {
+    add: (defaultValue?: StoreValue, insertIndex?: number) => void;
+    remove: (index: number | number[]) => void;
+    move: (from: number, to: number) => void;
+}
+export interface FormListProps {
+    prefixCls?: string;
+    name: string | number | (string | number)[];
+    rules?: ValidatorRule[];
+    initialValue?: any[];
+    children: (fields: FormListFieldData[], operation: FormListOperation, meta: {
+        errors: React.ReactNode[];
+        warnings: React.ReactNode[];
+    }) => React.ReactNode;
+}
+declare const FormList: React.FC<FormListProps>;
+export default FormList;

node_modules/antd/es/form/FormList.js

@@ -0,0 +1,43 @@
+"use client";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import * as React from 'react';
+import { List } from 'rc-field-form';
+import { devUseWarning } from '../_util/warning';
+import { ConfigContext } from '../config-provider';
+import { FormItemPrefixContext } from './context';
+const FormList = _a => {
+  var {
+      prefixCls: customizePrefixCls,
+      children
+    } = _a,
+    props = __rest(_a, ["prefixCls", "children"]);
+  if (process.env.NODE_ENV !== 'production') {
+    const warning = devUseWarning('Form.List');
+    process.env.NODE_ENV !== "production" ? warning(typeof props.name === 'number' || (Array.isArray(props.name) ? !!props.name.length : !!props.name), 'usage', 'Miss `name` prop.') : void 0;
+  }
+  const {
+    getPrefixCls
+  } = React.useContext(ConfigContext);
+  const prefixCls = getPrefixCls('form', customizePrefixCls);
+  const contextValue = React.useMemo(() => ({
+    prefixCls,
+    status: 'error'
+  }), [prefixCls]);
+  return /*#__PURE__*/React.createElement(List, Object.assign({}, props), (fields, operation, meta) => (/*#__PURE__*/React.createElement(FormItemPrefixContext.Provider, {
+    value: contextValue
+  }, children(fields.map(field => Object.assign(Object.assign({}, field), {
+    fieldKey: field.key
+  })), operation, {
+    errors: meta.errors,
+    warnings: meta.warnings
+  }))));
+};
+export default FormList;

node_modules/antd/es/form/context.d.ts

@@ -0,0 +1,53 @@
+import type { PropsWithChildren, ReactNode } from 'react';
+import * as React from 'react';
+import type { FormProviderProps as RcFormProviderProps } from 'rc-field-form/lib/FormContext';
+import type { Meta } from 'rc-field-form/lib/interface';
+import type { ColProps } from '../grid/col';
+import type { FormInstance, FormLayout, RequiredMark } from './Form';
+import type { FeedbackIcons, ValidateStatus } from './FormItem';
+import type { FormLabelAlign, NamePath } from './interface';
+/** Form Context. Set top form style and pass to Form Item usage. */
+export interface FormContextProps {
+    layout: FormLayout;
+    name?: string;
+    colon?: boolean;
+    labelAlign?: FormLabelAlign;
+    labelWrap?: boolean;
+    labelCol?: ColProps;
+    wrapperCol?: ColProps;
+    requiredMark?: RequiredMark;
+    itemRef: (name: (string | number)[]) => (node: React.ReactElement) => void;
+    form?: FormInstance;
+    feedbackIcons?: FeedbackIcons;
+}
+export declare const FormContext: React.Context<FormContextProps>;
+/** `noStyle` Form Item Context. Used for error collection */
+export type ReportMetaChange = (meta: Meta, uniqueKeys: React.Key[]) => void;
+export declare const NoStyleItemContext: React.Context<ReportMetaChange | null>;
+/** Form Provider */
+export interface FormProviderProps extends Omit<RcFormProviderProps, 'validateMessages'> {
+    prefixCls?: string;
+}
+export declare const FormProvider: React.FC<FormProviderProps>;
+/** Used for ErrorList only */
+export interface FormItemPrefixContextProps {
+    prefixCls: string;
+    status?: ValidateStatus;
+}
+export declare const FormItemPrefixContext: React.Context<FormItemPrefixContextProps>;
+export interface FormItemStatusContextProps {
+    isFormItemInput?: boolean;
+    status?: ValidateStatus;
+    errors?: React.ReactNode[];
+    warnings?: React.ReactNode[];
+    hasFeedback?: boolean;
+    feedbackIcon?: ReactNode;
+    name?: NamePath;
+}
+export declare const FormItemInputContext: React.Context<FormItemStatusContextProps>;
+export type NoFormStyleProps = PropsWithChildren<{
+    status?: boolean;
+    override?: boolean;
+}>;
+export declare const NoFormStyle: React.FC<NoFormStyleProps>;
+export declare const VariantContext: React.Context<"filled" | "outlined" | "borderless" | "underlined" | undefined>;

node_modules/antd/es/form/context.js

@@ -0,0 +1,45 @@
+"use client";
+
+import * as React from 'react';
+import { FormProvider as RcFormProvider } from 'rc-field-form';
+import omit from "rc-util/es/omit";
+export const FormContext = /*#__PURE__*/React.createContext({
+  labelAlign: 'right',
+  layout: 'horizontal',
+  itemRef: () => {}
+});
+export const NoStyleItemContext = /*#__PURE__*/React.createContext(null);
+export const FormProvider = props => {
+  const providerProps = omit(props, ['prefixCls']);
+  return /*#__PURE__*/React.createElement(RcFormProvider, Object.assign({}, providerProps));
+};
+export const FormItemPrefixContext = /*#__PURE__*/React.createContext({
+  prefixCls: ''
+});
+export const FormItemInputContext = /*#__PURE__*/React.createContext({});
+if (process.env.NODE_ENV !== 'production') {
+  FormItemInputContext.displayName = 'FormItemInputContext';
+}
+export const NoFormStyle = ({
+  children,
+  status,
+  override
+}) => {
+  const formItemInputContext = React.useContext(FormItemInputContext);
+  const newFormItemInputContext = React.useMemo(() => {
+    const newContext = Object.assign({}, formItemInputContext);
+    if (override) {
+      delete newContext.isFormItemInput;
+    }
+    if (status) {
+      delete newContext.status;
+      delete newContext.hasFeedback;
+      delete newContext.feedbackIcon;
+    }
+    return newContext;
+  }, [status, override, formItemInputContext]);
+  return /*#__PURE__*/React.createElement(FormItemInputContext.Provider, {
+    value: newFormItemInputContext
+  }, children);
+};
+export const VariantContext = /*#__PURE__*/React.createContext(undefined);

node_modules/antd/es/form/hooks/useChildren.d.ts

@@ -0,0 +1,2 @@
+import type { FormItemProps } from '../FormItem';
+export default function useChildren(children?: FormItemProps['children']): FormItemProps['children'];

node_modules/antd/es/form/hooks/useChildren.js

@@ -0,0 +1,8 @@
+import toArray from "rc-util/es/Children/toArray";
+export default function useChildren(children) {
+  if (typeof children === 'function') {
+    return children;
+  }
+  const childList = toArray(children);
+  return childList.length <= 1 ? childList[0] : childList;
+}

node_modules/antd/es/form/hooks/useDebounce.d.ts

@@ -0,0 +1 @@
+export default function useDebounce<T>(value: T[]): T[];

node_modules/antd/es/form/hooks/useDebounce.js

@@ -0,0 +1,13 @@
+import * as React from 'react';
+export default function useDebounce(value) {
+  const [cacheValue, setCacheValue] = React.useState(value);
+  React.useEffect(() => {
+    const timeout = setTimeout(() => {
+      setCacheValue(value);
+    }, value.length ? 0 : 10);
+    return () => {
+      clearTimeout(timeout);
+    };
+  }, [value]);
+  return cacheValue;
+}

node_modules/antd/es/form/hooks/useForm.d.ts

@@ -0,0 +1,9 @@
+import type { FormInstance as RcFormInstance } from 'rc-field-form';
+import type { NamePath, ScrollOptions } from '../interface';
+export interface FormInstance<Values = any> extends RcFormInstance<Values> {
+    scrollToField: (name: NamePath, options?: ScrollOptions) => void;
+    focusField: (name: NamePath) => void;
+    getFieldInstance: (name: NamePath) => any;
+}
+export declare function toNamePathStr(name: NamePath): string;
+export default function useForm<Values = any>(form?: FormInstance<Values>): [FormInstance<Values>];

node_modules/antd/es/form/hooks/useForm.js

@@ -0,0 +1,75 @@
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import * as React from 'react';
+import { useForm as useRcForm } from 'rc-field-form';
+import { getDOM } from "rc-util/es/Dom/findDOMNode";
+import scrollIntoView from 'scroll-into-view-if-needed';
+import { getFieldId, toArray } from '../util';
+export function toNamePathStr(name) {
+  const namePath = toArray(name);
+  return namePath.join('_');
+}
+function getFieldDOMNode(name, wrapForm) {
+  const field = wrapForm.getFieldInstance(name);
+  const fieldDom = getDOM(field);
+  if (fieldDom) {
+    return fieldDom;
+  }
+  const fieldId = getFieldId(toArray(name), wrapForm.__INTERNAL__.name);
+  if (fieldId) {
+    return document.getElementById(fieldId);
+  }
+}
+export default function useForm(form) {
+  const [rcForm] = useRcForm();
+  const itemsRef = React.useRef({});
+  const wrapForm = React.useMemo(() => form !== null && form !== void 0 ? form : Object.assign(Object.assign({}, rcForm), {
+    __INTERNAL__: {
+      itemRef: name => node => {
+        const namePathStr = toNamePathStr(name);
+        if (node) {
+          itemsRef.current[namePathStr] = node;
+        } else {
+          delete itemsRef.current[namePathStr];
+        }
+      }
+    },
+    scrollToField: (name, options = {}) => {
+      const {
+          focus
+        } = options,
+        restOpt = __rest(options, ["focus"]);
+      const node = getFieldDOMNode(name, wrapForm);
+      if (node) {
+        scrollIntoView(node, Object.assign({
+          scrollMode: 'if-needed',
+          block: 'nearest'
+        }, restOpt));
+        // Focus if scroll success
+        if (focus) {
+          wrapForm.focusField(name);
+        }
+      }
+    },
+    focusField: name => {
+      var _a, _b;
+      const itemRef = wrapForm.getFieldInstance(name);
+      if (typeof (itemRef === null || itemRef === void 0 ? void 0 : itemRef.focus) === 'function') {
+        itemRef.focus();
+      } else {
+        (_b = (_a = getFieldDOMNode(name, wrapForm)) === null || _a === void 0 ? void 0 : _a.focus) === null || _b === void 0 ? void 0 : _b.call(_a);
+      }
+    },
+    getFieldInstance: name => {
+      const namePathStr = toNamePathStr(name);
+      return itemsRef.current[namePathStr];
+    }
+  }), [form, rcForm]);
+  return [wrapForm];
+}

node_modules/antd/es/form/hooks/useFormInstance.d.ts

@@ -0,0 +1,2 @@
+import type { FormInstance } from './useForm';
+export default function useFormInstance<Value = any>(): FormInstance<Value>;

node_modules/antd/es/form/hooks/useFormInstance.js

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { FormContext } from '../context';
+export default function useFormInstance() {
+  const {
+    form
+  } = React.useContext(FormContext);
+  return form;
+}

node_modules/antd/es/form/hooks/useFormItemStatus.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { ValidateStatus } from 'antd/es/form/FormItem';
+type UseFormItemStatus = () => {
+    status?: ValidateStatus;
+    errors: React.ReactNode[];
+    warnings: React.ReactNode[];
+};
+declare const useFormItemStatus: UseFormItemStatus;
+export default useFormItemStatus;

node_modules/antd/es/form/hooks/useFormItemStatus.js

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { devUseWarning } from '../../_util/warning';
+import { FormItemInputContext } from '../context';
+const useFormItemStatus = () => {
+  const {
+    status,
+    errors = [],
+    warnings = []
+  } = React.useContext(FormItemInputContext);
+  if (process.env.NODE_ENV !== 'production') {
+    const warning = devUseWarning('Form.Item');
+    process.env.NODE_ENV !== "production" ? warning(status !== undefined, 'usage', 'Form.Item.useStatus should be used under Form.Item component. For more information: https://u.ant.design/form-item-usestatus') : void 0;
+  }
+  return {
+    status,
+    errors,
+    warnings
+  };
+};
+// Only used for compatible package. Not promise this will work on future version.
+useFormItemStatus.Context = FormItemInputContext;
+export default useFormItemStatus;

node_modules/antd/es/form/hooks/useFormWarning.d.ts

@@ -0,0 +1,2 @@
+import type { FormProps } from '../Form';
+export default function useFormWarning({ name }: FormProps): void;

node_modules/antd/es/form/hooks/useFormWarning.js

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { devUseWarning } from '../../_util/warning';
+const names = {};
+export default function useFormWarning({
+  name
+}) {
+  const warning = devUseWarning('Form');
+  React.useEffect(() => {
+    if (name) {
+      names[name] = (names[name] || 0) + 1;
+      process.env.NODE_ENV !== "production" ? warning(names[name] <= 1, 'usage', 'There exist multiple Form with same `name`.') : void 0;
+      return () => {
+        names[name] -= 1;
+      };
+    }
+  }, [name]);
+}

node_modules/antd/es/form/hooks/useFrameState.d.ts

@@ -0,0 +1,3 @@
+type Updater<ValueType> = (prev?: ValueType) => ValueType;
+export default function useFrameState<ValueType>(defaultValue: ValueType): [ValueType, (updater: Updater<ValueType>) => void];
+export {};

node_modules/antd/es/form/hooks/useFrameState.js

@@ -0,0 +1,36 @@
+import * as React from 'react';
+import raf from "rc-util/es/raf";
+export default function useFrameState(defaultValue) {
+  const [value, setValue] = React.useState(defaultValue);
+  const frameRef = React.useRef(null);
+  const batchRef = React.useRef([]);
+  const destroyRef = React.useRef(false);
+  React.useEffect(() => {
+    destroyRef.current = false;
+    return () => {
+      destroyRef.current = true;
+      raf.cancel(frameRef.current);
+      frameRef.current = null;
+    };
+  }, []);
+  function setFrameValue(updater) {
+    if (destroyRef.current) {
+      return;
+    }
+    if (frameRef.current === null) {
+      batchRef.current = [];
+      frameRef.current = raf(() => {
+        frameRef.current = null;
+        setValue(prevValue => {
+          let current = prevValue;
+          batchRef.current.forEach(func => {
+            current = func(current);
+          });
+          return current;
+        });
+      });
+    }
+    batchRef.current.push(updater);
+  }
+  return [value, setFrameValue];
+}

node_modules/antd/es/form/hooks/useItemRef.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import type { InternalNamePath } from '../interface';
+export default function useItemRef(): (name: InternalNamePath, children: any) => React.Ref<any> | undefined;

node_modules/antd/es/form/hooks/useItemRef.js

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { composeRef, getNodeRef } from "rc-util/es/ref";
+import { FormContext } from '../context';
+export default function useItemRef() {
+  const {
+    itemRef
+  } = React.useContext(FormContext);
+  const cacheRef = React.useRef({});
+  function getRef(name, children) {
+    // Outer caller already check the `supportRef`
+    const childrenRef = children && typeof children === 'object' && getNodeRef(children);
+    const nameStr = name.join('_');
+    if (cacheRef.current.name !== nameStr || cacheRef.current.originRef !== childrenRef) {
+      cacheRef.current.name = nameStr;
+      cacheRef.current.originRef = childrenRef;
+      cacheRef.current.ref = composeRef(itemRef(name), childrenRef);
+    }
+    return cacheRef.current.ref;
+  }
+  return getRef;
+}

node_modules/antd/es/form/hooks/useVariants.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigProviderProps, Variant } from '../../config-provider';
+type VariantComponents = keyof Pick<ConfigProviderProps, 'input' | 'inputNumber' | 'textArea' | 'mentions' | 'select' | 'cascader' | 'treeSelect' | 'datePicker' | 'timePicker' | 'rangePicker' | 'card'>;
+/**
+ * Compatible for legacy `bordered` prop.
+ */
+declare const useVariant: (component: VariantComponents, variant?: Variant, legacyBordered?: boolean) => [Variant, boolean];
+export default useVariant;

node_modules/antd/es/form/hooks/useVariants.js

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { ConfigContext, Variants } from '../../config-provider';
+import { VariantContext } from '../context';
+/**
+ * Compatible for legacy `bordered` prop.
+ */
+const useVariant = (component, variant, legacyBordered) => {
+  var _a, _b;
+  const {
+    variant: configVariant,
+    [component]: componentConfig
+  } = React.useContext(ConfigContext);
+  const ctxVariant = React.useContext(VariantContext);
+  const configComponentVariant = componentConfig === null || componentConfig === void 0 ? void 0 : componentConfig.variant;
+  let mergedVariant;
+  if (typeof variant !== 'undefined') {
+    mergedVariant = variant;
+  } else if (legacyBordered === false) {
+    mergedVariant = 'borderless';
+  } else {
+    // form variant > component global variant > global variant
+    mergedVariant = (_b = (_a = ctxVariant !== null && ctxVariant !== void 0 ? ctxVariant : configComponentVariant) !== null && _a !== void 0 ? _a : configVariant) !== null && _b !== void 0 ? _b : 'outlined';
+  }
+  const enableVariantCls = Variants.includes(mergedVariant);
+  return [mergedVariant, enableVariantCls];
+};
+export default useVariant;

node_modules/antd/es/form/index.d.ts

@@ -0,0 +1,26 @@
+import type { Rule, RuleObject, RuleRender } from 'rc-field-form/lib/interface';
+import { FormProvider } from './context';
+import ErrorList from './ErrorList';
+import type { ErrorListProps } from './ErrorList';
+import InternalForm, { useForm, useWatch } from './Form';
+import type { FormInstance, FormProps } from './Form';
+import Item from './FormItem';
+import type { FormItemProps } from './FormItem';
+import List from './FormList';
+import type { FormListFieldData, FormListOperation, FormListProps } from './FormList';
+import useFormInstance from './hooks/useFormInstance';
+type InternalFormType = typeof InternalForm;
+type CompoundedComponent = InternalFormType & {
+    useForm: typeof useForm;
+    useFormInstance: typeof useFormInstance;
+    useWatch: typeof useWatch;
+    Item: typeof Item;
+    List: typeof List;
+    ErrorList: typeof ErrorList;
+    Provider: typeof FormProvider;
+    /** @deprecated Only for warning usage. Do not use. */
+    create: () => void;
+};
+declare const Form: CompoundedComponent;
+export type { ErrorListProps, FormInstance, FormItemProps, FormListFieldData, FormListOperation, FormListProps, FormProps, Rule, RuleObject, RuleRender, };
+export default Form;

node_modules/antd/es/form/index.js

@@ -0,0 +1,21 @@
+"use client";
+
+import warning from '../_util/warning';
+import { FormProvider } from './context';
+import ErrorList from './ErrorList';
+import InternalForm, { useForm, useWatch } from './Form';
+import Item from './FormItem';
+import List from './FormList';
+import useFormInstance from './hooks/useFormInstance';
+const Form = InternalForm;
+Form.Item = Item;
+Form.List = List;
+Form.ErrorList = ErrorList;
+Form.useForm = useForm;
+Form.useFormInstance = useFormInstance;
+Form.useWatch = useWatch;
+Form.Provider = FormProvider;
+Form.create = () => {
+  process.env.NODE_ENV !== "production" ? warning(false, 'Form', 'antd v4 removed `Form.create`. Please remove or use `@ant-design/compatible` instead.') : void 0;
+};
+export default Form;

node_modules/antd/es/form/interface.d.ts

@@ -0,0 +1,7 @@
+import type { Options } from 'scroll-into-view-if-needed';
+export type { InternalNamePath, NamePath, Store, StoreValue } from 'rc-field-form/lib/interface';
+export type ScrollFocusOptions = Options & {
+    focus?: boolean;
+};
+export type ScrollOptions = ScrollFocusOptions;
+export type FormLabelAlign = 'left' | 'right';

node_modules/antd/es/form/interface.js

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

node_modules/antd/es/form/style/explain.d.ts

@@ -0,0 +1,4 @@
+import type { FormToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genFormValidateMotionStyle: GenerateStyle<FormToken>;
+export default genFormValidateMotionStyle;

node_modules/antd/es/form/style/explain.js

@@ -0,0 +1,44 @@
+const genFormValidateMotionStyle = token => {
+  const {
+    componentCls
+  } = token;
+  const helpCls = `${componentCls}-show-help`;
+  const helpItemCls = `${componentCls}-show-help-item`;
+  return {
+    [helpCls]: {
+      // Explain holder
+      transition: `opacity ${token.motionDurationFast} ${token.motionEaseInOut}`,
+      '&-appear, &-enter': {
+        opacity: 0,
+        '&-active': {
+          opacity: 1
+        }
+      },
+      '&-leave': {
+        opacity: 1,
+        '&-active': {
+          opacity: 0
+        }
+      },
+      // Explain
+      [helpItemCls]: {
+        overflow: 'hidden',
+        transition: `height ${token.motionDurationFast} ${token.motionEaseInOut},
+                     opacity ${token.motionDurationFast} ${token.motionEaseInOut},
+                     transform ${token.motionDurationFast} ${token.motionEaseInOut} !important`,
+        [`&${helpItemCls}-appear, &${helpItemCls}-enter`]: {
+          transform: `translateY(-5px)`,
+          opacity: 0,
+          '&-active': {
+            transform: 'translateY(0)',
+            opacity: 1
+          }
+        },
+        [`&${helpItemCls}-leave-active`]: {
+          transform: `translateY(-5px)`
+        }
+      }
+    }
+  };
+};
+export default genFormValidateMotionStyle;

node_modules/antd/es/form/style/fallbackCmp.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fallback of IE.
+ * Safe to remove.
+ */
+declare const _default: import("react").FunctionComponent<import("@ant-design/cssinjs-utils/lib/util/genStyleUtils").SubStyleComponentProps>;
+export default _default;

node_modules/antd/es/form/style/fallbackCmp.js

@@ -0,0 +1,28 @@
+/**
+ * Fallback of IE.
+ * Safe to remove.
+ */
+// Style as inline component
+import { prepareToken } from '.';
+import { genSubStyleComponent } from '../../theme/internal';
+// ============================= Fallback =============================
+const genFallbackStyle = token => {
+  const {
+    formItemCls
+  } = token;
+  return {
+    '@media screen and (-ms-high-contrast: active), (-ms-high-contrast: none)': {
+      // Fallback for IE, safe to remove we not support it anymore
+      [`${formItemCls}-control`]: {
+        display: 'flex'
+      }
+    }
+  };
+};
+// ============================== Export ==============================
+export default genSubStyleComponent(['Form', 'item-item'], (token, {
+  rootPrefixCls
+}) => {
+  const formToken = prepareToken(token, rootPrefixCls);
+  return genFallbackStyle(formToken);
+});

node_modules/antd/es/form/style/index.d.ts

@@ -0,0 +1,74 @@
+import type { CSSProperties } from 'react';
+import type { FullToken, GenStyleFn, GetDefaultToken } from '../../theme/internal';
+export interface ComponentToken {
+    /**
+     * @desc 必填项标记颜色
+     * @descEN Required mark color
+     */
+    labelRequiredMarkColor: string;
+    /**
+     * @desc 标签颜色
+     * @descEN Label color
+     */
+    labelColor: string;
+    /**
+     * @desc 标签字体大小
+     * @descEN Label font size
+     */
+    labelFontSize: number;
+    /**
+     * @desc 标签高度
+     * @descEN Label height
+     */
+    labelHeight: number | string;
+    /**
+     * @desc 标签冒号前间距
+     * @descEN Label colon margin-inline-start
+     */
+    labelColonMarginInlineStart: number;
+    /**
+     * @desc 标签冒号后间距
+     * @descEN Label colon margin-inline-end
+     */
+    labelColonMarginInlineEnd: number;
+    /**
+     * @desc 表单项间距
+     * @descEN Form item margin bottom
+     */
+    itemMarginBottom: number;
+    /**
+     * @desc 行内布局表单项间距
+     * @descEN Inline layout form item margin bottom
+     */
+    inlineItemMarginBottom: number;
+    /**
+     * @desc 垂直布局标签内边距
+     * @descEN Vertical layout label padding
+     */
+    verticalLabelPadding: CSSProperties['padding'];
+    /**
+     * @desc 垂直布局标签外边距
+     * @descEN Vertical layout label margin
+     */
+    verticalLabelMargin: CSSProperties['margin'];
+}
+/**
+ * @desc Form 组件的 Token
+ * @descEN Token for Form component
+ */
+export interface FormToken extends FullToken<'Form'> {
+    /**
+     * @desc 表单项类名
+     * @descEN Form item class name
+     */
+    formItemCls: string;
+    /**
+     * @desc 根前缀类名
+     * @descEN Root prefix class name
+     */
+    rootPrefixCls: string;
+}
+export declare const prepareComponentToken: GetDefaultToken<'Form'>;
+export declare const prepareToken: (token: Parameters<GenStyleFn<'Form'>>[0], rootPrefixCls: string) => FormToken;
+declare const _default: (prefixCls: string, rootCls?: string) => readonly [(node: React.ReactElement) => React.ReactElement, string, string];
+export default _default;

node_modules/antd/es/form/style/index.js

@@ -0,0 +1,470 @@
+import { unit } from '@ant-design/cssinjs';
+import { resetComponent } from '../../style';
+import { genCollapseMotion, zoomIn } from '../../style/motion';
+import { genStyleHooks, mergeToken } from '../../theme/internal';
+import genFormValidateMotionStyle from './explain';
+const resetForm = token => ({
+  legend: {
+    display: 'block',
+    width: '100%',
+    marginBottom: token.marginLG,
+    padding: 0,
+    color: token.colorTextDescription,
+    fontSize: token.fontSizeLG,
+    lineHeight: 'inherit',
+    border: 0,
+    borderBottom: `${unit(token.lineWidth)} ${token.lineType} ${token.colorBorder}`
+  },
+  'input[type="search"]': {
+    boxSizing: 'border-box'
+  },
+  // Position radios and checkboxes better
+  'input[type="radio"], input[type="checkbox"]': {
+    lineHeight: 'normal'
+  },
+  'input[type="file"]': {
+    display: 'block'
+  },
+  // Make range inputs behave like textual form controls
+  'input[type="range"]': {
+    display: 'block',
+    width: '100%'
+  },
+  // Make multiple select elements height not fixed
+  'select[multiple], select[size]': {
+    height: 'auto'
+  },
+  // Focus for file, radio, and checkbox
+  [`input[type='file']:focus,
+  input[type='radio']:focus,
+  input[type='checkbox']:focus`]: {
+    outline: 0,
+    boxShadow: `0 0 0 ${unit(token.controlOutlineWidth)} ${token.controlOutline}`
+  },
+  // Adjust output element
+  output: {
+    display: 'block',
+    paddingTop: 15,
+    color: token.colorText,
+    fontSize: token.fontSize,
+    lineHeight: token.lineHeight
+  }
+});
+const genFormSize = (token, height) => {
+  const {
+    formItemCls
+  } = token;
+  return {
+    [formItemCls]: {
+      [`${formItemCls}-label > label`]: {
+        height
+      },
+      [`${formItemCls}-control-input`]: {
+        minHeight: height
+      }
+    }
+  };
+};
+const genFormStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [token.componentCls]: Object.assign(Object.assign(Object.assign({}, resetComponent(token)), resetForm(token)), {
+      [`${componentCls}-text`]: {
+        display: 'inline-block',
+        paddingInlineEnd: token.paddingSM
+      },
+      // ================================================================
+      // =                             Size                             =
+      // ================================================================
+      '&-small': Object.assign({}, genFormSize(token, token.controlHeightSM)),
+      '&-large': Object.assign({}, genFormSize(token, token.controlHeightLG))
+    })
+  };
+};
+const genFormItemStyle = token => {
+  const {
+    formItemCls,
+    iconCls,
+    rootPrefixCls,
+    antCls,
+    labelRequiredMarkColor,
+    labelColor,
+    labelFontSize,
+    labelHeight,
+    labelColonMarginInlineStart,
+    labelColonMarginInlineEnd,
+    itemMarginBottom
+  } = token;
+  return {
+    [formItemCls]: Object.assign(Object.assign({}, resetComponent(token)), {
+      marginBottom: itemMarginBottom,
+      verticalAlign: 'top',
+      '&-with-help': {
+        transition: 'none'
+      },
+      [`&-hidden,
+        &-hidden${antCls}-row`]: {
+        // https://github.com/ant-design/ant-design/issues/26141
+        display: 'none'
+      },
+      '&-has-warning': {
+        [`${formItemCls}-split`]: {
+          color: token.colorError
+        }
+      },
+      '&-has-error': {
+        [`${formItemCls}-split`]: {
+          color: token.colorWarning
+        }
+      },
+      // ==============================================================
+      // =                            Label                           =
+      // ==============================================================
+      [`${formItemCls}-label`]: {
+        flexGrow: 0,
+        overflow: 'hidden',
+        whiteSpace: 'nowrap',
+        textAlign: 'end',
+        verticalAlign: 'middle',
+        '&-left': {
+          textAlign: 'start'
+        },
+        '&-wrap': {
+          overflow: 'unset',
+          lineHeight: token.lineHeight,
+          whiteSpace: 'unset',
+          '> label': {
+            verticalAlign: 'middle',
+            textWrap: 'balance'
+          }
+        },
+        '> label': {
+          position: 'relative',
+          display: 'inline-flex',
+          alignItems: 'center',
+          maxWidth: '100%',
+          height: labelHeight,
+          color: labelColor,
+          fontSize: labelFontSize,
+          [`> ${iconCls}`]: {
+            fontSize: token.fontSize,
+            verticalAlign: 'top'
+          },
+          [`&${formItemCls}-required`]: {
+            '&::before': {
+              display: 'inline-block',
+              marginInlineEnd: token.marginXXS,
+              color: labelRequiredMarkColor,
+              fontSize: token.fontSize,
+              fontFamily: 'SimSun, sans-serif',
+              lineHeight: 1,
+              content: '"*"'
+            },
+            [`&${formItemCls}-required-mark-hidden, &${formItemCls}-required-mark-optional`]: {
+              '&::before': {
+                display: 'none'
+              }
+            }
+          },
+          // Optional mark
+          [`${formItemCls}-optional`]: {
+            display: 'inline-block',
+            marginInlineStart: token.marginXXS,
+            color: token.colorTextDescription,
+            [`&${formItemCls}-required-mark-hidden`]: {
+              display: 'none'
+            }
+          },
+          // Optional mark
+          [`${formItemCls}-tooltip`]: {
+            color: token.colorTextDescription,
+            cursor: 'help',
+            writingMode: 'horizontal-tb',
+            marginInlineStart: token.marginXXS
+          },
+          '&::after': {
+            content: '":"',
+            position: 'relative',
+            marginBlock: 0,
+            marginInlineStart: labelColonMarginInlineStart,
+            marginInlineEnd: labelColonMarginInlineEnd
+          },
+          [`&${formItemCls}-no-colon::after`]: {
+            content: '"\\a0"'
+          }
+        }
+      },
+      // ==============================================================
+      // =                            Input                           =
+      // ==============================================================
+      [`${formItemCls}-control`]: {
+        ['--ant-display']: 'flex',
+        flexDirection: 'column',
+        flexGrow: 1,
+        [`&:first-child:not([class^="'${rootPrefixCls}-col-'"]):not([class*="' ${rootPrefixCls}-col-'"])`]: {
+          width: '100%'
+        },
+        '&-input': {
+          position: 'relative',
+          display: 'flex',
+          alignItems: 'center',
+          minHeight: token.controlHeight,
+          '&-content': {
+            flex: 'auto',
+            maxWidth: '100%',
+            // Fix https://github.com/ant-design/ant-design/issues/54042
+            // Remove impact of whitespaces
+            [`&:has(> ${antCls}-switch:only-child, > ${antCls}-rate:only-child)`]: {
+              display: 'flex',
+              alignItems: 'center'
+            }
+          }
+        }
+      },
+      // ==============================================================
+      // =                           Explain                          =
+      // ==============================================================
+      [formItemCls]: {
+        '&-additional': {
+          display: 'flex',
+          flexDirection: 'column'
+        },
+        '&-explain, &-extra': {
+          clear: 'both',
+          color: token.colorTextDescription,
+          fontSize: token.fontSize,
+          lineHeight: token.lineHeight
+        },
+        '&-explain-connected': {
+          width: '100%'
+        },
+        '&-extra': {
+          minHeight: token.controlHeightSM,
+          transition: `color ${token.motionDurationMid} ${token.motionEaseOut}` // sync input color transition
+        },
+        '&-explain': {
+          '&-error': {
+            color: token.colorError
+          },
+          '&-warning': {
+            color: token.colorWarning
+          }
+        }
+      },
+      [`&-with-help ${formItemCls}-explain`]: {
+        height: 'auto',
+        opacity: 1
+      },
+      // ==============================================================
+      // =                        Feedback Icon                       =
+      // ==============================================================
+      [`${formItemCls}-feedback-icon`]: {
+        fontSize: token.fontSize,
+        textAlign: 'center',
+        visibility: 'visible',
+        animationName: zoomIn,
+        animationDuration: token.motionDurationMid,
+        animationTimingFunction: token.motionEaseOutBack,
+        pointerEvents: 'none',
+        '&-success': {
+          color: token.colorSuccess
+        },
+        '&-error': {
+          color: token.colorError
+        },
+        '&-warning': {
+          color: token.colorWarning
+        },
+        '&-validating': {
+          color: token.colorPrimary
+        }
+      }
+    })
+  };
+};
+const makeVerticalLayoutLabel = token => ({
+  padding: token.verticalLabelPadding,
+  margin: token.verticalLabelMargin,
+  whiteSpace: 'initial',
+  textAlign: 'start',
+  '> label': {
+    margin: 0,
+    '&::after': {
+      // https://github.com/ant-design/ant-design/issues/43538
+      visibility: 'hidden'
+    }
+  }
+});
+const genHorizontalStyle = token => {
+  const {
+    antCls,
+    formItemCls
+  } = token;
+  return {
+    [`${formItemCls}-horizontal`]: {
+      [`${formItemCls}-label`]: {
+        flexGrow: 0
+      },
+      [`${formItemCls}-control`]: {
+        flex: '1 1 0',
+        // https://github.com/ant-design/ant-design/issues/32777
+        // https://github.com/ant-design/ant-design/issues/33773
+        minWidth: 0
+      },
+      // Do not change this to `ant-col-24`! `-24` match all the responsive rules
+      // https://github.com/ant-design/ant-design/issues/32980
+      // https://github.com/ant-design/ant-design/issues/34903
+      // https://github.com/ant-design/ant-design/issues/44538
+      [`${formItemCls}-label[class$='-24'], ${formItemCls}-label[class*='-24 ']`]: {
+        [`& + ${formItemCls}-control`]: {
+          minWidth: 'unset'
+        }
+      },
+      [`${antCls}-col-24${formItemCls}-label,
+        ${antCls}-col-xl-24${formItemCls}-label`]: makeVerticalLayoutLabel(token)
+    }
+  };
+};
+const genInlineStyle = token => {
+  const {
+    componentCls,
+    formItemCls,
+    inlineItemMarginBottom
+  } = token;
+  return {
+    [`${componentCls}-inline`]: {
+      display: 'flex',
+      flexWrap: 'wrap',
+      [`${formItemCls}-inline`]: {
+        flex: 'none',
+        marginInlineEnd: token.margin,
+        marginBottom: inlineItemMarginBottom,
+        '&-row': {
+          flexWrap: 'nowrap'
+        },
+        [`> ${formItemCls}-label,
+        > ${formItemCls}-control`]: {
+          display: 'inline-block',
+          verticalAlign: 'top'
+        },
+        [`> ${formItemCls}-label`]: {
+          flex: 'none'
+        },
+        [`${componentCls}-text`]: {
+          display: 'inline-block'
+        },
+        [`${formItemCls}-has-feedback`]: {
+          display: 'inline-block'
+        }
+      }
+    }
+  };
+};
+const makeVerticalLayout = token => {
+  const {
+    componentCls,
+    formItemCls,
+    rootPrefixCls
+  } = token;
+  return {
+    [`${formItemCls} ${formItemCls}-label`]: makeVerticalLayoutLabel(token),
+    // ref: https://github.com/ant-design/ant-design/issues/45122
+    [`${componentCls}:not(${componentCls}-inline)`]: {
+      [formItemCls]: {
+        flexWrap: 'wrap',
+        [`${formItemCls}-label, ${formItemCls}-control`]: {
+          // When developer pass `xs: { span }`,
+          // It should follow the `xs` screen config
+          // ref: https://github.com/ant-design/ant-design/issues/44386
+          [`&:not([class*=" ${rootPrefixCls}-col-xs"])`]: {
+            flex: '0 0 100%',
+            maxWidth: '100%'
+          }
+        }
+      }
+    }
+  };
+};
+const genVerticalStyle = token => {
+  const {
+    componentCls,
+    formItemCls,
+    antCls
+  } = token;
+  return {
+    [`${formItemCls}-vertical`]: {
+      [`${formItemCls}-row`]: {
+        flexDirection: 'column'
+      },
+      [`${formItemCls}-label > label`]: {
+        height: 'auto'
+      },
+      [`${formItemCls}-control`]: {
+        width: '100%'
+      },
+      [`${formItemCls}-label,
+        ${antCls}-col-24${formItemCls}-label,
+        ${antCls}-col-xl-24${formItemCls}-label`]: makeVerticalLayoutLabel(token)
+    },
+    [`@media (max-width: ${unit(token.screenXSMax)})`]: [makeVerticalLayout(token), {
+      [componentCls]: {
+        [`${formItemCls}:not(${formItemCls}-horizontal)`]: {
+          [`${antCls}-col-xs-24${formItemCls}-label`]: makeVerticalLayoutLabel(token)
+        }
+      }
+    }],
+    [`@media (max-width: ${unit(token.screenSMMax)})`]: {
+      [componentCls]: {
+        [`${formItemCls}:not(${formItemCls}-horizontal)`]: {
+          [`${antCls}-col-sm-24${formItemCls}-label`]: makeVerticalLayoutLabel(token)
+        }
+      }
+    },
+    [`@media (max-width: ${unit(token.screenMDMax)})`]: {
+      [componentCls]: {
+        [`${formItemCls}:not(${formItemCls}-horizontal)`]: {
+          [`${antCls}-col-md-24${formItemCls}-label`]: makeVerticalLayoutLabel(token)
+        }
+      }
+    },
+    [`@media (max-width: ${unit(token.screenLGMax)})`]: {
+      [componentCls]: {
+        [`${formItemCls}:not(${formItemCls}-horizontal)`]: {
+          [`${antCls}-col-lg-24${formItemCls}-label`]: makeVerticalLayoutLabel(token)
+        }
+      }
+    }
+  };
+};
+// ============================== Export ==============================
+export const prepareComponentToken = token => ({
+  labelRequiredMarkColor: token.colorError,
+  labelColor: token.colorTextHeading,
+  labelFontSize: token.fontSize,
+  labelHeight: token.controlHeight,
+  labelColonMarginInlineStart: token.marginXXS / 2,
+  labelColonMarginInlineEnd: token.marginXS,
+  itemMarginBottom: token.marginLG,
+  verticalLabelPadding: `0 0 ${token.paddingXS}px`,
+  verticalLabelMargin: 0,
+  inlineItemMarginBottom: 0
+});
+export const prepareToken = (token, rootPrefixCls) => {
+  const formToken = mergeToken(token, {
+    formItemCls: `${token.componentCls}-item`,
+    rootPrefixCls
+  });
+  return formToken;
+};
+export default genStyleHooks('Form', (token, {
+  rootPrefixCls
+}) => {
+  const formToken = prepareToken(token, rootPrefixCls);
+  return [genFormStyle(formToken), genFormItemStyle(formToken), genFormValidateMotionStyle(formToken), genHorizontalStyle(formToken), genInlineStyle(formToken), genVerticalStyle(formToken), genCollapseMotion(formToken), zoomIn];
+}, prepareComponentToken, {
+  // Let From style before the Grid
+  // ref https://github.com/ant-design/ant-design/issues/44386
+  order: -1000
+});

node_modules/antd/es/form/util.d.ts

@@ -0,0 +1,9 @@
+import type { Meta } from 'rc-field-form/lib/interface';
+import type { ValidateStatus } from './FormItem';
+import type { InternalNamePath } from './interface';
+export declare function toArray<T>(candidate?: T | T[] | false): T[];
+export declare function getFieldId(namePath: InternalNamePath, formName?: string): string | undefined;
+/**
+ * Get merged status by meta or passed `validateStatus`.
+ */
+export declare function getStatus<DefaultValue>(errors: React.ReactNode[], warnings: React.ReactNode[], meta: Meta, defaultValidateStatus: ValidateStatus | DefaultValue, hasFeedback?: boolean, validateStatus?: ValidateStatus): ValidateStatus | DefaultValue;

node_modules/antd/es/form/util.js

@@ -0,0 +1,41 @@
+// form item name black list.  in form ,you can use form.id get the form item element.
+// use object hasOwnProperty will get better performance if black list is longer.
+const formItemNameBlackList = ['parentNode'];
+// default form item id prefix.
+const defaultItemNamePrefixCls = 'form_item';
+export function toArray(candidate) {
+  if (candidate === undefined || candidate === false) {
+    return [];
+  }
+  return Array.isArray(candidate) ? candidate : [candidate];
+}
+export function getFieldId(namePath, formName) {
+  if (!namePath.length) {
+    return undefined;
+  }
+  const mergedId = namePath.join('_');
+  if (formName) {
+    return `${formName}_${mergedId}`;
+  }
+  const isIllegalName = formItemNameBlackList.includes(mergedId);
+  return isIllegalName ? `${defaultItemNamePrefixCls}_${mergedId}` : mergedId;
+}
+/**
+ * Get merged status by meta or passed `validateStatus`.
+ */
+export function getStatus(errors, warnings, meta, defaultValidateStatus, hasFeedback, validateStatus) {
+  let status = defaultValidateStatus;
+  if (validateStatus !== undefined) {
+    status = validateStatus;
+  } else if (meta.validating) {
+    status = 'validating';
+  } else if (errors.length) {
+    status = 'error';
+  } else if (warnings.length) {
+    status = 'warning';
+  } else if (meta.touched || hasFeedback && meta.validated) {
+    // success feedback should display when pass hasFeedback prop and current value is valid value
+    status = 'success';
+  }
+  return status;
+}

node_modules/antd/es/form/validateMessagesContext.d.ts

@@ -0,0 +1,3 @@
+import type { ValidateMessages } from 'rc-field-form/lib/interface';
+declare const _default: import("react").Context<ValidateMessages | undefined>;
+export default _default;

node_modules/antd/es/form/validateMessagesContext.js

@@ -0,0 +1,7 @@
+"use client";
+
+import { createContext } from 'react';
+// ZombieJ: We export single file here since
+// ConfigProvider use this which will make loop deps
+// to import whole `rc-field-form`
+export default /*#__PURE__*/createContext(undefined);