init

node_modules/element-plus/lib/components/form/index.d.ts

@@ -0,0 +1,15 @@
+import Form from './src/form.vue';
+import FormItem from './src/form-item.vue';
+import type { SFCWithInstall } from 'element-plus/es/utils';
+export declare const ElForm: SFCWithInstall<typeof Form> & {
+    FormItem: typeof FormItem;
+};
+export default ElForm;
+export declare const ElFormItem: SFCWithInstall<typeof FormItem>;
+export * from './src/form';
+export * from './src/form-item';
+export * from './src/types';
+export * from './src/constants';
+export * from './src/hooks';
+export type FormInstance = InstanceType<typeof Form> & unknown;
+export type FormItemInstance = InstanceType<typeof FormItem> & unknown;

node_modules/element-plus/lib/components/form/index.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var form$1 = require('./src/form2.js');
+var formItem$1 = require('./src/form-item2.js');
+var form = require('./src/form.js');
+var formItem = require('./src/form-item.js');
+var constants = require('./src/constants.js');
+var install = require('../../utils/vue/install.js');
+var useFormCommonProps = require('./src/hooks/use-form-common-props.js');
+var useFormItem = require('./src/hooks/use-form-item.js');
+
+const ElForm = install.withInstall(form$1["default"], {
+  FormItem: formItem$1["default"]
+});
+const ElFormItem = install.withNoopInstall(formItem$1["default"]);
+
+exports.formEmits = form.formEmits;
+exports.formMetaProps = form.formMetaProps;
+exports.formProps = form.formProps;
+exports.formItemProps = formItem.formItemProps;
+exports.formItemValidateStates = formItem.formItemValidateStates;
+exports.formContextKey = constants.formContextKey;
+exports.formItemContextKey = constants.formItemContextKey;
+exports.useDisabled = useFormCommonProps.useDisabled;
+exports.useFormDisabled = useFormCommonProps.useFormDisabled;
+exports.useFormSize = useFormCommonProps.useFormSize;
+exports.useSize = useFormCommonProps.useSize;
+exports.useFormItem = useFormItem.useFormItem;
+exports.useFormItemInputId = useFormItem.useFormItemInputId;
+exports.ElForm = ElForm;
+exports.ElFormItem = ElFormItem;
+exports["default"] = ElForm;
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/form/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../packages/components/form/index.ts"],"sourcesContent":["import { withInstall, withNoopInstall } from '@element-plus/utils'\nimport Form from './src/form.vue'\nimport FormItem from './src/form-item.vue'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport const ElForm: SFCWithInstall<typeof Form> & {\n  FormItem: typeof FormItem\n} = withInstall(Form, {\n  FormItem,\n})\nexport default ElForm\nexport const ElFormItem: SFCWithInstall<typeof FormItem> =\n  withNoopInstall(FormItem)\n\nexport * from './src/form'\nexport * from './src/form-item'\nexport * from './src/types'\nexport * from './src/constants'\nexport * from './src/hooks'\n\nexport type FormInstance = InstanceType<typeof Form> & unknown\nexport type FormItemInstance = InstanceType<typeof FormItem> & unknown\n"],"names":["withInstall","Form","FormItem","withNoopInstall"],"mappings":";;;;;;;;;;;;;AAGY,MAAC,MAAM,GAAGA,mBAAW,CAACC,iBAAI,EAAE;AACxC,YAAEC,qBAAQ;AACV,CAAC,EAAE;AAES,MAAC,UAAU,GAAGC,uBAAe,CAACD,qBAAQ;;;;;;;;;;;;;;;;;;;"}

node_modules/element-plus/lib/components/form/src/constants.d.ts

@@ -0,0 +1,4 @@
+import type { InjectionKey } from 'vue';
+import type { FormContext, FormItemContext } from './types';
+export declare const formContextKey: InjectionKey<FormContext>;
+export declare const formItemContextKey: InjectionKey<FormItemContext>;

node_modules/element-plus/lib/components/form/src/constants.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const formContextKey = Symbol("formContextKey");
+const formItemContextKey = Symbol("formItemContextKey");
+
+exports.formContextKey = formContextKey;
+exports.formItemContextKey = formItemContextKey;
+//# sourceMappingURL=constants.js.map

node_modules/element-plus/lib/components/form/src/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../../../../packages/components/form/src/constants.ts"],"sourcesContent":["import type { InjectionKey } from 'vue'\nimport type { FormContext, FormItemContext } from './types'\n\nexport const formContextKey: InjectionKey<FormContext> =\n  Symbol('formContextKey')\nexport const formItemContextKey: InjectionKey<FormItemContext> =\n  Symbol('formItemContextKey')\n"],"names":[],"mappings":";;;;AAAY,MAAC,cAAc,GAAG,MAAM,CAAC,gBAAgB,EAAE;AAC3C,MAAC,kBAAkB,GAAG,MAAM,CAAC,oBAAoB;;;;;"}

node_modules/element-plus/lib/components/form/src/form-item.d.ts

@@ -0,0 +1,42 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+import type { Arrayable } from 'element-plus/es/utils';
+import type { FormItemRule } from './types';
+export declare const formItemValidateStates: readonly ["", "error", "validating", "success"];
+export type FormItemValidateState = typeof formItemValidateStates[number];
+export type FormItemProp = Arrayable<string>;
+export declare const formItemProps: {
+    readonly label: StringConstructor;
+    readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "top" | "left" | "right", unknown, "", boolean>;
+    readonly prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => FormItemRule | FormItemRule[]) | (() => Arrayable<FormItemRule>) | ((new (...args: any[]) => FormItemRule | FormItemRule[]) | (() => Arrayable<FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly error: StringConstructor;
+    readonly validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly for: StringConstructor;
+    readonly inlineMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type FormItemProps = ExtractPropTypes<typeof formItemProps>;
+export type FormItemPropsPublic = __ExtractPublicPropTypes<typeof formItemProps>;

node_modules/element-plus/lib/components/form/src/form-item.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtime = require('../../../utils/vue/props/runtime.js');
+var size = require('../../../constants/size.js');
+
+const formItemValidateStates = [
+  "",
+  "error",
+  "validating",
+  "success"
+];
+const formItemProps = runtime.buildProps({
+  label: String,
+  labelWidth: {
+    type: [String, Number],
+    default: ""
+  },
+  labelPosition: {
+    type: String,
+    values: ["left", "right", "top", ""],
+    default: ""
+  },
+  prop: {
+    type: runtime.definePropType([String, Array])
+  },
+  required: {
+    type: Boolean,
+    default: void 0
+  },
+  rules: {
+    type: runtime.definePropType([Object, Array])
+  },
+  error: String,
+  validateStatus: {
+    type: String,
+    values: formItemValidateStates
+  },
+  for: String,
+  inlineMessage: {
+    type: Boolean,
+    default: void 0
+  },
+  showMessage: {
+    type: Boolean,
+    default: true
+  },
+  size: {
+    type: String,
+    values: size.componentSizes
+  }
+});
+
+exports.formItemProps = formItemProps;
+exports.formItemValidateStates = formItemValidateStates;
+//# sourceMappingURL=form-item.js.map

node_modules/element-plus/lib/components/form/src/form-item.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-item.js","sources":["../../../../../../packages/components/form/src/form-item.ts"],"sourcesContent":["import { componentSizes } from '@element-plus/constants'\nimport { buildProps, definePropType } from '@element-plus/utils'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\nimport type { Arrayable } from '@element-plus/utils'\nimport type { FormItemRule } from './types'\n\nexport const formItemValidateStates = [\n  '',\n  'error',\n  'validating',\n  'success',\n] as const\nexport type FormItemValidateState = typeof formItemValidateStates[number]\n\nexport type FormItemProp = Arrayable<string>\n\nexport const formItemProps = buildProps({\n  /**\n   * @description Label text.\n   */\n  label: String,\n  /**\n   * @description Width of label, e.g. `'50px'`. `'auto'` is supported.\n   */\n  labelWidth: {\n    type: [String, Number],\n    default: '',\n  },\n  /**\n   * @description Position of label. If set to `'left'` or `'right'`, `label-width` prop is also required. The default is extend from `form label-position`.\n   */\n  labelPosition: {\n    type: String,\n    values: ['left', 'right', 'top', ''],\n    default: '',\n  },\n  /**\n   * @description  A key of `model`. It could be an array of property paths (e.g `['a', 'b', '0']`). In the use of `validate` and `resetFields` method, the attribute is required.\n   */\n  prop: {\n    type: definePropType<FormItemProp>([String, Array]),\n  },\n  /**\n   * @description Whether the field is required or not, will be determined by validation rules if omitted.\n   */\n  required: {\n    type: Boolean,\n    default: undefined,\n  },\n  /**\n   * @description Validation rules of form, see the [following table](#formitemrule), more advanced usage at [async-validator](https://github.com/yiminghe/async-validator).\n   */\n  rules: {\n    type: definePropType<Arrayable<FormItemRule>>([Object, Array]),\n  },\n  /**\n   * @description Field error message, set its value and the field will validate error and show this message immediately.\n   */\n  error: String,\n  /**\n   * @description Validation state of formItem.\n   */\n  validateStatus: {\n    type: String,\n    values: formItemValidateStates,\n  },\n  /**\n   * @description Same as for in native label.\n   */\n  for: String,\n  /**\n   * @description Inline style validate message.\n   */\n  inlineMessage: {\n    type: Boolean,\n    default: undefined,\n  },\n  /**\n   * @description Whether to show the error message.\n   */\n  showMessage: {\n    type: Boolean,\n    default: true,\n  },\n  /**\n   * @description Control the size of components in this form-item.\n   */\n  size: {\n    type: String,\n    values: componentSizes,\n  },\n} as const)\nexport type FormItemProps = ExtractPropTypes<typeof formItemProps>\nexport type FormItemPropsPublic = __ExtractPublicPropTypes<typeof formItemProps>\n"],"names":["buildProps","definePropType","componentSizes"],"mappings":";;;;;;;AAEY,MAAC,sBAAsB,GAAG;AACtC,EAAE,EAAE;AACJ,EAAE,OAAO;AACT,EAAE,YAAY;AACd,EAAE,SAAS;AACX,EAAE;AACU,MAAC,aAAa,GAAGA,kBAAU,CAAC;AACxC,EAAE,KAAK,EAAE,MAAM;AACf,EAAE,UAAU,EAAE;AACd,IAAI,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;AAC1B,IAAI,OAAO,EAAE,EAAE;AACf,GAAG;AACH,EAAE,aAAa,EAAE;AACjB,IAAI,IAAI,EAAE,MAAM;AAChB,IAAI,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC;AACxC,IAAI,OAAO,EAAE,EAAE;AACf,GAAG;AACH,EAAE,IAAI,EAAE;AACR,IAAI,IAAI,EAAEC,sBAAc,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AACzC,GAAG;AACH,EAAE,QAAQ,EAAE;AACZ,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,KAAK,CAAC;AACnB,GAAG;AACH,EAAE,KAAK,EAAE;AACT,IAAI,IAAI,EAAEA,sBAAc,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AACzC,GAAG;AACH,EAAE,KAAK,EAAE,MAAM;AACf,EAAE,cAAc,EAAE;AAClB,IAAI,IAAI,EAAE,MAAM;AAChB,IAAI,MAAM,EAAE,sBAAsB;AAClC,GAAG;AACH,EAAE,GAAG,EAAE,MAAM;AACb,EAAE,aAAa,EAAE;AACjB,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,KAAK,CAAC;AACnB,GAAG;AACH,EAAE,WAAW,EAAE;AACf,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,IAAI;AACjB,GAAG;AACH,EAAE,IAAI,EAAE;AACR,IAAI,IAAI,EAAE,MAAM;AAChB,IAAI,MAAM,EAAEC,mBAAc;AAC1B,GAAG;AACH,CAAC;;;;;"}

node_modules/element-plus/lib/components/form/src/form-item.vue.d.ts

@@ -0,0 +1,116 @@
+import type { Arrayable } from 'element-plus/es/utils';
+import type { FormItemRule } from './types';
+declare function __VLS_template(): {
+    label?(_: {
+        label: string;
+    }): any;
+    default?(_: {}): any;
+    error?(_: {
+        error: string;
+    }): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    readonly label: StringConstructor;
+    readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "top" | "left" | "right", unknown, "", boolean>;
+    readonly prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => import("./form-item").FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => import("./form-item").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => FormItemRule | FormItemRule[]) | (() => Arrayable<FormItemRule>) | ((new (...args: any[]) => FormItemRule | FormItemRule[]) | (() => Arrayable<FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly error: StringConstructor;
+    readonly validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly for: StringConstructor;
+    readonly inlineMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, {
+    /**
+     * @description Form item size.
+     */
+    size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+    /**
+     * @description Validation message.
+     */
+    validateMessage: import("vue").Ref<string>;
+    /**
+     * @description Validation state.
+     */
+    validateState: import("vue").Ref<"" | "error" | "success" | "validating">;
+    /**
+     * @description Validate form item.
+     */
+    validate: (trigger: string, callback?: import("./types").FormValidateCallback) => import("./types").FormValidationResult;
+    /**
+     * @description Remove validation status of the field.
+     */
+    clearValidate: () => void;
+    /**
+     * @description Reset current field and remove validation result.
+     */
+    resetField: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly label: StringConstructor;
+    readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "top" | "left" | "right", unknown, "", boolean>;
+    readonly prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => import("./form-item").FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => import("./form-item").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => FormItemRule | FormItemRule[]) | (() => Arrayable<FormItemRule>) | ((new (...args: any[]) => FormItemRule | FormItemRule[]) | (() => Arrayable<FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly error: StringConstructor;
+    readonly validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly for: StringConstructor;
+    readonly inlineMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {
+    readonly required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+    readonly labelPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "top" | "left" | "right", unknown>;
+    readonly inlineMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/element-plus/lib/components/form/src/form-item2.js

@@ -0,0 +1,335 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var AsyncValidator = require('async-validator');
+var lodashUnified = require('lodash-unified');
+var core = require('@vueuse/core');
+var formItem = require('./form-item.js');
+var formLabelWrap = require('./form-label-wrap.js');
+var constants = require('./constants.js');
+var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+var index$1 = require('../../../hooks/use-id/index.js');
+var objects = require('../../../utils/objects.js');
+var useFormCommonProps = require('./hooks/use-form-common-props.js');
+var index = require('../../../hooks/use-namespace/index.js');
+var style = require('../../../utils/dom/style.js');
+var types = require('../../../utils/types.js');
+var shared = require('@vue/shared');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var AsyncValidator__default = /*#__PURE__*/_interopDefaultLegacy(AsyncValidator);
+
+const __default__ = vue.defineComponent({
+  name: "ElFormItem"
+});
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: formItem.formItemProps,
+  setup(__props, { expose }) {
+    const props = __props;
+    const slots = vue.useSlots();
+    const formContext = vue.inject(constants.formContextKey, void 0);
+    const parentFormItemContext = vue.inject(constants.formItemContextKey, void 0);
+    const _size = useFormCommonProps.useFormSize(void 0, { formItem: false });
+    const ns = index.useNamespace("form-item");
+    const labelId = index$1.useId().value;
+    const inputIds = vue.ref([]);
+    const validateState = vue.ref("");
+    const validateStateDebounced = core.refDebounced(validateState, 100);
+    const validateMessage = vue.ref("");
+    const formItemRef = vue.ref();
+    let initialValue = void 0;
+    let isResettingField = false;
+    const labelPosition = vue.computed(() => props.labelPosition || (formContext == null ? void 0 : formContext.labelPosition));
+    const labelStyle = vue.computed(() => {
+      if (labelPosition.value === "top") {
+        return {};
+      }
+      const labelWidth = style.addUnit(props.labelWidth || (formContext == null ? void 0 : formContext.labelWidth) || "");
+      if (labelWidth)
+        return { width: labelWidth };
+      return {};
+    });
+    const contentStyle = vue.computed(() => {
+      if (labelPosition.value === "top" || (formContext == null ? void 0 : formContext.inline)) {
+        return {};
+      }
+      if (!props.label && !props.labelWidth && isNested) {
+        return {};
+      }
+      const labelWidth = style.addUnit(props.labelWidth || (formContext == null ? void 0 : formContext.labelWidth) || "");
+      if (!props.label && !slots.label) {
+        return { marginLeft: labelWidth };
+      }
+      return {};
+    });
+    const formItemClasses = vue.computed(() => [
+      ns.b(),
+      ns.m(_size.value),
+      ns.is("error", validateState.value === "error"),
+      ns.is("validating", validateState.value === "validating"),
+      ns.is("success", validateState.value === "success"),
+      ns.is("required", isRequired.value || props.required),
+      ns.is("no-asterisk", formContext == null ? void 0 : formContext.hideRequiredAsterisk),
+      (formContext == null ? void 0 : formContext.requireAsteriskPosition) === "right" ? "asterisk-right" : "asterisk-left",
+      {
+        [ns.m("feedback")]: formContext == null ? void 0 : formContext.statusIcon,
+        [ns.m(`label-${labelPosition.value}`)]: labelPosition.value
+      }
+    ]);
+    const _inlineMessage = vue.computed(() => types.isBoolean(props.inlineMessage) ? props.inlineMessage : (formContext == null ? void 0 : formContext.inlineMessage) || false);
+    const validateClasses = vue.computed(() => [
+      ns.e("error"),
+      { [ns.em("error", "inline")]: _inlineMessage.value }
+    ]);
+    const propString = vue.computed(() => {
+      if (!props.prop)
+        return "";
+      return shared.isArray(props.prop) ? props.prop.join(".") : props.prop;
+    });
+    const hasLabel = vue.computed(() => {
+      return !!(props.label || slots.label);
+    });
+    const labelFor = vue.computed(() => {
+      var _a;
+      return (_a = props.for) != null ? _a : inputIds.value.length === 1 ? inputIds.value[0] : void 0;
+    });
+    const isGroup = vue.computed(() => {
+      return !labelFor.value && hasLabel.value;
+    });
+    const isNested = !!parentFormItemContext;
+    const fieldValue = vue.computed(() => {
+      const model = formContext == null ? void 0 : formContext.model;
+      if (!model || !props.prop) {
+        return;
+      }
+      return objects.getProp(model, props.prop).value;
+    });
+    const normalizedRules = vue.computed(() => {
+      const { required } = props;
+      const rules = [];
+      if (props.rules) {
+        rules.push(...lodashUnified.castArray(props.rules));
+      }
+      const formRules = formContext == null ? void 0 : formContext.rules;
+      if (formRules && props.prop) {
+        const _rules = objects.getProp(formRules, props.prop).value;
+        if (_rules) {
+          rules.push(...lodashUnified.castArray(_rules));
+        }
+      }
+      if (required !== void 0) {
+        const requiredRules = rules.map((rule, i) => [rule, i]).filter(([rule]) => "required" in rule);
+        if (requiredRules.length > 0) {
+          for (const [rule, i] of requiredRules) {
+            if (rule.required === required)
+              continue;
+            rules[i] = { ...rule, required };
+          }
+        } else {
+          rules.push({ required });
+        }
+      }
+      return rules;
+    });
+    const validateEnabled = vue.computed(() => normalizedRules.value.length > 0);
+    const getFilteredRule = (trigger) => {
+      const rules = normalizedRules.value;
+      return rules.filter((rule) => {
+        if (!rule.trigger || !trigger)
+          return true;
+        if (shared.isArray(rule.trigger)) {
+          return rule.trigger.includes(trigger);
+        } else {
+          return rule.trigger === trigger;
+        }
+      }).map(({ trigger: trigger2, ...rule }) => rule);
+    };
+    const isRequired = vue.computed(() => normalizedRules.value.some((rule) => rule.required));
+    const shouldShowError = vue.computed(() => {
+      var _a;
+      return validateStateDebounced.value === "error" && props.showMessage && ((_a = formContext == null ? void 0 : formContext.showMessage) != null ? _a : true);
+    });
+    const currentLabel = vue.computed(() => `${props.label || ""}${(formContext == null ? void 0 : formContext.labelSuffix) || ""}`);
+    const setValidationState = (state) => {
+      validateState.value = state;
+    };
+    const onValidationFailed = (error) => {
+      var _a, _b;
+      const { errors, fields } = error;
+      if (!errors || !fields) {
+        console.error(error);
+      }
+      setValidationState("error");
+      validateMessage.value = errors ? (_b = (_a = errors == null ? void 0 : errors[0]) == null ? void 0 : _a.message) != null ? _b : `${props.prop} is required` : "";
+      formContext == null ? void 0 : formContext.emit("validate", props.prop, false, validateMessage.value);
+    };
+    const onValidationSucceeded = () => {
+      setValidationState("success");
+      formContext == null ? void 0 : formContext.emit("validate", props.prop, true, "");
+    };
+    const doValidate = async (rules) => {
+      const modelName = propString.value;
+      const validator = new AsyncValidator__default["default"]({
+        [modelName]: rules
+      });
+      return validator.validate({ [modelName]: fieldValue.value }, { firstFields: true }).then(() => {
+        onValidationSucceeded();
+        return true;
+      }).catch((err) => {
+        onValidationFailed(err);
+        return Promise.reject(err);
+      });
+    };
+    const validate = async (trigger, callback) => {
+      if (isResettingField || !props.prop) {
+        return false;
+      }
+      const hasCallback = shared.isFunction(callback);
+      if (!validateEnabled.value) {
+        callback == null ? void 0 : callback(false);
+        return false;
+      }
+      const rules = getFilteredRule(trigger);
+      if (rules.length === 0) {
+        callback == null ? void 0 : callback(true);
+        return true;
+      }
+      setValidationState("validating");
+      return doValidate(rules).then(() => {
+        callback == null ? void 0 : callback(true);
+        return true;
+      }).catch((err) => {
+        const { fields } = err;
+        callback == null ? void 0 : callback(false, fields);
+        return hasCallback ? false : Promise.reject(fields);
+      });
+    };
+    const clearValidate = () => {
+      setValidationState("");
+      validateMessage.value = "";
+      isResettingField = false;
+    };
+    const resetField = async () => {
+      const model = formContext == null ? void 0 : formContext.model;
+      if (!model || !props.prop)
+        return;
+      const computedValue = objects.getProp(model, props.prop);
+      isResettingField = true;
+      computedValue.value = lodashUnified.clone(initialValue);
+      await vue.nextTick();
+      clearValidate();
+      isResettingField = false;
+    };
+    const addInputId = (id) => {
+      if (!inputIds.value.includes(id)) {
+        inputIds.value.push(id);
+      }
+    };
+    const removeInputId = (id) => {
+      inputIds.value = inputIds.value.filter((listId) => listId !== id);
+    };
+    vue.watch(() => props.error, (val) => {
+      validateMessage.value = val || "";
+      setValidationState(val ? "error" : "");
+    }, { immediate: true });
+    vue.watch(() => props.validateStatus, (val) => setValidationState(val || ""));
+    const context = vue.reactive({
+      ...vue.toRefs(props),
+      $el: formItemRef,
+      size: _size,
+      validateMessage,
+      validateState,
+      labelId,
+      inputIds,
+      isGroup,
+      hasLabel,
+      fieldValue,
+      addInputId,
+      removeInputId,
+      resetField,
+      clearValidate,
+      validate,
+      propString
+    });
+    vue.provide(constants.formItemContextKey, context);
+    vue.onMounted(() => {
+      if (props.prop) {
+        formContext == null ? void 0 : formContext.addField(context);
+        initialValue = lodashUnified.clone(fieldValue.value);
+      }
+    });
+    vue.onBeforeUnmount(() => {
+      formContext == null ? void 0 : formContext.removeField(context);
+    });
+    expose({
+      size: _size,
+      validateMessage,
+      validateState,
+      validate,
+      clearValidate,
+      resetField
+    });
+    return (_ctx, _cache) => {
+      var _a;
+      return vue.openBlock(), vue.createElementBlock("div", {
+        ref_key: "formItemRef",
+        ref: formItemRef,
+        class: vue.normalizeClass(vue.unref(formItemClasses)),
+        role: vue.unref(isGroup) ? "group" : void 0,
+        "aria-labelledby": vue.unref(isGroup) ? vue.unref(labelId) : void 0
+      }, [
+        vue.createVNode(vue.unref(formLabelWrap["default"]), {
+          "is-auto-width": vue.unref(labelStyle).width === "auto",
+          "update-all": ((_a = vue.unref(formContext)) == null ? void 0 : _a.labelWidth) === "auto"
+        }, {
+          default: vue.withCtx(() => [
+            vue.unref(hasLabel) ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(labelFor) ? "label" : "div"), {
+              key: 0,
+              id: vue.unref(labelId),
+              for: vue.unref(labelFor),
+              class: vue.normalizeClass(vue.unref(ns).e("label")),
+              style: vue.normalizeStyle(vue.unref(labelStyle))
+            }, {
+              default: vue.withCtx(() => [
+                vue.renderSlot(_ctx.$slots, "label", { label: vue.unref(currentLabel) }, () => [
+                  vue.createTextVNode(vue.toDisplayString(vue.unref(currentLabel)), 1)
+                ])
+              ]),
+              _: 3
+            }, 8, ["id", "for", "class", "style"])) : vue.createCommentVNode("v-if", true)
+          ]),
+          _: 3
+        }, 8, ["is-auto-width", "update-all"]),
+        vue.createElementVNode("div", {
+          class: vue.normalizeClass(vue.unref(ns).e("content")),
+          style: vue.normalizeStyle(vue.unref(contentStyle))
+        }, [
+          vue.renderSlot(_ctx.$slots, "default"),
+          vue.createVNode(vue.TransitionGroup, {
+            name: `${vue.unref(ns).namespace.value}-zoom-in-top`
+          }, {
+            default: vue.withCtx(() => [
+              vue.unref(shouldShowError) ? vue.renderSlot(_ctx.$slots, "error", {
+                key: 0,
+                error: validateMessage.value
+              }, () => [
+                vue.createElementVNode("div", {
+                  class: vue.normalizeClass(vue.unref(validateClasses))
+                }, vue.toDisplayString(validateMessage.value), 3)
+              ]) : vue.createCommentVNode("v-if", true)
+            ]),
+            _: 3
+          }, 8, ["name"])
+        ], 6)
+      ], 10, ["role", "aria-labelledby"]);
+    };
+  }
+});
+var FormItem = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "form-item.vue"]]);
+
+exports["default"] = FormItem;
+//# sourceMappingURL=form-item2.js.map

node_modules/element-plus/lib/components/form/src/form-label-wrap.d.ts

@@ -0,0 +1,11 @@
+declare const _default: import("vue").DefineComponent<{
+    isAutoWidth: BooleanConstructor;
+    updateAll: BooleanConstructor;
+}, () => JSX.Element | null, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    isAutoWidth: BooleanConstructor;
+    updateAll: BooleanConstructor;
+}>>, {
+    isAutoWidth: boolean;
+    updateAll: boolean;
+}>;
+export default _default;

node_modules/element-plus/lib/components/form/src/form-label-wrap.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var core = require('@vueuse/core');
+var constants = require('./constants.js');
+var error = require('../../../utils/error.js');
+var index = require('../../../hooks/use-namespace/index.js');
+
+const COMPONENT_NAME = "ElLabelWrap";
+var FormLabelWrap = vue.defineComponent({
+  name: COMPONENT_NAME,
+  props: {
+    isAutoWidth: Boolean,
+    updateAll: Boolean
+  },
+  setup(props, {
+    slots
+  }) {
+    const formContext = vue.inject(constants.formContextKey, void 0);
+    const formItemContext = vue.inject(constants.formItemContextKey);
+    if (!formItemContext)
+      error.throwError(COMPONENT_NAME, "usage: <el-form-item><label-wrap /></el-form-item>");
+    const ns = index.useNamespace("form");
+    const el = vue.ref();
+    const computedWidth = vue.ref(0);
+    const getLabelWidth = () => {
+      var _a;
+      if ((_a = el.value) == null ? void 0 : _a.firstElementChild) {
+        const width = window.getComputedStyle(el.value.firstElementChild).width;
+        return Math.ceil(Number.parseFloat(width));
+      } else {
+        return 0;
+      }
+    };
+    const updateLabelWidth = (action = "update") => {
+      vue.nextTick(() => {
+        if (slots.default && props.isAutoWidth) {
+          if (action === "update") {
+            computedWidth.value = getLabelWidth();
+          } else if (action === "remove") {
+            formContext == null ? void 0 : formContext.deregisterLabelWidth(computedWidth.value);
+          }
+        }
+      });
+    };
+    const updateLabelWidthFn = () => updateLabelWidth("update");
+    vue.onMounted(() => {
+      updateLabelWidthFn();
+    });
+    vue.onBeforeUnmount(() => {
+      updateLabelWidth("remove");
+    });
+    vue.onUpdated(() => updateLabelWidthFn());
+    vue.watch(computedWidth, (val, oldVal) => {
+      if (props.updateAll) {
+        formContext == null ? void 0 : formContext.registerLabelWidth(val, oldVal);
+      }
+    });
+    core.useResizeObserver(vue.computed(() => {
+      var _a, _b;
+      return (_b = (_a = el.value) == null ? void 0 : _a.firstElementChild) != null ? _b : null;
+    }), updateLabelWidthFn);
+    return () => {
+      var _a, _b;
+      if (!slots)
+        return null;
+      const {
+        isAutoWidth
+      } = props;
+      if (isAutoWidth) {
+        const autoLabelWidth = formContext == null ? void 0 : formContext.autoLabelWidth;
+        const hasLabel = formItemContext == null ? void 0 : formItemContext.hasLabel;
+        const style = {};
+        if (hasLabel && autoLabelWidth && autoLabelWidth !== "auto") {
+          const marginWidth = Math.max(0, Number.parseInt(autoLabelWidth, 10) - computedWidth.value);
+          const labelPosition = formItemContext.labelPosition || formContext.labelPosition;
+          const marginPosition = labelPosition === "left" ? "marginRight" : "marginLeft";
+          if (marginWidth) {
+            style[marginPosition] = `${marginWidth}px`;
+          }
+        }
+        return vue.createVNode("div", {
+          "ref": el,
+          "class": [ns.be("item", "label-wrap")],
+          "style": style
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      } else {
+        return vue.createVNode(vue.Fragment, {
+          "ref": el
+        }, [(_b = slots.default) == null ? void 0 : _b.call(slots)]);
+      }
+    };
+  }
+});
+
+exports["default"] = FormLabelWrap;
+//# sourceMappingURL=form-label-wrap.js.map

node_modules/element-plus/lib/components/form/src/form.d.ts

@@ -0,0 +1,47 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+import type { FormItemProp } from './form-item';
+export declare const formMetaProps: {
+    readonly size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabled: BooleanConstructor;
+};
+export declare const formProps: {
+    readonly model: ObjectConstructor;
+    readonly rules: {
+        readonly type: import("vue").PropType<Partial<Record<string, import("element-plus/es/utils").Arrayable<import("./types").FormItemRule>>>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+    readonly requireAsteriskPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+    readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    readonly labelSuffix: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly inline: BooleanConstructor;
+    readonly inlineMessage: BooleanConstructor;
+    readonly statusIcon: BooleanConstructor;
+    readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly validateOnRuleChange: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly hideRequiredAsterisk: BooleanConstructor;
+    readonly scrollToError: BooleanConstructor;
+    readonly scrollIntoViewOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => boolean | ScrollIntoViewOptions) | (() => boolean | ScrollIntoViewOptions) | ((new (...args: any[]) => boolean | ScrollIntoViewOptions) | (() => boolean | ScrollIntoViewOptions))[], unknown, unknown, true, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabled: BooleanConstructor;
+};
+export type FormProps = ExtractPropTypes<typeof formProps>;
+export type FormPropsPublic = __ExtractPublicPropTypes<typeof formProps>;
+export type FormMetaProps = ExtractPropTypes<typeof formMetaProps>;
+export type FormMetaPropsPublic = __ExtractPublicPropTypes<typeof formMetaProps>;
+export declare const formEmits: {
+    validate: (prop: FormItemProp, isValid: boolean, message: string) => boolean;
+};
+export type FormEmits = typeof formEmits;

node_modules/element-plus/lib/components/form/src/form.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtime = require('../../../utils/vue/props/runtime.js');
+var size = require('../../../constants/size.js');
+var shared = require('@vue/shared');
+var types = require('../../../utils/types.js');
+
+const formMetaProps = runtime.buildProps({
+  size: {
+    type: String,
+    values: size.componentSizes
+  },
+  disabled: Boolean
+});
+const formProps = runtime.buildProps({
+  ...formMetaProps,
+  model: Object,
+  rules: {
+    type: runtime.definePropType(Object)
+  },
+  labelPosition: {
+    type: String,
+    values: ["left", "right", "top"],
+    default: "right"
+  },
+  requireAsteriskPosition: {
+    type: String,
+    values: ["left", "right"],
+    default: "left"
+  },
+  labelWidth: {
+    type: [String, Number],
+    default: ""
+  },
+  labelSuffix: {
+    type: String,
+    default: ""
+  },
+  inline: Boolean,
+  inlineMessage: Boolean,
+  statusIcon: Boolean,
+  showMessage: {
+    type: Boolean,
+    default: true
+  },
+  validateOnRuleChange: {
+    type: Boolean,
+    default: true
+  },
+  hideRequiredAsterisk: Boolean,
+  scrollToError: Boolean,
+  scrollIntoViewOptions: {
+    type: runtime.definePropType([Object, Boolean]),
+    default: true
+  }
+});
+const formEmits = {
+  validate: (prop, isValid, message) => (shared.isArray(prop) || shared.isString(prop)) && types.isBoolean(isValid) && shared.isString(message)
+};
+
+exports.formEmits = formEmits;
+exports.formMetaProps = formMetaProps;
+exports.formProps = formProps;
+//# sourceMappingURL=form.js.map

node_modules/element-plus/lib/components/form/src/form.vue.d.ts

@@ -0,0 +1,684 @@
+import type { Arrayable } from 'element-plus/es/utils';
+import type { FormItemContext, FormValidateCallback, FormValidationResult } from './types';
+import type { FormItemProp } from './form-item';
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    readonly model: ObjectConstructor;
+    readonly rules: {
+        readonly type: import("vue").PropType<Partial<Record<string, Arrayable<import("./types").FormItemRule>>>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+    readonly requireAsteriskPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+    readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    readonly labelSuffix: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly inline: BooleanConstructor;
+    readonly inlineMessage: BooleanConstructor;
+    readonly statusIcon: BooleanConstructor;
+    readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly validateOnRuleChange: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly hideRequiredAsterisk: BooleanConstructor;
+    readonly scrollToError: BooleanConstructor;
+    readonly scrollIntoViewOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => boolean | ScrollIntoViewOptions) | (() => boolean | ScrollIntoViewOptions) | ((new (...args: any[]) => boolean | ScrollIntoViewOptions) | (() => boolean | ScrollIntoViewOptions))[], unknown, unknown, true, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabled: BooleanConstructor;
+}, {
+    /**
+     * @description Validate the whole form. Receives a callback or returns `Promise`.
+     */
+    validate: (callback?: FormValidateCallback) => FormValidationResult;
+    /**
+     * @description Validate specified fields.
+     */
+    validateField: (props?: Arrayable<FormItemProp>, callback?: FormValidateCallback) => FormValidationResult;
+    /**
+     * @description Reset specified fields and remove validation result.
+     */
+    resetFields: (props?: Arrayable<FormItemProp>) => void;
+    /**
+     * @description Clear validation message for specified fields.
+     */
+    clearValidate: (props?: Arrayable<FormItemProp>) => void;
+    /**
+     * @description Scroll to the specified fields.
+     */
+    scrollToField: (prop: FormItemProp) => void;
+    /**
+     * @description Get a field context.
+     */
+    getField: (prop: FormItemProp) => FormItemContext | undefined;
+    /**
+     * @description All fields context.
+     */
+    fields: {
+        $el: HTMLDivElement | undefined;
+        size: import("element-plus").ComponentSize;
+        validateMessage: string;
+        validateState: import("./form-item").FormItemValidateState;
+        isGroup: boolean;
+        labelId: string;
+        inputIds: string[];
+        hasLabel: boolean;
+        fieldValue: any;
+        propString: string;
+        addInputId: (id: string) => void;
+        removeInputId: (id: string) => void;
+        validate: (trigger: string, callback?: FormValidateCallback) => FormValidationResult;
+        resetField: () => void;
+        clearValidate: () => void;
+        readonly labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly labelPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "top" | "left" | "right", unknown>;
+        readonly showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly label?: string | undefined;
+        readonly prop?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => FormItemProp))[], unknown, unknown> | undefined;
+        readonly required?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
+        readonly error?: string | undefined;
+        readonly rules?: {
+            trigger?: Arrayable<string> | undefined;
+            type?: import("async-validator").RuleType | undefined;
+            required?: boolean | undefined;
+            pattern?: string | {
+                exec: (string: string) => RegExpExecArray | null;
+                test: (string: string) => boolean;
+                readonly source: string;
+                readonly global: boolean;
+                readonly ignoreCase: boolean;
+                readonly multiline: boolean;
+                lastIndex: number;
+                compile: (pattern: string, flags?: string) => RegExp;
+                readonly flags: string;
+                readonly sticky: boolean;
+                readonly unicode: boolean;
+                readonly dotAll: boolean;
+                [Symbol.match]: (string: string) => RegExpMatchArray | null;
+                [Symbol.replace]: {
+                    (string: string, replaceValue: string): string;
+                    (string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                };
+                [Symbol.search]: (string: string) => number;
+                [Symbol.split]: (string: string, limit?: number) => string[];
+            } | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+            len?: number | undefined;
+            enum?: Array<string | number | boolean | null | undefined> | undefined;
+            whitespace?: boolean | undefined;
+            fields?: Record<string, import("async-validator").Rule> | undefined;
+            options?: {
+                suppressWarning?: boolean | undefined;
+                suppressValidatorError?: boolean | undefined;
+                first?: boolean | undefined;
+                firstFields?: (boolean | string[]) | undefined;
+                messages?: {
+                    default?: (string | ((...args: unknown[]) => string)) | undefined;
+                    required?: (string | ((args_0: string | undefined) => string)) | undefined;
+                    enum?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                    whitespace?: (string | ((args_0: string | undefined) => string)) | undefined;
+                    date?: {
+                        format?: (string | ((...args: unknown[]) => string)) | undefined;
+                        parse?: (string | ((...args: unknown[]) => string)) | undefined;
+                        invalid?: (string | ((...args: unknown[]) => string)) | undefined;
+                    } | undefined;
+                    types?: {
+                        string?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        method?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        array?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        object?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        number?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        date?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        boolean?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        integer?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        float?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        regexp?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        email?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        url?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        hex?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                    } | undefined;
+                    string?: {
+                        len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                    } | undefined;
+                    number?: {
+                        len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                    } | undefined;
+                    array?: {
+                        len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                    } | undefined;
+                    pattern?: {
+                        mismatch?: (string | ((args_0: string | undefined, args_1: any, args_2: string | RegExp | undefined) => string)) | undefined;
+                    } | undefined;
+                } | undefined;
+                keys?: string[] | undefined;
+                error?: ((rule: import("async-validator").InternalRuleItem, message: string) => import("async-validator").ValidateError) | undefined;
+            } | undefined;
+            defaultField?: {
+                type?: import("async-validator").RuleType | undefined;
+                required?: boolean | undefined;
+                pattern?: string | {
+                    exec: (string: string) => RegExpExecArray | null;
+                    test: (string: string) => boolean;
+                    readonly source: string;
+                    readonly global: boolean;
+                    readonly ignoreCase: boolean;
+                    readonly multiline: boolean;
+                    lastIndex: number;
+                    compile: (pattern: string, flags?: string) => RegExp;
+                    readonly flags: string;
+                    readonly sticky: boolean;
+                    readonly unicode: boolean;
+                    readonly dotAll: boolean;
+                    [Symbol.match]: (string: string) => RegExpMatchArray | null;
+                    [Symbol.replace]: {
+                        (string: string, replaceValue: string): string;
+                        (string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                    };
+                    [Symbol.search]: (string: string) => number;
+                    [Symbol.split]: (string: string, limit?: number) => string[];
+                } | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+                len?: number | undefined;
+                enum?: Array<string | number | boolean | null | undefined> | undefined;
+                whitespace?: boolean | undefined;
+                fields?: Record<string, import("async-validator").Rule> | undefined;
+                options?: {
+                    suppressWarning?: boolean | undefined;
+                    suppressValidatorError?: boolean | undefined;
+                    first?: boolean | undefined;
+                    firstFields?: (boolean | string[]) | undefined;
+                    messages?: {
+                        default?: (string | ((...args: unknown[]) => string)) | undefined;
+                        required?: (string | ((args_0: string | undefined) => string)) | undefined;
+                        enum?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        whitespace?: (string | ((args_0: string | undefined) => string)) | undefined;
+                        date?: {
+                            format?: (string | ((...args: unknown[]) => string)) | undefined;
+                            parse?: (string | ((...args: unknown[]) => string)) | undefined;
+                            invalid?: (string | ((...args: unknown[]) => string)) | undefined;
+                        } | undefined;
+                        types?: {
+                            string?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            method?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            array?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            object?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            number?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            date?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            boolean?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            integer?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            float?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            regexp?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            email?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            url?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            hex?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        } | undefined;
+                        string?: {
+                            len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                        } | undefined;
+                        number?: {
+                            len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                        } | undefined;
+                        array?: {
+                            len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                        } | undefined;
+                        pattern?: {
+                            mismatch?: (string | ((args_0: string | undefined, args_1: any, args_2: string | RegExp | undefined) => string)) | undefined;
+                        } | undefined;
+                    } | undefined;
+                    keys?: string[] | undefined;
+                    error?: ((rule: import("async-validator").InternalRuleItem, message: string) => import("async-validator").ValidateError) | undefined;
+                } | undefined;
+                defaultField?: any | any[] | undefined;
+                transform?: ((value: import("async-validator").Value) => import("async-validator").Value) | undefined;
+                message?: (string | ((a?: string) => string)) | undefined;
+                asyncValidator?: ((rule: import("async-validator").InternalRuleItem, value: import("async-validator").Value, callback: (error?: string | Error) => void, source: import("async-validator").Values, options: import("async-validator").ValidateOption) => void | Promise<void>) | undefined;
+                validator?: ((rule: import("async-validator").InternalRuleItem, value: import("async-validator").Value, callback: (error?: string | Error) => void, source: import("async-validator").Values, options: import("async-validator").ValidateOption) => import("async-validator").SyncValidateResult | void) | undefined;
+            } | {
+                type?: import("async-validator").RuleType | undefined;
+                required?: boolean | undefined;
+                pattern?: string | {
+                    exec: (string: string) => RegExpExecArray | null;
+                    test: (string: string) => boolean;
+                    readonly source: string;
+                    readonly global: boolean;
+                    readonly ignoreCase: boolean;
+                    readonly multiline: boolean;
+                    lastIndex: number;
+                    compile: (pattern: string, flags?: string) => RegExp;
+                    readonly flags: string;
+                    readonly sticky: boolean;
+                    readonly unicode: boolean;
+                    readonly dotAll: boolean;
+                    [Symbol.match]: (string: string) => RegExpMatchArray | null;
+                    [Symbol.replace]: {
+                        (string: string, replaceValue: string): string;
+                        (string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                    };
+                    [Symbol.search]: (string: string) => number;
+                    [Symbol.split]: (string: string, limit?: number) => string[];
+                } | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+                len?: number | undefined;
+                enum?: Array<string | number | boolean | null | undefined> | undefined;
+                whitespace?: boolean | undefined;
+                fields?: Record<string, import("async-validator").Rule> | undefined;
+                options?: {
+                    suppressWarning?: boolean | undefined;
+                    suppressValidatorError?: boolean | undefined;
+                    first?: boolean | undefined;
+                    firstFields?: (boolean | string[]) | undefined;
+                    messages?: {
+                        default?: (string | ((...args: unknown[]) => string)) | undefined;
+                        required?: (string | ((args_0: string | undefined) => string)) | undefined;
+                        enum?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        whitespace?: (string | ((args_0: string | undefined) => string)) | undefined;
+                        date?: {
+                            format?: (string | ((...args: unknown[]) => string)) | undefined;
+                            parse?: (string | ((...args: unknown[]) => string)) | undefined;
+                            invalid?: (string | ((...args: unknown[]) => string)) | undefined;
+                        } | undefined;
+                        types?: {
+                            string?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            method?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            array?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            object?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            number?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            date?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            boolean?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            integer?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            float?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            regexp?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            email?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            url?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            hex?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        } | undefined;
+                        string?: {
+                            len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                        } | undefined;
+                        number?: {
+                            len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                        } | undefined;
+                        array?: {
+                            len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                        } | undefined;
+                        pattern?: {
+                            mismatch?: (string | ((args_0: string | undefined, args_1: any, args_2: string | RegExp | undefined) => string)) | undefined;
+                        } | undefined;
+                    } | undefined;
+                    keys?: string[] | undefined;
+                    error?: ((rule: import("async-validator").InternalRuleItem, message: string) => import("async-validator").ValidateError) | undefined;
+                } | undefined;
+                defaultField?: any | any[] | undefined;
+                transform?: ((value: import("async-validator").Value) => import("async-validator").Value) | undefined;
+                message?: (string | ((a?: string) => string)) | undefined;
+                asyncValidator?: ((rule: import("async-validator").InternalRuleItem, value: import("async-validator").Value, callback: (error?: string | Error) => void, source: import("async-validator").Values, options: import("async-validator").ValidateOption) => void | Promise<void>) | undefined;
+                validator?: ((rule: import("async-validator").InternalRuleItem, value: import("async-validator").Value, callback: (error?: string | Error) => void, source: import("async-validator").Values, options: import("async-validator").ValidateOption) => import("async-validator").SyncValidateResult | void) | undefined;
+            }[] | undefined;
+            transform?: ((value: import("async-validator").Value) => import("async-validator").Value) | undefined;
+            message?: (string | ((a?: string) => string)) | undefined;
+            asyncValidator?: ((rule: import("async-validator").InternalRuleItem, value: import("async-validator").Value, callback: (error?: string | Error) => void, source: import("async-validator").Values, options: import("async-validator").ValidateOption) => void | Promise<void>) | undefined;
+            validator?: ((rule: import("async-validator").InternalRuleItem, value: import("async-validator").Value, callback: (error?: string | Error) => void, source: import("async-validator").Values, options: import("async-validator").ValidateOption) => import("async-validator").SyncValidateResult | void) | undefined;
+        } | {
+            trigger?: Arrayable<string> | undefined;
+            type?: import("async-validator").RuleType | undefined;
+            required?: boolean | undefined;
+            pattern?: string | {
+                exec: (string: string) => RegExpExecArray | null;
+                test: (string: string) => boolean;
+                readonly source: string;
+                readonly global: boolean;
+                readonly ignoreCase: boolean;
+                readonly multiline: boolean;
+                lastIndex: number;
+                compile: (pattern: string, flags?: string) => RegExp;
+                readonly flags: string;
+                readonly sticky: boolean;
+                readonly unicode: boolean;
+                readonly dotAll: boolean;
+                [Symbol.match]: (string: string) => RegExpMatchArray | null;
+                [Symbol.replace]: {
+                    (string: string, replaceValue: string): string;
+                    (string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                };
+                [Symbol.search]: (string: string) => number;
+                [Symbol.split]: (string: string, limit?: number) => string[];
+            } | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+            len?: number | undefined;
+            enum?: Array<string | number | boolean | null | undefined> | undefined;
+            whitespace?: boolean | undefined;
+            fields?: Record<string, import("async-validator").Rule> | undefined;
+            options?: {
+                suppressWarning?: boolean | undefined;
+                suppressValidatorError?: boolean | undefined;
+                first?: boolean | undefined;
+                firstFields?: (boolean | string[]) | undefined;
+                messages?: {
+                    default?: (string | ((...args: unknown[]) => string)) | undefined;
+                    required?: (string | ((args_0: string | undefined) => string)) | undefined;
+                    enum?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                    whitespace?: (string | ((args_0: string | undefined) => string)) | undefined;
+                    date?: {
+                        format?: (string | ((...args: unknown[]) => string)) | undefined;
+                        parse?: (string | ((...args: unknown[]) => string)) | undefined;
+                        invalid?: (string | ((...args: unknown[]) => string)) | undefined;
+                    } | undefined;
+                    types?: {
+                        string?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        method?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        array?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        object?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        number?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        date?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        boolean?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        integer?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        float?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        regexp?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        email?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        url?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        hex?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                    } | undefined;
+                    string?: {
+                        len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                    } | undefined;
+                    number?: {
+                        len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                    } | undefined;
+                    array?: {
+                        len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                        range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                    } | undefined;
+                    pattern?: {
+                        mismatch?: (string | ((args_0: string | undefined, args_1: any, args_2: string | RegExp | undefined) => string)) | undefined;
+                    } | undefined;
+                } | undefined;
+                keys?: string[] | undefined;
+                error?: ((rule: import("async-validator").InternalRuleItem, message: string) => import("async-validator").ValidateError) | undefined;
+            } | undefined;
+            defaultField?: {
+                type?: import("async-validator").RuleType | undefined;
+                required?: boolean | undefined;
+                pattern?: string | {
+                    exec: (string: string) => RegExpExecArray | null;
+                    test: (string: string) => boolean;
+                    readonly source: string;
+                    readonly global: boolean;
+                    readonly ignoreCase: boolean;
+                    readonly multiline: boolean;
+                    lastIndex: number;
+                    compile: (pattern: string, flags?: string) => RegExp;
+                    readonly flags: string;
+                    readonly sticky: boolean;
+                    readonly unicode: boolean;
+                    readonly dotAll: boolean;
+                    [Symbol.match]: (string: string) => RegExpMatchArray | null;
+                    [Symbol.replace]: {
+                        (string: string, replaceValue: string): string;
+                        (string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                    };
+                    [Symbol.search]: (string: string) => number;
+                    [Symbol.split]: (string: string, limit?: number) => string[];
+                } | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+                len?: number | undefined;
+                enum?: Array<string | number | boolean | null | undefined> | undefined;
+                whitespace?: boolean | undefined;
+                fields?: Record<string, import("async-validator").Rule> | undefined;
+                options?: {
+                    suppressWarning?: boolean | undefined;
+                    suppressValidatorError?: boolean | undefined;
+                    first?: boolean | undefined;
+                    firstFields?: (boolean | string[]) | undefined;
+                    messages?: {
+                        default?: (string | ((...args: unknown[]) => string)) | undefined;
+                        required?: (string | ((args_0: string | undefined) => string)) | undefined;
+                        enum?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        whitespace?: (string | ((args_0: string | undefined) => string)) | undefined;
+                        date?: {
+                            format?: (string | ((...args: unknown[]) => string)) | undefined;
+                            parse?: (string | ((...args: unknown[]) => string)) | undefined;
+                            invalid?: (string | ((...args: unknown[]) => string)) | undefined;
+                        } | undefined;
+                        types?: {
+                            string?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            method?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            array?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            object?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            number?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            date?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            boolean?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            integer?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            float?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            regexp?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            email?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            url?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            hex?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        } | undefined;
+                        string?: {
+                            len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                        } | undefined;
+                        number?: {
+                            len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                        } | undefined;
+                        array?: {
+                            len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                        } | undefined;
+                        pattern?: {
+                            mismatch?: (string | ((args_0: string | undefined, args_1: any, args_2: string | RegExp | undefined) => string)) | undefined;
+                        } | undefined;
+                    } | undefined;
+                    keys?: string[] | undefined;
+                    error?: ((rule: import("async-validator").InternalRuleItem, message: string) => import("async-validator").ValidateError) | undefined;
+                } | undefined;
+                defaultField?: any | any[] | undefined;
+                transform?: ((value: import("async-validator").Value) => import("async-validator").Value) | undefined;
+                message?: (string | ((a?: string) => string)) | undefined;
+                asyncValidator?: ((rule: import("async-validator").InternalRuleItem, value: import("async-validator").Value, callback: (error?: string | Error) => void, source: import("async-validator").Values, options: import("async-validator").ValidateOption) => void | Promise<void>) | undefined;
+                validator?: ((rule: import("async-validator").InternalRuleItem, value: import("async-validator").Value, callback: (error?: string | Error) => void, source: import("async-validator").Values, options: import("async-validator").ValidateOption) => import("async-validator").SyncValidateResult | void) | undefined;
+            } | {
+                type?: import("async-validator").RuleType | undefined;
+                required?: boolean | undefined;
+                pattern?: string | {
+                    exec: (string: string) => RegExpExecArray | null;
+                    test: (string: string) => boolean;
+                    readonly source: string;
+                    readonly global: boolean;
+                    readonly ignoreCase: boolean;
+                    readonly multiline: boolean;
+                    lastIndex: number;
+                    compile: (pattern: string, flags?: string) => RegExp;
+                    readonly flags: string;
+                    readonly sticky: boolean;
+                    readonly unicode: boolean;
+                    readonly dotAll: boolean;
+                    [Symbol.match]: (string: string) => RegExpMatchArray | null;
+                    [Symbol.replace]: {
+                        (string: string, replaceValue: string): string;
+                        (string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                    };
+                    [Symbol.search]: (string: string) => number;
+                    [Symbol.split]: (string: string, limit?: number) => string[];
+                } | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+                len?: number | undefined;
+                enum?: Array<string | number | boolean | null | undefined> | undefined;
+                whitespace?: boolean | undefined;
+                fields?: Record<string, import("async-validator").Rule> | undefined;
+                options?: {
+                    suppressWarning?: boolean | undefined;
+                    suppressValidatorError?: boolean | undefined;
+                    first?: boolean | undefined;
+                    firstFields?: (boolean | string[]) | undefined;
+                    messages?: {
+                        default?: (string | ((...args: unknown[]) => string)) | undefined;
+                        required?: (string | ((args_0: string | undefined) => string)) | undefined;
+                        enum?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        whitespace?: (string | ((args_0: string | undefined) => string)) | undefined;
+                        date?: {
+                            format?: (string | ((...args: unknown[]) => string)) | undefined;
+                            parse?: (string | ((...args: unknown[]) => string)) | undefined;
+                            invalid?: (string | ((...args: unknown[]) => string)) | undefined;
+                        } | undefined;
+                        types?: {
+                            string?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            method?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            array?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            object?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            number?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            date?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            boolean?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            integer?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            float?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            regexp?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            email?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            url?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                            hex?: (string | ((args_0: string | undefined, args_1: string | undefined) => string)) | undefined;
+                        } | undefined;
+                        string?: {
+                            len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                        } | undefined;
+                        number?: {
+                            len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                        } | undefined;
+                        array?: {
+                            len?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            min?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            max?: (string | ((args_0: string | undefined, args_1: number | undefined) => string)) | undefined;
+                            range?: (string | ((args_0: string | undefined, args_1: number | undefined, args_2: number | undefined) => string)) | undefined;
+                        } | undefined;
+                        pattern?: {
+                            mismatch?: (string | ((args_0: string | undefined, args_1: any, args_2: string | RegExp | undefined) => string)) | undefined;
+                        } | undefined;
+                    } | undefined;
+                    keys?: string[] | undefined;
+                    error?: ((rule: import("async-validator").InternalRuleItem, message: string) => import("async-validator").ValidateError) | undefined;
+                } | undefined;
+                defaultField?: any | any[] | undefined;
+                transform?: ((value: import("async-validator").Value) => import("async-validator").Value) | undefined;
+                message?: (string | ((a?: string) => string)) | undefined;
+                asyncValidator?: ((rule: import("async-validator").InternalRuleItem, value: import("async-validator").Value, callback: (error?: string | Error) => void, source: import("async-validator").Values, options: import("async-validator").ValidateOption) => void | Promise<void>) | undefined;
+                validator?: ((rule: import("async-validator").InternalRuleItem, value: import("async-validator").Value, callback: (error?: string | Error) => void, source: import("async-validator").Values, options: import("async-validator").ValidateOption) => import("async-validator").SyncValidateResult | void) | undefined;
+            }[] | undefined;
+            transform?: ((value: import("async-validator").Value) => import("async-validator").Value) | undefined;
+            message?: (string | ((a?: string) => string)) | undefined;
+            asyncValidator?: ((rule: import("async-validator").InternalRuleItem, value: import("async-validator").Value, callback: (error?: string | Error) => void, source: import("async-validator").Values, options: import("async-validator").ValidateOption) => void | Promise<void>) | undefined;
+            validator?: ((rule: import("async-validator").InternalRuleItem, value: import("async-validator").Value, callback: (error?: string | Error) => void, source: import("async-validator").Values, options: import("async-validator").ValidateOption) => import("async-validator").SyncValidateResult | void) | undefined;
+        }[] | undefined;
+        readonly validateStatus?: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
+        readonly inlineMessage?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
+        readonly for?: string | undefined;
+    }[];
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    validate: (prop: FormItemProp, isValid: boolean, message: string) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly model: ObjectConstructor;
+    readonly rules: {
+        readonly type: import("vue").PropType<Partial<Record<string, Arrayable<import("./types").FormItemRule>>>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+    readonly requireAsteriskPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+    readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    readonly labelSuffix: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly inline: BooleanConstructor;
+    readonly inlineMessage: BooleanConstructor;
+    readonly statusIcon: BooleanConstructor;
+    readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly validateOnRuleChange: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly hideRequiredAsterisk: BooleanConstructor;
+    readonly scrollToError: BooleanConstructor;
+    readonly scrollIntoViewOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => boolean | ScrollIntoViewOptions) | (() => boolean | ScrollIntoViewOptions) | ((new (...args: any[]) => boolean | ScrollIntoViewOptions) | (() => boolean | ScrollIntoViewOptions))[], unknown, unknown, true, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabled: BooleanConstructor;
+}>> & {
+    onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+}, {
+    readonly disabled: boolean;
+    readonly inline: boolean;
+    readonly labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+    readonly labelPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+    readonly inlineMessage: boolean;
+    readonly showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly requireAsteriskPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+    readonly labelSuffix: string;
+    readonly validateOnRuleChange: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly scrollIntoViewOptions: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => boolean | ScrollIntoViewOptions) | (() => boolean | ScrollIntoViewOptions) | ((new (...args: any[]) => boolean | ScrollIntoViewOptions) | (() => boolean | ScrollIntoViewOptions))[], unknown, unknown>;
+    readonly statusIcon: boolean;
+    readonly hideRequiredAsterisk: boolean;
+    readonly scrollToError: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/element-plus/lib/components/form/src/form2.js

@@ -0,0 +1,166 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var constants = require('./constants.js');
+var form = require('./form.js');
+var utils = require('./utils.js');
+var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+var useFormCommonProps = require('./hooks/use-form-common-props.js');
+var index = require('../../../hooks/use-namespace/index.js');
+var error = require('../../../utils/error.js');
+var shared = require('@vue/shared');
+
+const COMPONENT_NAME = "ElForm";
+const __default__ = vue.defineComponent({
+  name: COMPONENT_NAME
+});
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: form.formProps,
+  emits: form.formEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const formRef = vue.ref();
+    const fields = vue.reactive([]);
+    const formSize = useFormCommonProps.useFormSize();
+    const ns = index.useNamespace("form");
+    const formClasses = vue.computed(() => {
+      const { labelPosition, inline } = props;
+      return [
+        ns.b(),
+        ns.m(formSize.value || "default"),
+        {
+          [ns.m(`label-${labelPosition}`)]: labelPosition,
+          [ns.m("inline")]: inline
+        }
+      ];
+    });
+    const getField = (prop) => {
+      return utils.filterFields(fields, [prop])[0];
+    };
+    const addField = (field) => {
+      fields.push(field);
+    };
+    const removeField = (field) => {
+      if (field.prop) {
+        fields.splice(fields.indexOf(field), 1);
+      }
+    };
+    const resetFields = (properties = []) => {
+      if (!props.model) {
+        return;
+      }
+      utils.filterFields(fields, properties).forEach((field) => field.resetField());
+    };
+    const clearValidate = (props2 = []) => {
+      utils.filterFields(fields, props2).forEach((field) => field.clearValidate());
+    };
+    const isValidatable = vue.computed(() => {
+      const hasModel = !!props.model;
+      return hasModel;
+    });
+    const obtainValidateFields = (props2) => {
+      if (fields.length === 0)
+        return [];
+      const filteredFields = utils.filterFields(fields, props2);
+      if (!filteredFields.length) {
+        return [];
+      }
+      return filteredFields;
+    };
+    const validate = async (callback) => validateField(void 0, callback);
+    const doValidateField = async (props2 = []) => {
+      if (!isValidatable.value)
+        return false;
+      const fields2 = obtainValidateFields(props2);
+      if (fields2.length === 0)
+        return true;
+      let validationErrors = {};
+      for (const field of fields2) {
+        try {
+          await field.validate("");
+          if (field.validateState === "error" && !field.error)
+            field.resetField();
+        } catch (fields3) {
+          validationErrors = {
+            ...validationErrors,
+            ...fields3
+          };
+        }
+      }
+      if (Object.keys(validationErrors).length === 0)
+        return true;
+      return Promise.reject(validationErrors);
+    };
+    const validateField = async (modelProps = [], callback) => {
+      let result = false;
+      const shouldThrow = !shared.isFunction(callback);
+      try {
+        result = await doValidateField(modelProps);
+        if (result === true) {
+          await (callback == null ? void 0 : callback(result));
+        }
+        return result;
+      } catch (e) {
+        if (e instanceof Error)
+          throw e;
+        const invalidFields = e;
+        if (props.scrollToError) {
+          if (formRef.value) {
+            const formItem = formRef.value.querySelector(`.${ns.b()}-item.is-error`);
+            formItem == null ? void 0 : formItem.scrollIntoView(props.scrollIntoViewOptions);
+          }
+        }
+        !result && await (callback == null ? void 0 : callback(false, invalidFields));
+        return shouldThrow && Promise.reject(invalidFields);
+      }
+    };
+    const scrollToField = (prop) => {
+      var _a;
+      const field = getField(prop);
+      if (field) {
+        (_a = field.$el) == null ? void 0 : _a.scrollIntoView(props.scrollIntoViewOptions);
+      }
+    };
+    vue.watch(() => props.rules, () => {
+      if (props.validateOnRuleChange) {
+        validate().catch((err) => error.debugWarn());
+      }
+    }, { deep: true, flush: "post" });
+    vue.provide(constants.formContextKey, vue.reactive({
+      ...vue.toRefs(props),
+      emit,
+      resetFields,
+      clearValidate,
+      validateField,
+      getField,
+      addField,
+      removeField,
+      ...utils.useFormLabelWidth()
+    }));
+    expose({
+      validate,
+      validateField,
+      resetFields,
+      clearValidate,
+      scrollToField,
+      getField,
+      fields
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("form", {
+        ref_key: "formRef",
+        ref: formRef,
+        class: vue.normalizeClass(vue.unref(formClasses))
+      }, [
+        vue.renderSlot(_ctx.$slots, "default")
+      ], 2);
+    };
+  }
+});
+var Form = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "form.vue"]]);
+
+exports["default"] = Form;
+//# sourceMappingURL=form2.js.map

node_modules/element-plus/lib/components/form/src/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './use-form-common-props';
+export * from './use-form-item';

node_modules/element-plus/lib/components/form/src/hooks/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useFormCommonProps = require('./use-form-common-props.js');
+var useFormItem = require('./use-form-item.js');
+
+
+
+exports.useDisabled = useFormCommonProps.useDisabled;
+exports.useFormDisabled = useFormCommonProps.useFormDisabled;
+exports.useFormSize = useFormCommonProps.useFormSize;
+exports.useSize = useFormCommonProps.useSize;
+exports.useFormItem = useFormItem.useFormItem;
+exports.useFormItemInputId = useFormItem.useFormItemInputId;
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/form/src/hooks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

node_modules/element-plus/lib/components/form/src/hooks/use-form-common-props.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentSize } from 'element-plus/es/constants';
+import type { MaybeRef } from '@vueuse/core';
+export declare const useFormSize: (fallback?: MaybeRef<ComponentSize | undefined>, ignore?: Partial<Record<"prop" | "form" | "formItem" | "global", boolean>>) => import("vue").ComputedRef<"" | "small" | "default" | "large">;
+export declare const useFormDisabled: (fallback?: MaybeRef<boolean | undefined>) => import("vue").ComputedRef<boolean>;
+export declare const useSize: (fallback?: MaybeRef<ComponentSize | undefined>, ignore?: Partial<Record<"prop" | "form" | "formItem" | "global", boolean>>) => import("vue").ComputedRef<"" | "small" | "default" | "large">;
+export declare const useDisabled: (fallback?: MaybeRef<boolean | undefined>) => import("vue").ComputedRef<boolean>;

node_modules/element-plus/lib/components/form/src/hooks/use-form-common-props.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index$1 = require('../../../../hooks/use-size/index.js');
+var index = require('../../../../hooks/use-prop/index.js');
+var constants = require('../constants.js');
+
+const useFormSize = (fallback, ignore = {}) => {
+  const emptyRef = vue.ref(void 0);
+  const size = ignore.prop ? emptyRef : index.useProp("size");
+  const globalConfig = ignore.global ? emptyRef : index$1.useGlobalSize();
+  const form = ignore.form ? { size: void 0 } : vue.inject(constants.formContextKey, void 0);
+  const formItem = ignore.formItem ? { size: void 0 } : vue.inject(constants.formItemContextKey, void 0);
+  return vue.computed(() => size.value || vue.unref(fallback) || (formItem == null ? void 0 : formItem.size) || (form == null ? void 0 : form.size) || globalConfig.value || "");
+};
+const useFormDisabled = (fallback) => {
+  const disabled = index.useProp("disabled");
+  const form = vue.inject(constants.formContextKey, void 0);
+  return vue.computed(() => disabled.value || vue.unref(fallback) || (form == null ? void 0 : form.disabled) || false);
+};
+const useSize = useFormSize;
+const useDisabled = useFormDisabled;
+
+exports.useDisabled = useDisabled;
+exports.useFormDisabled = useFormDisabled;
+exports.useFormSize = useFormSize;
+exports.useSize = useSize;
+//# sourceMappingURL=use-form-common-props.js.map

node_modules/element-plus/lib/components/form/src/hooks/use-form-common-props.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-form-common-props.js","sources":["../../../../../../../packages/components/form/src/hooks/use-form-common-props.ts"],"sourcesContent":["import { computed, inject, ref, unref } from 'vue'\nimport { useGlobalSize } from '@element-plus/hooks/use-size'\nimport { useProp } from '@element-plus/hooks/use-prop'\nimport { formContextKey, formItemContextKey } from '../constants'\n\nimport type { ComponentSize } from '@element-plus/constants'\nimport type { MaybeRef } from '@vueuse/core'\n\nexport const useFormSize = (\n  fallback?: MaybeRef<ComponentSize | undefined>,\n  ignore: Partial<Record<'prop' | 'form' | 'formItem' | 'global', boolean>> = {}\n) => {\n  const emptyRef = ref(undefined)\n\n  const size = ignore.prop ? emptyRef : useProp<ComponentSize>('size')\n  const globalConfig = ignore.global ? emptyRef : useGlobalSize()\n  const form = ignore.form\n    ? { size: undefined }\n    : inject(formContextKey, undefined)\n  const formItem = ignore.formItem\n    ? { size: undefined }\n    : inject(formItemContextKey, undefined)\n\n  return computed(\n    (): ComponentSize =>\n      size.value ||\n      unref(fallback) ||\n      formItem?.size ||\n      form?.size ||\n      globalConfig.value ||\n      ''\n  )\n}\n\nexport const useFormDisabled = (fallback?: MaybeRef<boolean | undefined>) => {\n  const disabled = useProp<boolean>('disabled')\n  const form = inject(formContextKey, undefined)\n  return computed(\n    () => disabled.value || unref(fallback) || form?.disabled || false\n  )\n}\n\n// These exports are used for preventing breaking changes\nexport const useSize = useFormSize\nexport const useDisabled = useFormDisabled\n"],"names":["ref","useProp","useGlobalSize","inject","formContextKey","formItemContextKey","computed","unref"],"mappings":";;;;;;;;;AAIY,MAAC,WAAW,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE,KAAK;AACtD,EAAE,MAAM,QAAQ,GAAGA,OAAG,CAAC,KAAK,CAAC,CAAC,CAAC;AAC/B,EAAE,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,GAAG,QAAQ,GAAGC,aAAO,CAAC,MAAM,CAAC,CAAC;AACxD,EAAE,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,GAAG,QAAQ,GAAGC,qBAAa,EAAE,CAAC;AAClE,EAAE,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,GAAGC,UAAM,CAACC,wBAAc,EAAE,KAAK,CAAC,CAAC,CAAC;AAC/E,EAAE,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,GAAGD,UAAM,CAACE,4BAAkB,EAAE,KAAK,CAAC,CAAC,CAAC;AAC3F,EAAE,OAAOC,YAAQ,CAAC,MAAM,IAAI,CAAC,KAAK,IAAIC,SAAK,CAAC,QAAQ,CAAC,KAAK,QAAQ,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,YAAY,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;AACzK,EAAE;AACU,MAAC,eAAe,GAAG,CAAC,QAAQ,KAAK;AAC7C,EAAE,MAAM,QAAQ,GAAGN,aAAO,CAAC,UAAU,CAAC,CAAC;AACvC,EAAE,MAAM,IAAI,GAAGE,UAAM,CAACC,wBAAc,EAAE,KAAK,CAAC,CAAC,CAAC;AAC9C,EAAE,OAAOE,YAAQ,CAAC,MAAM,QAAQ,CAAC,KAAK,IAAIC,SAAK,CAAC,QAAQ,CAAC,KAAK,IAAI,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,CAAC;AAC/G,EAAE;AACU,MAAC,OAAO,GAAG,YAAY;AACvB,MAAC,WAAW,GAAG;;;;;;;"}

node_modules/element-plus/lib/components/form/src/hooks/use-form-item.d.ts

@@ -0,0 +1,19 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { FormItemContext } from '../types';
+export declare const useFormItem: () => {
+    form: import("../types").FormContext | undefined;
+    formItem: FormItemContext | undefined;
+};
+export type IUseFormItemInputCommonProps = {
+    id?: string;
+    label?: string | number | boolean | Record<string, any>;
+    ariaLabel?: string | number | boolean | Record<string, any>;
+};
+export declare const useFormItemInputId: (props: Partial<IUseFormItemInputCommonProps>, { formItemContext, disableIdGeneration, disableIdManagement, }: {
+    formItemContext?: FormItemContext;
+    disableIdGeneration?: ComputedRef<boolean> | Ref<boolean>;
+    disableIdManagement?: ComputedRef<boolean> | Ref<boolean>;
+}) => {
+    isLabeledByFormItem: ComputedRef<boolean>;
+    inputId: Ref<string | undefined>;
+};

node_modules/element-plus/lib/components/form/src/hooks/use-form-item.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index = require('../../../../hooks/use-id/index.js');
+var constants = require('../constants.js');
+
+const useFormItem = () => {
+  const form = vue.inject(constants.formContextKey, void 0);
+  const formItem = vue.inject(constants.formItemContextKey, void 0);
+  return {
+    form,
+    formItem
+  };
+};
+const useFormItemInputId = (props, {
+  formItemContext,
+  disableIdGeneration,
+  disableIdManagement
+}) => {
+  if (!disableIdGeneration) {
+    disableIdGeneration = vue.ref(false);
+  }
+  if (!disableIdManagement) {
+    disableIdManagement = vue.ref(false);
+  }
+  const instance = vue.getCurrentInstance();
+  const inLabel = () => {
+    let parent = instance == null ? void 0 : instance.parent;
+    while (parent) {
+      if (parent.type.name === "ElFormItem") {
+        return false;
+      }
+      if (parent.type.name === "ElLabelWrap") {
+        return true;
+      }
+      parent = parent.parent;
+    }
+    return false;
+  };
+  const inputId = vue.ref();
+  let idUnwatch = void 0;
+  const isLabeledByFormItem = vue.computed(() => {
+    var _a;
+    return !!(!(props.label || props.ariaLabel) && formItemContext && formItemContext.inputIds && ((_a = formItemContext.inputIds) == null ? void 0 : _a.length) <= 1);
+  });
+  vue.onMounted(() => {
+    idUnwatch = vue.watch([vue.toRef(props, "id"), disableIdGeneration], ([id, disableIdGeneration2]) => {
+      const newId = id != null ? id : !disableIdGeneration2 ? index.useId().value : void 0;
+      if (newId !== inputId.value) {
+        if ((formItemContext == null ? void 0 : formItemContext.removeInputId) && !inLabel()) {
+          inputId.value && formItemContext.removeInputId(inputId.value);
+          if (!(disableIdManagement == null ? void 0 : disableIdManagement.value) && !disableIdGeneration2 && newId) {
+            formItemContext.addInputId(newId);
+          }
+        }
+        inputId.value = newId;
+      }
+    }, { immediate: true });
+  });
+  vue.onUnmounted(() => {
+    idUnwatch && idUnwatch();
+    if (formItemContext == null ? void 0 : formItemContext.removeInputId) {
+      inputId.value && formItemContext.removeInputId(inputId.value);
+    }
+  });
+  return {
+    isLabeledByFormItem,
+    inputId
+  };
+};
+
+exports.useFormItem = useFormItem;
+exports.useFormItemInputId = useFormItemInputId;
+//# sourceMappingURL=use-form-item.js.map

node_modules/element-plus/lib/components/form/src/types.d.ts

@@ -0,0 +1,45 @@
+import type { SetupContext, UnwrapRef } from 'vue';
+import type { RuleItem, ValidateError, ValidateFieldsError } from 'async-validator';
+import type { ComponentSize } from 'element-plus/es/constants';
+import type { Arrayable, FieldPath } from 'element-plus/es/utils';
+import type { MaybeRef } from '@vueuse/core';
+import type { FormItemProp, FormItemProps, FormItemValidateState } from './form-item';
+import type { FormEmits, FormProps } from './form';
+import type { useFormLabelWidth } from './utils';
+export type FormLabelWidthContext = ReturnType<typeof useFormLabelWidth>;
+export interface FormItemRule extends RuleItem {
+    trigger?: Arrayable<string>;
+}
+export type FormRules<T extends MaybeRef<Record<string, any> | string> = string> = Partial<Record<UnwrapRef<T> extends string ? UnwrapRef<T> : FieldPath<UnwrapRef<T>>, Arrayable<FormItemRule>>>;
+export type FormValidationResult = Promise<boolean>;
+export type FormValidateCallback = (isValid: boolean, invalidFields?: ValidateFieldsError) => Promise<void> | void;
+export interface FormValidateFailure {
+    errors: ValidateError[] | null;
+    fields: ValidateFieldsError;
+}
+export type FormContext = FormProps & UnwrapRef<FormLabelWidthContext> & {
+    emit: SetupContext<FormEmits>['emit'];
+    getField: (prop: FormItemProp) => FormItemContext | undefined;
+    addField: (field: FormItemContext) => void;
+    removeField: (field: FormItemContext) => void;
+    resetFields: (props?: Arrayable<FormItemProp>) => void;
+    clearValidate: (props?: Arrayable<FormItemProp>) => void;
+    validateField: (props?: Arrayable<FormItemProp>, callback?: FormValidateCallback) => FormValidationResult;
+};
+export interface FormItemContext extends FormItemProps {
+    $el: HTMLDivElement | undefined;
+    size: ComponentSize;
+    validateMessage: string;
+    validateState: FormItemValidateState;
+    isGroup: boolean;
+    labelId: string;
+    inputIds: string[];
+    hasLabel: boolean;
+    fieldValue: any;
+    propString: string;
+    addInputId: (id: string) => void;
+    removeInputId: (id: string) => void;
+    validate: (trigger: string, callback?: FormValidateCallback) => FormValidationResult;
+    resetField(): void;
+    clearValidate(): void;
+}

node_modules/element-plus/lib/components/form/src/types.js

@@ -0,0 +1,3 @@
+'use strict';
+
+//# sourceMappingURL=types.js.map

node_modules/element-plus/lib/components/form/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

node_modules/element-plus/lib/components/form/src/utils.d.ts

@@ -0,0 +1,9 @@
+import type { Arrayable } from 'element-plus/es/utils';
+import type { FormItemContext } from './types';
+import type { FormItemProp } from './form-item';
+export declare function useFormLabelWidth(): {
+    autoLabelWidth: import("vue").ComputedRef<string>;
+    registerLabelWidth: (val: number, oldVal: number) => void;
+    deregisterLabelWidth: (val: number) => void;
+};
+export declare const filterFields: (fields: FormItemContext[], props: Arrayable<FormItemProp>) => FormItemContext[];

node_modules/element-plus/lib/components/form/src/utils.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var lodashUnified = require('lodash-unified');
+var shared = require('@vue/shared');
+
+function useFormLabelWidth() {
+  const potentialLabelWidthArr = vue.ref([]);
+  const autoLabelWidth = vue.computed(() => {
+    if (!potentialLabelWidthArr.value.length)
+      return "0";
+    const max = Math.max(...potentialLabelWidthArr.value);
+    return max ? `${max}px` : "";
+  });
+  function getLabelWidthIndex(width) {
+    const index = potentialLabelWidthArr.value.indexOf(width);
+    if (index === -1 && autoLabelWidth.value === "0") ;
+    return index;
+  }
+  function registerLabelWidth(val, oldVal) {
+    if (val && oldVal) {
+      const index = getLabelWidthIndex(oldVal);
+      potentialLabelWidthArr.value.splice(index, 1, val);
+    } else if (val) {
+      potentialLabelWidthArr.value.push(val);
+    }
+  }
+  function deregisterLabelWidth(val) {
+    const index = getLabelWidthIndex(val);
+    if (index > -1) {
+      potentialLabelWidthArr.value.splice(index, 1);
+    }
+  }
+  return {
+    autoLabelWidth,
+    registerLabelWidth,
+    deregisterLabelWidth
+  };
+}
+const filterFields = (fields, props) => {
+  const normalized = lodashUnified.castArray(props).map((prop) => shared.isArray(prop) ? prop.join(".") : prop);
+  return normalized.length > 0 ? fields.filter((field) => field.propString && normalized.includes(field.propString)) : fields;
+};
+
+exports.filterFields = filterFields;
+exports.useFormLabelWidth = useFormLabelWidth;
+//# sourceMappingURL=utils.js.map

node_modules/element-plus/lib/components/form/src/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../../../packages/components/form/src/utils.ts"],"sourcesContent":["import { computed, ref } from 'vue'\nimport { debugWarn, ensureArray, isArray } from '@element-plus/utils'\n\nimport type { Arrayable } from '@element-plus/utils'\nimport type { FormItemContext } from './types'\nimport type { FormItemProp } from './form-item'\n\nconst SCOPE = 'ElForm'\n\nexport function useFormLabelWidth() {\n  const potentialLabelWidthArr = ref<number[]>([])\n\n  const autoLabelWidth = computed(() => {\n    if (!potentialLabelWidthArr.value.length) return '0'\n    const max = Math.max(...potentialLabelWidthArr.value)\n    return max ? `${max}px` : ''\n  })\n\n  function getLabelWidthIndex(width: number) {\n    const index = potentialLabelWidthArr.value.indexOf(width)\n    if (index === -1 && autoLabelWidth.value === '0') {\n      debugWarn(SCOPE, `unexpected width ${width}`)\n    }\n    return index\n  }\n\n  function registerLabelWidth(val: number, oldVal: number) {\n    if (val && oldVal) {\n      const index = getLabelWidthIndex(oldVal)\n      potentialLabelWidthArr.value.splice(index, 1, val)\n    } else if (val) {\n      potentialLabelWidthArr.value.push(val)\n    }\n  }\n\n  function deregisterLabelWidth(val: number) {\n    const index = getLabelWidthIndex(val)\n    if (index > -1) {\n      potentialLabelWidthArr.value.splice(index, 1)\n    }\n  }\n\n  return {\n    autoLabelWidth,\n    registerLabelWidth,\n    deregisterLabelWidth,\n  }\n}\n\nexport const filterFields = (\n  fields: FormItemContext[],\n  props: Arrayable<FormItemProp>\n) => {\n  const normalized = ensureArray(props).map((prop) =>\n    isArray(prop) ? prop.join('.') : prop\n  )\n  return normalized.length > 0\n    ? fields.filter(\n        (field) => field.propString && normalized.includes(field.propString)\n      )\n    : fields\n}\n"],"names":["ref","computed","ensureArray","isArray"],"mappings":";;;;;;;;AAGO,SAAS,iBAAiB,GAAG;AACpC,EAAE,MAAM,sBAAsB,GAAGA,OAAG,CAAC,EAAE,CAAC,CAAC;AACzC,EAAE,MAAM,cAAc,GAAGC,YAAQ,CAAC,MAAM;AACxC,IAAI,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,MAAM;AAC5C,MAAM,OAAO,GAAG,CAAC;AACjB,IAAI,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,sBAAsB,CAAC,KAAK,CAAC,CAAC;AAC1D,IAAI,OAAO,GAAG,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC;AACjC,GAAG,CAAC,CAAC;AACL,EAAE,SAAS,kBAAkB,CAAC,KAAK,EAAE;AACrC,IAAI,MAAM,KAAK,GAAG,sBAAsB,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9D,IAAI,IAAI,KAAK,KAAK,CAAC,CAAC,IAAI,cAAc,CAAC,KAAK,KAAK,GAAG,EAAE,CAEjD;AACL,IAAI,OAAO,KAAK,CAAC;AACjB,GAAG;AACH,EAAE,SAAS,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE;AAC3C,IAAI,IAAI,GAAG,IAAI,MAAM,EAAE;AACvB,MAAM,MAAM,KAAK,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;AAC/C,MAAM,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;AACzD,KAAK,MAAM,IAAI,GAAG,EAAE;AACpB,MAAM,sBAAsB,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC7C,KAAK;AACL,GAAG;AACH,EAAE,SAAS,oBAAoB,CAAC,GAAG,EAAE;AACrC,IAAI,MAAM,KAAK,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC;AAC1C,IAAI,IAAI,KAAK,GAAG,CAAC,CAAC,EAAE;AACpB,MAAM,sBAAsB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AACpD,KAAK;AACL,GAAG;AACH,EAAE,OAAO;AACT,IAAI,cAAc;AAClB,IAAI,kBAAkB;AACtB,IAAI,oBAAoB;AACxB,GAAG,CAAC;AACJ,CAAC;AACW,MAAC,YAAY,GAAG,CAAC,MAAM,EAAE,KAAK,KAAK;AAC/C,EAAE,MAAM,UAAU,GAAGC,uBAAW,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,KAAKC,cAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;AAC7F,EAAE,OAAO,UAAU,CAAC,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,KAAK,CAAC,UAAU,IAAI,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,GAAG,MAAM,CAAC;AAC9H;;;;;"}

node_modules/element-plus/lib/components/form/style/css.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/theme-chalk/el-form.css';

node_modules/element-plus/lib/components/form/style/css.js

@@ -0,0 +1,6 @@
+'use strict';
+
+require('../../base/style/css.js');
+require('element-plus/theme-chalk/el-form.css');
+
+//# sourceMappingURL=css.js.map

node_modules/element-plus/lib/components/form/style/css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}

node_modules/element-plus/lib/components/form/style/index.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/theme-chalk/src/form.scss';

node_modules/element-plus/lib/components/form/style/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+require('../../base/style/index.js');
+require('element-plus/theme-chalk/src/form.scss');
+
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/form/style/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}