agentworkshop 0.8.2 → 0.8.4

package/.output/server/chunks/build/form-Cw2Ex9w5.mjs

@@ -0,0 +1,3543 @@
+import { aT as Icon, k as useConfigInject_default, aU as useProviderSize, aV as useProviderDisabled, aW as useInjectGlobalForm, o as _extends$1, q as classNames, r as _objectSpread2, v as initDefaultProps, ap as LoadingOutlined, C as CloseCircleFilled, a8 as ExclamationCircleFilled, D as CheckCircleFilled, z as filterEmpty, x as genComponentStyleHook, y as merge, aX as zoomIn, P as PropTypes, J as functionType, I as booleanType, E as stringType, F as someType, H as anyType, G as objectType, aa as tuple, ab as useLocaleReceiver, ac as localeValues, K as resetComponent, a1 as isObject$1, aY as _getTag_default, aZ as isBuffer, a_ as isArrayLike, a$ as getTransitionGroupProps, s as getTransitionProps, aB as isArray, b0 as isPrototype, b1 as baseUnary, b2 as baseKeys, S as isValidElement, b3 as isObjectLike, aC as Symbol$1, a3 as root, b4 as nodeUtil, aE as isArguments, b5 as isTypedArray, b6 as Map$1 } from '../virtual/entry.mjs';
+import { t as tooltip_default } from './tooltip-GlMrUZzx.mjs';
+import { g as genCollapseMotion, h as collapseMotion, c as baseAssignValue, j as getPrototype, L as ListCache, k as SetCache, e as eq, l as cacheHas, s as setToArray, M as MapCache, m as baseFindIndex, f as isPlainObject, n as arrayIncludes } from './input-CJgB-RL6.mjs';
+import { f as flatRest, a as arrayMap, b as assignValue, c as castPath, t as toKey, i as identity, d as arrayPush, e as baseGet, g as isKey, h as hasIn, j as isIndex, s as setToString, o as overRest } from './hasIn-RYRGomyg.mjs';
+import { a as useProvideFormItemContext, F as FormItemInputContext, u as useInjectFormItemContext, b as FormItemContext_default } from './FormItemContext-DmuQqaeJ.mjs';
+import { d as debounce, t as toNumber } from './tag-CRW-anwy.mjs';
+import { u as useResponsiveObserver, r as responsiveArray } from './responsiveObserve-CzRpNXkr.mjs';
+import { u as useFlexGapSupport_default } from './space-BByD-mFE.mjs';
+import { createVNode, defineComponent, computed, ref, watch, shallowRef, watchEffect, reactive, Fragment, unref, provide, inject, nextTick, toRaw, Transition, withDirectives, TransitionGroup, vShow, cloneVNode } from 'vue';
+
+// This icon file is generated automatically.
+var QuestionCircleOutlined$1 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z" } }, { "tag": "path", "attrs": { "d": "M623.6 316.7C593.6 290.4 554 276 512 276s-81.6 14.5-111.6 40.7C369.2 344 352 380.7 352 420v7.6c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8V420c0-44.1 43.1-80 96-80s96 35.9 96 80c0 31.1-22 59.6-56.1 72.7-21.2 8.1-39.2 22.3-52.1 40.9-13.1 19-19.9 41.8-19.9 64.9V620c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8v-22.7a48.3 48.3 0 0130.9-44.8c59-22.7 97.1-74.7 97.1-132.5.1-39.3-17.1-76-48.3-103.3zM472 732a40 40 0 1080 0 40 40 0 10-80 0z" } }] }, "name": "question-circle", "theme": "outlined" };
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? Object(arguments[i]) : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var QuestionCircleOutlined = function QuestionCircleOutlined(props, context) {
+  var p = _objectSpread({}, props, context.attrs);
+
+  return createVNode(Icon, _objectSpread({}, p, {
+    "icon": QuestionCircleOutlined$1
+  }), null);
+};
+
+QuestionCircleOutlined.displayName = 'QuestionCircleOutlined';
+QuestionCircleOutlined.inheritAttrs = false;
+
+function t(t2) {
+  return "object" == typeof t2 && null != t2 && 1 === t2.nodeType;
+}
+function e(t2, e2) {
+  return (!e2 || "hidden" !== t2) && "visible" !== t2 && "clip" !== t2;
+}
+function n(t2, n2) {
+  if (t2.clientHeight < t2.scrollHeight || t2.clientWidth < t2.scrollWidth) {
+    var r2 = getComputedStyle(t2, null);
+    return e(r2.overflowY, n2) || e(r2.overflowX, n2) || (function(t3) {
+      var e2 = (function(t4) {
+        if (!t4.ownerDocument || !t4.ownerDocument.defaultView) return null;
+        try {
+          return t4.ownerDocument.defaultView.frameElement;
+        } catch (t5) {
+          return null;
+        }
+      })(t3);
+      return !!e2 && (e2.clientHeight < t3.scrollHeight || e2.clientWidth < t3.scrollWidth);
+    })(t2);
+  }
+  return false;
+}
+function r(t2, e2, n2, r2, i2, o, l, d) {
+  return o < t2 && l > e2 || o > t2 && l < e2 ? 0 : o <= t2 && d <= n2 || l >= e2 && d >= n2 ? o - t2 - r2 : l > e2 && d < n2 || o < t2 && d > n2 ? l - e2 + i2 : 0;
+}
+var i = function(e2, i2) {
+  var o = void 0, l = i2.scrollMode, d = i2.block, f = i2.inline, h = i2.boundary, u = i2.skipOverflowHiddenElements, s = "function" == typeof h ? h : function(t2) {
+    return t2 !== h;
+  };
+  if (!t(e2)) throw new TypeError("Invalid target");
+  for (var a, c, g = (void 0).scrollingElement || (void 0).documentElement, p = [], m = e2; t(m) && s(m); ) {
+    if ((m = null == (c = (a = m).parentElement) ? a.getRootNode().host || null : c) === g) {
+      p.push(m);
+      break;
+    }
+    null != m && m === (void 0).body && n(m) && !n((void 0).documentElement) || null != m && n(m, u) && p.push(m);
+  }
+  for (var w = o.visualViewport ? o.visualViewport.width : innerWidth, v = o.visualViewport ? o.visualViewport.height : innerHeight, W = (void 0).scrollX || pageXOffset, H = (void 0).scrollY || pageYOffset, b = e2.getBoundingClientRect(), y = b.height, E = b.width, M = b.top, V = b.right, x = b.bottom, I = b.left, C = "start" === d || "nearest" === d ? M : "end" === d ? x : M + y / 2, R = "center" === f ? I + E / 2 : "end" === f ? V : I, T = [], k = 0; k < p.length; k++) {
+    var B = p[k], D = B.getBoundingClientRect(), O = D.height, X = D.width, Y = D.top, L = D.right, S = D.bottom, j = D.left;
+    if ("if-needed" === l && M >= 0 && I >= 0 && x <= v && V <= w && M >= Y && x <= S && I >= j && V <= L) return T;
+    var N = getComputedStyle(B), q = parseInt(N.borderLeftWidth, 10), z = parseInt(N.borderTopWidth, 10), A = parseInt(N.borderRightWidth, 10), F = parseInt(N.borderBottomWidth, 10), G = 0, J = 0, K = "offsetWidth" in B ? B.offsetWidth - B.clientWidth - q - A : 0, P = "offsetHeight" in B ? B.offsetHeight - B.clientHeight - z - F : 0, Q = "offsetWidth" in B ? 0 === B.offsetWidth ? 0 : X / B.offsetWidth : 0, U = "offsetHeight" in B ? 0 === B.offsetHeight ? 0 : O / B.offsetHeight : 0;
+    if (g === B) G = "start" === d ? C : "end" === d ? C - v : "nearest" === d ? r(H, H + v, v, z, F, H + C, H + C + y, y) : C - v / 2, J = "start" === f ? R : "center" === f ? R - w / 2 : "end" === f ? R - w : r(W, W + w, w, q, A, W + R, W + R + E, E), G = Math.max(0, G + H), J = Math.max(0, J + W);
+    else {
+      G = "start" === d ? C - Y - z : "end" === d ? C - S + F + P : "nearest" === d ? r(Y, S, O, z, F + P, C, C + y, y) : C - (Y + O / 2) + P / 2, J = "start" === f ? R - j - q : "center" === f ? R - (j + X / 2) + K / 2 : "end" === f ? R - L + A + K : r(j, L, X, q, A + K, R, R + E, E);
+      var Z = B.scrollLeft, $ = B.scrollTop;
+      C += $ - (G = Math.max(0, Math.min($ + G / U, B.scrollHeight - O / U + P))), R += Z - (J = Math.max(0, Math.min(Z + J / Q, B.scrollWidth - X / Q + K)));
+    }
+    T.push({
+      el: B,
+      top: G,
+      left: J
+    });
+  }
+  return T;
+};
+function isOptionsObject(options) {
+  return options === Object(options) && Object.keys(options).length !== 0;
+}
+function defaultBehavior(actions, behavior) {
+  if (behavior === void 0) behavior = "auto";
+  var canSmoothScroll = "scrollBehavior" in (void 0).body.style;
+  actions.forEach(function(_ref) {
+    var el = _ref.el, top = _ref.top, left = _ref.left;
+    if (el.scroll && canSmoothScroll) el.scroll({
+      top,
+      left,
+      behavior
+    });
+    else {
+      el.scrollTop = top;
+      el.scrollLeft = left;
+    }
+  });
+}
+function getOptions(options) {
+  if (options === false) return {
+    block: "end",
+    inline: "nearest"
+  };
+  if (isOptionsObject(options)) return options;
+  return {
+    block: "start",
+    inline: "nearest"
+  };
+}
+function scrollIntoView(target, options) {
+  var isTargetAttached = target.isConnected || target.ownerDocument.documentElement.contains(target);
+  if (isOptionsObject(options) && typeof options.behavior === "function") return options.behavior(isTargetAttached ? i(target, options) : []);
+  if (!isTargetAttached) return;
+  var computeOptions = getOptions(options);
+  return defaultBehavior(i(target, computeOptions), computeOptions.behavior);
+}
+function stackClear() {
+  this.__data__ = new ListCache();
+  this.size = 0;
+}
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    var pairs = data.__data__;
+    if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = stackClear;
+Stack.prototype["delete"] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+function arraySome(array4, predicate) {
+  var index = -1, length = array4 == null ? 0 : array4.length;
+  while (++index < length) if (predicate(array4[index], index, array4)) return true;
+  return false;
+}
+var COMPARE_PARTIAL_FLAG$5 = 1;
+var COMPARE_UNORDERED_FLAG$3 = 2;
+function equalArrays(array4, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, arrLength = array4.length, othLength = other.length;
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) return false;
+  var arrStacked = stack.get(array4);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) return arrStacked == other && othStacked == array4;
+  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new SetCache() : void 0;
+  stack.set(array4, other);
+  stack.set(other, array4);
+  while (++index < arrLength) {
+    var arrValue = array4[index], othValue = other[index];
+    if (customizer) var compared = isPartial ? customizer(othValue, arrValue, index, other, array4, stack) : customizer(arrValue, othValue, index, array4, other, stack);
+    if (compared !== void 0) {
+      if (compared) continue;
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!arraySome(other, function(othValue2, othIndex) {
+        if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) return seen.push(othIndex);
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = false;
+      break;
+    }
+  }
+  stack["delete"](array4);
+  stack["delete"](other);
+  return result;
+}
+var Uint8Array = root.Uint8Array;
+function mapToArray(map) {
+  var index = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+var COMPARE_PARTIAL_FLAG$4 = 1;
+var COMPARE_UNORDERED_FLAG$2 = 2;
+var boolTag$2 = "[object Boolean]";
+var dateTag$2 = "[object Date]";
+var errorTag$1 = "[object Error]";
+var mapTag$3 = "[object Map]";
+var numberTag$2 = "[object Number]";
+var regexpTag$2 = "[object RegExp]";
+var setTag$3 = "[object Set]";
+var stringTag$2 = "[object String]";
+var symbolTag$2 = "[object Symbol]";
+var arrayBufferTag$2 = "[object ArrayBuffer]";
+var dataViewTag$2 = "[object DataView]";
+var symbolProto$1 = Symbol$1 ? Symbol$1.prototype : void 0;
+var symbolValueOf$1 = symbolProto$1 ? symbolProto$1.valueOf : void 0;
+function equalByTag(object4, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag$2:
+      if (object4.byteLength != other.byteLength || object4.byteOffset != other.byteOffset) return false;
+      object4 = object4.buffer;
+      other = other.buffer;
+    case arrayBufferTag$2:
+      if (object4.byteLength != other.byteLength || !equalFunc(new Uint8Array(object4), new Uint8Array(other))) return false;
+      return true;
+    case boolTag$2:
+    case dateTag$2:
+    case numberTag$2:
+      return eq(+object4, +other);
+    case errorTag$1:
+      return object4.name == other.name && object4.message == other.message;
+    case regexpTag$2:
+    case stringTag$2:
+      return object4 == other + "";
+    case mapTag$3:
+      var convert = mapToArray;
+    case setTag$3:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
+      convert || (convert = setToArray);
+      if (object4.size != other.size && !isPartial) return false;
+      var stacked = stack.get(object4);
+      if (stacked) return stacked == other;
+      bitmask |= COMPARE_UNORDERED_FLAG$2;
+      stack.set(object4, other);
+      var result = equalArrays(convert(object4), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object4);
+      return result;
+    case symbolTag$2:
+      if (symbolValueOf$1) return symbolValueOf$1.call(object4) == symbolValueOf$1.call(other);
+  }
+  return false;
+}
+function baseGetAllKeys(object4, keysFunc, symbolsFunc) {
+  var result = keysFunc(object4);
+  return isArray(object4) ? result : arrayPush(result, symbolsFunc(object4));
+}
+function arrayFilter(array4, predicate) {
+  var index = -1, length = array4 == null ? 0 : array4.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array4[index];
+    if (predicate(value, index, array4)) result[resIndex++] = value;
+  }
+  return result;
+}
+function stubArray() {
+  return [];
+}
+var propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray : function(object4) {
+  if (object4 == null) return [];
+  object4 = Object(object4);
+  return arrayFilter(nativeGetSymbols(object4), function(symbol) {
+    return propertyIsEnumerable.call(object4, symbol);
+  });
+};
+function baseTimes(n2, iteratee) {
+  var index = -1, result = Array(n2);
+  while (++index < n2) result[index] = iteratee(index);
+  return result;
+}
+var hasOwnProperty$5 = Object.prototype.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+  for (var key in value) if ((inherited || hasOwnProperty$5.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex(key, length)))) result.push(key);
+  return result;
+}
+function keys(object4) {
+  return isArrayLike(object4) ? arrayLikeKeys(object4) : baseKeys(object4);
+}
+function getAllKeys(object4) {
+  return baseGetAllKeys(object4, keys, getSymbols);
+}
+var COMPARE_PARTIAL_FLAG$3 = 1;
+var hasOwnProperty$4 = Object.prototype.hasOwnProperty;
+function equalObjects(object4, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys(object4), objLength = objProps.length;
+  if (objLength != getAllKeys(other).length && !isPartial) return false;
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty$4.call(other, key))) return false;
+  }
+  var objStacked = stack.get(object4);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) return objStacked == other && othStacked == object4;
+  var result = true;
+  stack.set(object4, other);
+  stack.set(other, object4);
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object4[key], othValue = other[key];
+    if (customizer) var compared = isPartial ? customizer(othValue, objValue, key, other, object4, stack) : customizer(objValue, othValue, key, object4, other, stack);
+    if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == "constructor");
+  }
+  if (result && !skipCtor) {
+    var objCtor = object4.constructor, othCtor = other.constructor;
+    if (objCtor != othCtor && "constructor" in object4 && "constructor" in other && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) result = false;
+  }
+  stack["delete"](object4);
+  stack["delete"](other);
+  return result;
+}
+var COMPARE_PARTIAL_FLAG$2 = 1;
+var argsTag$1 = "[object Arguments]";
+var arrayTag$1 = "[object Array]";
+var objectTag$1 = "[object Object]";
+var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+function baseIsEqualDeep(object4, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray(object4), othIsArr = isArray(other), objTag = objIsArr ? arrayTag$1 : _getTag_default(object4), othTag = othIsArr ? arrayTag$1 : _getTag_default(other);
+  objTag = objTag == argsTag$1 ? objectTag$1 : objTag;
+  othTag = othTag == argsTag$1 ? objectTag$1 : othTag;
+  var objIsObj = objTag == objectTag$1, othIsObj = othTag == objectTag$1, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer(object4)) {
+    if (!isBuffer(other)) return false;
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack());
+    return objIsArr || isTypedArray(object4) ? equalArrays(object4, other, bitmask, customizer, equalFunc, stack) : equalByTag(object4, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
+    var objIsWrapped = objIsObj && hasOwnProperty$3.call(object4, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty$3.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object4.value() : object4, othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new Stack());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) return false;
+  stack || (stack = new Stack());
+  return equalObjects(object4, other, bitmask, customizer, equalFunc, stack);
+}
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) return true;
+  if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) return value !== value && other !== other;
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+function isEqual(value, other) {
+  return baseIsEqual(value, other);
+}
+var INFINITY = 1 / 0;
+var MAX_INTEGER = 17976931348623157e292;
+function toFinite(value) {
+  if (!value) return value === 0 ? value : 0;
+  value = toNumber(value);
+  if (value === INFINITY || value === -INFINITY) return (value < 0 ? -1 : 1) * MAX_INTEGER;
+  return value === value ? value : 0;
+}
+function toInteger(value) {
+  var result = toFinite(value), remainder = result % 1;
+  return result === result ? remainder ? result - remainder : result : 0;
+}
+var objectCreate = Object.create;
+var baseCreate = /* @__PURE__ */ (function() {
+  function object4() {
+  }
+  return function(proto) {
+    if (!isObject$1(proto)) return {};
+    if (objectCreate) return objectCreate(proto);
+    object4.prototype = proto;
+    var result = new object4();
+    object4.prototype = void 0;
+    return result;
+  };
+})();
+function copyArray(source, array4) {
+  var index = -1, length = source.length;
+  array4 || (array4 = Array(length));
+  while (++index < length) array4[index] = source[index];
+  return array4;
+}
+function arrayEach(array4, iteratee) {
+  var index = -1, length = array4 == null ? 0 : array4.length;
+  while (++index < length) if (iteratee(array4[index], index, array4) === false) break;
+  return array4;
+}
+function copyObject(source, props, object4, customizer) {
+  var isNew = !object4;
+  object4 || (object4 = {});
+  var index = -1, length = props.length;
+  while (++index < length) {
+    var key = props[index];
+    var newValue = void 0;
+    if (newValue === void 0) newValue = source[key];
+    if (isNew) baseAssignValue(object4, key, newValue);
+    else assignValue(object4, key, newValue);
+  }
+  return object4;
+}
+function baseRest(func, start) {
+  return setToString(overRest(func, start, identity), func + "");
+}
+function nativeKeysIn(object4) {
+  var result = [];
+  if (object4 != null) for (var key in Object(object4)) result.push(key);
+  return result;
+}
+var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
+function baseKeysIn(object4) {
+  if (!isObject$1(object4)) return nativeKeysIn(object4);
+  var isProto = isPrototype(object4), result = [];
+  for (var key in object4) if (!(key == "constructor" && (isProto || !hasOwnProperty$2.call(object4, key)))) result.push(key);
+  return result;
+}
+function keysIn(object4) {
+  return isArrayLike(object4) ? arrayLikeKeys(object4, true) : baseKeysIn(object4);
+}
+function get$1(object4, path, defaultValue) {
+  var result = object4 == null ? void 0 : baseGet(object4, path);
+  return result === void 0 ? defaultValue : result;
+}
+function baseSlice(array4, start, end) {
+  var index = -1, length = array4.length;
+  if (start < 0) start = -start > length ? 0 : length + start;
+  end = end > length ? length : end;
+  if (end < 0) end += length;
+  length = start > end ? 0 : end - start >>> 0;
+  start >>>= 0;
+  var result = Array(length);
+  while (++index < length) result[index] = array4[index + start];
+  return result;
+}
+function baseAssign(object4, source) {
+  return object4 && copyObject(source, keys(source), object4);
+}
+function baseAssignIn(object4, source) {
+  return object4 && copyObject(source, keysIn(source), object4);
+}
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var Buffer = freeModule && freeModule.exports === freeExports ? root.Buffer : void 0;
+var allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+function cloneBuffer(buffer, isDeep) {
+  if (isDeep) return buffer.slice();
+  var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+  buffer.copy(result);
+  return result;
+}
+function copySymbols(source, object4) {
+  return copyObject(source, getSymbols(source), object4);
+}
+var getSymbolsIn = !Object.getOwnPropertySymbols ? stubArray : function(object4) {
+  var result = [];
+  while (object4) {
+    arrayPush(result, getSymbols(object4));
+    object4 = getPrototype(object4);
+  }
+  return result;
+};
+function copySymbolsIn(source, object4) {
+  return copyObject(source, getSymbolsIn(source), object4);
+}
+function getAllKeysIn(object4) {
+  return baseGetAllKeys(object4, keysIn, getSymbolsIn);
+}
+var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+function initCloneArray(array4) {
+  var length = array4.length, result = new array4.constructor(length);
+  if (length && typeof array4[0] == "string" && hasOwnProperty$1.call(array4, "index")) {
+    result.index = array4.index;
+    result.input = array4.input;
+  }
+  return result;
+}
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+  return result;
+}
+function cloneDataView(dataView, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+var reFlags = /\w*$/;
+function cloneRegExp(regexp4) {
+  var result = new regexp4.constructor(regexp4.source, reFlags.exec(regexp4));
+  result.lastIndex = regexp4.lastIndex;
+  return result;
+}
+var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0;
+var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function cloneSymbol(symbol) {
+  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+var boolTag$1 = "[object Boolean]";
+var dateTag$1 = "[object Date]";
+var mapTag$2 = "[object Map]";
+var numberTag$1 = "[object Number]";
+var regexpTag$1 = "[object RegExp]";
+var setTag$2 = "[object Set]";
+var stringTag$1 = "[object String]";
+var symbolTag$1 = "[object Symbol]";
+var arrayBufferTag$1 = "[object ArrayBuffer]";
+var dataViewTag$1 = "[object DataView]";
+var float32Tag$1 = "[object Float32Array]";
+var float64Tag$1 = "[object Float64Array]";
+var int8Tag$1 = "[object Int8Array]";
+var int16Tag$1 = "[object Int16Array]";
+var int32Tag$1 = "[object Int32Array]";
+var uint8Tag$1 = "[object Uint8Array]";
+var uint8ClampedTag$1 = "[object Uint8ClampedArray]";
+var uint16Tag$1 = "[object Uint16Array]";
+var uint32Tag$1 = "[object Uint32Array]";
+function initCloneByTag(object4, tag, isDeep) {
+  var Ctor = object4.constructor;
+  switch (tag) {
+    case arrayBufferTag$1:
+      return cloneArrayBuffer(object4);
+    case boolTag$1:
+    case dateTag$1:
+      return new Ctor(+object4);
+    case dataViewTag$1:
+      return cloneDataView(object4, isDeep);
+    case float32Tag$1:
+    case float64Tag$1:
+    case int8Tag$1:
+    case int16Tag$1:
+    case int32Tag$1:
+    case uint8Tag$1:
+    case uint8ClampedTag$1:
+    case uint16Tag$1:
+    case uint32Tag$1:
+      return cloneTypedArray(object4, isDeep);
+    case mapTag$2:
+      return new Ctor();
+    case numberTag$1:
+    case stringTag$1:
+      return new Ctor(object4);
+    case regexpTag$1:
+      return cloneRegExp(object4);
+    case setTag$2:
+      return new Ctor();
+    case symbolTag$1:
+      return cloneSymbol(object4);
+  }
+}
+function initCloneObject(object4) {
+  return typeof object4.constructor == "function" && !isPrototype(object4) ? baseCreate(getPrototype(object4)) : {};
+}
+var mapTag$1 = "[object Map]";
+function baseIsMap(value) {
+  return isObjectLike(value) && _getTag_default(value) == mapTag$1;
+}
+var nodeIsMap = nodeUtil && nodeUtil.isMap;
+var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
+var setTag$1 = "[object Set]";
+function baseIsSet(value) {
+  return isObjectLike(value) && _getTag_default(value) == setTag$1;
+}
+var nodeIsSet = nodeUtil && nodeUtil.isSet;
+var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+var CLONE_DEEP_FLAG$2 = 1;
+var CLONE_FLAT_FLAG$1 = 2;
+var CLONE_SYMBOLS_FLAG$2 = 4;
+var argsTag = "[object Arguments]";
+var arrayTag = "[object Array]";
+var boolTag = "[object Boolean]";
+var dateTag = "[object Date]";
+var errorTag = "[object Error]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var mapTag = "[object Map]";
+var numberTag = "[object Number]";
+var objectTag = "[object Object]";
+var regexpTag = "[object RegExp]";
+var setTag = "[object Set]";
+var stringTag = "[object String]";
+var symbolTag = "[object Symbol]";
+var weakMapTag = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var dataViewTag = "[object DataView]";
+var float32Tag = "[object Float32Array]";
+var float64Tag = "[object Float64Array]";
+var int8Tag = "[object Int8Array]";
+var int16Tag = "[object Int16Array]";
+var int32Tag = "[object Int32Array]";
+var uint8Tag = "[object Uint8Array]";
+var uint8ClampedTag = "[object Uint8ClampedArray]";
+var uint16Tag = "[object Uint16Array]";
+var uint32Tag = "[object Uint32Array]";
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
+function baseClone(value, bitmask, customizer, key, object4, stack) {
+  var result, isDeep = bitmask & CLONE_DEEP_FLAG$2, isFlat = bitmask & CLONE_FLAT_FLAG$1, isFull = bitmask & CLONE_SYMBOLS_FLAG$2;
+  if (customizer) result = object4 ? customizer(value, key, object4, stack) : customizer(value);
+  if (result !== void 0) return result;
+  if (!isObject$1(value)) return value;
+  var isArr = isArray(value);
+  if (isArr) {
+    result = initCloneArray(value);
+    if (!isDeep) return copyArray(value, result);
+  } else {
+    var tag = _getTag_default(value), isFunc = tag == funcTag || tag == genTag;
+    if (isBuffer(value)) return cloneBuffer(value, isDeep);
+    if (tag == objectTag || tag == argsTag || isFunc && !object4) {
+      result = isFlat || isFunc ? {} : initCloneObject(value);
+      if (!isDeep) return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
+    } else {
+      if (!cloneableTags[tag]) return object4 ? value : {};
+      result = initCloneByTag(value, tag, isDeep);
+    }
+  }
+  stack || (stack = new Stack());
+  var stacked = stack.get(value);
+  if (stacked) return stacked;
+  stack.set(value, result);
+  if (isSet(value)) value.forEach(function(subValue) {
+    result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+  });
+  else if (isMap(value)) value.forEach(function(subValue, key2) {
+    result.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+  });
+  var props = isArr ? void 0 : (isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys)(value);
+  arrayEach(props || value, function(subValue, key2) {
+    if (props) {
+      key2 = subValue;
+      subValue = value[key2];
+    }
+    assignValue(result, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+  });
+  return result;
+}
+var CLONE_DEEP_FLAG$1 = 1;
+var CLONE_SYMBOLS_FLAG$1 = 4;
+function cloneDeep(value) {
+  return baseClone(value, CLONE_DEEP_FLAG$1 | CLONE_SYMBOLS_FLAG$1);
+}
+var COMPARE_PARTIAL_FLAG$1 = 1;
+var COMPARE_UNORDERED_FLAG$1 = 2;
+function baseIsMatch(object4, source, matchData, customizer) {
+  var index = matchData.length, length = index;
+  if (object4 == null) return !length;
+  object4 = Object(object4);
+  while (index--) {
+    var data = matchData[index];
+    if (data[2] ? data[1] !== object4[data[0]] : !(data[0] in object4)) return false;
+  }
+  while (++index < length) {
+    data = matchData[index];
+    var key = data[0], objValue = object4[key], srcValue = data[1];
+    if (data[2]) {
+      if (objValue === void 0 && !(key in object4)) return false;
+    } else {
+      var stack = new Stack();
+      var result; 
+      if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) return false;
+    }
+  }
+  return true;
+}
+function isStrictComparable(value) {
+  return value === value && !isObject$1(value);
+}
+function getMatchData(object4) {
+  var result = keys(object4), length = result.length;
+  while (length--) {
+    var key = result[length], value = object4[key];
+    result[length] = [
+      key,
+      value,
+      isStrictComparable(value)
+    ];
+  }
+  return result;
+}
+function matchesStrictComparable(key, srcValue) {
+  return function(object4) {
+    if (object4 == null) return false;
+    return object4[key] === srcValue && (srcValue !== void 0 || key in Object(object4));
+  };
+}
+function baseMatches(source) {
+  var matchData = getMatchData(source);
+  if (matchData.length == 1 && matchData[0][2]) return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+  return function(object4) {
+    return object4 === source || baseIsMatch(object4, source, matchData);
+  };
+}
+var COMPARE_PARTIAL_FLAG = 1;
+var COMPARE_UNORDERED_FLAG = 2;
+function baseMatchesProperty(path, srcValue) {
+  if (isKey(path) && isStrictComparable(srcValue)) return matchesStrictComparable(toKey(path), srcValue);
+  return function(object4) {
+    var objValue = get$1(object4, path);
+    return objValue === void 0 && objValue === srcValue ? hasIn(object4, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+  };
+}
+function baseProperty(key) {
+  return function(object4) {
+    return object4 == null ? void 0 : object4[key];
+  };
+}
+function basePropertyDeep(path) {
+  return function(object4) {
+    return baseGet(object4, path);
+  };
+}
+function property(path) {
+  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+}
+function baseIteratee(value) {
+  if (typeof value == "function") return value;
+  if (value == null) return identity;
+  if (typeof value == "object") return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
+  return property(value);
+}
+function isArrayLikeObject(value) {
+  return isObjectLike(value) && isArrayLike(value);
+}
+function last(array4) {
+  var length = array4 == null ? 0 : array4.length;
+  return length ? array4[length - 1] : void 0;
+}
+function createFind(findIndexFunc) {
+  return function(collection, predicate, fromIndex) {
+    var iterable = Object(collection);
+    if (!isArrayLike(collection)) {
+      var iteratee = baseIteratee(predicate);
+      collection = keys(collection);
+      predicate = function(key) {
+        return iteratee(iterable[key], key, iterable);
+      };
+    }
+    var index = findIndexFunc(collection, predicate, fromIndex);
+    return index > -1 ? iterable[iteratee ? collection[index] : index] : void 0;
+  };
+}
+var nativeMax = Math.max;
+function findIndex(array4, predicate, fromIndex) {
+  var length = array4 == null ? 0 : array4.length;
+  if (!length) return -1;
+  var index = fromIndex == null ? 0 : toInteger(fromIndex);
+  if (index < 0) index = nativeMax(length + index, 0);
+  return baseFindIndex(array4, baseIteratee(predicate), index);
+}
+var find = createFind(findIndex);
+var nativeMin = Math.min;
+function baseIntersection(arrays, iteratee, comparator) {
+  var includes = arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array(othLength), maxLength = Infinity, result = [];
+  while (othIndex--) {
+    var array4 = arrays[othIndex];
+    maxLength = nativeMin(array4.length, maxLength);
+    caches[othIndex] = (length >= 120 && array4.length >= 120) ? new SetCache(othIndex && array4) : void 0;
+  }
+  array4 = arrays[0];
+  var index = -1, seen = caches[0];
+  outer: while (++index < length && result.length < maxLength) {
+    var value = array4[index], computed2 = value;
+    value = value !== 0 ? value : 0;
+    if (!(seen ? cacheHas(seen, computed2) : includes(result, computed2))) {
+      othIndex = othLength;
+      while (--othIndex) {
+        var cache = caches[othIndex];
+        if (!(cache ? cacheHas(cache, computed2) : includes(arrays[othIndex], computed2))) continue outer;
+      }
+      if (seen) seen.push(computed2);
+      result.push(value);
+    }
+  }
+  return result;
+}
+function castArrayLikeObject(value) {
+  return isArrayLikeObject(value) ? value : [];
+}
+var intersection = baseRest(function(arrays) {
+  var mapped = arrayMap(arrays, castArrayLikeObject);
+  return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : [];
+});
+function parent(object4, path) {
+  return path.length < 2 ? object4 : baseGet(object4, baseSlice(path, 0, -1));
+}
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function baseUnset(object4, path) {
+  path = castPath(path, object4);
+  var index = -1, length = path.length;
+  if (!length) return true;
+  while (++index < length) {
+    var key = toKey(path[index]);
+    if (key === "__proto__" && !hasOwnProperty.call(object4, "__proto__")) return false;
+    if ((key === "constructor" || key === "prototype") && index < length - 1) return false;
+  }
+  var obj = parent(object4, path);
+  return obj == null || delete obj[toKey(last(path))];
+}
+function customOmitClone(value) {
+  return isPlainObject(value) ? void 0 : value;
+}
+var CLONE_DEEP_FLAG = 1;
+var CLONE_FLAT_FLAG = 2;
+var CLONE_SYMBOLS_FLAG = 4;
+var omit = flatRest(function(object4, paths) {
+  var result = {};
+  if (object4 == null) return result;
+  var isDeep = false;
+  paths = arrayMap(paths, function(path) {
+    path = castPath(path, object4);
+    isDeep || (isDeep = path.length > 1);
+    return path;
+  });
+  copyObject(object4, getAllKeysIn(object4), result);
+  if (isDeep) result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
+  var length = paths.length;
+  while (length--) baseUnset(result, paths[length]);
+  return result;
+});
+var RowContextKey = /* @__PURE__ */ Symbol("rowContextKey");
+var useProvideRow = (state) => {
+  provide(RowContextKey, state);
+};
+var useInjectRow = () => {
+  return inject(RowContextKey, {
+    gutter: computed(() => void 0),
+    wrap: computed(() => void 0),
+    supportFlexGap: computed(() => void 0)
+  });
+};
+var genGridRowStyle = (token) => {
+  const { componentCls } = token;
+  return { [componentCls]: {
+    display: "flex",
+    flexFlow: "row wrap",
+    minWidth: 0,
+    "&::before, &::after": { display: "flex" },
+    "&-no-wrap": { flexWrap: "nowrap" },
+    "&-start": { justifyContent: "flex-start" },
+    "&-center": { justifyContent: "center" },
+    "&-end": { justifyContent: "flex-end" },
+    "&-space-between": { justifyContent: "space-between" },
+    "&-space-around ": { justifyContent: "space-around" },
+    "&-space-evenly ": { justifyContent: "space-evenly" },
+    "&-top": { alignItems: "flex-start" },
+    "&-middle": { alignItems: "center" },
+    "&-bottom": { alignItems: "flex-end" }
+  } };
+};
+var genGridColStyle = (token) => {
+  const { componentCls } = token;
+  return { [componentCls]: {
+    position: "relative",
+    maxWidth: "100%",
+    minHeight: 1
+  } };
+};
+var genLoopGridColumnsStyle = (token, sizeCls) => {
+  const { componentCls, gridColumns } = token;
+  const gridColumnsStyle = {};
+  for (let i2 = gridColumns; i2 >= 0; i2--) if (i2 === 0) {
+    gridColumnsStyle[`${componentCls}${sizeCls}-${i2}`] = { display: "none" };
+    gridColumnsStyle[`${componentCls}-push-${i2}`] = { insetInlineStart: "auto" };
+    gridColumnsStyle[`${componentCls}-pull-${i2}`] = { insetInlineEnd: "auto" };
+    gridColumnsStyle[`${componentCls}${sizeCls}-push-${i2}`] = { insetInlineStart: "auto" };
+    gridColumnsStyle[`${componentCls}${sizeCls}-pull-${i2}`] = { insetInlineEnd: "auto" };
+    gridColumnsStyle[`${componentCls}${sizeCls}-offset-${i2}`] = { marginInlineEnd: 0 };
+    gridColumnsStyle[`${componentCls}${sizeCls}-order-${i2}`] = { order: 0 };
+  } else {
+    gridColumnsStyle[`${componentCls}${sizeCls}-${i2}`] = {
+      display: "block",
+      flex: `0 0 ${i2 / gridColumns * 100}%`,
+      maxWidth: `${i2 / gridColumns * 100}%`
+    };
+    gridColumnsStyle[`${componentCls}${sizeCls}-push-${i2}`] = { insetInlineStart: `${i2 / gridColumns * 100}%` };
+    gridColumnsStyle[`${componentCls}${sizeCls}-pull-${i2}`] = { insetInlineEnd: `${i2 / gridColumns * 100}%` };
+    gridColumnsStyle[`${componentCls}${sizeCls}-offset-${i2}`] = { marginInlineStart: `${i2 / gridColumns * 100}%` };
+    gridColumnsStyle[`${componentCls}${sizeCls}-order-${i2}`] = { order: i2 };
+  }
+  return gridColumnsStyle;
+};
+var genGridStyle = (token, sizeCls) => genLoopGridColumnsStyle(token, sizeCls);
+var genGridMediaStyle = (token, screenSize, sizeCls) => ({ [`@media (min-width: ${screenSize}px)`]: _extends$1({}, genGridStyle(token, sizeCls)) });
+var useRowStyle = genComponentStyleHook("Grid", (token) => [genGridRowStyle(token)]);
+var useColStyle = genComponentStyleHook("Grid", (token) => {
+  const gridToken = merge(token, { gridColumns: 24 });
+  const gridMediaSizesMap = {
+    "-sm": gridToken.screenSMMin,
+    "-md": gridToken.screenMDMin,
+    "-lg": gridToken.screenLGMin,
+    "-xl": gridToken.screenXLMin,
+    "-xxl": gridToken.screenXXLMin
+  };
+  return [
+    genGridColStyle(gridToken),
+    genGridStyle(gridToken, ""),
+    genGridStyle(gridToken, "-xs"),
+    Object.keys(gridMediaSizesMap).map((key) => genGridMediaStyle(gridToken, gridMediaSizesMap[key], key)).reduce((pre, cur) => _extends$1(_extends$1({}, pre), cur), {})
+  ];
+});
+var rowProps = () => ({
+  align: someType([String, Object]),
+  justify: someType([String, Object]),
+  prefixCls: String,
+  gutter: someType([
+    Number,
+    Array,
+    Object
+  ], 0),
+  wrap: {
+    type: Boolean,
+    default: void 0
+  }
+});
+var ARow = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "ARow",
+  inheritAttrs: false,
+  props: rowProps(),
+  setup(props, _ref) {
+    let { slots, attrs } = _ref;
+    const { prefixCls, direction } = useConfigInject_default("row", props);
+    const [wrapSSR, hashId] = useRowStyle(prefixCls);
+    useResponsiveObserver();
+    const screens = ref({
+      xs: true,
+      sm: true,
+      md: true,
+      lg: true,
+      xl: true,
+      xxl: true
+    });
+    const curScreens = ref({
+      xs: false,
+      sm: false,
+      md: false,
+      lg: false,
+      xl: false,
+      xxl: false
+    });
+    const mergePropsByScreen = (oriProp) => {
+      return computed(() => {
+        if (typeof props[oriProp] === "string") return props[oriProp];
+        if (typeof props[oriProp] !== "object") return "";
+        for (let i2 = 0; i2 < responsiveArray.length; i2++) {
+          const breakpoint = responsiveArray[i2];
+          if (!curScreens.value[breakpoint]) continue;
+          const curVal = props[oriProp][breakpoint];
+          if (curVal !== void 0) return curVal;
+        }
+        return "";
+      });
+    };
+    const mergeAlign = mergePropsByScreen("align");
+    const mergeJustify = mergePropsByScreen("justify");
+    const supportFlexGap = useFlexGapSupport_default();
+    const gutter = computed(() => {
+      const results = [void 0, void 0];
+      const { gutter: gutter2 = 0 } = props;
+      (Array.isArray(gutter2) ? gutter2 : [gutter2, void 0]).forEach((g, index) => {
+        if (typeof g === "object") for (let i2 = 0; i2 < responsiveArray.length; i2++) {
+          const breakpoint = responsiveArray[i2];
+          if (screens.value[breakpoint] && g[breakpoint] !== void 0) {
+            results[index] = g[breakpoint];
+            break;
+          }
+        }
+        else results[index] = g;
+      });
+      return results;
+    });
+    useProvideRow({
+      gutter,
+      supportFlexGap,
+      wrap: computed(() => props.wrap)
+    });
+    const classes = computed(() => classNames(prefixCls.value, {
+      [`${prefixCls.value}-no-wrap`]: props.wrap === false,
+      [`${prefixCls.value}-${mergeJustify.value}`]: mergeJustify.value,
+      [`${prefixCls.value}-${mergeAlign.value}`]: mergeAlign.value,
+      [`${prefixCls.value}-rtl`]: direction.value === "rtl"
+    }, attrs.class, hashId.value));
+    const rowStyle = computed(() => {
+      const gt = gutter.value;
+      const style = {};
+      const horizontalGutter = gt[0] != null && gt[0] > 0 ? `${gt[0] / -2}px` : void 0;
+      const verticalGutter = gt[1] != null && gt[1] > 0 ? `${gt[1] / -2}px` : void 0;
+      if (horizontalGutter) {
+        style.marginLeft = horizontalGutter;
+        style.marginRight = horizontalGutter;
+      }
+      if (supportFlexGap.value) style.rowGap = `${gt[1]}px`;
+      else if (verticalGutter) {
+        style.marginTop = verticalGutter;
+        style.marginBottom = verticalGutter;
+      }
+      return style;
+    });
+    return () => {
+      var _a;
+      return wrapSSR(createVNode("div", _objectSpread2(_objectSpread2({}, attrs), {}, {
+        "class": classes.value,
+        "style": _extends$1(_extends$1({}, rowStyle.value), attrs.style)
+      }), [(_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots)]));
+    };
+  }
+});
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i2 = 1; i2 < arguments.length; i2++) {
+      var source = arguments[i2];
+      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.bind() : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : 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 (e2) {
+    return false;
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) _construct = Reflect.construct.bind();
+  else _construct = function _construct2(Parent2, args2, Class2) {
+    var a = [null];
+    a.push.apply(a, args2);
+    var instance = new (Function.bind.apply(Parent2, a))();
+    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" ? /* @__PURE__ */ 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) ;
+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 i2 = 0;
+  var len = args.length;
+  if (typeof template === "function") return template.apply(null, args);
+  if (typeof template === "string") return template.replace(formatRegExp, function(x) {
+    if (x === "%%") return "%";
+    if (i2 >= len) return x;
+    switch (x) {
+      case "%s":
+        return String(args[i2++]);
+      case "%d":
+        return Number(args[i2++]);
+      case "%j":
+        try {
+          return JSON.stringify(args[i2++]);
+        } catch (_) {
+          return "[Circular]";
+        }
+      default:
+        return x;
+    }
+  });
+  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 index = 0;
+  var arrLength = arr.length;
+  function next(errors) {
+    if (errors && errors.length) {
+      callback(errors);
+      return;
+    }
+    var original = index;
+    index = index + 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 = _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) {
+      asyncSerialArray(flattenObjArr(objArr), func, function next(errors) {
+        callback(errors);
+        return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
+      });
+    });
+    _pending["catch"](function(e2) {
+      return e2;
+    });
+    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(e2) {
+    return e2;
+  });
+  return pending;
+}
+function isErrorObj(obj) {
+  return !!(obj && obj.message !== void 0);
+}
+function getValue$1(value, path) {
+  var v = value;
+  for (var i2 = 0; i2 < path.length; i2++) {
+    if (v == void 0) return v;
+    v = v[path[i2]];
+  }
+  return v;
+}
+function complementError(rule, source) {
+  return function(oe) {
+    var fieldValue;
+    if (rule.fullFields) fieldValue = getValue$1(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 urlReg;
+var getUrlRegex = (function() {
+  if (urlReg) return urlReg;
+  var word = "[a-fA-F\\d:]";
+  var b = function b2(options) {
+    return options && options.includeBoundaries ? "(?:(?<=\\s|^)(?=" + word + ")|(?<=" + word + ")(?=\\s|$))" : "";
+  };
+  var v4 = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}";
+  var v6seg = "[a-fA-F\\d]{1,4}";
+  var v6 = ("\n(?:\n(?:" + v6seg + ":){7}(?:" + v6seg + "|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8\n(?:" + v6seg + ":){6}(?:" + v4 + "|:" + v6seg + "|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4\n(?:" + v6seg + ":){5}(?::" + v4 + "|(?::" + v6seg + "){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4\n(?:" + v6seg + ":){4}(?:(?::" + v6seg + "){0,1}:" + v4 + "|(?::" + v6seg + "){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4\n(?:" + v6seg + ":){3}(?:(?::" + v6seg + "){0,2}:" + v4 + "|(?::" + v6seg + "){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4\n(?:" + v6seg + ":){2}(?:(?::" + v6seg + "){0,3}:" + v4 + "|(?::" + v6seg + "){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4\n(?:" + v6seg + ":){1}(?:(?::" + v6seg + "){0,4}:" + v4 + "|(?::" + v6seg + "){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4\n(?::(?:(?::" + v6seg + "){0,5}:" + v4 + "|(?::" + v6seg + "){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4\n)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1\n").replace(/\s*\/\/.*$/gm, "").replace(/\n/g, "").trim();
+  var v46Exact = new RegExp("(?:^" + v4 + "$)|(?:^" + v6 + "$)");
+  var v4exact = new RegExp("^" + v4 + "$");
+  var v6exact = new RegExp("^" + v6 + "$");
+  var ip = function ip2(options) {
+    return options && options.exact ? v46Exact : new RegExp("(?:" + b(options) + v4 + b(options) + ")|(?:" + b(options) + v6 + b(options) + ")", "g");
+  };
+  ip.v4 = function(options) {
+    return options && options.exact ? v4exact : new RegExp("" + b(options) + v4 + b(options), "g");
+  };
+  ip.v6 = function(options) {
+    return options && options.exact ? v6exact : new RegExp("" + b(options) + v6 + b(options), "g");
+  };
+  var protocol = "(?:(?:[a-z]+:)?//)";
+  var auth = "(?:\\S+(?::\\S*)?@)?";
+  var ipv4 = ip.v4().source;
+  var ipv6 = ip.v6().source;
+  var regex = "(?:" + protocol + "|www\\.)" + auth + "(?:localhost|" + ipv4 + "|" + ipv6 + '|(?:(?:[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,})))(?::\\d{2,5})?(?:[/?#][^\\s"]*)?';
+  urlReg = new RegExp("(?:^" + regex + "$)", "i");
+  return urlReg;
+});
+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,}))$/,
+  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 (e2) {
+      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(getUrlRegex());
+  },
+  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 rules = {
+  required: required$1,
+  whitespace,
+  type: type$1,
+  range,
+  "enum": 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(", ")));
+  },
+  pattern: 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") {
+        if (!new RegExp(rule.pattern).test(value)) errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
+      }
+    }
+  }
+};
+var string = function string2(rule, value, callback, source, options) {
+  var errors = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 = [];
+  if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+    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 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 any(rule, value, callback, source, options) {
+    var errors = [];
+    if (rule.required || !rule.required && source.hasOwnProperty(rule.field)) {
+      if (isEmptyValue(value) && !rule.required) return callback();
+      rules.required(rule, value, source, errors, options);
+    }
+    callback(errors);
+  }
+};
+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(e2) {
+        if (Array.isArray(e2)) {
+          var _errors;
+          errors = (_errors = errors).concat.apply(_errors, e2);
+        } else errors.push(e2);
+      }
+      for (var i2 = 0; i2 < results.length; i2++) add(results[i2]);
+      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 = {};
+    (options.keys || Object.keys(this.rules)).forEach(function(z) {
+      var arr = _this2.rules[z];
+      var value = source[z];
+      arr.forEach(function(r2) {
+        var rule = r2;
+        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(e2) {
+        if (e2 === void 0) e2 = [];
+        var errorList = Array.isArray(e2) ? e2 : [e2];
+        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];
+            paredFieldsSchema[field] = (Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema]).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) {
+        try {
+          res = rule.validator(rule, data.value, cb, data.source, options);
+        } catch (error) {
+          console.error == null || console.error(error);
+          if (!options.suppressValidatorError) setTimeout(function() {
+            throw error;
+          }, 0);
+          cb(error.message);
+        }
+        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(e2) {
+        return cb(e2);
+      });
+    }, 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 keys2 = Object.keys(rule);
+    var messageIndex = keys2.indexOf("message");
+    if (messageIndex !== -1) keys2.splice(messageIndex, 1);
+    if (keys2.length === 1 && keys2[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;
+function toArray$1(value) {
+  if (value === void 0 || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function get(entity, path) {
+  let current = entity;
+  for (let i2 = 0; i2 < path.length; i2 += 1) {
+    if (current === null || current === void 0) return;
+    current = current[path[i2]];
+  }
+  return current;
+}
+function internalSet(entity, paths, value, removeIfUndefined) {
+  if (!paths.length) return value;
+  const [path, ...restPath] = paths;
+  let clone;
+  if (!entity && typeof path === "number") clone = [];
+  else if (Array.isArray(entity)) clone = [...entity];
+  else clone = _extends$1({}, entity);
+  if (removeIfUndefined && value === void 0 && restPath.length === 1) delete clone[path][restPath[0]];
+  else clone[path] = internalSet(clone[path], restPath, value, removeIfUndefined);
+  return clone;
+}
+function set(entity, paths, value) {
+  let removeIfUndefined = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+  if (paths.length && removeIfUndefined && value === void 0 && !get(entity, paths.slice(0, -1))) return entity;
+  return internalSet(entity, paths, value, removeIfUndefined);
+}
+function getNamePath(path) {
+  return toArray$1(path);
+}
+function getValue(store, namePath) {
+  return get(store, namePath);
+}
+function setValue(store, namePath, value) {
+  return set(store, namePath, value, arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false);
+}
+function containsNamePath(namePathList, namePath) {
+  return namePathList && namePathList.some((path) => matchNamePath(path, namePath));
+}
+function isObject(obj) {
+  return typeof obj === "object" && obj !== null && Object.getPrototypeOf(obj) === Object.prototype;
+}
+function internalSetValues(store, values) {
+  const newStore = Array.isArray(store) ? [...store] : _extends$1({}, store);
+  if (!values) return newStore;
+  Object.keys(values).forEach((key) => {
+    const prevValue = newStore[key];
+    const value = values[key];
+    const recursive = isObject(prevValue) && isObject(value);
+    newStore[key] = recursive ? internalSetValues(prevValue, value || {}) : value;
+  });
+  return newStore;
+}
+function setValues(store) {
+  for (var _len = arguments.length, restValues = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) restValues[_key - 1] = arguments[_key];
+  return restValues.reduce((current, newStore) => internalSetValues(current, newStore), store);
+}
+function cloneByNamePathList(store, namePathList) {
+  let newStore = {};
+  namePathList.forEach((namePath) => {
+    const value = getValue(store, namePath);
+    newStore = setValue(newStore, namePath, value);
+  });
+  return newStore;
+}
+function matchNamePath(namePath, changedNamePath) {
+  if (!namePath || !changedNamePath || namePath.length !== changedNamePath.length) return false;
+  return namePath.every((nameUnit, i2) => changedNamePath[i2] === nameUnit);
+}
+var typeTemplate = "'${name}' is not a valid ${type}";
+var defaultValidateMessages = {
+  default: "Validation error on field '${name}'",
+  required: "'${name}' is required",
+  enum: "'${name}' must be one of [${enum}]",
+  whitespace: "'${name}' cannot be empty",
+  date: {
+    format: "'${name}' is invalid for format date",
+    parse: "'${name}' could not be parsed as date",
+    invalid: "'${name}' is invalid date"
+  },
+  types: {
+    string: typeTemplate,
+    method: typeTemplate,
+    array: typeTemplate,
+    object: typeTemplate,
+    number: typeTemplate,
+    date: typeTemplate,
+    boolean: typeTemplate,
+    integer: typeTemplate,
+    float: typeTemplate,
+    regexp: typeTemplate,
+    email: typeTemplate,
+    url: typeTemplate,
+    hex: typeTemplate
+  },
+  string: {
+    len: "'${name}' must be exactly ${len} characters",
+    min: "'${name}' must be at least ${min} characters",
+    max: "'${name}' cannot be longer than ${max} characters",
+    range: "'${name}' must be between ${min} and ${max} characters"
+  },
+  number: {
+    len: "'${name}' must equal ${len}",
+    min: "'${name}' cannot be less than ${min}",
+    max: "'${name}' cannot be greater than ${max}",
+    range: "'${name}' must be between ${min} and ${max}"
+  },
+  array: {
+    len: "'${name}' must be exactly ${len} in length",
+    min: "'${name}' cannot be less than ${min} in length",
+    max: "'${name}' cannot be greater than ${max} in length",
+    range: "'${name}' must be between ${min} and ${max} in length"
+  },
+  pattern: { mismatch: "'${name}' does not match pattern ${pattern}" }
+};
+var __awaiter = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e2) {
+        reject(e2);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e2) {
+        reject(e2);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, [])).next());
+  });
+};
+var AsyncValidator = Schema;
+function replaceMessage(template, kv) {
+  return template.replace(/\$\{\w+\}/g, (str) => {
+    return kv[str.slice(2, -1)];
+  });
+}
+function validateRule(name, value, rule, options, messageVariables) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const cloneRule = _extends$1({}, rule);
+    delete cloneRule.ruleIndex;
+    delete cloneRule.trigger;
+    let subRuleField = null;
+    if (cloneRule && cloneRule.type === "array" && cloneRule.defaultField) {
+      subRuleField = cloneRule.defaultField;
+      delete cloneRule.defaultField;
+    }
+    const validator = new AsyncValidator({ [name]: [cloneRule] });
+    const messages2 = setValues({}, defaultValidateMessages, options.validateMessages);
+    validator.messages(messages2);
+    let result = [];
+    try {
+      yield Promise.resolve(validator.validate({ [name]: value }, _extends$1({}, options)));
+    } catch (errObj) {
+      if (errObj.errors) result = errObj.errors.map((_ref, index) => {
+        let { message } = _ref;
+        return isValidElement(message) ? cloneVNode(message, { key: `error_${index}` }) : message;
+      });
+      else {
+        console.error(errObj);
+        result = [messages2.default()];
+      }
+    }
+    if (!result.length && subRuleField) return (yield Promise.all(value.map((subValue, i2) => validateRule(`${name}.${i2}`, subValue, subRuleField, options, messageVariables)))).reduce((prev, errors) => [...prev, ...errors], []);
+    const kv = _extends$1(_extends$1(_extends$1({}, rule), {
+      name,
+      enum: (rule.enum || []).join(", ")
+    }), messageVariables);
+    return result.map((error) => {
+      if (typeof error === "string") return replaceMessage(error, kv);
+      return error;
+    });
+  });
+}
+function validateRules(namePath, value, rules2, options, validateFirst, messageVariables) {
+  const name = namePath.join(".");
+  const filledRules = rules2.map((currentRule, ruleIndex) => {
+    const originValidatorFunc = currentRule.validator;
+    const cloneRule = _extends$1(_extends$1({}, currentRule), { ruleIndex });
+    if (originValidatorFunc) cloneRule.validator = (rule, val, callback) => {
+      let hasPromise = false;
+      const wrappedCallback = function() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+        Promise.resolve().then(() => {
+          if (!hasPromise) callback(...args);
+        });
+      };
+      const promise = originValidatorFunc(rule, val, wrappedCallback);
+      hasPromise = promise && typeof promise.then === "function" && typeof promise.catch === "function";
+      if (hasPromise) promise.then(() => {
+        callback();
+      }).catch((err) => {
+        callback(err || " ");
+      });
+    };
+    return cloneRule;
+  }).sort((_ref2, _ref3) => {
+    let { warningOnly: w1, ruleIndex: i1 } = _ref2;
+    let { warningOnly: w2, ruleIndex: i2 } = _ref3;
+    if (!!w1 === !!w2) return i1 - i2;
+    if (w1) return 1;
+    return -1;
+  });
+  let summaryPromise;
+  if (validateFirst === true) summaryPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+    for (let i2 = 0; i2 < filledRules.length; i2 += 1) {
+      const rule = filledRules[i2];
+      const errors = yield validateRule(name, value, rule, options, messageVariables);
+      if (errors.length) {
+        reject([{
+          errors,
+          rule
+        }]);
+        return;
+      }
+    }
+    resolve([]);
+  }));
+  else {
+    const rulePromises = filledRules.map((rule) => validateRule(name, value, rule, options, messageVariables).then((errors) => ({
+      errors,
+      rule
+    })));
+    summaryPromise = (validateFirst ? finishOnFirstFailed(rulePromises) : finishOnAllFailed(rulePromises)).then((errors) => {
+      return Promise.reject(errors);
+    });
+  }
+  summaryPromise.catch((e2) => e2);
+  return summaryPromise;
+}
+function finishOnAllFailed(rulePromises) {
+  return __awaiter(this, void 0, void 0, function* () {
+    return Promise.all(rulePromises).then((errorsList) => {
+      return [].concat(...errorsList);
+    });
+  });
+}
+function finishOnFirstFailed(rulePromises) {
+  return __awaiter(this, void 0, void 0, function* () {
+    let count = 0;
+    return new Promise((resolve) => {
+      rulePromises.forEach((promise) => {
+        promise.then((ruleError) => {
+          if (ruleError.errors.length) resolve([ruleError]);
+          count += 1;
+          if (count === rulePromises.length) resolve([]);
+        });
+      });
+    });
+  });
+}
+var FormContextKey = /* @__PURE__ */ Symbol("formContextKey");
+var useProvideForm = (state) => {
+  provide(FormContextKey, state);
+};
+var useInjectForm = () => {
+  return inject(FormContextKey, {
+    name: computed(() => void 0),
+    labelAlign: computed(() => "right"),
+    vertical: computed(() => false),
+    addField: (_eventKey, _field) => {
+    },
+    removeField: (_eventKey) => {
+    },
+    model: computed(() => void 0),
+    rules: computed(() => void 0),
+    colon: computed(() => void 0),
+    labelWrap: computed(() => void 0),
+    labelCol: computed(() => void 0),
+    requiredMark: computed(() => false),
+    validateTrigger: computed(() => void 0),
+    onValidate: () => {
+    },
+    validateMessages: computed(() => defaultValidateMessages)
+  });
+};
+var FormItemPrefixContextKey = /* @__PURE__ */ Symbol("formItemPrefixContextKey");
+var useProvideFormItemPrefix = (state) => {
+  provide(FormItemPrefixContextKey, state);
+};
+var useInjectFormItemPrefix = () => {
+  return inject(FormItemPrefixContextKey, { prefixCls: computed(() => "") });
+};
+function parseFlex(flex) {
+  if (typeof flex === "number") return `${flex} ${flex} auto`;
+  if (/^\d+(\.\d+)?(px|em|rem|%)$/.test(flex)) return `0 0 ${flex}`;
+  return flex;
+}
+var colProps = () => ({
+  span: [String, Number],
+  order: [String, Number],
+  offset: [String, Number],
+  push: [String, Number],
+  pull: [String, Number],
+  xs: {
+    type: [
+      String,
+      Number,
+      Object
+    ],
+    default: void 0
+  },
+  sm: {
+    type: [
+      String,
+      Number,
+      Object
+    ],
+    default: void 0
+  },
+  md: {
+    type: [
+      String,
+      Number,
+      Object
+    ],
+    default: void 0
+  },
+  lg: {
+    type: [
+      String,
+      Number,
+      Object
+    ],
+    default: void 0
+  },
+  xl: {
+    type: [
+      String,
+      Number,
+      Object
+    ],
+    default: void 0
+  },
+  xxl: {
+    type: [
+      String,
+      Number,
+      Object
+    ],
+    default: void 0
+  },
+  prefixCls: String,
+  flex: [String, Number]
+});
+var sizes = [
+  "xs",
+  "sm",
+  "md",
+  "lg",
+  "xl",
+  "xxl"
+];
+var Col_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "ACol",
+  inheritAttrs: false,
+  props: colProps(),
+  setup(props, _ref) {
+    let { slots, attrs } = _ref;
+    const { gutter, supportFlexGap, wrap } = useInjectRow();
+    const { prefixCls, direction } = useConfigInject_default("col", props);
+    const [wrapSSR, hashId] = useColStyle(prefixCls);
+    const classes = computed(() => {
+      const { span, order, offset, push, pull } = props;
+      const pre = prefixCls.value;
+      let sizeClassObj = {};
+      sizes.forEach((size) => {
+        let sizeProps = {};
+        const propSize = props[size];
+        if (typeof propSize === "number") sizeProps.span = propSize;
+        else if (typeof propSize === "object") sizeProps = propSize || {};
+        sizeClassObj = _extends$1(_extends$1({}, sizeClassObj), {
+          [`${pre}-${size}-${sizeProps.span}`]: sizeProps.span !== void 0,
+          [`${pre}-${size}-order-${sizeProps.order}`]: sizeProps.order || sizeProps.order === 0,
+          [`${pre}-${size}-offset-${sizeProps.offset}`]: sizeProps.offset || sizeProps.offset === 0,
+          [`${pre}-${size}-push-${sizeProps.push}`]: sizeProps.push || sizeProps.push === 0,
+          [`${pre}-${size}-pull-${sizeProps.pull}`]: sizeProps.pull || sizeProps.pull === 0,
+          [`${pre}-rtl`]: direction.value === "rtl"
+        });
+      });
+      return classNames(pre, {
+        [`${pre}-${span}`]: span !== void 0,
+        [`${pre}-order-${order}`]: order,
+        [`${pre}-offset-${offset}`]: offset,
+        [`${pre}-push-${push}`]: push,
+        [`${pre}-pull-${pull}`]: pull
+      }, sizeClassObj, attrs.class, hashId.value);
+    });
+    const mergedStyle = computed(() => {
+      const { flex } = props;
+      const gutterVal = gutter.value;
+      const style = {};
+      if (gutterVal && gutterVal[0] > 0) {
+        const horizontalGutter = `${gutterVal[0] / 2}px`;
+        style.paddingLeft = horizontalGutter;
+        style.paddingRight = horizontalGutter;
+      }
+      if (gutterVal && gutterVal[1] > 0 && !supportFlexGap.value) {
+        const verticalGutter = `${gutterVal[1] / 2}px`;
+        style.paddingTop = verticalGutter;
+        style.paddingBottom = verticalGutter;
+      }
+      if (flex) {
+        style.flex = parseFlex(flex);
+        if (wrap.value === false && !style.minWidth) style.minWidth = 0;
+      }
+      return style;
+    });
+    return () => {
+      var _a;
+      return wrapSSR(createVNode("div", _objectSpread2(_objectSpread2({}, attrs), {}, {
+        "class": classes.value,
+        "style": [mergedStyle.value, attrs.style]
+      }), [(_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots)]));
+    };
+  }
+});
+var FormItemLabel = (props, _ref) => {
+  let { slots, emit, attrs } = _ref;
+  var _a, _b, _c, _d, _e;
+  const { prefixCls, htmlFor, labelCol, labelAlign, colon, required: required4, requiredMark } = _extends$1(_extends$1({}, props), attrs);
+  const [formLocale] = useLocaleReceiver("Form");
+  const label = (_a = props.label) !== null && _a !== void 0 ? _a : (_b = slots.label) === null || _b === void 0 ? void 0 : _b.call(slots);
+  if (!label) return null;
+  const { vertical, labelAlign: contextLabelAlign, labelCol: contextLabelCol, labelWrap, colon: contextColon } = useInjectForm();
+  const mergedLabelCol = labelCol || (contextLabelCol === null || contextLabelCol === void 0 ? void 0 : contextLabelCol.value) || {};
+  const mergedLabelAlign = labelAlign || (contextLabelAlign === null || contextLabelAlign === void 0 ? void 0 : contextLabelAlign.value);
+  const labelClsBasic = `${prefixCls}-item-label`;
+  const labelColClassName = classNames(labelClsBasic, mergedLabelAlign === "left" && `${labelClsBasic}-left`, mergedLabelCol.class, { [`${labelClsBasic}-wrap`]: !!labelWrap.value });
+  let labelChildren = label;
+  const computedColon = colon === true || (contextColon === null || contextColon === void 0 ? void 0 : contextColon.value) !== false && colon !== false;
+  if (computedColon && !vertical.value && typeof label === "string" && label.trim() !== "") labelChildren = label.replace(/[:|：]\s*$/, "");
+  if (props.tooltip || slots.tooltip) {
+    const tooltipNode = createVNode("span", { "class": `${prefixCls}-item-tooltip` }, [createVNode(tooltip_default, { "title": props.tooltip }, { default: () => [createVNode(QuestionCircleOutlined, null, null)] })]);
+    labelChildren = createVNode(Fragment, null, [labelChildren, slots.tooltip ? (_c = slots.tooltip) === null || _c === void 0 ? void 0 : _c.call(slots, { class: `${prefixCls}-item-tooltip` }) : tooltipNode]);
+  }
+  if (requiredMark === "optional" && !required4) labelChildren = createVNode(Fragment, null, [labelChildren, createVNode("span", { "class": `${prefixCls}-item-optional` }, [((_d = formLocale.value) === null || _d === void 0 ? void 0 : _d.optional) || ((_e = localeValues.Form) === null || _e === void 0 ? void 0 : _e.optional)])]);
+  const labelClassName = classNames({
+    [`${prefixCls}-item-required`]: required4,
+    [`${prefixCls}-item-required-mark-optional`]: requiredMark === "optional",
+    [`${prefixCls}-item-no-colon`]: !computedColon
+  });
+  return createVNode(Col_default, _objectSpread2(_objectSpread2({}, mergedLabelCol), {}, { "class": labelColClassName }), { default: () => [createVNode("label", {
+    "for": htmlFor,
+    "class": labelClassName,
+    "title": typeof label === "string" ? label : "",
+    "onClick": (e2) => emit("click", e2)
+  }, [labelChildren])] });
+};
+FormItemLabel.displayName = "FormItemLabel";
+FormItemLabel.inheritAttrs = false;
+var genFormValidateMotionStyle = (token) => {
+  const { componentCls } = token;
+  const helpCls = `${componentCls}-show-help`;
+  const helpItemCls = `${componentCls}-show-help-item`;
+  return { [helpCls]: {
+    transition: `opacity ${token.motionDurationSlow} ${token.motionEaseInOut}`,
+    "&-appear, &-enter": {
+      opacity: 0,
+      "&-active": { opacity: 1 }
+    },
+    "&-leave": {
+      opacity: 1,
+      "&-active": { opacity: 0 }
+    },
+    [helpItemCls]: {
+      overflow: "hidden",
+      transition: `height ${token.motionDurationSlow} ${token.motionEaseInOut},
+                     opacity ${token.motionDurationSlow} ${token.motionEaseInOut},
+                     transform ${token.motionDurationSlow} ${token.motionEaseInOut} !important`,
+      [`&${helpItemCls}-appear, &${helpItemCls}-enter`]: {
+        transform: `translateY(-5px)`,
+        opacity: 0,
+        [`&-active`]: {
+          transform: "translateY(0)",
+          opacity: 1
+        }
+      },
+      [`&${helpItemCls}-leave-active`]: { transform: `translateY(-5px)` }
+    }
+  } };
+};
+var resetForm = (token) => ({
+  legend: {
+    display: "block",
+    width: "100%",
+    marginBottom: token.marginLG,
+    padding: 0,
+    color: token.colorTextDescription,
+    fontSize: token.fontSizeLG,
+    lineHeight: "inherit",
+    border: 0,
+    borderBottom: `${token.lineWidth}px ${token.lineType} ${token.colorBorder}`
+  },
+  label: { fontSize: token.fontSize },
+  'input[type="search"]': { boxSizing: "border-box" },
+  'input[type="radio"], input[type="checkbox"]': { lineHeight: "normal" },
+  'input[type="file"]': { display: "block" },
+  'input[type="range"]': {
+    display: "block",
+    width: "100%"
+  },
+  "select[multiple], select[size]": { height: "auto" },
+  [`input[type='file']:focus,
+  input[type='radio']:focus,
+  input[type='checkbox']:focus`]: {
+    outline: 0,
+    boxShadow: `0 0 0 ${token.controlOutlineWidth}px ${token.controlOutline}`
+  },
+  output: {
+    display: "block",
+    paddingTop: 15,
+    color: token.colorText,
+    fontSize: token.fontSize,
+    lineHeight: token.lineHeight
+  }
+});
+var genFormSize = (token, height) => {
+  const { formItemCls } = token;
+  return { [formItemCls]: {
+    [`${formItemCls}-label > label`]: { height },
+    [`${formItemCls}-control-input`]: { minHeight: height }
+  } };
+};
+var genFormStyle = (token) => {
+  const { componentCls } = token;
+  return { [token.componentCls]: _extends$1(_extends$1(_extends$1({}, resetComponent(token)), resetForm(token)), {
+    [`${componentCls}-text`]: {
+      display: "inline-block",
+      paddingInlineEnd: token.paddingSM
+    },
+    "&-small": _extends$1({}, genFormSize(token, token.controlHeightSM)),
+    "&-large": _extends$1({}, genFormSize(token, token.controlHeightLG))
+  }) };
+};
+var genFormItemStyle = (token) => {
+  const { formItemCls, iconCls, componentCls, rootPrefixCls } = token;
+  return { [formItemCls]: _extends$1(_extends$1({}, resetComponent(token)), {
+    marginBottom: token.marginLG,
+    verticalAlign: "top",
+    "&-with-help": { transition: "none" },
+    [`&-hidden,
+        &-hidden.${rootPrefixCls}-row`]: { display: "none" },
+    "&-has-warning": { [`${formItemCls}-split`]: { color: token.colorError } },
+    "&-has-error": { [`${formItemCls}-split`]: { color: token.colorWarning } },
+    [`${formItemCls}-label`]: {
+      display: "inline-block",
+      flexGrow: 0,
+      overflow: "hidden",
+      whiteSpace: "nowrap",
+      textAlign: "end",
+      verticalAlign: "middle",
+      "&-left": { textAlign: "start" },
+      "&-wrap": {
+        overflow: "unset",
+        lineHeight: `${token.lineHeight} - 0.25em`,
+        whiteSpace: "unset"
+      },
+      "> label": {
+        position: "relative",
+        display: "inline-flex",
+        alignItems: "center",
+        maxWidth: "100%",
+        height: token.controlHeight,
+        color: token.colorTextHeading,
+        fontSize: token.fontSize,
+        [`> ${iconCls}`]: {
+          fontSize: token.fontSize,
+          verticalAlign: "top"
+        },
+        [`&${formItemCls}-required:not(${formItemCls}-required-mark-optional)::before`]: {
+          display: "inline-block",
+          marginInlineEnd: token.marginXXS,
+          color: token.colorError,
+          fontSize: token.fontSize,
+          fontFamily: "SimSun, sans-serif",
+          lineHeight: 1,
+          content: '"*"',
+          [`${componentCls}-hide-required-mark &`]: { display: "none" }
+        },
+        [`${formItemCls}-optional`]: {
+          display: "inline-block",
+          marginInlineStart: token.marginXXS,
+          color: token.colorTextDescription,
+          [`${componentCls}-hide-required-mark &`]: { display: "none" }
+        },
+        [`${formItemCls}-tooltip`]: {
+          color: token.colorTextDescription,
+          cursor: "help",
+          writingMode: "horizontal-tb",
+          marginInlineStart: token.marginXXS
+        },
+        "&::after": {
+          content: '":"',
+          position: "relative",
+          marginBlock: 0,
+          marginInlineStart: token.marginXXS / 2,
+          marginInlineEnd: token.marginXS
+        },
+        [`&${formItemCls}-no-colon::after`]: { content: '" "' }
+      }
+    },
+    [`${formItemCls}-control`]: {
+      display: "flex",
+      flexDirection: "column",
+      flexGrow: 1,
+      [`&:first-child:not([class^="'${rootPrefixCls}-col-'"]):not([class*="' ${rootPrefixCls}-col-'"])`]: { width: "100%" },
+      "&-input": {
+        position: "relative",
+        display: "flex",
+        alignItems: "center",
+        minHeight: token.controlHeight,
+        "&-content": {
+          flex: "auto",
+          maxWidth: "100%"
+        }
+      }
+    },
+    [formItemCls]: {
+      "&-explain, &-extra": {
+        clear: "both",
+        color: token.colorTextDescription,
+        fontSize: token.fontSize,
+        lineHeight: token.lineHeight
+      },
+      "&-explain-connected": { width: "100%" },
+      "&-extra": {
+        minHeight: token.controlHeightSM,
+        transition: `color ${token.motionDurationMid} ${token.motionEaseOut}`
+      },
+      "&-explain": {
+        "&-error": { color: token.colorError },
+        "&-warning": { color: token.colorWarning }
+      }
+    },
+    [`&-with-help ${formItemCls}-explain`]: {
+      height: "auto",
+      opacity: 1
+    },
+    [`${formItemCls}-feedback-icon`]: {
+      fontSize: token.fontSize,
+      textAlign: "center",
+      visibility: "visible",
+      animationName: zoomIn,
+      animationDuration: token.motionDurationMid,
+      animationTimingFunction: token.motionEaseOutBack,
+      pointerEvents: "none",
+      "&-success": { color: token.colorSuccess },
+      "&-error": { color: token.colorError },
+      "&-warning": { color: token.colorWarning },
+      "&-validating": { color: token.colorPrimary }
+    }
+  }) };
+};
+var genHorizontalStyle = (token) => {
+  const { componentCls, formItemCls, rootPrefixCls } = token;
+  return { [`${componentCls}-horizontal`]: {
+    [`${formItemCls}-label`]: { flexGrow: 0 },
+    [`${formItemCls}-control`]: {
+      flex: "1 1 0",
+      minWidth: 0
+    },
+    [`${formItemCls}-label.${rootPrefixCls}-col-24 + ${formItemCls}-control`]: { minWidth: "unset" }
+  } };
+};
+var genInlineStyle = (token) => {
+  const { componentCls, formItemCls } = token;
+  return { [`${componentCls}-inline`]: {
+    display: "flex",
+    flexWrap: "wrap",
+    [formItemCls]: {
+      flex: "none",
+      flexWrap: "nowrap",
+      marginInlineEnd: token.margin,
+      marginBottom: 0,
+      "&-with-help": { marginBottom: token.marginLG },
+      [`> ${formItemCls}-label,
+        > ${formItemCls}-control`]: {
+        display: "inline-block",
+        verticalAlign: "top"
+      },
+      [`> ${formItemCls}-label`]: { flex: "none" },
+      [`${componentCls}-text`]: { display: "inline-block" },
+      [`${formItemCls}-has-feedback`]: { display: "inline-block" }
+    }
+  } };
+};
+var makeVerticalLayoutLabel = (token) => ({
+  margin: 0,
+  padding: `0 0 ${token.paddingXS}px`,
+  whiteSpace: "initial",
+  textAlign: "start",
+  "> label": {
+    margin: 0,
+    "&::after": { display: "none" }
+  }
+});
+var makeVerticalLayout = (token) => {
+  const { componentCls, formItemCls } = token;
+  return {
+    [`${formItemCls} ${formItemCls}-label`]: makeVerticalLayoutLabel(token),
+    [componentCls]: { [formItemCls]: {
+      flexWrap: "wrap",
+      [`${formItemCls}-label,
+          ${formItemCls}-control`]: {
+        flex: "0 0 100%",
+        maxWidth: "100%"
+      }
+    } }
+  };
+};
+var genVerticalStyle = (token) => {
+  const { componentCls, formItemCls, rootPrefixCls } = token;
+  return {
+    [`${componentCls}-vertical`]: { [formItemCls]: {
+      "&-row": { flexDirection: "column" },
+      "&-label > label": { height: "auto" },
+      [`${componentCls}-item-control`]: { width: "100%" }
+    } },
+    [`${componentCls}-vertical ${formItemCls}-label,
+      .${rootPrefixCls}-col-24${formItemCls}-label,
+      .${rootPrefixCls}-col-xl-24${formItemCls}-label`]: makeVerticalLayoutLabel(token),
+    [`@media (max-width: ${token.screenXSMax}px)`]: [makeVerticalLayout(token), { [componentCls]: { [`.${rootPrefixCls}-col-xs-24${formItemCls}-label`]: makeVerticalLayoutLabel(token) } }],
+    [`@media (max-width: ${token.screenSMMax}px)`]: { [componentCls]: { [`.${rootPrefixCls}-col-sm-24${formItemCls}-label`]: makeVerticalLayoutLabel(token) } },
+    [`@media (max-width: ${token.screenMDMax}px)`]: { [componentCls]: { [`.${rootPrefixCls}-col-md-24${formItemCls}-label`]: makeVerticalLayoutLabel(token) } },
+    [`@media (max-width: ${token.screenLGMax}px)`]: { [componentCls]: { [`.${rootPrefixCls}-col-lg-24${formItemCls}-label`]: makeVerticalLayoutLabel(token) } }
+  };
+};
+var style_default = genComponentStyleHook("Form", (token, _ref) => {
+  let { rootPrefixCls } = _ref;
+  const formToken = merge(token, {
+    formItemCls: `${token.componentCls}-item`,
+    rootPrefixCls
+  });
+  return [
+    genFormStyle(formToken),
+    genFormItemStyle(formToken),
+    genFormValidateMotionStyle(formToken),
+    genHorizontalStyle(formToken),
+    genInlineStyle(formToken),
+    genVerticalStyle(formToken),
+    genCollapseMotion(formToken),
+    zoomIn
+  ];
+});
+var ErrorList_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "ErrorList",
+  inheritAttrs: false,
+  props: [
+    "errors",
+    "help",
+    "onErrorVisibleChanged",
+    "helpStatus",
+    "warnings"
+  ],
+  setup(props, _ref) {
+    let { attrs } = _ref;
+    const { prefixCls, status } = useInjectFormItemPrefix();
+    const baseClassName = computed(() => `${prefixCls.value}-item-explain`);
+    const visible = computed(() => !!(props.errors && props.errors.length));
+    const innerStatus = ref(status.value);
+    const [, hashId] = style_default(prefixCls);
+    watch([visible, status], () => {
+      if (visible.value) innerStatus.value = status.value;
+    });
+    return () => {
+      var _a, _b;
+      const colMItem = collapseMotion(`${prefixCls.value}-show-help-item`);
+      const transitionGroupProps = getTransitionGroupProps(`${prefixCls.value}-show-help-item`, colMItem);
+      transitionGroupProps.role = "alert";
+      transitionGroupProps.class = [
+        hashId.value,
+        baseClassName.value,
+        attrs.class,
+        `${prefixCls.value}-show-help`
+      ];
+      return createVNode(Transition, _objectSpread2(_objectSpread2({}, getTransitionProps(`${prefixCls.value}-show-help`)), {}, {
+        "onAfterEnter": () => props.onErrorVisibleChanged(true),
+        "onAfterLeave": () => props.onErrorVisibleChanged(false)
+      }), { default: () => [withDirectives(createVNode(TransitionGroup, _objectSpread2(_objectSpread2({}, transitionGroupProps), {}, { "tag": "div" }), { default: () => [(_b = props.errors) === null || _b === void 0 ? void 0 : _b.map((error, index) => createVNode("div", {
+        "key": index,
+        "class": innerStatus.value ? `${baseClassName.value}-${innerStatus.value}` : ""
+      }, [error]))] }), [[vShow, !!((_a = props.errors) === null || _a === void 0 ? void 0 : _a.length)]])] });
+    };
+  }
+});
+var FormItemInput = defineComponent({
+  compatConfig: { MODE: 3 },
+  slots: Object,
+  inheritAttrs: false,
+  props: [
+    "prefixCls",
+    "errors",
+    "hasFeedback",
+    "onDomErrorVisibleChange",
+    "wrapperCol",
+    "help",
+    "extra",
+    "status",
+    "marginBottom",
+    "onErrorVisibleChanged"
+  ],
+  setup(props, _ref) {
+    let { slots } = _ref;
+    const formContext = useInjectForm();
+    const { wrapperCol: contextWrapperCol } = formContext;
+    const subFormContext = _extends$1({}, formContext);
+    delete subFormContext.labelCol;
+    delete subFormContext.wrapperCol;
+    useProvideForm(subFormContext);
+    useProvideFormItemPrefix({
+      prefixCls: computed(() => props.prefixCls),
+      status: computed(() => props.status)
+    });
+    return () => {
+      var _a, _b, _c;
+      const { prefixCls, wrapperCol, marginBottom, onErrorVisibleChanged, help = (_a = slots.help) === null || _a === void 0 ? void 0 : _a.call(slots), errors = filterEmpty((_b = slots.errors) === null || _b === void 0 ? void 0 : _b.call(slots)), extra = (_c = slots.extra) === null || _c === void 0 ? void 0 : _c.call(slots) } = props;
+      const baseClassName = `${prefixCls}-item`;
+      const mergedWrapperCol = wrapperCol || (contextWrapperCol === null || contextWrapperCol === void 0 ? void 0 : contextWrapperCol.value) || {};
+      const className = classNames(`${baseClassName}-control`, mergedWrapperCol.class);
+      return createVNode(Col_default, _objectSpread2(_objectSpread2({}, mergedWrapperCol), {}, { "class": className }), { default: () => {
+        var _a2;
+        return createVNode(Fragment, null, [
+          createVNode("div", { "class": `${baseClassName}-control-input` }, [createVNode("div", { "class": `${baseClassName}-control-input-content` }, [(_a2 = slots.default) === null || _a2 === void 0 ? void 0 : _a2.call(slots)])]),
+          marginBottom !== null || errors.length ? createVNode("div", { "style": {
+            display: "flex",
+            flexWrap: "nowrap"
+          } }, [createVNode(ErrorList_default, {
+            "errors": errors,
+            "help": help,
+            "class": `${baseClassName}-explain-connected`,
+            "onErrorVisibleChanged": onErrorVisibleChanged
+          }, null), !!marginBottom && createVNode("div", { "style": {
+            width: 0,
+            height: `${marginBottom}px`
+          } }, null)]) : null,
+          extra ? createVNode("div", { "class": `${baseClassName}-extra` }, [extra]) : null
+        ]);
+      } });
+    };
+  }
+});
+function useDebounce(value) {
+  const cacheValue = shallowRef(value.value.slice());
+  let timeout = null;
+  watchEffect(() => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      cacheValue.value = value.value;
+    }, value.value.length ? 0 : 10);
+  });
+  return cacheValue;
+}
+tuple("success", "warning", "error", "validating", "");
+var iconMap = {
+  success: CheckCircleFilled,
+  warning: ExclamationCircleFilled,
+  error: CloseCircleFilled,
+  validating: LoadingOutlined
+};
+function getPropByPath$1(obj, namePathList, strict) {
+  let tempObj = obj;
+  const keyArr = namePathList;
+  let i2 = 0;
+  try {
+    for (let len = keyArr.length; i2 < len - 1; ++i2) {
+      if (!tempObj && !strict) break;
+      const key = keyArr[i2];
+      if (key in tempObj) tempObj = tempObj[key];
+      else {
+        if (strict) throw Error("please transfer a valid name path to form item!");
+        break;
+      }
+    }
+    if (strict && !tempObj) throw Error("please transfer a valid name path to form item!");
+  } catch (error) {
+    console.error("please transfer a valid name path to form item!");
+  }
+  return {
+    o: tempObj,
+    k: keyArr[i2],
+    v: tempObj ? tempObj[keyArr[i2]] : void 0
+  };
+}
+var formItemProps = () => ({
+  htmlFor: String,
+  prefixCls: String,
+  label: PropTypes.any,
+  help: PropTypes.any,
+  extra: PropTypes.any,
+  labelCol: { type: Object },
+  wrapperCol: { type: Object },
+  hasFeedback: {
+    type: Boolean,
+    default: false
+  },
+  colon: {
+    type: Boolean,
+    default: void 0
+  },
+  labelAlign: String,
+  prop: { type: [
+    String,
+    Number,
+    Array
+  ] },
+  name: { type: [
+    String,
+    Number,
+    Array
+  ] },
+  rules: [Array, Object],
+  autoLink: {
+    type: Boolean,
+    default: true
+  },
+  required: {
+    type: Boolean,
+    default: void 0
+  },
+  validateFirst: {
+    type: Boolean,
+    default: void 0
+  },
+  validateStatus: PropTypes.oneOf(tuple("", "success", "warning", "error", "validating")),
+  validateTrigger: { type: [String, Array] },
+  messageVariables: { type: Object },
+  hidden: Boolean,
+  noStyle: Boolean,
+  tooltip: String
+});
+var indexGuid = 0;
+var defaultItemNamePrefixCls = "form_item";
+var FormItem_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "AFormItem",
+  inheritAttrs: false,
+  __ANT_NEW_FORM_ITEM: true,
+  props: formItemProps(),
+  slots: Object,
+  setup(props, _ref) {
+    let { slots, attrs, expose } = _ref;
+    props.prop;
+    const eventKey = `form-item-${++indexGuid}`;
+    const { prefixCls } = useConfigInject_default("form", props);
+    const [wrapSSR, hashId] = style_default(prefixCls);
+    const itemRef = shallowRef();
+    const formContext = useInjectForm();
+    const fieldName = computed(() => props.name || props.prop);
+    const errors = shallowRef([]);
+    const validateDisabled = shallowRef(false);
+    const inputRef = shallowRef();
+    const namePath = computed(() => {
+      const val = fieldName.value;
+      return getNamePath(val);
+    });
+    const fieldId = computed(() => {
+      if (!namePath.value.length) return;
+      else {
+        const formName = formContext.name.value;
+        const mergedId = namePath.value.join("_");
+        return formName ? `${formName}_${mergedId}` : `${defaultItemNamePrefixCls}_${mergedId}`;
+      }
+    });
+    const getNewFieldValue = () => {
+      const model = formContext.model.value;
+      if (!model || !fieldName.value) return;
+      else return getPropByPath$1(model, namePath.value, true).v;
+    };
+    const fieldValue = computed(() => getNewFieldValue());
+    const initialValue = shallowRef(cloneDeep(fieldValue.value));
+    const mergedValidateTrigger = computed(() => {
+      let validateTrigger = props.validateTrigger !== void 0 ? props.validateTrigger : formContext.validateTrigger.value;
+      validateTrigger = validateTrigger === void 0 ? "change" : validateTrigger;
+      return toArray$1(validateTrigger);
+    });
+    const rulesRef = computed(() => {
+      let formRules = formContext.rules.value;
+      const selfRules = props.rules;
+      const requiredRule = props.required !== void 0 ? {
+        required: !!props.required,
+        trigger: mergedValidateTrigger.value
+      } : [];
+      const prop = getPropByPath$1(formRules, namePath.value);
+      formRules = formRules ? prop.o[prop.k] || prop.v : [];
+      const rules2 = [].concat(selfRules || formRules || []);
+      if (find(rules2, (rule) => rule.required)) return rules2;
+      else return rules2.concat(requiredRule);
+    });
+    const isRequired2 = computed(() => {
+      const rules2 = rulesRef.value;
+      let isRequired3 = false;
+      if (rules2 && rules2.length) rules2.every((rule) => {
+        if (rule.required) {
+          isRequired3 = true;
+          return false;
+        }
+        return true;
+      });
+      return isRequired3 || props.required;
+    });
+    const validateState = shallowRef();
+    watchEffect(() => {
+      validateState.value = props.validateStatus;
+    });
+    const messageVariables = computed(() => {
+      let variables = {};
+      if (typeof props.label === "string") variables.label = props.label;
+      else if (props.name) variables.label = String(props.name);
+      if (props.messageVariables) variables = _extends$1(_extends$1({}, variables), props.messageVariables);
+      return variables;
+    });
+    const validateRules$1 = (options) => {
+      if (namePath.value.length === 0) return;
+      const { validateFirst = false } = props;
+      const { triggerName } = options || {};
+      let filteredRules = rulesRef.value;
+      if (triggerName) filteredRules = filteredRules.filter((rule) => {
+        const { trigger } = rule;
+        if (!trigger && !mergedValidateTrigger.value.length) return true;
+        return toArray$1(trigger || mergedValidateTrigger.value).includes(triggerName);
+      });
+      if (!filteredRules.length) return Promise.resolve();
+      const promise = validateRules(namePath.value, fieldValue.value, filteredRules, _extends$1({ validateMessages: formContext.validateMessages.value }, options), validateFirst, messageVariables.value);
+      validateState.value = "validating";
+      errors.value = [];
+      promise.catch((e2) => e2).then(function() {
+        let results = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+        if (validateState.value === "validating") {
+          const res = results.filter((result) => result && result.errors.length);
+          validateState.value = res.length ? "error" : "success";
+          errors.value = res.map((r2) => r2.errors);
+          formContext.onValidate(fieldName.value, !errors.value.length, errors.value.length ? toRaw(errors.value[0]) : null);
+        }
+      });
+      return promise;
+    };
+    const onFieldBlur = () => {
+      validateRules$1({ triggerName: "blur" });
+    };
+    const onFieldChange = () => {
+      if (validateDisabled.value) {
+        validateDisabled.value = false;
+        return;
+      }
+      validateRules$1({ triggerName: "change" });
+    };
+    const clearValidate = () => {
+      validateState.value = props.validateStatus;
+      validateDisabled.value = false;
+      errors.value = [];
+    };
+    const resetField = () => {
+      var _a;
+      validateState.value = props.validateStatus;
+      validateDisabled.value = true;
+      errors.value = [];
+      const model = formContext.model.value || {};
+      const value = fieldValue.value;
+      const prop = getPropByPath$1(model, namePath.value, true);
+      if (Array.isArray(value)) prop.o[prop.k] = [].concat((_a = initialValue.value) !== null && _a !== void 0 ? _a : []);
+      else prop.o[prop.k] = initialValue.value;
+      nextTick(() => {
+        validateDisabled.value = false;
+      });
+    };
+    const htmlFor = computed(() => {
+      return props.htmlFor === void 0 ? fieldId.value : props.htmlFor;
+    });
+    const onLabelClick = () => {
+      const id = htmlFor.value;
+      if (!id || !inputRef.value) return;
+      const control = inputRef.value.$el.querySelector(`[id="${id}"]`);
+      if (control && control.focus) control.focus();
+    };
+    expose({
+      onFieldBlur,
+      onFieldChange,
+      clearValidate,
+      resetField
+    });
+    useProvideFormItemContext({
+      id: fieldId,
+      onFieldBlur: () => {
+        if (props.autoLink) onFieldBlur();
+      },
+      onFieldChange: () => {
+        if (props.autoLink) onFieldChange();
+      },
+      clearValidate
+    }, computed(() => {
+      return !!(props.autoLink && formContext.model.value && fieldName.value);
+    }));
+    let registered = false;
+    watch(fieldName, (val) => {
+      if (val) {
+        if (!registered) {
+          registered = true;
+          formContext.addField(eventKey, {
+            fieldValue,
+            fieldId,
+            fieldName,
+            resetField,
+            clearValidate,
+            namePath,
+            validateRules: validateRules$1,
+            rules: rulesRef
+          });
+        }
+      } else {
+        registered = false;
+        formContext.removeField(eventKey);
+      }
+    }, { immediate: true });
+    const debounceErrors = useDebounce(errors);
+    const mergedValidateStatus = computed(() => {
+      if (props.validateStatus !== void 0) return props.validateStatus;
+      else if (debounceErrors.value.length) return "error";
+      return validateState.value;
+    });
+    const itemClassName = computed(() => ({
+      [`${prefixCls.value}-item`]: true,
+      [hashId.value]: true,
+      [`${prefixCls.value}-item-has-feedback`]: mergedValidateStatus.value && props.hasFeedback,
+      [`${prefixCls.value}-item-has-success`]: mergedValidateStatus.value === "success",
+      [`${prefixCls.value}-item-has-warning`]: mergedValidateStatus.value === "warning",
+      [`${prefixCls.value}-item-has-error`]: mergedValidateStatus.value === "error",
+      [`${prefixCls.value}-item-is-validating`]: mergedValidateStatus.value === "validating",
+      [`${prefixCls.value}-item-hidden`]: props.hidden
+    }));
+    const formItemInputContext = reactive({});
+    FormItemInputContext.useProvide(formItemInputContext);
+    watchEffect(() => {
+      let feedbackIcon;
+      if (props.hasFeedback) {
+        const IconNode = mergedValidateStatus.value && iconMap[mergedValidateStatus.value];
+        feedbackIcon = IconNode ? createVNode("span", { "class": classNames(`${prefixCls.value}-item-feedback-icon`, `${prefixCls.value}-item-feedback-icon-${mergedValidateStatus.value}`) }, [createVNode(IconNode, null, null)]) : null;
+      }
+      _extends$1(formItemInputContext, {
+        status: mergedValidateStatus.value,
+        hasFeedback: props.hasFeedback,
+        feedbackIcon,
+        isFormItemInput: true
+      });
+    });
+    const marginBottom = shallowRef(null);
+    const showMarginOffset = shallowRef(false);
+    const onErrorVisibleChanged = (nextVisible) => {
+      if (!nextVisible) marginBottom.value = null;
+    };
+    return () => {
+      var _a, _b;
+      if (props.noStyle) return (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots);
+      const help = (_b = props.help) !== null && _b !== void 0 ? _b : slots.help ? filterEmpty(slots.help()) : null;
+      const withHelp = !!(help !== void 0 && help !== null && Array.isArray(help) && help.length || debounceErrors.value.length);
+      showMarginOffset.value = withHelp;
+      return wrapSSR(createVNode("div", {
+        "class": [
+          itemClassName.value,
+          withHelp ? `${prefixCls.value}-item-with-help` : "",
+          attrs.class
+        ],
+        "ref": itemRef
+      }, [createVNode(ARow, _objectSpread2(_objectSpread2({}, attrs), {}, {
+        "class": `${prefixCls.value}-item-row`,
+        "key": "row"
+      }), { default: () => {
+        var _a2, _b2;
+        return createVNode(Fragment, null, [createVNode(FormItemLabel, _objectSpread2(_objectSpread2({}, props), {}, {
+          "htmlFor": htmlFor.value,
+          "required": isRequired2.value,
+          "requiredMark": formContext.requiredMark.value,
+          "prefixCls": prefixCls.value,
+          "onClick": onLabelClick,
+          "label": props.label
+        }), {
+          label: slots.label,
+          tooltip: slots.tooltip
+        }), createVNode(FormItemInput, _objectSpread2(_objectSpread2({}, props), {}, {
+          "errors": help !== void 0 && help !== null ? toArray$1(help) : debounceErrors.value,
+          "marginBottom": marginBottom.value,
+          "prefixCls": prefixCls.value,
+          "status": mergedValidateStatus.value,
+          "ref": inputRef,
+          "help": help,
+          "extra": (_a2 = props.extra) !== null && _a2 !== void 0 ? _a2 : (_b2 = slots.extra) === null || _b2 === void 0 ? void 0 : _b2.call(slots),
+          "onErrorVisibleChanged": onErrorVisibleChanged
+        }), { default: slots.default })]);
+      } }), !!marginBottom.value && createVNode("div", {
+        "class": `${prefixCls.value}-margin-offset`,
+        "style": { marginBottom: `-${marginBottom.value}px` }
+      }, null)]));
+    };
+  }
+});
+function allPromiseFinish(promiseList) {
+  let hasError = false;
+  let count = promiseList.length;
+  const results = [];
+  if (!promiseList.length) return Promise.resolve([]);
+  return new Promise((resolve, reject) => {
+    promiseList.forEach((promise, index) => {
+      promise.catch((e2) => {
+        hasError = true;
+        return e2;
+      }).then((result) => {
+        count -= 1;
+        results[index] = result;
+        if (count > 0) return;
+        if (hasError) reject(results);
+        resolve(results);
+      });
+    });
+  });
+}
+function isRequired(rules2) {
+  let isRequired2 = false;
+  if (rules2 && rules2.length) rules2.every((rule) => {
+    if (rule.required) {
+      isRequired2 = true;
+      return false;
+    }
+    return true;
+  });
+  return isRequired2;
+}
+function toArray(value) {
+  if (value === void 0 || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function getPropByPath(obj, path, strict) {
+  let tempObj = obj;
+  path = path.replace(/\[(\w+)\]/g, ".$1");
+  path = path.replace(/^\./, "");
+  const keyArr = path.split(".");
+  let i2 = 0;
+  for (let len = keyArr.length; i2 < len - 1; ++i2) {
+    if (!tempObj && !strict) break;
+    const key = keyArr[i2];
+    if (key in tempObj) tempObj = tempObj[key];
+    else {
+      if (strict) throw new Error("please transfer a valid name path to validate!");
+      break;
+    }
+  }
+  return {
+    o: tempObj,
+    k: keyArr[i2],
+    v: tempObj ? tempObj[keyArr[i2]] : null,
+    isValid: tempObj && keyArr[i2] in tempObj
+  };
+}
+function useForm(modelRef) {
+  let rulesRef = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ref({});
+  let options = arguments.length > 2 ? arguments[2] : void 0;
+  const initialModel = cloneDeep(unref(modelRef));
+  const validateInfos = reactive({});
+  const rulesKeys = shallowRef([]);
+  const resetFields = (newValues) => {
+    _extends$1(unref(modelRef), _extends$1(_extends$1({}, cloneDeep(initialModel)), newValues));
+    nextTick(() => {
+      Object.keys(validateInfos).forEach((key) => {
+        validateInfos[key] = {
+          autoLink: false,
+          required: isRequired(unref(rulesRef)[key])
+        };
+      });
+    });
+  };
+  const filterRules = function() {
+    let rules2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    let trigger = arguments.length > 1 ? arguments[1] : void 0;
+    if (!trigger.length) return rules2;
+    else return rules2.filter((rule) => {
+      return intersection(toArray(rule.trigger || "change"), trigger).length;
+    });
+  };
+  let lastValidatePromise = null;
+  const validateFields = function(names) {
+    let option = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    let strict = arguments.length > 2 ? arguments[2] : void 0;
+    const promiseList = [];
+    const values = {};
+    for (let i2 = 0; i2 < names.length; i2++) {
+      const name = names[i2];
+      const prop = getPropByPath(unref(modelRef), name, strict);
+      if (!prop.isValid) continue;
+      values[name] = prop.v;
+      const rules2 = filterRules(unref(rulesRef)[name], toArray(option && option.trigger));
+      if (rules2.length) promiseList.push(validateField(name, prop.v, rules2, option || {}).then(() => ({
+        name,
+        errors: [],
+        warnings: []
+      })).catch((ruleErrors) => {
+        const mergedErrors = [];
+        const mergedWarnings = [];
+        ruleErrors.forEach((_ref) => {
+          let { rule: { warningOnly }, errors } = _ref;
+          if (warningOnly) mergedWarnings.push(...errors);
+          else mergedErrors.push(...errors);
+        });
+        if (mergedErrors.length) return Promise.reject({
+          name,
+          errors: mergedErrors,
+          warnings: mergedWarnings
+        });
+        return {
+          name,
+          errors: mergedErrors,
+          warnings: mergedWarnings
+        };
+      }));
+    }
+    const summaryPromise = allPromiseFinish(promiseList);
+    lastValidatePromise = summaryPromise;
+    const returnPromise = summaryPromise.then(() => {
+      if (lastValidatePromise === summaryPromise) return Promise.resolve(values);
+      return Promise.reject([]);
+    }).catch((results) => {
+      const errorList = results.filter((result) => result && result.errors.length);
+      return errorList.length ? Promise.reject({
+        values,
+        errorFields: errorList,
+        outOfDate: lastValidatePromise !== summaryPromise
+      }) : Promise.resolve(values);
+    });
+    returnPromise.catch((e2) => e2);
+    return returnPromise;
+  };
+  const validateField = function(name, value, rules2) {
+    let option = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
+    const promise = validateRules([name], value, rules2, _extends$1({ validateMessages: defaultValidateMessages }, option), !!option.validateFirst);
+    if (!validateInfos[name]) return promise.catch((e2) => e2);
+    validateInfos[name].validateStatus = "validating";
+    promise.catch((e2) => e2).then(function() {
+      let results = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+      var _a;
+      if (validateInfos[name].validateStatus === "validating") {
+        const res = results.filter((result) => result && result.errors.length);
+        validateInfos[name].validateStatus = res.length ? "error" : "success";
+        validateInfos[name].help = res.length ? res.map((r2) => r2.errors) : null;
+        (_a = options === null || options === void 0 ? void 0 : options.onValidate) === null || _a === void 0 || _a.call(options, name, !res.length, res.length ? toRaw(validateInfos[name].help[0]) : null);
+      }
+    });
+    return promise;
+  };
+  const validate = (names, option) => {
+    let keys2 = [];
+    let strict = true;
+    if (!names) {
+      strict = false;
+      keys2 = rulesKeys.value;
+    } else if (Array.isArray(names)) keys2 = names;
+    else keys2 = [names];
+    const promises = validateFields(keys2, option || {}, strict);
+    promises.catch((e2) => e2);
+    return promises;
+  };
+  const clearValidate = (names) => {
+    let keys2 = [];
+    if (!names) keys2 = rulesKeys.value;
+    else if (Array.isArray(names)) keys2 = names;
+    else keys2 = [names];
+    keys2.forEach((key) => {
+      validateInfos[key] && _extends$1(validateInfos[key], {
+        validateStatus: "",
+        help: null
+      });
+    });
+  };
+  const mergeValidateInfo = (items) => {
+    const info = { autoLink: false };
+    const help = [];
+    const infos = Array.isArray(items) ? items : [items];
+    for (let i2 = 0; i2 < infos.length; i2++) {
+      const arg = infos[i2];
+      if ((arg === null || arg === void 0 ? void 0 : arg.validateStatus) === "error") {
+        info.validateStatus = "error";
+        arg.help && help.push(arg.help);
+      }
+      info.required = info.required || (arg === null || arg === void 0 ? void 0 : arg.required);
+    }
+    info.help = help;
+    return info;
+  };
+  let oldModel = initialModel;
+  let isFirstTime = true;
+  const modelFn = (model) => {
+    const names = [];
+    rulesKeys.value.forEach((key) => {
+      const prop = getPropByPath(model, key, false);
+      const oldProp = getPropByPath(oldModel, key, false);
+      if (isFirstTime && (options === null || options === void 0 ? void 0 : options.immediate) && prop.isValid || !isEqual(prop.v, oldProp.v)) names.push(key);
+    });
+    validate(names, { trigger: "change" });
+    isFirstTime = false;
+    oldModel = cloneDeep(toRaw(model));
+  };
+  const debounceOptions = options === null || options === void 0 ? void 0 : options.debounce;
+  let first = true;
+  watch(rulesRef, () => {
+    rulesKeys.value = rulesRef ? Object.keys(unref(rulesRef)) : [];
+    if (!first && options && options.validateOnRuleChange) validate();
+    first = false;
+  }, {
+    deep: true,
+    immediate: true
+  });
+  watch(rulesKeys, () => {
+    const newValidateInfos = {};
+    rulesKeys.value.forEach((key) => {
+      newValidateInfos[key] = _extends$1({}, validateInfos[key], {
+        autoLink: false,
+        required: isRequired(unref(rulesRef)[key])
+      });
+      delete validateInfos[key];
+    });
+    for (const key in validateInfos) if (Object.prototype.hasOwnProperty.call(validateInfos, key)) delete validateInfos[key];
+    _extends$1(validateInfos, newValidateInfos);
+  }, { immediate: true });
+  watch(modelRef, debounceOptions && debounceOptions.wait ? debounce(modelFn, debounceOptions.wait, omit(debounceOptions, ["wait"])) : modelFn, {
+    immediate: options && !!options.immediate,
+    deep: true
+  });
+  return {
+    modelRef,
+    rulesRef,
+    initialModel,
+    validateInfos,
+    resetFields,
+    validate,
+    validateField,
+    mergeValidateInfo,
+    clearValidate
+  };
+}
+var formProps = () => ({
+  layout: PropTypes.oneOf(tuple("horizontal", "inline", "vertical")),
+  labelCol: objectType(),
+  wrapperCol: objectType(),
+  colon: booleanType(),
+  labelAlign: stringType(),
+  labelWrap: booleanType(),
+  prefixCls: String,
+  requiredMark: someType([String, Boolean]),
+  /** @deprecated Will warning in future branch. Pls use `requiredMark` instead. */
+  hideRequiredMark: booleanType(),
+  model: PropTypes.object,
+  rules: objectType(),
+  validateMessages: objectType(),
+  validateOnRuleChange: booleanType(),
+  scrollToFirstError: anyType(),
+  onSubmit: functionType(),
+  name: String,
+  validateTrigger: someType([String, Array]),
+  size: stringType(),
+  disabled: booleanType(),
+  onValuesChange: functionType(),
+  onFieldsChange: functionType(),
+  onFinish: functionType(),
+  onFinishFailed: functionType(),
+  onValidate: functionType()
+});
+function isEqualName(name1, name2) {
+  return isEqual(toArray$1(name1), toArray$1(name2));
+}
+var Form = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "AForm",
+  inheritAttrs: false,
+  props: initDefaultProps(formProps(), {
+    layout: "horizontal",
+    hideRequiredMark: false,
+    colon: true
+  }),
+  Item: FormItem_default,
+  useForm,
+  setup(props, _ref) {
+    let { emit, slots, expose, attrs } = _ref;
+    const { prefixCls, direction, form: contextForm, size, disabled } = useConfigInject_default("form", props);
+    const requiredMark = computed(() => props.requiredMark === "" || props.requiredMark);
+    const mergedRequiredMark = computed(() => {
+      var _a;
+      if (requiredMark.value !== void 0) return requiredMark.value;
+      if (contextForm && ((_a = contextForm.value) === null || _a === void 0 ? void 0 : _a.requiredMark) !== void 0) return contextForm.value.requiredMark;
+      if (props.hideRequiredMark) return false;
+      return true;
+    });
+    useProviderSize(size);
+    useProviderDisabled(disabled);
+    const mergedColon = computed(() => {
+      var _a, _b;
+      return (_a = props.colon) !== null && _a !== void 0 ? _a : (_b = contextForm.value) === null || _b === void 0 ? void 0 : _b.colon;
+    });
+    const { validateMessages: globalValidateMessages } = useInjectGlobalForm();
+    const validateMessages = computed(() => {
+      return _extends$1(_extends$1(_extends$1({}, defaultValidateMessages), globalValidateMessages.value), props.validateMessages);
+    });
+    const [wrapSSR, hashId] = style_default(prefixCls);
+    const formClassName = computed(() => classNames(prefixCls.value, {
+      [`${prefixCls.value}-${props.layout}`]: true,
+      [`${prefixCls.value}-hide-required-mark`]: mergedRequiredMark.value === false,
+      [`${prefixCls.value}-rtl`]: direction.value === "rtl",
+      [`${prefixCls.value}-${size.value}`]: size.value
+    }, hashId.value));
+    const lastValidatePromise = ref();
+    const fields = {};
+    const addField = (eventKey, field) => {
+      fields[eventKey] = field;
+    };
+    const removeField = (eventKey) => {
+      delete fields[eventKey];
+    };
+    const getFieldsByNameList = (nameList) => {
+      const provideNameList = !!nameList;
+      const namePathList = provideNameList ? toArray$1(nameList).map(getNamePath) : [];
+      if (!provideNameList) return Object.values(fields);
+      else return Object.values(fields).filter((field) => namePathList.findIndex((namePath) => isEqualName(namePath, field.fieldName.value)) > -1);
+    };
+    const resetFields = (name) => {
+      if (!props.model) {
+        return;
+      }
+      getFieldsByNameList(name).forEach((field) => {
+        field.resetField();
+      });
+    };
+    const clearValidate = (name) => {
+      getFieldsByNameList(name).forEach((field) => {
+        field.clearValidate();
+      });
+    };
+    const handleFinishFailed = (errorInfo) => {
+      const { scrollToFirstError } = props;
+      emit("finishFailed", errorInfo);
+      if (scrollToFirstError && errorInfo.errorFields.length) {
+        let scrollToFieldOptions = {};
+        if (typeof scrollToFirstError === "object") scrollToFieldOptions = scrollToFirstError;
+        scrollToField(errorInfo.errorFields[0].name, scrollToFieldOptions);
+      }
+    };
+    const validate = function() {
+      return validateField(...arguments);
+    };
+    const scrollToField = function(name) {
+      let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      const fields2 = getFieldsByNameList(name ? [name] : void 0);
+      if (fields2.length) {
+        const fieldId = fields2[0].fieldId.value;
+        const node = fieldId ? (void 0).getElementById(fieldId) : null;
+        if (node) scrollIntoView(node, _extends$1({
+          scrollMode: "if-needed",
+          block: "nearest"
+        }, options));
+      }
+    };
+    const getFieldsValue = function() {
+      let nameList = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+      if (nameList === true) {
+        const allNameList = [];
+        Object.values(fields).forEach((_ref2) => {
+          let { namePath } = _ref2;
+          allNameList.push(namePath.value);
+        });
+        return cloneByNamePathList(props.model, allNameList);
+      } else return cloneByNamePathList(props.model, nameList);
+    };
+    const validateFields = (nameList, options) => {
+      if (!props.model) {
+        return Promise.reject("Form `model` is required for validateFields to work.");
+      }
+      const provideNameList = !!nameList;
+      const namePathList = provideNameList ? toArray$1(nameList).map(getNamePath) : [];
+      const promiseList = [];
+      Object.values(fields).forEach((field) => {
+        var _a;
+        if (!provideNameList) namePathList.push(field.namePath.value);
+        if (!((_a = field.rules) === null || _a === void 0 ? void 0 : _a.value.length)) return;
+        const fieldNamePath = field.namePath.value;
+        if (!provideNameList || containsNamePath(namePathList, fieldNamePath)) {
+          const promise = field.validateRules(_extends$1({ validateMessages: validateMessages.value }, options));
+          promiseList.push(promise.then(() => ({
+            name: fieldNamePath,
+            errors: [],
+            warnings: []
+          })).catch((ruleErrors) => {
+            const mergedErrors = [];
+            const mergedWarnings = [];
+            ruleErrors.forEach((_ref3) => {
+              let { rule: { warningOnly }, errors } = _ref3;
+              if (warningOnly) mergedWarnings.push(...errors);
+              else mergedErrors.push(...errors);
+            });
+            if (mergedErrors.length) return Promise.reject({
+              name: fieldNamePath,
+              errors: mergedErrors,
+              warnings: mergedWarnings
+            });
+            return {
+              name: fieldNamePath,
+              errors: mergedErrors,
+              warnings: mergedWarnings
+            };
+          }));
+        }
+      });
+      const summaryPromise = allPromiseFinish(promiseList);
+      lastValidatePromise.value = summaryPromise;
+      const returnPromise = summaryPromise.then(() => {
+        if (lastValidatePromise.value === summaryPromise) return Promise.resolve(getFieldsValue(namePathList));
+        return Promise.reject([]);
+      }).catch((results) => {
+        const errorList = results.filter((result) => result && result.errors.length);
+        return Promise.reject({
+          values: getFieldsValue(namePathList),
+          errorFields: errorList,
+          outOfDate: lastValidatePromise.value !== summaryPromise
+        });
+      });
+      returnPromise.catch((e2) => e2);
+      return returnPromise;
+    };
+    const validateField = function() {
+      return validateFields(...arguments);
+    };
+    const handleSubmit = (e2) => {
+      e2.preventDefault();
+      e2.stopPropagation();
+      emit("submit", e2);
+      if (props.model) validateFields().then((values) => {
+        emit("finish", values);
+      }).catch((errors) => {
+        handleFinishFailed(errors);
+      });
+    };
+    expose({
+      resetFields,
+      clearValidate,
+      validateFields,
+      getFieldsValue,
+      validate,
+      scrollToField
+    });
+    useProvideForm({
+      model: computed(() => props.model),
+      name: computed(() => props.name),
+      labelAlign: computed(() => props.labelAlign),
+      labelCol: computed(() => props.labelCol),
+      labelWrap: computed(() => props.labelWrap),
+      wrapperCol: computed(() => props.wrapperCol),
+      vertical: computed(() => props.layout === "vertical"),
+      colon: mergedColon,
+      requiredMark: mergedRequiredMark,
+      validateTrigger: computed(() => props.validateTrigger),
+      rules: computed(() => props.rules),
+      addField,
+      removeField,
+      onValidate: (name, status, errors) => {
+        emit("validate", name, status, errors);
+      },
+      validateMessages
+    });
+    watch(() => props.rules, () => {
+      if (props.validateOnRuleChange) validateFields();
+    });
+    return () => {
+      var _a;
+      return wrapSSR(createVNode("form", _objectSpread2(_objectSpread2({}, attrs), {}, {
+        "onSubmit": handleSubmit,
+        "class": [formClassName.value, attrs.class]
+      }), [(_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots)]));
+    };
+  }
+});
+Form.useInjectFormItemContext = useInjectFormItemContext;
+Form.ItemRest = FormItemContext_default;
+Form.install = function(app) {
+  app.component(Form.name, Form);
+  app.component(Form.Item.name, Form.Item);
+  app.component(FormItemContext_default.name, FormItemContext_default);
+  return app;
+};
+var form_default = Form;
+
+export { FormItem_default as F, form_default as f };
+//# sourceMappingURL=form-Cw2Ex9w5.mjs.map