vue-devui 1.0.0-alpha.6 → 1.0.0-beta.12

package/form/index.es.js

@@ -0,0 +1,2244 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { defineComponent, provide, createVNode, ref, toRefs, reactive, watch, withDirectives, resolveDirective, resolveComponent, inject, computed, onMounted, onBeforeUnmount, Teleport } from "vue";
+function mitt(n) {
+  return { all: n = n || new Map(), on: function(t, e) {
+    var i = n.get(t);
+    i ? i.push(e) : n.set(t, [e]);
+  }, off: function(t, e) {
+    var i = n.get(t);
+    i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
+  }, emit: function(t, e) {
+    var i = n.get(t);
+    i && i.slice().map(function(n2) {
+      n2(e);
+    }), (i = n.get("*")) && i.slice().map(function(n2) {
+      n2(t, e);
+    });
+  } };
+}
+const formProps = {
+  formData: {
+    type: Object,
+    default: {}
+  },
+  layout: {
+    type: String,
+    default: "horizontal"
+  },
+  labelSize: {
+    type: String,
+    default: ""
+  },
+  labelAlign: {
+    type: String,
+    default: "start"
+  },
+  rules: {
+    type: Object,
+    default: {}
+  },
+  columnsClass: {
+    type: String,
+    default: ""
+  },
+  name: {
+    type: String,
+    default: ""
+  },
+  messageShowType: {
+    type: String,
+    default: "popover"
+  }
+};
+const formItemProps = {
+  dHasFeedback: {
+    type: Boolean,
+    default: false
+  },
+  prop: {
+    type: String,
+    default: ""
+  }
+};
+const formLabelProps = {
+  required: {
+    type: Boolean,
+    default: false
+  },
+  hasHelp: {
+    type: Boolean,
+    default: false
+  },
+  helpTips: {
+    type: String,
+    default: ""
+  }
+};
+const formControlProps = {
+  feedbackStatus: {
+    type: String,
+    default: ""
+  },
+  extraInfo: {
+    type: String,
+    default: ""
+  }
+};
+const dFormEvents = {
+  addField: "d.form.addField",
+  removeField: "d.form.removeField"
+};
+const formInjectionKey = Symbol("dForm");
+const formItemInjectionKey = Symbol("dFormItem");
+const dFormItemEvents = {
+  blur: "d.form.blur",
+  change: "d.form.change",
+  input: "d.form.input"
+};
+var eventBus = mitt();
+const EventBus = eventBus;
+function isObject$1(obj) {
+  return Object.prototype.toString.call(obj).slice(8, -1) === "Object";
+}
+function hasKey(obj, key) {
+  if (!isObject$1(obj))
+    return false;
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function getElOffset(curEl) {
+  let totalLeft = 0;
+  let totalTop = 0;
+  let par = curEl.offsetParent;
+  totalLeft += curEl.offsetLeft;
+  totalTop += curEl.offsetTop;
+  while (par) {
+    if (navigator.userAgent.indexOf("MSIE 8.0") === -1) {
+      totalTop += par.clientTop;
+      totalLeft += par.clientLeft;
+    }
+    totalTop += par.offsetTop;
+    totalLeft += par.offsetLeft;
+    par = par.offsetParent;
+  }
+  return { left: totalLeft, top: totalTop };
+}
+var form = "";
+var Form = defineComponent({
+  name: "DForm",
+  props: formProps,
+  emits: ["submit"],
+  setup(props, ctx2) {
+    const formMitt = mitt();
+    const fields = [];
+    const resetFormFields = () => {
+      fields.forEach((field) => {
+        field.resetField();
+      });
+    };
+    formMitt.on(dFormEvents.addField, (field) => {
+      if (field) {
+        fields.push(field);
+      }
+    });
+    formMitt.on(dFormEvents.removeField, (field) => {
+      if (field.prop) {
+        fields.splice(fields.indexOf(field), 1);
+      }
+    });
+    provide(formInjectionKey, {
+      formData: props.formData,
+      formMitt,
+      labelData: {
+        layout: props.layout,
+        labelSize: props.labelSize,
+        labelAlign: props.labelAlign
+      },
+      rules: props.rules,
+      columnsClass: props.columnsClass,
+      messageShowType: "popover"
+    });
+    const onSubmit = (e) => {
+      e.preventDefault();
+      ctx2.emit("submit", e);
+      EventBus.emit(`formSubmit:${props.name}`);
+    };
+    return {
+      fields,
+      formMitt,
+      onSubmit,
+      resetFormFields
+    };
+  },
+  render() {
+    var _a, _b;
+    const {
+      onSubmit
+    } = this;
+    return createVNode("form", {
+      "onSubmit": onSubmit,
+      "class": "d-form"
+    }, [(_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a)]);
+  }
+});
+var Icon = defineComponent({
+  name: "DIcon",
+  props: {
+    name: {
+      type: String,
+      required: true
+    },
+    size: {
+      type: String,
+      default: "inherit"
+    },
+    color: {
+      type: String,
+      default: "inherit"
+    },
+    classPrefix: {
+      type: String,
+      default: "icon"
+    }
+  },
+  setup(props) {
+    return __spreadValues({}, props);
+  },
+  render() {
+    const {
+      name,
+      size,
+      color,
+      classPrefix
+    } = this;
+    return /^((https?):)?\/\//.test(name) ? createVNode("img", {
+      "src": name,
+      "alt": name.split("/")[name.split("/").length - 1],
+      "style": {
+        width: size,
+        verticalAlign: "text-bottom"
+      }
+    }, null) : createVNode("i", {
+      "class": `${classPrefix} ${classPrefix}-${name}`,
+      "style": {
+        fontSize: size,
+        color
+      }
+    }, null);
+  }
+});
+var debounce$1 = (callBack, wait) => {
+  let time = null;
+  return () => {
+    time && clearTimeout(time);
+    time = setTimeout(() => {
+      callBack == null ? void 0 : callBack();
+    }, wait);
+  };
+};
+const inBrowser = typeof window !== "undefined";
+function on(element, eventName, handler) {
+  if (document.addEventListener) {
+    if (element && eventName && handler) {
+      element.addEventListener(eventName, handler, false);
+    }
+  } else {
+    if (element && eventName && handler) {
+      element.attachEvent("on" + eventName, handler);
+    }
+  }
+}
+const ctx = Symbol("@@clickoutside");
+const nodeList = new Map();
+let startClick;
+let nid = 0;
+let isFirst = true;
+function createDocumentHandler(el, binding, vnode) {
+  if (inBrowser && isFirst) {
+    isFirst = false;
+    on(document, "mousedown", (e) => {
+      startClick = e;
+    });
+    on(document, "mouseup", (e) => {
+      for (const [id, node] of nodeList) {
+        node[ctx].documentHandler(e, startClick);
+      }
+    });
+  }
+  return function(mouseup, mousedown) {
+    if (!vnode || !binding.instance || !mouseup.target || !mousedown.target || el.contains(mouseup.target) || el.contains(mousedown.target) || el === mouseup.target) {
+      return;
+    }
+    el[ctx].bindingFn && el[ctx].bindingFn();
+  };
+}
+const clickoutsideDirective = {
+  beforeMount: function(el, binding, vnode) {
+    nid++;
+    nodeList.set(nid, el);
+    el[ctx] = {
+      nid,
+      documentHandler: createDocumentHandler(el, binding, vnode),
+      bindingFn: binding.value
+    };
+  },
+  updated: function(el, binding, vnode) {
+    el[ctx].documentHandler = createDocumentHandler(el, binding, vnode);
+    el[ctx].bindingFn = binding.value;
+  },
+  unmounted: function(el) {
+    nodeList.delete(el[ctx].nid);
+    delete el[ctx];
+  }
+};
+var popover = "";
+const popTypeClass = {
+  success: {
+    name: "right-o",
+    color: "rgb(61, 204, 166)"
+  },
+  error: {
+    name: "error-o",
+    color: "rgb(249, 95, 91)"
+  },
+  info: {
+    name: "info-o",
+    color: "rgb(81, 112, 255)"
+  },
+  warning: {
+    name: "warning-o",
+    color: "rgb(254, 204, 85)"
+  },
+  default: {}
+};
+var Popover = defineComponent({
+  name: "DPopover",
+  directives: {
+    clickoutside: clickoutsideDirective
+  },
+  props: {
+    visible: {
+      type: Boolean,
+      default: false
+    },
+    position: {
+      type: String,
+      default: "bottom"
+    },
+    content: {
+      type: String,
+      default: "default"
+    },
+    trigger: {
+      type: String,
+      default: "click"
+    },
+    zIndex: {
+      type: Number,
+      default: 1060
+    },
+    popType: {
+      type: String,
+      default: "default"
+    },
+    showAnimation: {
+      type: Boolean,
+      default: true
+    },
+    mouseEnterDelay: {
+      type: Number,
+      default: 150
+    },
+    mouseLeaveDelay: {
+      type: Number,
+      default: 100
+    },
+    popMaxWidth: {
+      type: Number,
+      default: void 0
+    },
+    popoverStyle: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(props, ctx2) {
+    const {
+      slots
+    } = ctx2;
+    const visible = ref(props.visible);
+    const {
+      position,
+      content,
+      zIndex,
+      trigger,
+      popType,
+      popoverStyle,
+      mouseEnterDelay,
+      mouseLeaveDelay,
+      showAnimation,
+      popMaxWidth
+    } = toRefs(props);
+    const style2 = __spreadValues({
+      zIndex: zIndex.value
+    }, popoverStyle.value);
+    const isClick = trigger.value === "click";
+    const iconType = reactive(popTypeClass[popType.value]);
+    const event = function() {
+      if (visible.value) {
+        visible.value = false;
+        return;
+      }
+      visible.value = true;
+    };
+    const onClick = isClick ? event : null;
+    const enter = debounce$1(() => {
+      visible.value = true;
+    }, mouseEnterDelay.value);
+    const leave = debounce$1(() => {
+      visible.value = false;
+    }, mouseLeaveDelay.value);
+    const onMouseenter = isClick ? null : enter;
+    const onMouseleave = isClick ? null : leave;
+    const hiddenContext = () => {
+      visible.value = false;
+    };
+    popMaxWidth.value && (style2.maxWidth = `${popMaxWidth.value}px`);
+    watch(() => props.visible, (newVal) => {
+      visible.value = newVal;
+    });
+    return () => {
+      var _a, _b;
+      return createVNode("div", {
+        "class": ["devui-popover", position.value, {
+          "devui-popover-animation": showAnimation.value,
+          "devui-popover-isVisible": visible.value
+        }]
+      }, [withDirectives(createVNode("div", {
+        "class": "devui-popover-reference",
+        "onMouseenter": onMouseenter,
+        "onMouseleave": onMouseleave,
+        "onClick": onClick
+      }, [(_a = slots.reference) == null ? void 0 : _a.call(slots)]), [[resolveDirective("clickoutside"), hiddenContext]]), createVNode("div", {
+        "class": ["devui-popover-content", iconType.name ? "is-icon" : ""],
+        "style": style2
+      }, [iconType.name && createVNode(resolveComponent("d-icon"), {
+        "name": iconType.name,
+        "color": iconType.color,
+        "class": "devui-popover-icon",
+        "size": "16px"
+      }, null), ((_b = slots.content) == null ? void 0 : _b.call(slots)) || createVNode("span", null, [content.value]), createVNode("span", {
+        "class": "after",
+        "style": style2
+      }, null)])]);
+    };
+  }
+});
+var formLabel = "";
+var FormLabel = defineComponent({
+  name: "DFormLabel",
+  props: formLabelProps,
+  setup(props, ctx2) {
+    const dForm = reactive(inject(formInjectionKey, {}));
+    const labelData = reactive(dForm.labelData);
+    const isHorizontal = computed(() => labelData.layout === "horizontal").value;
+    const isLg = computed(() => labelData.labelSize === "lg").value;
+    const isSm = computed(() => labelData.labelSize === "sm").value;
+    const isCenter = computed(() => labelData.labelAlign === "center").value;
+    const isEnd = computed(() => labelData.labelAlign === "end").value;
+    const wrapperCls = `form-label${isHorizontal ? isSm ? " form-label_sm" : isLg ? " form-label_lg" : " form-label_sd" : ""}${isCenter ? " form-label_center" : isEnd ? " form-label_end" : ""}`;
+    const className = `${props.required ? " devui-required" : ""}`;
+    const style2 = {
+      display: isHorizontal ? "inline" : "inline-block"
+    };
+    return () => {
+      var _a, _b;
+      return createVNode("span", {
+        "class": wrapperCls,
+        "style": style2
+      }, [createVNode("span", {
+        "class": className
+      }, [(_b = (_a = ctx2.slots).default) == null ? void 0 : _b.call(_a), props.hasHelp && props.helpTips && createVNode(Popover, {
+        "content": props.helpTips,
+        "showAnimation": false,
+        "position": "top",
+        "trigger": "hover"
+      }, {
+        reference: () => createVNode("span", {
+          "class": "form-label-help"
+        }, [createVNode(Icon, {
+          "name": "helping",
+          "color": "#252b3a"
+        }, null)])
+      })])]);
+    };
+  }
+});
+function _extends() {
+  _extends = Object.assign || function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct)
+    return false;
+  if (Reflect.construct.sham)
+    return false;
+  if (typeof Proxy === "function")
+    return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function _construct2(Parent2, args2, Class2) {
+      var a = [null];
+      a.push.apply(a, args2);
+      var Constructor = Function.bind.apply(Parent2, a);
+      var instance = new Constructor();
+      if (Class2)
+        _setPrototypeOf(instance, Class2.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : void 0;
+  _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
+    if (Class2 === null || !_isNativeFunction(Class2))
+      return Class2;
+    if (typeof Class2 !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class2))
+        return _cache.get(Class2);
+      _cache.set(Class2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class2.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class2);
+  };
+  return _wrapNativeSuper(Class);
+}
+var formatRegExp = /%[sdj%]/g;
+var warning = function warning2() {
+};
+if (typeof process !== "undefined" && process.env && false) {
+  warning = function warning3(type4, errors) {
+    if (typeof console !== "undefined" && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === "undefined") {
+      if (errors.every(function(e) {
+        return typeof e === "string";
+      })) {
+        console.warn(type4, errors);
+      }
+    }
+  };
+}
+function convertFieldsError(errors) {
+  if (!errors || !errors.length)
+    return null;
+  var fields = {};
+  errors.forEach(function(error) {
+    var field = error.field;
+    fields[field] = fields[field] || [];
+    fields[field].push(error);
+  });
+  return fields;
+}
+function format(template) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+  var i = 0;
+  var len = args.length;
+  if (typeof template === "function") {
+    return template.apply(null, args);
+  }
+  if (typeof template === "string") {
+    var str = template.replace(formatRegExp, function(x) {
+      if (x === "%%") {
+        return "%";
+      }
+      if (i >= len) {
+        return x;
+      }
+      switch (x) {
+        case "%s":
+          return String(args[i++]);
+        case "%d":
+          return Number(args[i++]);
+        case "%j":
+          try {
+            return JSON.stringify(args[i++]);
+          } catch (_) {
+            return "[Circular]";
+          }
+          break;
+        default:
+          return x;
+      }
+    });
+    return str;
+  }
+  return template;
+}
+function isNativeStringType(type4) {
+  return type4 === "string" || type4 === "url" || type4 === "hex" || type4 === "email" || type4 === "date" || type4 === "pattern";
+}
+function isEmptyValue(value, type4) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (type4 === "array" && Array.isArray(value) && !value.length) {
+    return true;
+  }
+  if (isNativeStringType(type4) && typeof value === "string" && !value) {
+    return true;
+  }
+  return false;
+}
+function asyncParallelArray(arr, func, callback) {
+  var results = [];
+  var total = 0;
+  var arrLength = arr.length;
+  function count(errors) {
+    results.push.apply(results, errors || []);
+    total++;
+    if (total === arrLength) {
+      callback(results);
+    }
+  }
+  arr.forEach(function(a) {
+    func(a, count);
+  });
+}
+function asyncSerialArray(arr, func, callback) {
+  var index2 = 0;
+  var arrLength = arr.length;
+  function next(errors) {
+    if (errors && errors.length) {
+      callback(errors);
+      return;
+    }
+    var original = index2;
+    index2 = index2 + 1;
+    if (original < arrLength) {
+      func(arr[original], next);
+    } else {
+      callback([]);
+    }
+  }
+  next([]);
+}
+function flattenObjArr(objArr) {
+  var ret = [];
+  Object.keys(objArr).forEach(function(k) {
+    ret.push.apply(ret, objArr[k] || []);
+  });
+  return ret;
+}
+var AsyncValidationError = /* @__PURE__ */ function(_Error) {
+  _inheritsLoose(AsyncValidationError2, _Error);
+  function AsyncValidationError2(errors, fields) {
+    var _this;
+    _this = _Error.call(this, "Async Validation Error") || this;
+    _this.errors = errors;
+    _this.fields = fields;
+    return _this;
+  }
+  return AsyncValidationError2;
+}(/* @__PURE__ */ _wrapNativeSuper(Error));
+function asyncMap(objArr, option, func, callback, source) {
+  if (option.first) {
+    var _pending = new Promise(function(resolve, reject) {
+      var next = function next2(errors) {
+        callback(errors);
+        return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
+      };
+      var flattenArr = flattenObjArr(objArr);
+      asyncSerialArray(flattenArr, func, next);
+    });
+    _pending["catch"](function(e) {
+      return e;
+    });
+    return _pending;
+  }
+  var firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
+  var objArrKeys = Object.keys(objArr);
+  var objArrLength = objArrKeys.length;
+  var total = 0;
+  var results = [];
+  var pending = new Promise(function(resolve, reject) {
+    var next = function next2(errors) {
+      results.push.apply(results, errors);
+      total++;
+      if (total === objArrLength) {
+        callback(results);
+        return results.length ? reject(new AsyncValidationError(results, convertFieldsError(results))) : resolve(source);
+      }
+    };
+    if (!objArrKeys.length) {
+      callback(results);
+      resolve(source);
+    }
+    objArrKeys.forEach(function(key) {
+      var arr = objArr[key];
+      if (firstFields.indexOf(key) !== -1) {
+        asyncSerialArray(arr, func, next);
+      } else {
+        asyncParallelArray(arr, func, next);
+      }
+    });
+  });
+  pending["catch"](function(e) {
+    return e;
+  });
+  return pending;
+}
+function isErrorObj(obj) {
+  return !!(obj && obj.message !== void 0);
+}
+function getValue(value, path) {
+  var v = value;
+  for (var i = 0; i < path.length; i++) {
+    if (v == void 0) {
+      return v;
+    }
+    v = v[path[i]];
+  }
+  return v;
+}
+function complementError(rule, source) {
+  return function(oe) {
+    var fieldValue;
+    if (rule.fullFields) {
+      fieldValue = getValue(source, rule.fullFields);
+    } else {
+      fieldValue = source[oe.field || rule.fullField];
+    }
+    if (isErrorObj(oe)) {
+      oe.field = oe.field || rule.fullField;
+      oe.fieldValue = fieldValue;
+      return oe;
+    }
+    return {
+      message: typeof oe === "function" ? oe() : oe,
+      fieldValue,
+      field: oe.field || rule.fullField
+    };
+  };
+}
+function deepMerge(target, source) {
+  if (source) {
+    for (var s in source) {
+      if (source.hasOwnProperty(s)) {
+        var value = source[s];
+        if (typeof value === "object" && typeof target[s] === "object") {
+          target[s] = _extends({}, target[s], value);
+        } else {
+          target[s] = value;
+        }
+      }
+    }
+  }
+  return target;
+}
+var required$1 = function required(rule, value, source, errors, options, type4) {
+  if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type4 || rule.type))) {
+    errors.push(format(options.messages.required, rule.fullField));
+  }
+};
+var whitespace = function whitespace2(rule, value, source, errors, options) {
+  if (/^\s+$/.test(value) || value === "") {
+    errors.push(format(options.messages.whitespace, rule.fullField));
+  }
+};
+var pattern$2 = {
+  email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
+  url: new RegExp("^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$", "i"),
+  hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
+};
+var types = {
+  integer: function integer(value) {
+    return types.number(value) && parseInt(value, 10) === value;
+  },
+  "float": function float(value) {
+    return types.number(value) && !types.integer(value);
+  },
+  array: function array(value) {
+    return Array.isArray(value);
+  },
+  regexp: function regexp(value) {
+    if (value instanceof RegExp) {
+      return true;
+    }
+    try {
+      return !!new RegExp(value);
+    } catch (e) {
+      return false;
+    }
+  },
+  date: function date(value) {
+    return typeof value.getTime === "function" && typeof value.getMonth === "function" && typeof value.getYear === "function" && !isNaN(value.getTime());
+  },
+  number: function number(value) {
+    if (isNaN(value)) {
+      return false;
+    }
+    return typeof value === "number";
+  },
+  object: function object(value) {
+    return typeof value === "object" && !types.array(value);
+  },
+  method: function method(value) {
+    return typeof value === "function";
+  },
+  email: function email(value) {
+    return typeof value === "string" && value.length <= 320 && !!value.match(pattern$2.email);
+  },
+  url: function url(value) {
+    return typeof value === "string" && value.length <= 2048 && !!value.match(pattern$2.url);
+  },
+  hex: function hex(value) {
+    return typeof value === "string" && !!value.match(pattern$2.hex);
+  }
+};
+var type$1 = function type(rule, value, source, errors, options) {
+  if (rule.required && value === void 0) {
+    required$1(rule, value, source, errors, options);
+    return;
+  }
+  var custom = ["integer", "float", "array", "regexp", "object", "method", "email", "number", "date", "url", "hex"];
+  var ruleType = rule.type;
+  if (custom.indexOf(ruleType) > -1) {
+    if (!types[ruleType](value)) {
+      errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
+    }
+  } else if (ruleType && typeof value !== rule.type) {
+    errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
+  }
+};
+var range = function range2(rule, value, source, errors, options) {
+  var len = typeof rule.len === "number";
+  var min = typeof rule.min === "number";
+  var max = typeof rule.max === "number";
+  var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  var val = value;
+  var key = null;
+  var num = typeof value === "number";
+  var str = typeof value === "string";
+  var arr = Array.isArray(value);
+  if (num) {
+    key = "number";
+  } else if (str) {
+    key = "string";
+  } else if (arr) {
+    key = "array";
+  }
+  if (!key) {
+    return false;
+  }
+  if (arr) {
+    val = value.length;
+  }
+  if (str) {
+    val = value.replace(spRegexp, "_").length;
+  }
+  if (len) {
+    if (val !== rule.len) {
+      errors.push(format(options.messages[key].len, rule.fullField, rule.len));
+    }
+  } else if (min && !max && val < rule.min) {
+    errors.push(format(options.messages[key].min, rule.fullField, rule.min));
+  } else if (max && !min && val > rule.max) {
+    errors.push(format(options.messages[key].max, rule.fullField, rule.max));
+  } else if (min && max && (val < rule.min || val > rule.max)) {
+    errors.push(format(options.messages[key].range, rule.fullField, rule.min, rule.max));
+  }
+};
+var ENUM$1 = "enum";
+var enumerable$1 = function enumerable(rule, value, source, errors, options) {
+  rule[ENUM$1] = Array.isArray(rule[ENUM$1]) ? rule[ENUM$1] : [];
+  if (rule[ENUM$1].indexOf(value) === -1) {
+    errors.push(format(options.messages[ENUM$1], rule.fullField, rule[ENUM$1].join(", ")));
+  }
+};
+var pattern$1 = function pattern(rule, value, source, errors, options) {
+  if (rule.pattern) {
+    if (rule.pattern instanceof RegExp) {
+      rule.pattern.lastIndex = 0;
+      if (!rule.pattern.test(value)) {
+        errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
+      }
+    } else if (typeof rule.pattern === "string") {
+      var _pattern = new RegExp(rule.pattern);
+      if (!_pattern.test(value)) {
+        errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
+      }
+    }
+  }
+};
+var rules = {
+  required: required$1,
+  whitespace,
+  type: type$1,
+  range,
+  "enum": enumerable$1,
+  pattern: pattern$1
+};
+var string = function string2(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value, "string") && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options, "string");
+    if (!isEmptyValue(value, "string")) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+      rules.pattern(rule, value, source, errors, options);
+      if (rule.whitespace === true) {
+        rules.whitespace(rule, value, source, errors, options);
+      }
+    }
+  }
+  callback(errors);
+};
+var method2 = function method3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var number2 = function number3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (value === "") {
+      value = void 0;
+    }
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _boolean = function _boolean2(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var regexp2 = function regexp3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (!isEmptyValue(value)) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var integer2 = function integer3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var floatFn = function floatFn2(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var array2 = function array3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((value === void 0 || value === null) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options, "array");
+    if (value !== void 0 && value !== null) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var object2 = function object3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var ENUM = "enum";
+var enumerable2 = function enumerable3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== void 0) {
+      rules[ENUM](rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var pattern2 = function pattern3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value, "string") && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (!isEmptyValue(value, "string")) {
+      rules.pattern(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var date2 = function date3(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value, "date") && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (!isEmptyValue(value, "date")) {
+      var dateObject;
+      if (value instanceof Date) {
+        dateObject = value;
+      } else {
+        dateObject = new Date(value);
+      }
+      rules.type(rule, dateObject, source, errors, options);
+      if (dateObject) {
+        rules.range(rule, dateObject.getTime(), source, errors, options);
+      }
+    }
+  }
+  callback(errors);
+};
+var required2 = function required3(rule, value, callback, source, options) {
+  var errors = [];
+  var type4 = Array.isArray(value) ? "array" : typeof value;
+  rules.required(rule, value, source, errors, options, type4);
+  callback(errors);
+};
+var type2 = function type3(rule, value, callback, source, options) {
+  var ruleType = rule.type;
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value, ruleType) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options, ruleType);
+    if (!isEmptyValue(value, ruleType)) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var any = function any2(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+  }
+  callback(errors);
+};
+var validators = {
+  string,
+  method: method2,
+  number: number2,
+  "boolean": _boolean,
+  regexp: regexp2,
+  integer: integer2,
+  "float": floatFn,
+  array: array2,
+  object: object2,
+  "enum": enumerable2,
+  pattern: pattern2,
+  date: date2,
+  url: type2,
+  hex: type2,
+  email: type2,
+  required: required2,
+  any
+};
+function newMessages() {
+  return {
+    "default": "Validation error on field %s",
+    required: "%s is required",
+    "enum": "%s must be one of %s",
+    whitespace: "%s cannot be empty",
+    date: {
+      format: "%s date %s is invalid for format %s",
+      parse: "%s date could not be parsed, %s is invalid ",
+      invalid: "%s date %s is invalid"
+    },
+    types: {
+      string: "%s is not a %s",
+      method: "%s is not a %s (function)",
+      array: "%s is not an %s",
+      object: "%s is not an %s",
+      number: "%s is not a %s",
+      date: "%s is not a %s",
+      "boolean": "%s is not a %s",
+      integer: "%s is not an %s",
+      "float": "%s is not a %s",
+      regexp: "%s is not a valid %s",
+      email: "%s is not a valid %s",
+      url: "%s is not a valid %s",
+      hex: "%s is not a valid %s"
+    },
+    string: {
+      len: "%s must be exactly %s characters",
+      min: "%s must be at least %s characters",
+      max: "%s cannot be longer than %s characters",
+      range: "%s must be between %s and %s characters"
+    },
+    number: {
+      len: "%s must equal %s",
+      min: "%s cannot be less than %s",
+      max: "%s cannot be greater than %s",
+      range: "%s must be between %s and %s"
+    },
+    array: {
+      len: "%s must be exactly %s in length",
+      min: "%s cannot be less than %s in length",
+      max: "%s cannot be greater than %s in length",
+      range: "%s must be between %s and %s in length"
+    },
+    pattern: {
+      mismatch: "%s value %s does not match pattern %s"
+    },
+    clone: function clone() {
+      var cloned = JSON.parse(JSON.stringify(this));
+      cloned.clone = this.clone;
+      return cloned;
+    }
+  };
+}
+var messages = newMessages();
+var Schema = /* @__PURE__ */ function() {
+  function Schema2(descriptor) {
+    this.rules = null;
+    this._messages = messages;
+    this.define(descriptor);
+  }
+  var _proto = Schema2.prototype;
+  _proto.define = function define(rules2) {
+    var _this = this;
+    if (!rules2) {
+      throw new Error("Cannot configure a schema with no rules");
+    }
+    if (typeof rules2 !== "object" || Array.isArray(rules2)) {
+      throw new Error("Rules must be an object");
+    }
+    this.rules = {};
+    Object.keys(rules2).forEach(function(name) {
+      var item = rules2[name];
+      _this.rules[name] = Array.isArray(item) ? item : [item];
+    });
+  };
+  _proto.messages = function messages2(_messages) {
+    if (_messages) {
+      this._messages = deepMerge(newMessages(), _messages);
+    }
+    return this._messages;
+  };
+  _proto.validate = function validate(source_, o, oc) {
+    var _this2 = this;
+    if (o === void 0) {
+      o = {};
+    }
+    if (oc === void 0) {
+      oc = function oc2() {
+      };
+    }
+    var source = source_;
+    var options = o;
+    var callback = oc;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    if (!this.rules || Object.keys(this.rules).length === 0) {
+      if (callback) {
+        callback(null, source);
+      }
+      return Promise.resolve(source);
+    }
+    function complete(results) {
+      var errors = [];
+      var fields = {};
+      function add(e) {
+        if (Array.isArray(e)) {
+          var _errors;
+          errors = (_errors = errors).concat.apply(_errors, e);
+        } else {
+          errors.push(e);
+        }
+      }
+      for (var i = 0; i < results.length; i++) {
+        add(results[i]);
+      }
+      if (!errors.length) {
+        callback(null, source);
+      } else {
+        fields = convertFieldsError(errors);
+        callback(errors, fields);
+      }
+    }
+    if (options.messages) {
+      var messages$1 = this.messages();
+      if (messages$1 === messages) {
+        messages$1 = newMessages();
+      }
+      deepMerge(messages$1, options.messages);
+      options.messages = messages$1;
+    } else {
+      options.messages = this.messages();
+    }
+    var series = {};
+    var keys = options.keys || Object.keys(this.rules);
+    keys.forEach(function(z) {
+      var arr = _this2.rules[z];
+      var value = source[z];
+      arr.forEach(function(r) {
+        var rule = r;
+        if (typeof rule.transform === "function") {
+          if (source === source_) {
+            source = _extends({}, source);
+          }
+          value = source[z] = rule.transform(value);
+        }
+        if (typeof rule === "function") {
+          rule = {
+            validator: rule
+          };
+        } else {
+          rule = _extends({}, rule);
+        }
+        rule.validator = _this2.getValidationMethod(rule);
+        if (!rule.validator) {
+          return;
+        }
+        rule.field = z;
+        rule.fullField = rule.fullField || z;
+        rule.type = _this2.getType(rule);
+        series[z] = series[z] || [];
+        series[z].push({
+          rule,
+          value,
+          source,
+          field: z
+        });
+      });
+    });
+    var errorFields = {};
+    return asyncMap(series, options, function(data, doIt) {
+      var rule = data.rule;
+      var deep = (rule.type === "object" || rule.type === "array") && (typeof rule.fields === "object" || typeof rule.defaultField === "object");
+      deep = deep && (rule.required || !rule.required && data.value);
+      rule.field = data.field;
+      function addFullField(key, schema) {
+        return _extends({}, schema, {
+          fullField: rule.fullField + "." + key,
+          fullFields: rule.fullFields ? [].concat(rule.fullFields, [key]) : [key]
+        });
+      }
+      function cb(e) {
+        if (e === void 0) {
+          e = [];
+        }
+        var errorList = Array.isArray(e) ? e : [e];
+        if (!options.suppressWarning && errorList.length) {
+          Schema2.warning("async-validator:", errorList);
+        }
+        if (errorList.length && rule.message !== void 0) {
+          errorList = [].concat(rule.message);
+        }
+        var filledErrors = errorList.map(complementError(rule, source));
+        if (options.first && filledErrors.length) {
+          errorFields[rule.field] = 1;
+          return doIt(filledErrors);
+        }
+        if (!deep) {
+          doIt(filledErrors);
+        } else {
+          if (rule.required && !data.value) {
+            if (rule.message !== void 0) {
+              filledErrors = [].concat(rule.message).map(complementError(rule, source));
+            } else if (options.error) {
+              filledErrors = [options.error(rule, format(options.messages.required, rule.field))];
+            }
+            return doIt(filledErrors);
+          }
+          var fieldsSchema = {};
+          if (rule.defaultField) {
+            Object.keys(data.value).map(function(key) {
+              fieldsSchema[key] = rule.defaultField;
+            });
+          }
+          fieldsSchema = _extends({}, fieldsSchema, data.rule.fields);
+          var paredFieldsSchema = {};
+          Object.keys(fieldsSchema).forEach(function(field) {
+            var fieldSchema = fieldsSchema[field];
+            var fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
+            paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
+          });
+          var schema = new Schema2(paredFieldsSchema);
+          schema.messages(options.messages);
+          if (data.rule.options) {
+            data.rule.options.messages = options.messages;
+            data.rule.options.error = options.error;
+          }
+          schema.validate(data.value, data.rule.options || options, function(errs) {
+            var finalErrors = [];
+            if (filledErrors && filledErrors.length) {
+              finalErrors.push.apply(finalErrors, filledErrors);
+            }
+            if (errs && errs.length) {
+              finalErrors.push.apply(finalErrors, errs);
+            }
+            doIt(finalErrors.length ? finalErrors : null);
+          });
+        }
+      }
+      var res;
+      if (rule.asyncValidator) {
+        res = rule.asyncValidator(rule, data.value, cb, data.source, options);
+      } else if (rule.validator) {
+        res = rule.validator(rule, data.value, cb, data.source, options);
+        if (res === true) {
+          cb();
+        } else if (res === false) {
+          cb(typeof rule.message === "function" ? rule.message(rule.fullField || rule.field) : rule.message || (rule.fullField || rule.field) + " fails");
+        } else if (res instanceof Array) {
+          cb(res);
+        } else if (res instanceof Error) {
+          cb(res.message);
+        }
+      }
+      if (res && res.then) {
+        res.then(function() {
+          return cb();
+        }, function(e) {
+          return cb(e);
+        });
+      }
+    }, function(results) {
+      complete(results);
+    }, source);
+  };
+  _proto.getType = function getType(rule) {
+    if (rule.type === void 0 && rule.pattern instanceof RegExp) {
+      rule.type = "pattern";
+    }
+    if (typeof rule.validator !== "function" && rule.type && !validators.hasOwnProperty(rule.type)) {
+      throw new Error(format("Unknown rule type %s", rule.type));
+    }
+    return rule.type || "string";
+  };
+  _proto.getValidationMethod = function getValidationMethod(rule) {
+    if (typeof rule.validator === "function") {
+      return rule.validator;
+    }
+    var keys = Object.keys(rule);
+    var messageIndex = keys.indexOf("message");
+    if (messageIndex !== -1) {
+      keys.splice(messageIndex, 1);
+    }
+    if (keys.length === 1 && keys[0] === "required") {
+      return validators.required;
+    }
+    return validators[this.getType(rule)] || void 0;
+  };
+  return Schema2;
+}();
+Schema.register = function register(type4, validator) {
+  if (typeof validator !== "function") {
+    throw new Error("Cannot register a validator by type, validator is not a function");
+  }
+  validators[type4] = validator;
+};
+Schema.warning = warning;
+Schema.messages = messages;
+Schema.validators = validators;
+var formItem = "";
+var FormItem = defineComponent({
+  name: "DFormItem",
+  props: formItemProps,
+  setup(props, ctx2) {
+    const formItemMitt = mitt();
+    const dForm = reactive(inject(formInjectionKey, {}));
+    const formData = reactive(dForm.formData);
+    const columnsClass = ref(dForm.columnsClass);
+    const initFormItemData = formData[props.prop];
+    const labelData = reactive(dForm.labelData);
+    const rules2 = reactive(dForm.rules);
+    const resetField = () => {
+      formData[props.prop] = initFormItemData;
+    };
+    const formItem2 = reactive({
+      dHasFeedback: props.dHasFeedback,
+      prop: props.prop,
+      formItemMitt,
+      resetField
+    });
+    provide(formItemInjectionKey, formItem2);
+    const isHorizontal = labelData.layout === "horizontal";
+    const isVertical = labelData.layout === "vertical";
+    const isColumns = labelData.layout === "columns";
+    const showMessage = ref(false);
+    const tipMessage = ref("");
+    const validate = (trigger) => {
+      const ruleKey = props.prop;
+      const ruleItem = rules2[ruleKey];
+      const descriptor = {};
+      descriptor[ruleKey] = ruleItem;
+      const validator = new Schema(descriptor);
+      validator.validate({
+        [ruleKey]: formData[ruleKey]
+      }).then(() => {
+        showMessage.value = false;
+        tipMessage.value = "";
+      }).catch(({
+        errors
+      }) => {
+        showMessage.value = true;
+        tipMessage.value = errors[0].message;
+      });
+    };
+    const validateEvents = [];
+    const addValidateEvents = () => {
+      if (rules2 && rules2[props.prop]) {
+        const ruleItem = rules2[props.prop];
+        let eventName = ruleItem["trigger"];
+        if (Array.isArray(ruleItem)) {
+          ruleItem.forEach((item) => {
+            eventName = item["trigger"];
+            const cb = () => validate();
+            validateEvents.push({
+              eventName: cb
+            });
+            formItem2.formItemMitt.on(dFormItemEvents[eventName], cb);
+          });
+        } else {
+          const cb = () => validate();
+          validateEvents.push({
+            eventName: cb
+          });
+          ruleItem && formItem2.formItemMitt.on(dFormItemEvents[eventName], cb);
+        }
+      }
+    };
+    const removeValidateEvents = () => {
+      if (rules2 && rules2[props.prop] && validateEvents.length > 0) {
+        validateEvents.forEach((item) => {
+          formItem2.formItemMitt.off(item.eventName, item.cb);
+        });
+      }
+    };
+    onMounted(() => {
+      dForm.formMitt.emit(dFormEvents.addField, formItem2);
+      addValidateEvents();
+    });
+    onBeforeUnmount(() => {
+      dForm.formMitt.emit(dFormEvents.removeField, formItem2);
+      removeValidateEvents();
+    });
+    return () => {
+      var _a, _b;
+      return createVNode("div", {
+        "class": `form-item${isHorizontal ? "" : isVertical ? " form-item-vertical" : " form-item-columns"}${isColumns ? " column-item " + columnsClass.value : ""}`
+      }, [(_b = (_a = ctx2.slots).default) == null ? void 0 : _b.call(_a), createVNode("div", {
+        "class": `d-validate-tip${isHorizontal ? " d-validate-tip-horizontal" : ""}`
+      }, [showMessage.value && tipMessage.value])]);
+    };
+  }
+});
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal$1 = freeGlobal;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal$1 || freeSelf || Function("return this")();
+var root$1 = root;
+var Symbol$1 = root$1.Symbol;
+var Symbol$2 = Symbol$1;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty = objectProto$1.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$1.toString;
+var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var objectProto = Object.prototype;
+var nativeObjectToString = objectProto.toString;
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var symbolTag = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+}
+function arrayMap(array4, iteratee) {
+  var index2 = -1, length = array4 == null ? 0 : array4.length, result = Array(length);
+  while (++index2 < length) {
+    result[index2] = iteratee(array4[index2], index2, array4);
+  }
+  return result;
+}
+var isArray = Array.isArray;
+var isArray$1 = isArray;
+var INFINITY = 1 / 0;
+var symbolProto = Symbol$2 ? Symbol$2.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray$1(value)) {
+    return arrayMap(value, baseToString) + "";
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+var reWhitespace = /\s/;
+function trimmedEndIndex(string3) {
+  var index2 = string3.length;
+  while (index2-- && reWhitespace.test(string3.charAt(index2))) {
+  }
+  return index2;
+}
+var reTrimStart = /^\s+/;
+function baseTrim(string3) {
+  return string3 ? string3.slice(0, trimmedEndIndex(string3) + 1).replace(reTrimStart, "") : string3;
+}
+function isObject(value) {
+  var type4 = typeof value;
+  return value != null && (type4 == "object" || type4 == "function");
+}
+var NAN = 0 / 0;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+function toNumber(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+function toString(value) {
+  return value == null ? "" : baseToString(value);
+}
+var now = function() {
+  return root$1.Date.now();
+};
+var now$1 = now;
+var FUNC_ERROR_TEXT = "Expected a function";
+var nativeMax = Math.max, nativeMin = Math.min;
+function debounce(func, wait, options) {
+  var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+  if (typeof func != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  wait = toNumber(wait) || 0;
+  if (isObject(options)) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    var args = lastArgs, thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+    return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    var time = now$1();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(now$1());
+  }
+  function debounced() {
+    var time = now$1(), isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+var idCounter = 0;
+function uniqueId(prefix) {
+  var id = ++idCounter;
+  return toString(prefix) + id;
+}
+var formControl = "";
+var FormControl = defineComponent({
+  name: "DFormControl",
+  props: formControlProps,
+  setup(props, ctx2) {
+    const formControl2 = ref();
+    const dForm = reactive(inject(formInjectionKey, {}));
+    const labelData = reactive(dForm.labelData);
+    const isHorizontal = labelData.layout === "horizontal";
+    const uid = uniqueId("dfc-");
+    const showPopover = ref(false);
+    const tipMessage = ref("");
+    const popPosition = ref("bottom");
+    let rectInfo = {
+      width: 0,
+      height: 0
+    };
+    let elOffset = {
+      left: 0,
+      top: 0
+    };
+    let popoverLeftPosition = 0;
+    let popoverTopPosition = 0;
+    onMounted(() => {
+      const el = document.getElementById(uid);
+      elOffset = getElOffset(el);
+      EventBus.on("showPopoverErrorMessage", (data) => {
+        if (uid === data.uid) {
+          rectInfo = el.getBoundingClientRect();
+          popoverLeftPosition = popPosition.value === "top" || popPosition.value === "bottom" ? rectInfo.right - rectInfo.width / 2 : rectInfo.right;
+          popoverTopPosition = popPosition.value === "top" ? elOffset.top + rectInfo.height / 2 - rectInfo.height : elOffset.top + rectInfo.height / 2;
+          showPopover.value = data.showPopover;
+          tipMessage.value = data.message;
+          popPosition.value = data.popPosition;
+        }
+      });
+    });
+    const iconData = computed(() => {
+      switch (props.feedbackStatus) {
+        case "pending":
+          return {
+            name: "priority",
+            color: "#e9edfa"
+          };
+        case "success":
+          return {
+            name: "right-o",
+            color: "rgb(61, 204, 166)"
+          };
+        case "error":
+          return {
+            name: "error-o",
+            color: "rgb(249, 95, 91)"
+          };
+        default:
+          return {
+            name: "",
+            color: ""
+          };
+      }
+    });
+    return () => {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      const {
+        feedbackStatus,
+        extraInfo
+      } = props;
+      return createVNode("div", {
+        "class": "form-control",
+        "ref": formControl2,
+        "data-uid": uid
+      }, [createVNode(Teleport, {
+        "to": "body"
+      }, {
+        default: () => [createVNode("div", {
+          "style": {
+            position: "absolute",
+            left: popoverLeftPosition + "px",
+            top: popoverTopPosition + "px",
+            width: rectInfo.width + "px",
+            height: rectInfo.height + "px"
+          }
+        }, [createVNode(Popover, {
+          "visible": showPopover.value,
+          "content": tipMessage.value,
+          "popType": "error",
+          "position": popPosition.value
+        }, null)])]
+      }), createVNode("div", {
+        "class": `devui-form-control-container${isHorizontal ? " devui-form-control-container-horizontal" : ""}${feedbackStatus ? " has-feedback" : ""}${feedbackStatus === "error" ? " feedback-error" : ""}`
+      }, [createVNode("div", {
+        "class": "devui-control-content-wrapper",
+        "id": uid
+      }, [(_b = (_a = ctx2.slots).default) == null ? void 0 : _b.call(_a)]), (feedbackStatus || ((_d = (_c = ctx2.slots).suffixTemplate) == null ? void 0 : _d.call(_c))) && createVNode("span", {
+        "class": "feedback-status"
+      }, [((_f = (_e = ctx2.slots).suffixTemplate) == null ? void 0 : _f.call(_e)) ? (_h = (_g = ctx2.slots).suffixTemplate) == null ? void 0 : _h.call(_g) : createVNode(Icon, {
+        "name": iconData.value.name,
+        "color": iconData.value.color
+      }, null)])]), extraInfo && createVNode("div", {
+        "class": "devui-form-control-extra-info"
+      }, [extraInfo])]);
+    };
+  }
+});
+var formOperation = "";
+var FormOperation = defineComponent({
+  name: "DFormOperation",
+  props: {},
+  setup(props, ctx2) {
+    return () => {
+      var _a, _b;
+      return createVNode("div", {
+        "class": "form-operation"
+      }, [(_b = (_a = ctx2.slots).default) == null ? void 0 : _b.call(_a)]);
+    };
+  }
+});
+var style = "";
+var ErrorStrategyEnum;
+(function(ErrorStrategyEnum2) {
+  ErrorStrategyEnum2["dirty"] = "dirty";
+  ErrorStrategyEnum2["pristine"] = "pristine";
+})(ErrorStrategyEnum || (ErrorStrategyEnum = {}));
+var UpdateOnEnum;
+(function(UpdateOnEnum2) {
+  UpdateOnEnum2["input"] = "input";
+  UpdateOnEnum2["focus"] = "focus";
+  UpdateOnEnum2["change"] = "change";
+  UpdateOnEnum2["blur"] = "blur";
+  UpdateOnEnum2["submit"] = "submit";
+})(UpdateOnEnum || (UpdateOnEnum = {}));
+var MessageShowTypeEnum;
+(function(MessageShowTypeEnum2) {
+  MessageShowTypeEnum2["popover"] = "popover";
+  MessageShowTypeEnum2["text"] = "text";
+  MessageShowTypeEnum2["none"] = "none";
+  MessageShowTypeEnum2["toast"] = "toast";
+})(MessageShowTypeEnum || (MessageShowTypeEnum = {}));
+function getAvaliableRuleObj(ruleName, value) {
+  if (!ruleName) {
+    console.error("[v-d-validate] validator's key is invalid");
+    return null;
+  }
+  switch (ruleName) {
+    case "maxlength":
+      return {
+        type: "string",
+        max: value,
+        asyncValidator: (rule, val) => {
+          return new Promise((resolve, reject) => {
+            if (val.length > value) {
+              reject("\u6700\u5927\u957F\u5EA6\u4E3A" + value);
+            } else {
+              resolve("\u6821\u9A8C\u901A\u8FC7");
+            }
+          });
+        }
+      };
+    case "minlength":
+      return {
+        type: "string",
+        min: value,
+        asyncValidator: (rule, val) => {
+          return new Promise((resolve, reject) => {
+            if (val.length < value) {
+              reject("\u6700\u5C0F\u957F\u5EA6\u4E3A" + value);
+            } else {
+              resolve("\u6821\u9A8C\u901A\u8FC7");
+            }
+          });
+        }
+      };
+    case "min":
+      return {
+        type: "number",
+        asyncValidator: (rule, val) => {
+          return new Promise((resolve, reject) => {
+            if (val < value) {
+              reject("\u6700\u5C0F\u503C\u4E3A" + value);
+            } else {
+              resolve("\u6821\u9A8C\u901A\u8FC7");
+            }
+          });
+        }
+      };
+    case "max":
+      return {
+        type: "number",
+        asyncValidator: (rule, val) => {
+          return new Promise((resolve, reject) => {
+            if (val > value) {
+              reject("\u6700\u5927\u503C\u4E3A" + value);
+            } else {
+              resolve("\u6821\u9A8C\u901A\u8FC7");
+            }
+          });
+        }
+      };
+    case "required":
+      return {
+        reqiured: true,
+        asyncValidator: (rule, val) => {
+          return new Promise((resolve, reject) => {
+            if (!val) {
+              reject("\u5FC5\u586B\u9879");
+            } else {
+              resolve("\u6821\u9A8C\u901A\u8FC7");
+            }
+          });
+        }
+      };
+    case "requiredTrue":
+      return {
+        asyncValidator: (rule, val) => {
+          return new Promise((resolve, reject) => {
+            if (!val) {
+              reject("\u5FC5\u987B\u4E3Atrue\u503C");
+            } else {
+              resolve("\u6821\u9A8C\u901A\u8FC7");
+            }
+          });
+        }
+      };
+    case "email":
+      return {
+        type: "email",
+        message: "\u90AE\u7BB1\u683C\u5F0F\u4E0D\u6B63\u786E"
+      };
+    case "pattern":
+      return {
+        type: "regexp",
+        pattern: value,
+        message: "\u53EA\u80FD\u5305\u542B\u6570\u5B57\u4E0E\u5927\u5C0F\u5199\u5B57\u7B26",
+        validator: (rule, val) => value.test(val)
+      };
+    case "whitespace":
+      return {
+        message: "\u8F93\u5165\u4E0D\u80FD\u5168\u90E8\u4E3A\u7A7A\u683C\u6216\u7A7A\u5B57\u7B26",
+        validator: (rule, val) => !!val.trim()
+      };
+    default:
+      return {
+        [ruleName]: value
+      };
+  }
+}
+function getKeyValueOfObjectList(obj) {
+  const kvArr = [];
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      kvArr.push({
+        key,
+        value: obj[key]
+      });
+    }
+  }
+  return kvArr;
+}
+function handleErrorStrategy(el) {
+  const classList = [...el.classList];
+  classList.push("d-validate-rules-error-pristine");
+  el.setAttribute("class", classList.join(" "));
+}
+function handleErrorStrategyPass(el) {
+  const classList = [...el.classList];
+  const index2 = classList.indexOf("d-validate-rules-error-pristine");
+  index2 !== -1 && classList.splice(index2, 1);
+  el.setAttribute("class", classList.join(" "));
+}
+function handleValidateError({ el, tipEl, message, isFormTag, messageShowType, dfcUID, popPosition = "right-bottom" }) {
+  if (isFormTag && messageShowType === MessageShowTypeEnum.toast) {
+    alert(message);
+    return;
+  }
+  if (MessageShowTypeEnum.popover === messageShowType) {
+    EventBus.emit("showPopoverErrorMessage", { showPopover: true, message, uid: dfcUID, popPosition });
+    return;
+  }
+  tipEl.innerText = "" + message;
+  tipEl.style.display = "inline-flex";
+  tipEl.setAttribute("class", "d-validate-tip");
+  handleErrorStrategy(el);
+}
+function handleValidatePass(el, tipEl) {
+  tipEl.style.display = "none";
+  handleErrorStrategyPass(el);
+}
+function getRefName(binding) {
+  const _refs = binding.instance.$refs;
+  const refName = Object.keys(_refs)[0];
+  return refName;
+}
+function getFormName(binding) {
+  const _refs = binding.instance.$refs;
+  const key = Object.keys(_refs)[0];
+  return _refs[key]["name"];
+}
+function validateFn({ validator, modelValue, el, tipEl, isFormTag, messageShowType, dfcUID, popPosition }) {
+  validator.validate({ modelName: modelValue }).then(() => {
+    handleValidatePass(el, tipEl);
+  }).catch((err) => {
+    const { errors } = err;
+    if (!errors || errors.length === 0)
+      return;
+    let msg = "";
+    if (typeof errors[0].message === "object") {
+      msg = errors[0].message.default;
+    } else {
+      msg = errors[0].message;
+    }
+    handleValidateError({ el, tipEl, message: msg, isFormTag, messageShowType, dfcUID, popPosition });
+  });
+}
+function checkValidPopsition(positionStr) {
+  const validPosition = ["left", "right", "top", "bottom", "left-top", "left-bottom", "top-left", "top-right", "right-top", "right-bottom", "bottom-left", "bottom-right"];
+  const isValid = validPosition.includes(positionStr);
+  !isValid && console.warn(`invalid popPosition value '${positionStr}'.`);
+  return isValid;
+}
+var dValidateRules = {
+  mounted(el, binding, vnode) {
+    var _a;
+    const isFormTag = el.tagName === "FORM";
+    const dfcUID = el.parentNode.parentNode.parentElement.dataset.uid;
+    const refName = getRefName(binding);
+    const hasOptions = isObject$1(binding.value) && hasKey(binding.value, "options");
+    let {
+      rules: bindingRules,
+      options = {},
+      messageShowType = MessageShowTypeEnum.popover
+    } = binding.value;
+    let { errorStrategy } = binding.value;
+    if (refName) {
+      messageShowType = (_a = binding.instance[refName]["messageShowType"]) != null ? _a : "popover";
+    }
+    let {
+      updateOn = UpdateOnEnum.change,
+      errorStrategy: ErrorStrategy = ErrorStrategyEnum.dirty,
+      asyncDebounceTime = 300,
+      popPosition = ["right", "bottom"]
+    } = options;
+    if (messageShowType === MessageShowTypeEnum.popover) {
+      if (Array.isArray(popPosition)) {
+        popPosition = popPosition.length > 1 ? popPosition.join("-") : popPosition[0];
+        if (!checkValidPopsition(popPosition)) {
+          popPosition = "right-bottom";
+        }
+      } else if (!checkValidPopsition(popPosition)) {
+        popPosition = "right-bottom";
+      }
+    }
+    if (!errorStrategy) {
+      errorStrategy = ErrorStrategy;
+    }
+    let customRule = {};
+    if (hasOptions) {
+      customRule = bindingRules != null ? bindingRules : binding.value;
+    } else {
+      customRule = binding.value;
+    }
+    const isCustomValidator = customRule && isObject$1(customRule) && (hasKey(customRule, "validators") || hasKey(customRule, "asyncValidators"));
+    const rules2 = Array.isArray(customRule) ? customRule : [customRule];
+    const tipEl = document.createElement("span");
+    if (messageShowType !== MessageShowTypeEnum.none) {
+      el.parentNode.append(tipEl);
+    }
+    const descriptor = {
+      modelName: []
+    };
+    rules2.forEach((rule) => {
+      const kvObjList = !Array.isArray(rule) && getKeyValueOfObjectList(rule);
+      let ruleObj = {};
+      let avaliableRuleObj = {};
+      kvObjList.forEach((item) => {
+        avaliableRuleObj = getAvaliableRuleObj(item.key, item.value);
+        ruleObj = __spreadValues(__spreadValues({}, ruleObj), avaliableRuleObj);
+      });
+      descriptor.modelName.push(ruleObj);
+    });
+    if (isCustomValidator) {
+      const { validators: validators2, asyncValidators } = customRule;
+      validators2 && validators2.forEach((item) => {
+        const ruleObj = {
+          message: (item == null ? void 0 : item.message) || "",
+          validator: (rule, value) => item.validator(rule, value)
+        };
+        descriptor.modelName.push(ruleObj);
+      });
+      asyncValidators && asyncValidators.forEach((item) => {
+        const ruleObj = {
+          message: (item == null ? void 0 : item.message) || "",
+          asyncValidator: (rule, value) => {
+            return new Promise(debounce((resolve, reject) => {
+              const res = item.asyncValidator(rule, value);
+              if (res) {
+                resolve("");
+              } else {
+                reject(rule.message);
+              }
+            }, asyncDebounceTime));
+          }
+        };
+        descriptor.modelName.push(ruleObj);
+      });
+    }
+    const validator = new Schema(descriptor);
+    const htmlEventValidateHandler = (e) => {
+      const modelValue = e.target.value;
+      if (messageShowType === MessageShowTypeEnum.popover) {
+        EventBus.emit("showPopoverErrorMessage", { showPopover: false, message: "", uid: dfcUID, popPosition });
+      }
+      validateFn({ validator, modelValue, el, tipEl, isFormTag: false, messageShowType, dfcUID, popPosition });
+    };
+    vnode.children[0].el.addEventListener(updateOn, htmlEventValidateHandler);
+    if (errorStrategy === ErrorStrategyEnum.pristine) {
+      handleErrorStrategy(el);
+      vnode.children[0].props.value = "" + vnode.children[0].props.value;
+    }
+    const formName = getFormName(binding);
+    formName && EventBus.on(`formSubmit:${formName}`, () => {
+      const modelValue = isFormTag ? "" : vnode.children[0].el.value;
+      validateFn({ validator, modelValue, el, tipEl, isFormTag, messageShowType });
+    });
+  }
+};
+Form.install = function(app) {
+  app.component(Form.name, Form);
+  app.directive("d-validate-rules", dValidateRules);
+};
+FormLabel.install = function(app) {
+  app.component(FormLabel.name, FormLabel);
+};
+FormItem.install = function(app) {
+  app.component(FormItem.name, FormItem);
+};
+FormControl.install = function(app) {
+  app.component(FormControl.name, FormControl);
+};
+FormOperation.install = function(app) {
+  app.component(FormOperation.name, FormOperation);
+};
+var index = {
+  title: "Form \u8868\u5355",
+  category: "\u6570\u636E\u5F55\u5165",
+  status: "75%",
+  install(app) {
+    app.use(Form);
+    app.use(FormLabel);
+    app.use(FormItem);
+    app.use(FormControl);
+    app.use(FormOperation);
+  }
+};
+export { Form, FormControl, FormItem, FormLabel, FormOperation, index as default };