@arco-design/mobile-react 2.36.0 → 2.36.2

package/dist/index.js

@@ -112,7 +112,7 @@
      * ```
      */
 
-    function isArray$1(obj) {
+    function isArray$2(obj) {
       return opt.call(obj) === '[object Array]';
     }
     /**
@@ -130,7 +130,7 @@
      * ```
      */
 
-    function isObject$2(obj) {
+    function isObject$3(obj) {
       return opt.call(obj) === '[object Object]';
     }
     /**
@@ -204,7 +204,7 @@
      * ```
      */
 
-    function isFunction(obj) {
+    function isFunction$1(obj) {
       return Object.prototype.toString.call(obj).toLowerCase() === '[object function]';
     }
     /**
@@ -223,7 +223,7 @@
      */
 
     function isEmptyArray(obj) {
-      return isArray$1(obj) && !(obj === null || obj === void 0 ? void 0 : obj.length);
+      return isArray$2(obj) && !(obj === null || obj === void 0 ? void 0 : obj.length);
     }
     /**
      * 深比较两个对象是否相等
@@ -247,7 +247,7 @@
         return obj === sub;
       }
 
-      if (isFunction(obj) && isFunction(sub)) {
+      if (isFunction$1(obj) && isFunction$1(sub)) {
         return obj === sub || obj.toString() === sub.toString();
       }
 
@@ -300,9 +300,9 @@
 
         if (isString(v)) {
           classNames.push(v);
-        } else if (isArray$1(v)) {
+        } else if (isArray$2(v)) {
           classNames = classNames.concat(v);
-        } else if (isObject$2(v)) {
+        } else if (isObject$3(v)) {
           Object.keys(v).forEach(function (k) {
             if (v[k]) {
               classNames.push(k);
@@ -1975,7 +1975,7 @@
         Object.keys(originMT).forEach(function (key) {
           var originValue = originMT[key];
           var curValue = newMT === null || newMT === void 0 ? void 0 : newMT[key];
-          targetMT[key] = isObject$2(originValue) ? __assign$2(__assign$2({}, originValue), curValue) : curValue || originValue;
+          targetMT[key] = isObject$3(originValue) ? __assign$2(__assign$2({}, originValue), curValue) : curValue || originValue;
         });
       }
 
@@ -3695,7 +3695,7 @@
           Object.keys(this.rules).forEach(function (key) {
             var spPromiseGroup = [];
 
-            if (isArray$1(_this.rules[key])) {
+            if (isArray$2(_this.rules[key])) {
               for (var i = 0; i < _this.rules[key].length; i++) {
                 var rule = _this.rules[key][i];
 
@@ -4702,7 +4702,7 @@
       };
     }
 
-    function isObject$1(obj) {
+    function isObject$2(obj) {
       return Object.prototype.toString.call(obj) === '[object Object]';
     }
 
@@ -4719,7 +4719,7 @@
       // Avoid console warning
       var __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = CopyReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
-      if (isObject$1(__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED)) {
+      if (isObject$2(__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED)) {
         __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.usingClientEntryPoint = skipWarning;
       }
     };
@@ -5581,7 +5581,7 @@
     var NAN = 0 / 0;
 
     /** `Object#toString` result references. */
-    var symbolTag = '[object Symbol]';
+    var symbolTag$2 = '[object Symbol]';
 
     /** Used to match leading and trailing whitespace. */
     var reTrim = /^\s+|\s+$/g;
@@ -5599,23 +5599,23 @@
     var freeParseInt = parseInt;
 
     /** Detect free variable `global` from Node.js. */
-    var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+    var freeGlobal$1 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
 
     /** Detect free variable `self`. */
-    var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+    var freeSelf$1 = typeof self == 'object' && self && self.Object === Object && self;
 
     /** Used as a reference to the global object. */
-    var root$1 = freeGlobal || freeSelf || Function('return this')();
+    var root$2 = freeGlobal$1 || freeSelf$1 || Function('return this')();
 
     /** Used for built-in method references. */
-    var objectProto = Object.prototype;
+    var objectProto$d = Object.prototype;
 
     /**
      * Used to resolve the
      * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
      * of values.
      */
-    var objectToString = objectProto.toString;
+    var objectToString$1 = objectProto$d.toString;
 
     /* Built-in method references for those with the same name as other `lodash` methods. */
     var nativeMax = Math.max,
@@ -5638,7 +5638,7 @@
      * // => Logs the number of milliseconds it took for the deferred invocation.
      */
     var now = function() {
-      return root$1.Date.now();
+      return root$2.Date.now();
     };
 
     /**
@@ -5711,7 +5711,7 @@
         throw new TypeError(FUNC_ERROR_TEXT);
       }
       wait = toNumber(wait) || 0;
-      if (isObject(options)) {
+      if (isObject$1(options)) {
         leading = !!options.leading;
         maxing = 'maxWait' in options;
         maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
@@ -5868,7 +5868,7 @@
       if (typeof func != 'function') {
         throw new TypeError(FUNC_ERROR_TEXT);
       }
-      if (isObject(options)) {
+      if (isObject$1(options)) {
         leading = 'leading' in options ? !!options.leading : leading;
         trailing = 'trailing' in options ? !!options.trailing : trailing;
       }
@@ -5904,7 +5904,7 @@
      * _.isObject(null);
      * // => false
      */
-    function isObject(value) {
+    function isObject$1(value) {
       var type = typeof value;
       return !!value && (type == 'object' || type == 'function');
     }
@@ -5933,7 +5933,7 @@
      * _.isObjectLike(null);
      * // => false
      */
-    function isObjectLike(value) {
+    function isObjectLike$1(value) {
       return !!value && typeof value == 'object';
     }
 
@@ -5956,7 +5956,7 @@
      */
     function isSymbol(value) {
       return typeof value == 'symbol' ||
-        (isObjectLike(value) && objectToString.call(value) == symbolTag);
+        (isObjectLike$1(value) && objectToString$1.call(value) == symbolTag$2);
     }
 
     /**
@@ -5989,9 +5989,9 @@
       if (isSymbol(value)) {
         return NAN;
       }
-      if (isObject(value)) {
+      if (isObject$1(value)) {
         var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
-        value = isObject(other) ? (other + '') : other;
+        value = isObject$1(other) ? (other + '') : other;
       }
       if (typeof value != 'string') {
         return value === 0 ? value : +value;
@@ -10947,12 +10947,6 @@
 
         stopPropagation && e.stopPropagation();
 
-        if (bouncingRef.current) {
-          bouncingRef.current = false;
-          jumpTo(index, false);
-          return;
-        }
-
         if (!touchStartedRef.current) {
           return;
         }
@@ -10964,7 +10958,14 @@
           return;
         }
 
-        touchMovedRef.current = false;
+        touchMovedRef.current = false; // bugfix: 回弹判断逻辑需在touchMovedRef标识重置逻辑之后，否则会在触发回弹后导致标识无法重置引起滑动判断问题
+        // @en bugfix: The logic for the bounce judgment needs to be after the touchMovedRef reset logic, otherwise it will cause the problem of slide judgment after the bounce is triggered.
+
+        if (bouncingRef.current) {
+          bouncingRef.current = false;
+          jumpTo(index, false);
+          return;
+        }
 
         if (posAdjustingRef.current || touchStoppedRef.current) {
           return;
@@ -12317,12 +12318,12 @@
     var inBrowser = typeof window !== 'undefined'; // 判断根元素
     // @en Determine the root element
 
-    var root = inBrowser ? window : global; // 根据id清除对应的animationFrame
+    var root$1 = inBrowser ? window : global; // 根据id清除对应的animationFrame
     // @en Clear the corresponding animationFrame according to the id
 
     function cancelRaf(id) {
-      var cancelAnimationFrame = root.cancelAnimationFrame || root.clearTimeout;
-      cancelAnimationFrame.call(root, id);
+      var cancelAnimationFrame = root$1.cancelAnimationFrame || root$1.clearTimeout;
+      cancelAnimationFrame.call(root$1, id);
     } // 计算现在时间
     // @en Calculate the current time
 
@@ -12340,8 +12341,8 @@
 
 
     function raf(fn) {
-      var requestAnimationFrame = root.requestAnimationFrame || rafPolyfill;
-      return requestAnimationFrame.call(root, fn);
+      var requestAnimationFrame = root$1.requestAnimationFrame || rafPolyfill;
+      return requestAnimationFrame.call(root$1, fn);
     } // 补0成需要的格式
     // @en Fill 0 into the required format
 
@@ -13224,7 +13225,7 @@
       }));
     });
 
-    var isArray = function isArray(dt) {
+    var isArray$1 = function isArray(dt) {
       return dt ? Array.isArray(dt[0]) : false;
     };
 
@@ -13281,7 +13282,7 @@
       var innerData = React.useMemo(function () {
         var newData;
 
-        if (isArray(data)) {
+        if (isArray$1(data)) {
           if (isStrOrNum(data)) {
             newData = data.map(function (item) {
               return item.map(function (cell) {
@@ -14930,7 +14931,7 @@
      * */
 
     function isCascadeArray(options) {
-      return typeof options[0] === 'object' && !isArray$1(options[0]);
+      return typeof options[0] === 'object' && !isArray$2(options[0]);
     }
     /**
      * 格式化传入的数组
@@ -16341,9 +16342,11 @@
             currentText += temp;
             l = m;
           }
-        } // Remove the exclude char at the end of the content.
+        } // Remove the last character if it is orphaned high-surrogate characters (indicative of incomplete emoji).
 
 
+        currentText = currentText.replace(/[\uD800-\uDBFF]+$/, ''); // Remove the exclude char at the end of the content.
+
         while (endExcludes && endExcludes.includes(currentText[currentText.length - 1])) {
           currentText = currentText.slice(0, -1);
         } // Callback after reflow.
@@ -17789,188 +17792,2860 @@
 
     });
 
-    var defaultFunc = function defaultFunc() {};
+    // 注意：自动识别form关联组件的依据，请勿轻易改变代码结构
+    // Notice: Automatically identify the basis of the associated component of the form, DO NOT change the code structure.
+    var FormInternalComponentType;
 
-    var defaultFormDataMethods = {
-      getFieldValue: function getFieldValue(name) {
-        return name;
-      },
-      getFieldsValue: function getFieldsValue(_names) {
-        return {};
-      },
-      getFieldError: function getFieldError(_name) {
-        return [];
-      },
-      setFieldValue: function setFieldValue(_name, _value) {
-        return true;
-      },
-      setFieldsValue: function setFieldsValue(_values) {
-        return true;
-      },
-      registerField: function registerField(_name, _self) {
-        return function () {};
-      },
-      resetFields: defaultFunc,
-      validateFields: defaultFunc,
-      submit: defaultFunc,
-      getInternalHooks: function getInternalHooks() {
-        return {
-          registerField: defaultFunc,
-          setInitialValues: defaultFunc,
-          setCallbacks: defaultFunc
-        };
-      }
-    }; // 在field的静态的状态下设置
+    (function (FormInternalComponentType) {
+      FormInternalComponentType["Input"] = "Input";
+      FormInternalComponentType["Textarea"] = "Textarea";
+      FormInternalComponentType["Checkbox"] = "Checkbox";
+      FormInternalComponentType["CheckboxGroup"] = "CheckboxGroup";
+      FormInternalComponentType["DatePicker"] = "DatePicker";
+      FormInternalComponentType["Picker"] = "Picker";
+      FormInternalComponentType["Radio"] = "Radio";
+      FormInternalComponentType["RadioGroup"] = "RadioGroup";
+      FormInternalComponentType["Slider"] = "Slider";
+      FormInternalComponentType["Switch"] = "Switch";
+      FormInternalComponentType["ImagePicker"] = "ImagePicker";
+      FormInternalComponentType["Rate"] = "Rate";
+      FormInternalComponentType["Stepper"] = "Stepper";
+    })(FormInternalComponentType || (FormInternalComponentType = {}));
 
-    var FormData =
-    /** @class */
-    function () {
-      function FormData() {
-        var _this = this;
+    var ValidateStatus;
 
-        this._formData = {}; // 数据源
+    (function (ValidateStatus) {
+      ValidateStatus["Init"] = "init";
+      ValidateStatus["Error"] = "error";
+      ValidateStatus["Warning"] = "warning";
+      ValidateStatus["Validating"] = "validating";
+      ValidateStatus["Success"] = "success";
+    })(ValidateStatus || (ValidateStatus = {}));
 
-        this._fieldsList = {}; // 字段列表
+    var ValueChangeType;
 
-        this._initialValues = {}; // 初始值
+    (function (ValueChangeType) {
+      /* form update */
+      ValueChangeType[ValueChangeType["Update"] = 0] = "Update";
+      /* form clear */
 
-        this._callbacks = {};
+      ValueChangeType[ValueChangeType["Reset"] = 1] = "Reset";
+    })(ValueChangeType || (ValueChangeType = {}));
 
-        this.setFieldsValue = function (values) {
-          var oldValues = Object.keys(values).reduce(function (acc, key) {
-            var _a;
+    /**
+     * Removes all key-value entries from the list cache.
+     *
+     * @private
+     * @name clear
+     * @memberOf ListCache
+     */
+    function listCacheClear() {
+      this.__data__ = [];
+      this.size = 0;
+    }
 
-            return __assign$3(__assign$3({}, acc), (_a = {}, _a[key] = _this.getFieldValue(key), _a));
-          }, {});
-          _this._formData = __assign$3(__assign$3({}, _this._formData), values);
-          var onValuesChange = _this._callbacks.onValuesChange;
-          onValuesChange && onValuesChange(values, _this._formData);
+    var _listCacheClear = listCacheClear;
 
-          _this.notifyField(values, oldValues);
+    /**
+     * Performs a
+     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+     * comparison between two values to determine if they are equivalent.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to compare.
+     * @param {*} other The other value to compare.
+     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+     * @example
+     *
+     * var object = { 'a': 1 };
+     * var other = { 'a': 1 };
+     *
+     * _.eq(object, object);
+     * // => true
+     *
+     * _.eq(object, other);
+     * // => false
+     *
+     * _.eq('a', 'a');
+     * // => true
+     *
+     * _.eq('a', Object('a'));
+     * // => false
+     *
+     * _.eq(NaN, NaN);
+     * // => true
+     */
+    function eq(value, other) {
+      return value === other || (value !== value && other !== other);
+    }
 
-          return true;
-        };
+    var eq_1 = eq;
 
-        this.setFieldValue = function (name, value) {
-          var _a, _b, _c, _d;
+    /**
+     * Gets the index at which the `key` is found in `array` of key-value pairs.
+     *
+     * @private
+     * @param {Array} array The array to inspect.
+     * @param {*} key The key to search for.
+     * @returns {number} Returns the index of the matched value, else `-1`.
+     */
+    function assocIndexOf(array, key) {
+      var length = array.length;
+      while (length--) {
+        if (eq_1(array[length][0], key)) {
+          return length;
+        }
+      }
+      return -1;
+    }
 
-          var oldValues = (_a = {}, _a[name] = _this.getFieldValue(name), _a);
-          _this._formData = __assign$3(__assign$3({}, _this._formData), (_b = {}, _b[name] = value, _b));
-          var onValuesChange = _this._callbacks.onValuesChange;
-          onValuesChange && onValuesChange((_c = {}, _c[name] = value, _c), _this._formData);
+    var _assocIndexOf = assocIndexOf;
 
-          _this.notifyField((_d = {}, _d[name] = value, _d), oldValues);
+    /** Used for built-in method references. */
+    var arrayProto = Array.prototype;
 
-          return true;
-        };
+    /** Built-in value references. */
+    var splice = arrayProto.splice;
 
-        this.notifyField = function (values, oldValues) {
-          Object.keys(values).map(function (fieldName) {
-            var _a;
+    /**
+     * Removes `key` and its value from the list cache.
+     *
+     * @private
+     * @name delete
+     * @memberOf ListCache
+     * @param {string} key The key of the value to remove.
+     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+     */
+    function listCacheDelete(key) {
+      var data = this.__data__,
+          index = _assocIndexOf(data, key);
 
-            var fieldObj = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[fieldName]) || null;
+      if (index < 0) {
+        return false;
+      }
+      var lastIndex = data.length - 1;
+      if (index == lastIndex) {
+        data.pop();
+      } else {
+        splice.call(data, index, 1);
+      }
+      --this.size;
+      return true;
+    }
 
-            if (fieldObj) {
-              fieldObj.onValueChange(values[fieldName], oldValues[fieldName]);
-            }
-          });
-        };
+    var _listCacheDelete = listCacheDelete;
 
-        this.getFieldsValue = function (names) {
-          if (names) {
-            return names.map(function (name) {
-              return _this.getFieldValue(name);
-            });
-          }
+    /**
+     * Gets the list cache value for `key`.
+     *
+     * @private
+     * @name get
+     * @memberOf ListCache
+     * @param {string} key The key of the value to get.
+     * @returns {*} Returns the entry value.
+     */
+    function listCacheGet(key) {
+      var data = this.__data__,
+          index = _assocIndexOf(data, key);
 
-          return _this._formData;
-        };
+      return index < 0 ? undefined : data[index][1];
+    }
 
-        this.getFieldValue = function (name) {
-          var _a;
+    var _listCacheGet = listCacheGet;
 
-          return (_a = _this._formData) === null || _a === void 0 ? void 0 : _a[name];
-        };
+    /**
+     * Checks if a list cache value for `key` exists.
+     *
+     * @private
+     * @name has
+     * @memberOf ListCache
+     * @param {string} key The key of the entry to check.
+     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+     */
+    function listCacheHas(key) {
+      return _assocIndexOf(this.__data__, key) > -1;
+    }
 
-        this.getFieldError = function (name) {
-          var _a;
+    var _listCacheHas = listCacheHas;
 
-          var field = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[name]) || null;
+    /**
+     * Sets the list cache `key` to `value`.
+     *
+     * @private
+     * @name set
+     * @memberOf ListCache
+     * @param {string} key The key of the value to set.
+     * @param {*} value The value to set.
+     * @returns {Object} Returns the list cache instance.
+     */
+    function listCacheSet(key, value) {
+      var data = this.__data__,
+          index = _assocIndexOf(data, key);
 
-          if (field) {
-            return field.getFieldError();
-          }
+      if (index < 0) {
+        ++this.size;
+        data.push([key, value]);
+      } else {
+        data[index][1] = value;
+      }
+      return this;
+    }
 
-          return [];
-        };
+    var _listCacheSet = listCacheSet;
 
-        this.getFieldsError = function (names) {
-          var fields = names || Object.keys(_this._fieldsList);
-          return fields.reduce(function (pre, name) {
-            var _a;
+    /**
+     * Creates an list cache object.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    function ListCache(entries) {
+      var index = -1,
+          length = entries == null ? 0 : entries.length;
 
-            var theField = (_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[name];
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
 
-            if (theField) {
-              pre[name] = theField === null || theField === void 0 ? void 0 : theField.getFieldError();
-            }
+    // Add methods to `ListCache`.
+    ListCache.prototype.clear = _listCacheClear;
+    ListCache.prototype['delete'] = _listCacheDelete;
+    ListCache.prototype.get = _listCacheGet;
+    ListCache.prototype.has = _listCacheHas;
+    ListCache.prototype.set = _listCacheSet;
 
-            return pre;
-          }, {});
-        };
+    var _ListCache = ListCache;
 
-        this.isFieldTouched = function (name) {
-          var _a;
+    /**
+     * Removes all key-value entries from the stack.
+     *
+     * @private
+     * @name clear
+     * @memberOf Stack
+     */
+    function stackClear() {
+      this.__data__ = new _ListCache;
+      this.size = 0;
+    }
 
-          var field = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[name]) || null;
+    var _stackClear = stackClear;
 
-          if (field) {
-            return field.isFieldTouched();
-          }
+    /**
+     * Removes `key` and its value from the stack.
+     *
+     * @private
+     * @name delete
+     * @memberOf Stack
+     * @param {string} key The key of the value to remove.
+     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+     */
+    function stackDelete(key) {
+      var data = this.__data__,
+          result = data['delete'](key);
 
-          return false;
-        };
+      this.size = data.size;
+      return result;
+    }
 
-        this.registerField = function (name, self) {
-          var _a, _b;
+    var _stackDelete = stackDelete;
 
-          _this._fieldsList[name] = self;
-          var initialValue = self.props.initialValue;
+    /**
+     * Gets the stack value for `key`.
+     *
+     * @private
+     * @name get
+     * @memberOf Stack
+     * @param {string} key The key of the value to get.
+     * @returns {*} Returns the entry value.
+     */
+    function stackGet(key) {
+      return this.__data__.get(key);
+    }
 
-          if (initialValue !== undefined && name) {
-            _this._initialValues = __assign$3(__assign$3({}, _this._initialValues), (_a = {}, _a[name] = initialValue, _a));
+    var _stackGet = stackGet;
 
-            _this.setFieldsValue(__assign$3(__assign$3({}, _this._formData), (_b = {}, _b[name] = initialValue, _b)));
-          }
+    /**
+     * Checks if a stack value for `key` exists.
+     *
+     * @private
+     * @name has
+     * @memberOf Stack
+     * @param {string} key The key of the entry to check.
+     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+     */
+    function stackHas(key) {
+      return this.__data__.has(key);
+    }
 
-          return function () {
-            if (name in _this._fieldsList) {
-              delete _this._fieldsList[name];
-              delete _this._formData[name];
-            }
-          };
-        };
+    var _stackHas = stackHas;
 
-        this.setInitialValues = function (initVal) {
-          _this._initialValues = __assign$3({}, initVal || {});
+    /** Detect free variable `global` from Node.js. */
+    var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
 
-          _this.setFieldsValue(initVal);
-        };
+    var _freeGlobal = freeGlobal;
 
-        this.resetFields = function () {
-          _this.setFieldsValue(_this._initialValues);
-        };
+    /** Detect free variable `self`. */
+    var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
 
-        this.validateFields = function () {
-          var promiseList = [];
-          Object.values(_this._fieldsList).forEach(function (entity) {
-            var promise = entity.validateField();
-            promiseList.push(promise.then(function (errors) {
-              return errors;
-            }));
-          });
-          var summaryPromise = new es6Promise.Promise(function (resolve, reject) {
-            es6Promise.Promise.all(promiseList).then(function (res) {
+    /** Used as a reference to the global object. */
+    var root = _freeGlobal || freeSelf || Function('return this')();
+
+    var _root = root;
+
+    /** Built-in value references. */
+    var Symbol = _root.Symbol;
+
+    var _Symbol = Symbol;
+
+    /** Used for built-in method references. */
+    var objectProto$c = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$9 = objectProto$c.hasOwnProperty;
+
+    /**
+     * Used to resolve the
+     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+     * of values.
+     */
+    var nativeObjectToString$1 = objectProto$c.toString;
+
+    /** Built-in value references. */
+    var symToStringTag$1 = _Symbol ? _Symbol.toStringTag : undefined;
+
+    /**
+     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+     *
+     * @private
+     * @param {*} value The value to query.
+     * @returns {string} Returns the raw `toStringTag`.
+     */
+    function getRawTag(value) {
+      var isOwn = hasOwnProperty$9.call(value, symToStringTag$1),
+          tag = value[symToStringTag$1];
+
+      try {
+        value[symToStringTag$1] = undefined;
+        var unmasked = true;
+      } catch (e) {}
+
+      var result = nativeObjectToString$1.call(value);
+      if (unmasked) {
+        if (isOwn) {
+          value[symToStringTag$1] = tag;
+        } else {
+          delete value[symToStringTag$1];
+        }
+      }
+      return result;
+    }
+
+    var _getRawTag = getRawTag;
+
+    /** Used for built-in method references. */
+    var objectProto$b = Object.prototype;
+
+    /**
+     * Used to resolve the
+     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+     * of values.
+     */
+    var nativeObjectToString = objectProto$b.toString;
+
+    /**
+     * Converts `value` to a string using `Object.prototype.toString`.
+     *
+     * @private
+     * @param {*} value The value to convert.
+     * @returns {string} Returns the converted string.
+     */
+    function objectToString(value) {
+      return nativeObjectToString.call(value);
+    }
+
+    var _objectToString = objectToString;
+
+    /** `Object#toString` result references. */
+    var nullTag = '[object Null]',
+        undefinedTag = '[object Undefined]';
+
+    /** Built-in value references. */
+    var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;
+
+    /**
+     * The base implementation of `getTag` without fallbacks for buggy environments.
+     *
+     * @private
+     * @param {*} value The value to query.
+     * @returns {string} Returns the `toStringTag`.
+     */
+    function baseGetTag(value) {
+      if (value == null) {
+        return value === undefined ? undefinedTag : nullTag;
+      }
+      return (symToStringTag && symToStringTag in Object(value))
+        ? _getRawTag(value)
+        : _objectToString(value);
+    }
+
+    var _baseGetTag = baseGetTag;
+
+    /**
+     * Checks if `value` is the
+     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+     *
+     * @static
+     * @memberOf _
+     * @since 0.1.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+     * @example
+     *
+     * _.isObject({});
+     * // => true
+     *
+     * _.isObject([1, 2, 3]);
+     * // => true
+     *
+     * _.isObject(_.noop);
+     * // => true
+     *
+     * _.isObject(null);
+     * // => false
+     */
+    function isObject(value) {
+      var type = typeof value;
+      return value != null && (type == 'object' || type == 'function');
+    }
+
+    var isObject_1 = isObject;
+
+    /** `Object#toString` result references. */
+    var asyncTag = '[object AsyncFunction]',
+        funcTag$2 = '[object Function]',
+        genTag$1 = '[object GeneratorFunction]',
+        proxyTag = '[object Proxy]';
+
+    /**
+     * Checks if `value` is classified as a `Function` object.
+     *
+     * @static
+     * @memberOf _
+     * @since 0.1.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+     * @example
+     *
+     * _.isFunction(_);
+     * // => true
+     *
+     * _.isFunction(/abc/);
+     * // => false
+     */
+    function isFunction(value) {
+      if (!isObject_1(value)) {
+        return false;
+      }
+      // The use of `Object#toString` avoids issues with the `typeof` operator
+      // in Safari 9 which returns 'object' for typed arrays and other constructors.
+      var tag = _baseGetTag(value);
+      return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
+    }
+
+    var isFunction_1 = isFunction;
+
+    /** Used to detect overreaching core-js shims. */
+    var coreJsData = _root['__core-js_shared__'];
+
+    var _coreJsData = coreJsData;
+
+    /** Used to detect methods masquerading as native. */
+    var maskSrcKey = (function() {
+      var uid = /[^.]+$/.exec(_coreJsData && _coreJsData.keys && _coreJsData.keys.IE_PROTO || '');
+      return uid ? ('Symbol(src)_1.' + uid) : '';
+    }());
+
+    /**
+     * Checks if `func` has its source masked.
+     *
+     * @private
+     * @param {Function} func The function to check.
+     * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+     */
+    function isMasked(func) {
+      return !!maskSrcKey && (maskSrcKey in func);
+    }
+
+    var _isMasked = isMasked;
+
+    /** Used for built-in method references. */
+    var funcProto$1 = Function.prototype;
+
+    /** Used to resolve the decompiled source of functions. */
+    var funcToString$1 = funcProto$1.toString;
+
+    /**
+     * Converts `func` to its source code.
+     *
+     * @private
+     * @param {Function} func The function to convert.
+     * @returns {string} Returns the source code.
+     */
+    function toSource(func) {
+      if (func != null) {
+        try {
+          return funcToString$1.call(func);
+        } catch (e) {}
+        try {
+          return (func + '');
+        } catch (e) {}
+      }
+      return '';
+    }
+
+    var _toSource = toSource;
+
+    /**
+     * Used to match `RegExp`
+     * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+     */
+    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+    /** Used to detect host constructors (Safari). */
+    var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+    /** Used for built-in method references. */
+    var funcProto = Function.prototype,
+        objectProto$a = Object.prototype;
+
+    /** Used to resolve the decompiled source of functions. */
+    var funcToString = funcProto.toString;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$8 = objectProto$a.hasOwnProperty;
+
+    /** Used to detect if a method is native. */
+    var reIsNative = RegExp('^' +
+      funcToString.call(hasOwnProperty$8).replace(reRegExpChar, '\\$&')
+      .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+    );
+
+    /**
+     * The base implementation of `_.isNative` without bad shim checks.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a native function,
+     *  else `false`.
+     */
+    function baseIsNative(value) {
+      if (!isObject_1(value) || _isMasked(value)) {
+        return false;
+      }
+      var pattern = isFunction_1(value) ? reIsNative : reIsHostCtor;
+      return pattern.test(_toSource(value));
+    }
+
+    var _baseIsNative = baseIsNative;
+
+    /**
+     * Gets the value at `key` of `object`.
+     *
+     * @private
+     * @param {Object} [object] The object to query.
+     * @param {string} key The key of the property to get.
+     * @returns {*} Returns the property value.
+     */
+    function getValue(object, key) {
+      return object == null ? undefined : object[key];
+    }
+
+    var _getValue = getValue;
+
+    /**
+     * Gets the native function at `key` of `object`.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @param {string} key The key of the method to get.
+     * @returns {*} Returns the function if it's native, else `undefined`.
+     */
+    function getNative(object, key) {
+      var value = _getValue(object, key);
+      return _baseIsNative(value) ? value : undefined;
+    }
+
+    var _getNative = getNative;
+
+    /* Built-in method references that are verified to be native. */
+    var Map$1 = _getNative(_root, 'Map');
+
+    var _Map = Map$1;
+
+    /* Built-in method references that are verified to be native. */
+    var nativeCreate = _getNative(Object, 'create');
+
+    var _nativeCreate = nativeCreate;
+
+    /**
+     * Removes all key-value entries from the hash.
+     *
+     * @private
+     * @name clear
+     * @memberOf Hash
+     */
+    function hashClear() {
+      this.__data__ = _nativeCreate ? _nativeCreate(null) : {};
+      this.size = 0;
+    }
+
+    var _hashClear = hashClear;
+
+    /**
+     * Removes `key` and its value from the hash.
+     *
+     * @private
+     * @name delete
+     * @memberOf Hash
+     * @param {Object} hash The hash to modify.
+     * @param {string} key The key of the value to remove.
+     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+     */
+    function hashDelete(key) {
+      var result = this.has(key) && delete this.__data__[key];
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+
+    var _hashDelete = hashDelete;
+
+    /** Used to stand-in for `undefined` hash values. */
+    var HASH_UNDEFINED$1 = '__lodash_hash_undefined__';
+
+    /** Used for built-in method references. */
+    var objectProto$9 = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
+
+    /**
+     * Gets the hash value for `key`.
+     *
+     * @private
+     * @name get
+     * @memberOf Hash
+     * @param {string} key The key of the value to get.
+     * @returns {*} Returns the entry value.
+     */
+    function hashGet(key) {
+      var data = this.__data__;
+      if (_nativeCreate) {
+        var result = data[key];
+        return result === HASH_UNDEFINED$1 ? undefined : result;
+      }
+      return hasOwnProperty$7.call(data, key) ? data[key] : undefined;
+    }
+
+    var _hashGet = hashGet;
+
+    /** Used for built-in method references. */
+    var objectProto$8 = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$6 = objectProto$8.hasOwnProperty;
+
+    /**
+     * Checks if a hash value for `key` exists.
+     *
+     * @private
+     * @name has
+     * @memberOf Hash
+     * @param {string} key The key of the entry to check.
+     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+     */
+    function hashHas(key) {
+      var data = this.__data__;
+      return _nativeCreate ? (data[key] !== undefined) : hasOwnProperty$6.call(data, key);
+    }
+
+    var _hashHas = hashHas;
+
+    /** Used to stand-in for `undefined` hash values. */
+    var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+    /**
+     * Sets the hash `key` to `value`.
+     *
+     * @private
+     * @name set
+     * @memberOf Hash
+     * @param {string} key The key of the value to set.
+     * @param {*} value The value to set.
+     * @returns {Object} Returns the hash instance.
+     */
+    function hashSet(key, value) {
+      var data = this.__data__;
+      this.size += this.has(key) ? 0 : 1;
+      data[key] = (_nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+      return this;
+    }
+
+    var _hashSet = hashSet;
+
+    /**
+     * Creates a hash object.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    function Hash(entries) {
+      var index = -1,
+          length = entries == null ? 0 : entries.length;
+
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+
+    // Add methods to `Hash`.
+    Hash.prototype.clear = _hashClear;
+    Hash.prototype['delete'] = _hashDelete;
+    Hash.prototype.get = _hashGet;
+    Hash.prototype.has = _hashHas;
+    Hash.prototype.set = _hashSet;
+
+    var _Hash = Hash;
+
+    /**
+     * Removes all key-value entries from the map.
+     *
+     * @private
+     * @name clear
+     * @memberOf MapCache
+     */
+    function mapCacheClear() {
+      this.size = 0;
+      this.__data__ = {
+        'hash': new _Hash,
+        'map': new (_Map || _ListCache),
+        'string': new _Hash
+      };
+    }
+
+    var _mapCacheClear = mapCacheClear;
+
+    /**
+     * Checks if `value` is suitable for use as unique object key.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+     */
+    function isKeyable(value) {
+      var type = typeof value;
+      return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+        ? (value !== '__proto__')
+        : (value === null);
+    }
+
+    var _isKeyable = isKeyable;
+
+    /**
+     * Gets the data for `map`.
+     *
+     * @private
+     * @param {Object} map The map to query.
+     * @param {string} key The reference key.
+     * @returns {*} Returns the map data.
+     */
+    function getMapData(map, key) {
+      var data = map.__data__;
+      return _isKeyable(key)
+        ? data[typeof key == 'string' ? 'string' : 'hash']
+        : data.map;
+    }
+
+    var _getMapData = getMapData;
+
+    /**
+     * Removes `key` and its value from the map.
+     *
+     * @private
+     * @name delete
+     * @memberOf MapCache
+     * @param {string} key The key of the value to remove.
+     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+     */
+    function mapCacheDelete(key) {
+      var result = _getMapData(this, key)['delete'](key);
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+
+    var _mapCacheDelete = mapCacheDelete;
+
+    /**
+     * Gets the map value for `key`.
+     *
+     * @private
+     * @name get
+     * @memberOf MapCache
+     * @param {string} key The key of the value to get.
+     * @returns {*} Returns the entry value.
+     */
+    function mapCacheGet(key) {
+      return _getMapData(this, key).get(key);
+    }
+
+    var _mapCacheGet = mapCacheGet;
+
+    /**
+     * Checks if a map value for `key` exists.
+     *
+     * @private
+     * @name has
+     * @memberOf MapCache
+     * @param {string} key The key of the entry to check.
+     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+     */
+    function mapCacheHas(key) {
+      return _getMapData(this, key).has(key);
+    }
+
+    var _mapCacheHas = mapCacheHas;
+
+    /**
+     * Sets the map `key` to `value`.
+     *
+     * @private
+     * @name set
+     * @memberOf MapCache
+     * @param {string} key The key of the value to set.
+     * @param {*} value The value to set.
+     * @returns {Object} Returns the map cache instance.
+     */
+    function mapCacheSet(key, value) {
+      var data = _getMapData(this, key),
+          size = data.size;
+
+      data.set(key, value);
+      this.size += data.size == size ? 0 : 1;
+      return this;
+    }
+
+    var _mapCacheSet = mapCacheSet;
+
+    /**
+     * Creates a map cache object to store key-value pairs.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    function MapCache(entries) {
+      var index = -1,
+          length = entries == null ? 0 : entries.length;
+
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+
+    // Add methods to `MapCache`.
+    MapCache.prototype.clear = _mapCacheClear;
+    MapCache.prototype['delete'] = _mapCacheDelete;
+    MapCache.prototype.get = _mapCacheGet;
+    MapCache.prototype.has = _mapCacheHas;
+    MapCache.prototype.set = _mapCacheSet;
+
+    var _MapCache = MapCache;
+
+    /** Used as the size to enable large array optimizations. */
+    var LARGE_ARRAY_SIZE = 200;
+
+    /**
+     * Sets the stack `key` to `value`.
+     *
+     * @private
+     * @name set
+     * @memberOf Stack
+     * @param {string} key The key of the value to set.
+     * @param {*} value The value to set.
+     * @returns {Object} Returns the stack cache instance.
+     */
+    function stackSet(key, value) {
+      var data = this.__data__;
+      if (data instanceof _ListCache) {
+        var pairs = data.__data__;
+        if (!_Map || (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;
+    }
+
+    var _stackSet = stackSet;
+
+    /**
+     * Creates a stack cache object to store key-value pairs.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    function Stack(entries) {
+      var data = this.__data__ = new _ListCache(entries);
+      this.size = data.size;
+    }
+
+    // Add methods to `Stack`.
+    Stack.prototype.clear = _stackClear;
+    Stack.prototype['delete'] = _stackDelete;
+    Stack.prototype.get = _stackGet;
+    Stack.prototype.has = _stackHas;
+    Stack.prototype.set = _stackSet;
+
+    var _Stack = Stack;
+
+    /**
+     * A specialized version of `_.forEach` for arrays without support for
+     * iteratee shorthands.
+     *
+     * @private
+     * @param {Array} [array] The array to iterate over.
+     * @param {Function} iteratee The function invoked per iteration.
+     * @returns {Array} Returns `array`.
+     */
+    function arrayEach(array, iteratee) {
+      var index = -1,
+          length = array == null ? 0 : array.length;
+
+      while (++index < length) {
+        if (iteratee(array[index], index, array) === false) {
+          break;
+        }
+      }
+      return array;
+    }
+
+    var _arrayEach = arrayEach;
+
+    var defineProperty = (function() {
+      try {
+        var func = _getNative(Object, 'defineProperty');
+        func({}, '', {});
+        return func;
+      } catch (e) {}
+    }());
+
+    var _defineProperty$1 = defineProperty;
+
+    /**
+     * The base implementation of `assignValue` and `assignMergeValue` without
+     * value checks.
+     *
+     * @private
+     * @param {Object} object The object to modify.
+     * @param {string} key The key of the property to assign.
+     * @param {*} value The value to assign.
+     */
+    function baseAssignValue(object, key, value) {
+      if (key == '__proto__' && _defineProperty$1) {
+        _defineProperty$1(object, key, {
+          'configurable': true,
+          'enumerable': true,
+          'value': value,
+          'writable': true
+        });
+      } else {
+        object[key] = value;
+      }
+    }
+
+    var _baseAssignValue = baseAssignValue;
+
+    /** Used for built-in method references. */
+    var objectProto$7 = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$5 = objectProto$7.hasOwnProperty;
+
+    /**
+     * Assigns `value` to `key` of `object` if the existing value is not equivalent
+     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+     * for equality comparisons.
+     *
+     * @private
+     * @param {Object} object The object to modify.
+     * @param {string} key The key of the property to assign.
+     * @param {*} value The value to assign.
+     */
+    function assignValue(object, key, value) {
+      var objValue = object[key];
+      if (!(hasOwnProperty$5.call(object, key) && eq_1(objValue, value)) ||
+          (value === undefined && !(key in object))) {
+        _baseAssignValue(object, key, value);
+      }
+    }
+
+    var _assignValue = assignValue;
+
+    /**
+     * Copies properties of `source` to `object`.
+     *
+     * @private
+     * @param {Object} source The object to copy properties from.
+     * @param {Array} props The property identifiers to copy.
+     * @param {Object} [object={}] The object to copy properties to.
+     * @param {Function} [customizer] The function to customize copied values.
+     * @returns {Object} Returns `object`.
+     */
+    function copyObject(source, props, object, customizer) {
+      var isNew = !object;
+      object || (object = {});
+
+      var index = -1,
+          length = props.length;
+
+      while (++index < length) {
+        var key = props[index];
+
+        var newValue = customizer
+          ? customizer(object[key], source[key], key, object, source)
+          : undefined;
+
+        if (newValue === undefined) {
+          newValue = source[key];
+        }
+        if (isNew) {
+          _baseAssignValue(object, key, newValue);
+        } else {
+          _assignValue(object, key, newValue);
+        }
+      }
+      return object;
+    }
+
+    var _copyObject = copyObject;
+
+    /**
+     * The base implementation of `_.times` without support for iteratee shorthands
+     * or max array length checks.
+     *
+     * @private
+     * @param {number} n The number of times to invoke `iteratee`.
+     * @param {Function} iteratee The function invoked per iteration.
+     * @returns {Array} Returns the array of results.
+     */
+    function baseTimes(n, iteratee) {
+      var index = -1,
+          result = Array(n);
+
+      while (++index < n) {
+        result[index] = iteratee(index);
+      }
+      return result;
+    }
+
+    var _baseTimes = baseTimes;
+
+    /**
+     * Checks if `value` is object-like. A value is object-like if it's not `null`
+     * and has a `typeof` result of "object".
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+     * @example
+     *
+     * _.isObjectLike({});
+     * // => true
+     *
+     * _.isObjectLike([1, 2, 3]);
+     * // => true
+     *
+     * _.isObjectLike(_.noop);
+     * // => false
+     *
+     * _.isObjectLike(null);
+     * // => false
+     */
+    function isObjectLike(value) {
+      return value != null && typeof value == 'object';
+    }
+
+    var isObjectLike_1 = isObjectLike;
+
+    /** `Object#toString` result references. */
+    var argsTag$2 = '[object Arguments]';
+
+    /**
+     * The base implementation of `_.isArguments`.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+     */
+    function baseIsArguments(value) {
+      return isObjectLike_1(value) && _baseGetTag(value) == argsTag$2;
+    }
+
+    var _baseIsArguments = baseIsArguments;
+
+    /** Used for built-in method references. */
+    var objectProto$6 = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$4 = objectProto$6.hasOwnProperty;
+
+    /** Built-in value references. */
+    var propertyIsEnumerable$1 = objectProto$6.propertyIsEnumerable;
+
+    /**
+     * Checks if `value` is likely an `arguments` object.
+     *
+     * @static
+     * @memberOf _
+     * @since 0.1.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+     *  else `false`.
+     * @example
+     *
+     * _.isArguments(function() { return arguments; }());
+     * // => true
+     *
+     * _.isArguments([1, 2, 3]);
+     * // => false
+     */
+    var isArguments = _baseIsArguments(function() { return arguments; }()) ? _baseIsArguments : function(value) {
+      return isObjectLike_1(value) && hasOwnProperty$4.call(value, 'callee') &&
+        !propertyIsEnumerable$1.call(value, 'callee');
+    };
+
+    var isArguments_1 = isArguments;
+
+    /**
+     * Checks if `value` is classified as an `Array` object.
+     *
+     * @static
+     * @memberOf _
+     * @since 0.1.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+     * @example
+     *
+     * _.isArray([1, 2, 3]);
+     * // => true
+     *
+     * _.isArray(document.body.children);
+     * // => false
+     *
+     * _.isArray('abc');
+     * // => false
+     *
+     * _.isArray(_.noop);
+     * // => false
+     */
+    var isArray = Array.isArray;
+
+    var isArray_1 = isArray;
+
+    /**
+     * This method returns `false`.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.13.0
+     * @category Util
+     * @returns {boolean} Returns `false`.
+     * @example
+     *
+     * _.times(2, _.stubFalse);
+     * // => [false, false]
+     */
+    function stubFalse() {
+      return false;
+    }
+
+    var stubFalse_1 = stubFalse;
+
+    var isBuffer_1 = createCommonjsModule(function (module, exports) {
+    /** Detect free variable `exports`. */
+    var freeExports = exports && !exports.nodeType && exports;
+
+    /** Detect free variable `module`. */
+    var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
+
+    /** Detect the popular CommonJS extension `module.exports`. */
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+
+    /** Built-in value references. */
+    var Buffer = moduleExports ? _root.Buffer : undefined;
+
+    /* Built-in method references for those with the same name as other `lodash` methods. */
+    var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+
+    /**
+     * Checks if `value` is a buffer.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.3.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+     * @example
+     *
+     * _.isBuffer(new Buffer(2));
+     * // => true
+     *
+     * _.isBuffer(new Uint8Array(2));
+     * // => false
+     */
+    var isBuffer = nativeIsBuffer || stubFalse_1;
+
+    module.exports = isBuffer;
+    });
+
+    /** Used as references for various `Number` constants. */
+    var MAX_SAFE_INTEGER$1 = 9007199254740991;
+
+    /** Used to detect unsigned integer values. */
+    var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+    /**
+     * Checks if `value` is a valid array-like index.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+     */
+    function isIndex(value, length) {
+      var type = typeof value;
+      length = length == null ? MAX_SAFE_INTEGER$1 : length;
+
+      return !!length &&
+        (type == 'number' ||
+          (type != 'symbol' && reIsUint.test(value))) &&
+            (value > -1 && value % 1 == 0 && value < length);
+    }
+
+    var _isIndex = isIndex;
+
+    /** Used as references for various `Number` constants. */
+    var MAX_SAFE_INTEGER = 9007199254740991;
+
+    /**
+     * Checks if `value` is a valid array-like length.
+     *
+     * **Note:** This method is loosely based on
+     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+     * @example
+     *
+     * _.isLength(3);
+     * // => true
+     *
+     * _.isLength(Number.MIN_VALUE);
+     * // => false
+     *
+     * _.isLength(Infinity);
+     * // => false
+     *
+     * _.isLength('3');
+     * // => false
+     */
+    function isLength(value) {
+      return typeof value == 'number' &&
+        value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+    }
+
+    var isLength_1 = isLength;
+
+    /** `Object#toString` result references. */
+    var argsTag$1 = '[object Arguments]',
+        arrayTag$1 = '[object Array]',
+        boolTag$2 = '[object Boolean]',
+        dateTag$2 = '[object Date]',
+        errorTag$1 = '[object Error]',
+        funcTag$1 = '[object Function]',
+        mapTag$4 = '[object Map]',
+        numberTag$2 = '[object Number]',
+        objectTag$2 = '[object Object]',
+        regexpTag$2 = '[object RegExp]',
+        setTag$4 = '[object Set]',
+        stringTag$2 = '[object String]',
+        weakMapTag$2 = '[object WeakMap]';
+
+    var arrayBufferTag$2 = '[object ArrayBuffer]',
+        dataViewTag$3 = '[object DataView]',
+        float32Tag$2 = '[object Float32Array]',
+        float64Tag$2 = '[object Float64Array]',
+        int8Tag$2 = '[object Int8Array]',
+        int16Tag$2 = '[object Int16Array]',
+        int32Tag$2 = '[object Int32Array]',
+        uint8Tag$2 = '[object Uint8Array]',
+        uint8ClampedTag$2 = '[object Uint8ClampedArray]',
+        uint16Tag$2 = '[object Uint16Array]',
+        uint32Tag$2 = '[object Uint32Array]';
+
+    /** Used to identify `toStringTag` values of typed arrays. */
+    var typedArrayTags = {};
+    typedArrayTags[float32Tag$2] = typedArrayTags[float64Tag$2] =
+    typedArrayTags[int8Tag$2] = typedArrayTags[int16Tag$2] =
+    typedArrayTags[int32Tag$2] = typedArrayTags[uint8Tag$2] =
+    typedArrayTags[uint8ClampedTag$2] = typedArrayTags[uint16Tag$2] =
+    typedArrayTags[uint32Tag$2] = true;
+    typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] =
+    typedArrayTags[arrayBufferTag$2] = typedArrayTags[boolTag$2] =
+    typedArrayTags[dataViewTag$3] = typedArrayTags[dateTag$2] =
+    typedArrayTags[errorTag$1] = typedArrayTags[funcTag$1] =
+    typedArrayTags[mapTag$4] = typedArrayTags[numberTag$2] =
+    typedArrayTags[objectTag$2] = typedArrayTags[regexpTag$2] =
+    typedArrayTags[setTag$4] = typedArrayTags[stringTag$2] =
+    typedArrayTags[weakMapTag$2] = false;
+
+    /**
+     * The base implementation of `_.isTypedArray` without Node.js optimizations.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+     */
+    function baseIsTypedArray(value) {
+      return isObjectLike_1(value) &&
+        isLength_1(value.length) && !!typedArrayTags[_baseGetTag(value)];
+    }
+
+    var _baseIsTypedArray = baseIsTypedArray;
+
+    /**
+     * The base implementation of `_.unary` without support for storing metadata.
+     *
+     * @private
+     * @param {Function} func The function to cap arguments for.
+     * @returns {Function} Returns the new capped function.
+     */
+    function baseUnary(func) {
+      return function(value) {
+        return func(value);
+      };
+    }
+
+    var _baseUnary = baseUnary;
+
+    var _nodeUtil = createCommonjsModule(function (module, exports) {
+    /** Detect free variable `exports`. */
+    var freeExports = exports && !exports.nodeType && exports;
+
+    /** Detect free variable `module`. */
+    var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
+
+    /** Detect the popular CommonJS extension `module.exports`. */
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+
+    /** Detect free variable `process` from Node.js. */
+    var freeProcess = moduleExports && _freeGlobal.process;
+
+    /** Used to access faster Node.js helpers. */
+    var nodeUtil = (function() {
+      try {
+        // Use `util.types` for Node.js 10+.
+        var types = freeModule && freeModule.require && freeModule.require('util').types;
+
+        if (types) {
+          return types;
+        }
+
+        // Legacy `process.binding('util')` for Node.js < 10.
+        return freeProcess && freeProcess.binding && freeProcess.binding('util');
+      } catch (e) {}
+    }());
+
+    module.exports = nodeUtil;
+    });
+
+    /* Node.js helper references. */
+    var nodeIsTypedArray = _nodeUtil && _nodeUtil.isTypedArray;
+
+    /**
+     * Checks if `value` is classified as a typed array.
+     *
+     * @static
+     * @memberOf _
+     * @since 3.0.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+     * @example
+     *
+     * _.isTypedArray(new Uint8Array);
+     * // => true
+     *
+     * _.isTypedArray([]);
+     * // => false
+     */
+    var isTypedArray = nodeIsTypedArray ? _baseUnary(nodeIsTypedArray) : _baseIsTypedArray;
+
+    var isTypedArray_1 = isTypedArray;
+
+    /** Used for built-in method references. */
+    var objectProto$5 = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$3 = objectProto$5.hasOwnProperty;
+
+    /**
+     * Creates an array of the enumerable property names of the array-like `value`.
+     *
+     * @private
+     * @param {*} value The value to query.
+     * @param {boolean} inherited Specify returning inherited property names.
+     * @returns {Array} Returns the array of property names.
+     */
+    function arrayLikeKeys(value, inherited) {
+      var isArr = isArray_1(value),
+          isArg = !isArr && isArguments_1(value),
+          isBuff = !isArr && !isArg && isBuffer_1(value),
+          isType = !isArr && !isArg && !isBuff && isTypedArray_1(value),
+          skipIndexes = isArr || isArg || isBuff || isType,
+          result = skipIndexes ? _baseTimes(value.length, String) : [],
+          length = result.length;
+
+      for (var key in value) {
+        if ((inherited || hasOwnProperty$3.call(value, key)) &&
+            !(skipIndexes && (
+               // Safari 9 has enumerable `arguments.length` in strict mode.
+               key == 'length' ||
+               // Node.js 0.10 has enumerable non-index properties on buffers.
+               (isBuff && (key == 'offset' || key == 'parent')) ||
+               // PhantomJS 2 has enumerable non-index properties on typed arrays.
+               (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+               // Skip index properties.
+               _isIndex(key, length)
+            ))) {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+
+    var _arrayLikeKeys = arrayLikeKeys;
+
+    /** Used for built-in method references. */
+    var objectProto$4 = Object.prototype;
+
+    /**
+     * Checks if `value` is likely a prototype object.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+     */
+    function isPrototype(value) {
+      var Ctor = value && value.constructor,
+          proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$4;
+
+      return value === proto;
+    }
+
+    var _isPrototype = isPrototype;
+
+    /**
+     * Creates a unary function that invokes `func` with its argument transformed.
+     *
+     * @private
+     * @param {Function} func The function to wrap.
+     * @param {Function} transform The argument transform.
+     * @returns {Function} Returns the new function.
+     */
+    function overArg(func, transform) {
+      return function(arg) {
+        return func(transform(arg));
+      };
+    }
+
+    var _overArg = overArg;
+
+    /* Built-in method references for those with the same name as other `lodash` methods. */
+    var nativeKeys = _overArg(Object.keys, Object);
+
+    var _nativeKeys = nativeKeys;
+
+    /** Used for built-in method references. */
+    var objectProto$3 = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
+
+    /**
+     * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of property names.
+     */
+    function baseKeys(object) {
+      if (!_isPrototype(object)) {
+        return _nativeKeys(object);
+      }
+      var result = [];
+      for (var key in Object(object)) {
+        if (hasOwnProperty$2.call(object, key) && key != 'constructor') {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+
+    var _baseKeys = baseKeys;
+
+    /**
+     * Checks if `value` is array-like. A value is considered array-like if it's
+     * not a function and has a `value.length` that's an integer greater than or
+     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+     * @example
+     *
+     * _.isArrayLike([1, 2, 3]);
+     * // => true
+     *
+     * _.isArrayLike(document.body.children);
+     * // => true
+     *
+     * _.isArrayLike('abc');
+     * // => true
+     *
+     * _.isArrayLike(_.noop);
+     * // => false
+     */
+    function isArrayLike(value) {
+      return value != null && isLength_1(value.length) && !isFunction_1(value);
+    }
+
+    var isArrayLike_1 = isArrayLike;
+
+    /**
+     * Creates an array of the own enumerable property names of `object`.
+     *
+     * **Note:** Non-object values are coerced to objects. See the
+     * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+     * for more details.
+     *
+     * @static
+     * @since 0.1.0
+     * @memberOf _
+     * @category Object
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of property names.
+     * @example
+     *
+     * function Foo() {
+     *   this.a = 1;
+     *   this.b = 2;
+     * }
+     *
+     * Foo.prototype.c = 3;
+     *
+     * _.keys(new Foo);
+     * // => ['a', 'b'] (iteration order is not guaranteed)
+     *
+     * _.keys('hi');
+     * // => ['0', '1']
+     */
+    function keys(object) {
+      return isArrayLike_1(object) ? _arrayLikeKeys(object) : _baseKeys(object);
+    }
+
+    var keys_1 = keys;
+
+    /**
+     * The base implementation of `_.assign` without support for multiple sources
+     * or `customizer` functions.
+     *
+     * @private
+     * @param {Object} object The destination object.
+     * @param {Object} source The source object.
+     * @returns {Object} Returns `object`.
+     */
+    function baseAssign(object, source) {
+      return object && _copyObject(source, keys_1(source), object);
+    }
+
+    var _baseAssign = baseAssign;
+
+    /**
+     * This function is like
+     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+     * except that it includes inherited enumerable properties.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of property names.
+     */
+    function nativeKeysIn(object) {
+      var result = [];
+      if (object != null) {
+        for (var key in Object(object)) {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+
+    var _nativeKeysIn = nativeKeysIn;
+
+    /** Used for built-in method references. */
+    var objectProto$2 = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
+
+    /**
+     * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of property names.
+     */
+    function baseKeysIn(object) {
+      if (!isObject_1(object)) {
+        return _nativeKeysIn(object);
+      }
+      var isProto = _isPrototype(object),
+          result = [];
+
+      for (var key in object) {
+        if (!(key == 'constructor' && (isProto || !hasOwnProperty$1.call(object, key)))) {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+
+    var _baseKeysIn = baseKeysIn;
+
+    /**
+     * Creates an array of the own and inherited enumerable property names of `object`.
+     *
+     * **Note:** Non-object values are coerced to objects.
+     *
+     * @static
+     * @memberOf _
+     * @since 3.0.0
+     * @category Object
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of property names.
+     * @example
+     *
+     * function Foo() {
+     *   this.a = 1;
+     *   this.b = 2;
+     * }
+     *
+     * Foo.prototype.c = 3;
+     *
+     * _.keysIn(new Foo);
+     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+     */
+    function keysIn(object) {
+      return isArrayLike_1(object) ? _arrayLikeKeys(object, true) : _baseKeysIn(object);
+    }
+
+    var keysIn_1 = keysIn;
+
+    /**
+     * The base implementation of `_.assignIn` without support for multiple sources
+     * or `customizer` functions.
+     *
+     * @private
+     * @param {Object} object The destination object.
+     * @param {Object} source The source object.
+     * @returns {Object} Returns `object`.
+     */
+    function baseAssignIn(object, source) {
+      return object && _copyObject(source, keysIn_1(source), object);
+    }
+
+    var _baseAssignIn = baseAssignIn;
+
+    var _cloneBuffer = createCommonjsModule(function (module, exports) {
+    /** Detect free variable `exports`. */
+    var freeExports = exports && !exports.nodeType && exports;
+
+    /** Detect free variable `module`. */
+    var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
+
+    /** Detect the popular CommonJS extension `module.exports`. */
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+
+    /** Built-in value references. */
+    var Buffer = moduleExports ? _root.Buffer : undefined,
+        allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;
+
+    /**
+     * Creates a clone of  `buffer`.
+     *
+     * @private
+     * @param {Buffer} buffer The buffer to clone.
+     * @param {boolean} [isDeep] Specify a deep clone.
+     * @returns {Buffer} Returns the cloned buffer.
+     */
+    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;
+    }
+
+    module.exports = cloneBuffer;
+    });
+
+    /**
+     * Copies the values of `source` to `array`.
+     *
+     * @private
+     * @param {Array} source The array to copy values from.
+     * @param {Array} [array=[]] The array to copy values to.
+     * @returns {Array} Returns `array`.
+     */
+    function copyArray(source, array) {
+      var index = -1,
+          length = source.length;
+
+      array || (array = Array(length));
+      while (++index < length) {
+        array[index] = source[index];
+      }
+      return array;
+    }
+
+    var _copyArray = copyArray;
+
+    /**
+     * A specialized version of `_.filter` for arrays without support for
+     * iteratee shorthands.
+     *
+     * @private
+     * @param {Array} [array] The array to iterate over.
+     * @param {Function} predicate The function invoked per iteration.
+     * @returns {Array} Returns the new filtered array.
+     */
+    function arrayFilter(array, predicate) {
+      var index = -1,
+          length = array == null ? 0 : array.length,
+          resIndex = 0,
+          result = [];
+
+      while (++index < length) {
+        var value = array[index];
+        if (predicate(value, index, array)) {
+          result[resIndex++] = value;
+        }
+      }
+      return result;
+    }
+
+    var _arrayFilter = arrayFilter;
+
+    /**
+     * This method returns a new empty array.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.13.0
+     * @category Util
+     * @returns {Array} Returns the new empty array.
+     * @example
+     *
+     * var arrays = _.times(2, _.stubArray);
+     *
+     * console.log(arrays);
+     * // => [[], []]
+     *
+     * console.log(arrays[0] === arrays[1]);
+     * // => false
+     */
+    function stubArray() {
+      return [];
+    }
+
+    var stubArray_1 = stubArray;
+
+    /** Used for built-in method references. */
+    var objectProto$1 = Object.prototype;
+
+    /** Built-in value references. */
+    var propertyIsEnumerable = objectProto$1.propertyIsEnumerable;
+
+    /* Built-in method references for those with the same name as other `lodash` methods. */
+    var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
+
+    /**
+     * Creates an array of the own enumerable symbols of `object`.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of symbols.
+     */
+    var getSymbols = !nativeGetSymbols$1 ? stubArray_1 : function(object) {
+      if (object == null) {
+        return [];
+      }
+      object = Object(object);
+      return _arrayFilter(nativeGetSymbols$1(object), function(symbol) {
+        return propertyIsEnumerable.call(object, symbol);
+      });
+    };
+
+    var _getSymbols = getSymbols;
+
+    /**
+     * Copies own symbols of `source` to `object`.
+     *
+     * @private
+     * @param {Object} source The object to copy symbols from.
+     * @param {Object} [object={}] The object to copy symbols to.
+     * @returns {Object} Returns `object`.
+     */
+    function copySymbols(source, object) {
+      return _copyObject(source, _getSymbols(source), object);
+    }
+
+    var _copySymbols = copySymbols;
+
+    /**
+     * Appends the elements of `values` to `array`.
+     *
+     * @private
+     * @param {Array} array The array to modify.
+     * @param {Array} values The values to append.
+     * @returns {Array} Returns `array`.
+     */
+    function arrayPush(array, values) {
+      var index = -1,
+          length = values.length,
+          offset = array.length;
+
+      while (++index < length) {
+        array[offset + index] = values[index];
+      }
+      return array;
+    }
+
+    var _arrayPush = arrayPush;
+
+    /** Built-in value references. */
+    var getPrototype = _overArg(Object.getPrototypeOf, Object);
+
+    var _getPrototype = getPrototype;
+
+    /* Built-in method references for those with the same name as other `lodash` methods. */
+    var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+    /**
+     * Creates an array of the own and inherited enumerable symbols of `object`.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of symbols.
+     */
+    var getSymbolsIn = !nativeGetSymbols ? stubArray_1 : function(object) {
+      var result = [];
+      while (object) {
+        _arrayPush(result, _getSymbols(object));
+        object = _getPrototype(object);
+      }
+      return result;
+    };
+
+    var _getSymbolsIn = getSymbolsIn;
+
+    /**
+     * Copies own and inherited symbols of `source` to `object`.
+     *
+     * @private
+     * @param {Object} source The object to copy symbols from.
+     * @param {Object} [object={}] The object to copy symbols to.
+     * @returns {Object} Returns `object`.
+     */
+    function copySymbolsIn(source, object) {
+      return _copyObject(source, _getSymbolsIn(source), object);
+    }
+
+    var _copySymbolsIn = copySymbolsIn;
+
+    /**
+     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+     * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+     * symbols of `object`.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @param {Function} keysFunc The function to get the keys of `object`.
+     * @param {Function} symbolsFunc The function to get the symbols of `object`.
+     * @returns {Array} Returns the array of property names and symbols.
+     */
+    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+      var result = keysFunc(object);
+      return isArray_1(object) ? result : _arrayPush(result, symbolsFunc(object));
+    }
+
+    var _baseGetAllKeys = baseGetAllKeys;
+
+    /**
+     * Creates an array of own enumerable property names and symbols of `object`.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of property names and symbols.
+     */
+    function getAllKeys(object) {
+      return _baseGetAllKeys(object, keys_1, _getSymbols);
+    }
+
+    var _getAllKeys = getAllKeys;
+
+    /**
+     * Creates an array of own and inherited enumerable property names and
+     * symbols of `object`.
+     *
+     * @private
+     * @param {Object} object The object to query.
+     * @returns {Array} Returns the array of property names and symbols.
+     */
+    function getAllKeysIn(object) {
+      return _baseGetAllKeys(object, keysIn_1, _getSymbolsIn);
+    }
+
+    var _getAllKeysIn = getAllKeysIn;
+
+    /* Built-in method references that are verified to be native. */
+    var DataView = _getNative(_root, 'DataView');
+
+    var _DataView = DataView;
+
+    /* Built-in method references that are verified to be native. */
+    var Promise$1 = _getNative(_root, 'Promise');
+
+    var _Promise = Promise$1;
+
+    /* Built-in method references that are verified to be native. */
+    var Set = _getNative(_root, 'Set');
+
+    var _Set = Set;
+
+    /* Built-in method references that are verified to be native. */
+    var WeakMap$1 = _getNative(_root, 'WeakMap');
+
+    var _WeakMap = WeakMap$1;
+
+    /** `Object#toString` result references. */
+    var mapTag$3 = '[object Map]',
+        objectTag$1 = '[object Object]',
+        promiseTag = '[object Promise]',
+        setTag$3 = '[object Set]',
+        weakMapTag$1 = '[object WeakMap]';
+
+    var dataViewTag$2 = '[object DataView]';
+
+    /** Used to detect maps, sets, and weakmaps. */
+    var dataViewCtorString = _toSource(_DataView),
+        mapCtorString = _toSource(_Map),
+        promiseCtorString = _toSource(_Promise),
+        setCtorString = _toSource(_Set),
+        weakMapCtorString = _toSource(_WeakMap);
+
+    /**
+     * Gets the `toStringTag` of `value`.
+     *
+     * @private
+     * @param {*} value The value to query.
+     * @returns {string} Returns the `toStringTag`.
+     */
+    var getTag = _baseGetTag;
+
+    // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+    if ((_DataView && getTag(new _DataView(new ArrayBuffer(1))) != dataViewTag$2) ||
+        (_Map && getTag(new _Map) != mapTag$3) ||
+        (_Promise && getTag(_Promise.resolve()) != promiseTag) ||
+        (_Set && getTag(new _Set) != setTag$3) ||
+        (_WeakMap && getTag(new _WeakMap) != weakMapTag$1)) {
+      getTag = function(value) {
+        var result = _baseGetTag(value),
+            Ctor = result == objectTag$1 ? value.constructor : undefined,
+            ctorString = Ctor ? _toSource(Ctor) : '';
+
+        if (ctorString) {
+          switch (ctorString) {
+            case dataViewCtorString: return dataViewTag$2;
+            case mapCtorString: return mapTag$3;
+            case promiseCtorString: return promiseTag;
+            case setCtorString: return setTag$3;
+            case weakMapCtorString: return weakMapTag$1;
+          }
+        }
+        return result;
+      };
+    }
+
+    var _getTag = getTag;
+
+    /** Used for built-in method references. */
+    var objectProto = Object.prototype;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty = objectProto.hasOwnProperty;
+
+    /**
+     * Initializes an array clone.
+     *
+     * @private
+     * @param {Array} array The array to clone.
+     * @returns {Array} Returns the initialized clone.
+     */
+    function initCloneArray(array) {
+      var length = array.length,
+          result = new array.constructor(length);
+
+      // Add properties assigned by `RegExp#exec`.
+      if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
+        result.index = array.index;
+        result.input = array.input;
+      }
+      return result;
+    }
+
+    var _initCloneArray = initCloneArray;
+
+    /** Built-in value references. */
+    var Uint8Array = _root.Uint8Array;
+
+    var _Uint8Array = Uint8Array;
+
+    /**
+     * Creates a clone of `arrayBuffer`.
+     *
+     * @private
+     * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+     * @returns {ArrayBuffer} Returns the cloned array buffer.
+     */
+    function cloneArrayBuffer(arrayBuffer) {
+      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+      new _Uint8Array(result).set(new _Uint8Array(arrayBuffer));
+      return result;
+    }
+
+    var _cloneArrayBuffer = cloneArrayBuffer;
+
+    /**
+     * Creates a clone of `dataView`.
+     *
+     * @private
+     * @param {Object} dataView The data view to clone.
+     * @param {boolean} [isDeep] Specify a deep clone.
+     * @returns {Object} Returns the cloned data view.
+     */
+    function cloneDataView(dataView, isDeep) {
+      var buffer = isDeep ? _cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+      return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+    }
+
+    var _cloneDataView = cloneDataView;
+
+    /** Used to match `RegExp` flags from their coerced string values. */
+    var reFlags = /\w*$/;
+
+    /**
+     * Creates a clone of `regexp`.
+     *
+     * @private
+     * @param {Object} regexp The regexp to clone.
+     * @returns {Object} Returns the cloned regexp.
+     */
+    function cloneRegExp(regexp) {
+      var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+      result.lastIndex = regexp.lastIndex;
+      return result;
+    }
+
+    var _cloneRegExp = cloneRegExp;
+
+    /** Used to convert symbols to primitives and strings. */
+    var symbolProto = _Symbol ? _Symbol.prototype : undefined,
+        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+    /**
+     * Creates a clone of the `symbol` object.
+     *
+     * @private
+     * @param {Object} symbol The symbol object to clone.
+     * @returns {Object} Returns the cloned symbol object.
+     */
+    function cloneSymbol(symbol) {
+      return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+    }
+
+    var _cloneSymbol = cloneSymbol;
+
+    /**
+     * Creates a clone of `typedArray`.
+     *
+     * @private
+     * @param {Object} typedArray The typed array to clone.
+     * @param {boolean} [isDeep] Specify a deep clone.
+     * @returns {Object} Returns the cloned typed array.
+     */
+    function cloneTypedArray(typedArray, isDeep) {
+      var buffer = isDeep ? _cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+    }
+
+    var _cloneTypedArray = cloneTypedArray;
+
+    /** `Object#toString` result references. */
+    var boolTag$1 = '[object Boolean]',
+        dateTag$1 = '[object Date]',
+        mapTag$2 = '[object Map]',
+        numberTag$1 = '[object Number]',
+        regexpTag$1 = '[object RegExp]',
+        setTag$2 = '[object Set]',
+        stringTag$1 = '[object String]',
+        symbolTag$1 = '[object Symbol]';
+
+    var arrayBufferTag$1 = '[object ArrayBuffer]',
+        dataViewTag$1 = '[object DataView]',
+        float32Tag$1 = '[object Float32Array]',
+        float64Tag$1 = '[object Float64Array]',
+        int8Tag$1 = '[object Int8Array]',
+        int16Tag$1 = '[object Int16Array]',
+        int32Tag$1 = '[object Int32Array]',
+        uint8Tag$1 = '[object Uint8Array]',
+        uint8ClampedTag$1 = '[object Uint8ClampedArray]',
+        uint16Tag$1 = '[object Uint16Array]',
+        uint32Tag$1 = '[object Uint32Array]';
+
+    /**
+     * Initializes an object clone based on its `toStringTag`.
+     *
+     * **Note:** This function only supports cloning values with tags of
+     * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
+     *
+     * @private
+     * @param {Object} object The object to clone.
+     * @param {string} tag The `toStringTag` of the object to clone.
+     * @param {boolean} [isDeep] Specify a deep clone.
+     * @returns {Object} Returns the initialized clone.
+     */
+    function initCloneByTag(object, tag, isDeep) {
+      var Ctor = object.constructor;
+      switch (tag) {
+        case arrayBufferTag$1:
+          return _cloneArrayBuffer(object);
+
+        case boolTag$1:
+        case dateTag$1:
+          return new Ctor(+object);
+
+        case dataViewTag$1:
+          return _cloneDataView(object, 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(object, isDeep);
+
+        case mapTag$2:
+          return new Ctor;
+
+        case numberTag$1:
+        case stringTag$1:
+          return new Ctor(object);
+
+        case regexpTag$1:
+          return _cloneRegExp(object);
+
+        case setTag$2:
+          return new Ctor;
+
+        case symbolTag$1:
+          return _cloneSymbol(object);
+      }
+    }
+
+    var _initCloneByTag = initCloneByTag;
+
+    /** Built-in value references. */
+    var objectCreate = Object.create;
+
+    /**
+     * The base implementation of `_.create` without support for assigning
+     * properties to the created object.
+     *
+     * @private
+     * @param {Object} proto The object to inherit from.
+     * @returns {Object} Returns the new object.
+     */
+    var baseCreate = (function() {
+      function object() {}
+      return function(proto) {
+        if (!isObject_1(proto)) {
+          return {};
+        }
+        if (objectCreate) {
+          return objectCreate(proto);
+        }
+        object.prototype = proto;
+        var result = new object;
+        object.prototype = undefined;
+        return result;
+      };
+    }());
+
+    var _baseCreate = baseCreate;
+
+    /**
+     * Initializes an object clone.
+     *
+     * @private
+     * @param {Object} object The object to clone.
+     * @returns {Object} Returns the initialized clone.
+     */
+    function initCloneObject(object) {
+      return (typeof object.constructor == 'function' && !_isPrototype(object))
+        ? _baseCreate(_getPrototype(object))
+        : {};
+    }
+
+    var _initCloneObject = initCloneObject;
+
+    /** `Object#toString` result references. */
+    var mapTag$1 = '[object Map]';
+
+    /**
+     * The base implementation of `_.isMap` without Node.js optimizations.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+     */
+    function baseIsMap(value) {
+      return isObjectLike_1(value) && _getTag(value) == mapTag$1;
+    }
+
+    var _baseIsMap = baseIsMap;
+
+    /* Node.js helper references. */
+    var nodeIsMap = _nodeUtil && _nodeUtil.isMap;
+
+    /**
+     * Checks if `value` is classified as a `Map` object.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.3.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+     * @example
+     *
+     * _.isMap(new Map);
+     * // => true
+     *
+     * _.isMap(new WeakMap);
+     * // => false
+     */
+    var isMap = nodeIsMap ? _baseUnary(nodeIsMap) : _baseIsMap;
+
+    var isMap_1 = isMap;
+
+    /** `Object#toString` result references. */
+    var setTag$1 = '[object Set]';
+
+    /**
+     * The base implementation of `_.isSet` without Node.js optimizations.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+     */
+    function baseIsSet(value) {
+      return isObjectLike_1(value) && _getTag(value) == setTag$1;
+    }
+
+    var _baseIsSet = baseIsSet;
+
+    /* Node.js helper references. */
+    var nodeIsSet = _nodeUtil && _nodeUtil.isSet;
+
+    /**
+     * Checks if `value` is classified as a `Set` object.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.3.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+     * @example
+     *
+     * _.isSet(new Set);
+     * // => true
+     *
+     * _.isSet(new WeakSet);
+     * // => false
+     */
+    var isSet = nodeIsSet ? _baseUnary(nodeIsSet) : _baseIsSet;
+
+    var isSet_1 = isSet;
+
+    /** Used to compose bitmasks for cloning. */
+    var CLONE_DEEP_FLAG$1 = 1,
+        CLONE_FLAT_FLAG = 2,
+        CLONE_SYMBOLS_FLAG$1 = 4;
+
+    /** `Object#toString` result references. */
+    var argsTag = '[object Arguments]',
+        arrayTag = '[object Array]',
+        boolTag = '[object Boolean]',
+        dateTag = '[object Date]',
+        errorTag = '[object Error]',
+        funcTag = '[object Function]',
+        genTag = '[object GeneratorFunction]',
+        mapTag = '[object Map]',
+        numberTag = '[object Number]',
+        objectTag = '[object Object]',
+        regexpTag = '[object RegExp]',
+        setTag = '[object Set]',
+        stringTag = '[object String]',
+        symbolTag = '[object Symbol]',
+        weakMapTag = '[object WeakMap]';
+
+    var arrayBufferTag = '[object ArrayBuffer]',
+        dataViewTag = '[object DataView]',
+        float32Tag = '[object Float32Array]',
+        float64Tag = '[object Float64Array]',
+        int8Tag = '[object Int8Array]',
+        int16Tag = '[object Int16Array]',
+        int32Tag = '[object Int32Array]',
+        uint8Tag = '[object Uint8Array]',
+        uint8ClampedTag = '[object Uint8ClampedArray]',
+        uint16Tag = '[object Uint16Array]',
+        uint32Tag = '[object Uint32Array]';
+
+    /** Used to identify `toStringTag` values supported by `_.clone`. */
+    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;
+
+    /**
+     * The base implementation of `_.clone` and `_.cloneDeep` which tracks
+     * traversed objects.
+     *
+     * @private
+     * @param {*} value The value to clone.
+     * @param {boolean} bitmask The bitmask flags.
+     *  1 - Deep clone
+     *  2 - Flatten inherited properties
+     *  4 - Clone symbols
+     * @param {Function} [customizer] The function to customize cloning.
+     * @param {string} [key] The key of `value`.
+     * @param {Object} [object] The parent object of `value`.
+     * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+     * @returns {*} Returns the cloned value.
+     */
+    function baseClone(value, bitmask, customizer, key, object, stack) {
+      var result,
+          isDeep = bitmask & CLONE_DEEP_FLAG$1,
+          isFlat = bitmask & CLONE_FLAT_FLAG,
+          isFull = bitmask & CLONE_SYMBOLS_FLAG$1;
+
+      if (customizer) {
+        result = object ? customizer(value, key, object, stack) : customizer(value);
+      }
+      if (result !== undefined) {
+        return result;
+      }
+      if (!isObject_1(value)) {
+        return value;
+      }
+      var isArr = isArray_1(value);
+      if (isArr) {
+        result = _initCloneArray(value);
+        if (!isDeep) {
+          return _copyArray(value, result);
+        }
+      } else {
+        var tag = _getTag(value),
+            isFunc = tag == funcTag || tag == genTag;
+
+        if (isBuffer_1(value)) {
+          return _cloneBuffer(value, isDeep);
+        }
+        if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+          result = (isFlat || isFunc) ? {} : _initCloneObject(value);
+          if (!isDeep) {
+            return isFlat
+              ? _copySymbolsIn(value, _baseAssignIn(result, value))
+              : _copySymbols(value, _baseAssign(result, value));
+          }
+        } else {
+          if (!cloneableTags[tag]) {
+            return object ? value : {};
+          }
+          result = _initCloneByTag(value, tag, isDeep);
+        }
+      }
+      // Check for circular references and return its corresponding clone.
+      stack || (stack = new _Stack);
+      var stacked = stack.get(value);
+      if (stacked) {
+        return stacked;
+      }
+      stack.set(value, result);
+
+      if (isSet_1(value)) {
+        value.forEach(function(subValue) {
+          result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+        });
+      } else if (isMap_1(value)) {
+        value.forEach(function(subValue, key) {
+          result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
+        });
+      }
+
+      var keysFunc = isFull
+        ? (isFlat ? _getAllKeysIn : _getAllKeys)
+        : (isFlat ? keysIn_1 : keys_1);
+
+      var props = isArr ? undefined : keysFunc(value);
+      _arrayEach(props || value, function(subValue, key) {
+        if (props) {
+          key = subValue;
+          subValue = value[key];
+        }
+        // Recursively populate clone (susceptible to call stack limits).
+        _assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
+      });
+      return result;
+    }
+
+    var _baseClone = baseClone;
+
+    /** Used to compose bitmasks for cloning. */
+    var CLONE_DEEP_FLAG = 1,
+        CLONE_SYMBOLS_FLAG = 4;
+
+    /**
+     * This method is like `_.cloneWith` except that it recursively clones `value`.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to recursively clone.
+     * @param {Function} [customizer] The function to customize cloning.
+     * @returns {*} Returns the deep cloned value.
+     * @see _.cloneWith
+     * @example
+     *
+     * function customizer(value) {
+     *   if (_.isElement(value)) {
+     *     return value.cloneNode(true);
+     *   }
+     * }
+     *
+     * var el = _.cloneDeepWith(document.body, customizer);
+     *
+     * console.log(el === document.body);
+     * // => false
+     * console.log(el.nodeName);
+     * // => 'BODY'
+     * console.log(el.childNodes.length);
+     * // => 20
+     */
+    function cloneDeepWith(value, customizer) {
+      customizer = typeof customizer == 'function' ? customizer : undefined;
+      return _baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
+    }
+
+    var cloneDeepWith_1 = cloneDeepWith;
+
+    var isFieldRequired = function isFieldRequired(rules) {
+      if (rules === void 0) {
+        rules = [];
+      }
+
+      return (rules || []).some(function (rule) {
+        return rule === null || rule === void 0 ? void 0 : rule.required;
+      });
+    };
+    var getErrorAndWarnings = function getErrorAndWarnings(result) {
+      var errors = [];
+      var warnings = [];
+      var errorTypes = [];
+      result.map(function (_a) {
+        var _b = _a.message,
+            message = _b === void 0 ? [] : _b,
+            _c = _a.validateLevel,
+            validateLevel = _c === void 0 ? 'error' : _c,
+            resultErrorTypes = _a.errorTypes;
+
+        if (!(message === null || message === void 0 ? void 0 : message.length)) {
+          return;
+        }
+
+        if (validateLevel === 'warning') {
+          warnings = __spreadArrays$1(warnings, message);
+        } else {
+          errors = __spreadArrays$1(errors, message);
+          errorTypes = __spreadArrays$1(errorTypes, resultErrorTypes);
+        }
+      });
+      return {
+        warnings: warnings,
+        errors: errors,
+        errorTypes: errorTypes
+      };
+    };
+    var getDefaultValueForInterComponent = function getDefaultValueForInterComponent(componentType) {
+      switch (componentType) {
+        case FormInternalComponentType.Input:
+        case FormInternalComponentType.Textarea:
+          return undefined;
+
+        case FormInternalComponentType.CheckboxGroup:
+          return [];
+
+        case FormInternalComponentType.RadioGroup:
+          return null;
+
+        case FormInternalComponentType.Slider:
+        case FormInternalComponentType.Rate:
+          return 0;
+
+        default:
+          return undefined;
+      }
+    };
+    function deepClone(value) {
+      return cloneDeepWith_1(value, function (val) {
+        if (!isObject$3(val) && !isArray$2(val)) {
+          return val;
+        }
+      });
+    }
+
+    var defaultFunc = function defaultFunc() {};
+
+    var defaultFormDataMethods = {
+      getFieldValue: function getFieldValue(name) {
+        return name;
+      },
+      getFieldsValue: function getFieldsValue(_names) {
+        return {};
+      },
+      getFieldError: function getFieldError(_name) {
+        return [];
+      },
+      setFieldValue: function setFieldValue(_name, _value) {
+        return true;
+      },
+      setFieldsValue: function setFieldsValue(_values) {
+        return true;
+      },
+      registerField: function registerField(_name, _self) {
+        return function () {};
+      },
+      resetFields: defaultFunc,
+      validateFields: defaultFunc,
+      submit: defaultFunc,
+      getInternalHooks: function getInternalHooks() {
+        return {
+          registerField: defaultFunc,
+          setInitialValues: defaultFunc,
+          setCallbacks: defaultFunc,
+          getInitialValue: defaultFunc,
+          setInitialValue: defaultFunc,
+          innerSetFieldsValue: defaultFunc,
+          innerSetFieldValue: defaultFunc
+        };
+      }
+    }; // 在field的静态的状态下设置
+
+    var FormData =
+    /** @class */
+    function () {
+      function FormData() {
+        var _this = this;
+
+        this._formData = {}; // 数据源
+
+        this._fieldsList = {}; // 字段列表
+
+        this._initialValues = {}; // 初始值
+
+        this._callbacks = {};
+
+        this.commonSetFieldsValue = function (values, changeType) {
+          var oldValues = Object.keys(values).reduce(function (acc, key) {
+            var _a;
+
+            return __assign$3(__assign$3({}, acc), (_a = {}, _a[key] = _this.getFieldValue(key), _a));
+          }, {});
+          _this._formData = __assign$3(__assign$3({}, _this._formData), values);
+
+          _this.notifyField(values, oldValues, changeType);
+        };
+
+        this.setFieldsValue = function (values) {
+          _this.commonSetFieldsValue(values);
+
+          var onValuesChange = _this._callbacks.onValuesChange;
+          onValuesChange === null || onValuesChange === void 0 ? void 0 : onValuesChange(values, _this._formData);
+          return true;
+        };
+
+        this.innerSetFieldsValue = function (values, changeType) {
+          _this.commonSetFieldsValue(values, changeType);
+
+          var _a = _this._callbacks,
+              onValuesChange = _a.onValuesChange,
+              onChange = _a.onChange;
+          onValuesChange === null || onValuesChange === void 0 ? void 0 : onValuesChange(values, _this._formData);
+          onChange === null || onChange === void 0 ? void 0 : onChange(values, _this._formData);
+          return true;
+        };
+
+        this.commonSetFieldValue = function (name, value, changeType) {
+          var _a, _b, _c;
+
+          var oldValues = (_a = {}, _a[name] = _this.getFieldValue(name), _a);
+          _this._formData = __assign$3(__assign$3({}, _this._formData), (_b = {}, _b[name] = value, _b));
+
+          _this.notifyField((_c = {}, _c[name] = value, _c), oldValues, changeType);
+        };
+
+        this.setFieldValue = function (name, value) {
+          var _a;
+
+          _this.commonSetFieldValue(name, value);
+
+          var onValuesChange = _this._callbacks.onValuesChange;
+          onValuesChange && onValuesChange((_a = {}, _a[name] = value, _a), _this.getFieldsValue());
+          return true;
+        };
+
+        this.innerSetFieldValue = function (name, value, changeType) {
+          var _a, _b;
+
+          _this.commonSetFieldValue(name, value, changeType);
+
+          var _c = _this._callbacks,
+              onValuesChange = _c.onValuesChange,
+              onChange = _c.onChange;
+          onValuesChange && onValuesChange((_a = {}, _a[name] = value, _a), _this._formData);
+          onChange && onChange((_b = {}, _b[name] = value, _b), _this._formData);
+          return true;
+        };
+
+        this.notifyField = function (values, oldValues, changeType) {
+          if (changeType === void 0) {
+            changeType = ValueChangeType.Update;
+          }
+
+          Object.keys(values).map(function (fieldName) {
+            var _a;
+
+            var fieldObj = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[fieldName]) || null;
+
+            if (fieldObj) {
+              fieldObj.onValueChange(values[fieldName], oldValues[fieldName], {
+                changeType: changeType
+              });
+            }
+          });
+        };
+
+        this.getFieldsValue = function (names) {
+          if (names) {
+            return names.map(function (name) {
+              return _this.getFieldValue(name);
+            });
+          }
+
+          return deepClone(_this._formData);
+        };
+
+        this.getFieldValue = function (name) {
+          var _a;
+
+          return deepClone((_a = _this._formData) === null || _a === void 0 ? void 0 : _a[name]);
+        };
+
+        this.getFieldError = function (name) {
+          var _a;
+
+          var field = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[name]) || null;
+
+          if (field) {
+            return field.getFieldError();
+          }
+
+          return [];
+        };
+
+        this.getFieldsError = function (names) {
+          var fields = names || Object.keys(_this._fieldsList);
+          return fields.reduce(function (pre, name) {
+            var _a;
+
+            var theField = (_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[name];
+
+            if (theField) {
+              pre[name] = theField === null || theField === void 0 ? void 0 : theField.getFieldError();
+            }
+
+            return pre;
+          }, {});
+        };
+
+        this.isFieldTouched = function (name) {
+          var _a;
+
+          var field = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[name]) || null;
+
+          if (field) {
+            return field.isFieldTouched();
+          }
+
+          return false;
+        };
+
+        this.registerField = function (name, self) {
+          var _a, _b;
+
+          _this._fieldsList[name] = self;
+          var initialValue = self.props.initialValue;
+
+          if (initialValue !== undefined && name) {
+            _this._initialValues = __assign$3(__assign$3({}, _this._initialValues), (_a = {}, _a[name] = initialValue, _a));
+
+            _this.setFieldsValue(__assign$3(__assign$3({}, _this._formData), (_b = {}, _b[name] = initialValue, _b)));
+          }
+
+          return function () {
+            if (name in _this._fieldsList) {
+              delete _this._fieldsList[name];
+              delete _this._formData[name];
+            }
+          };
+        };
+
+        this.setInitialValues = function (initVal) {
+          _this._initialValues = deepClone(initVal || {});
+
+          _this.setFieldsValue(initVal);
+        };
+
+        this.setInitialValue = function (fieldName, value) {
+          if (!fieldName) {
+            return;
+          }
+
+          _this._initialValues[fieldName] = value;
+
+          _this.setFieldValue(fieldName, value);
+        };
+
+        this.getInitialValue = function (fieldName) {
+          return _this._initialValues[fieldName];
+        };
+
+        this.resetFields = function () {
+          var oldValues = __assign$3({}, _this._formData);
+
+          var initialValues = {};
+          Object.keys(_this._formData).forEach(function (fieldName) {
+            var _a;
+
+            var fieldObj = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[fieldName]) || null;
+
+            if (fieldObj) {
+              initialValues[fieldName] = fieldObj.getInitialValue();
+            }
+          });
+          var onValuesChange = _this._callbacks.onValuesChange;
+          onValuesChange && onValuesChange(initialValues, _this._formData);
+          _this._formData = initialValues;
+
+          _this.notifyField(initialValues, oldValues, ValueChangeType.Reset);
+        };
+
+        this.validateFields = function () {
+          var promiseList = [];
+          Object.values(_this._fieldsList).forEach(function (entity) {
+            var promise = entity.validateField();
+            promiseList.push(promise.then(function (errors) {
+              return errors;
+            }));
+          });
+          var summaryPromise = new es6Promise.Promise(function (resolve, reject) {
+            es6Promise.Promise.all(promiseList).then(function (res) {
               var errorResults = res.filter(function (item) {
                 var _a;
 
@@ -17990,7 +20665,7 @@
         this.submit = function () {
           _this.validateFields().then(function (result) {
             var onSubmit = _this._callbacks.onSubmit;
-            onSubmit === null || onSubmit === void 0 ? void 0 : onSubmit(_this._formData, result);
+            onSubmit === null || onSubmit === void 0 ? void 0 : onSubmit(_this.getFieldsValue(), result);
           }).catch(function (e) {
             var onSubmitFailed = _this._callbacks.onSubmitFailed;
 
@@ -17998,7 +20673,7 @@
               return;
             }
 
-            onSubmitFailed(_this._formData, e);
+            onSubmitFailed(_this.getFieldsValue(), e);
           });
         };
 
@@ -18027,7 +20702,11 @@
           return {
             registerField: _this.registerField,
             setInitialValues: _this.setInitialValues,
-            setCallbacks: _this.setCallbacks
+            setCallbacks: _this.setCallbacks,
+            getInitialValue: _this.getInitialValue,
+            setInitialValue: _this.setInitialValue,
+            innerSetFieldsValue: _this.innerSetFieldsValue,
+            innerSetFieldValue: _this.innerSetFieldValue
           };
         };
       }
@@ -18058,74 +20737,6 @@
       layout: 'horizontal'
     });
 
-    // 注意：自动识别form关联组件的依据，请勿轻易改变代码结构
-    // Notice: Automatically identify the basis of the associated component of the form, DO NOT change the code structure.
-    var FormInternalComponentType;
-
-    (function (FormInternalComponentType) {
-      FormInternalComponentType["Input"] = "Input";
-      FormInternalComponentType["Textarea"] = "Textarea";
-      FormInternalComponentType["Checkbox"] = "Checkbox";
-      FormInternalComponentType["CheckboxGroup"] = "CheckboxGroup";
-      FormInternalComponentType["DatePicker"] = "DatePicker";
-      FormInternalComponentType["Picker"] = "Picker";
-      FormInternalComponentType["Radio"] = "Radio";
-      FormInternalComponentType["RadioGroup"] = "RadioGroup";
-      FormInternalComponentType["Slider"] = "Slider";
-      FormInternalComponentType["Switch"] = "Switch";
-      FormInternalComponentType["ImagePicker"] = "ImagePicker";
-      FormInternalComponentType["Rate"] = "Rate";
-      FormInternalComponentType["Stepper"] = "Stepper";
-    })(FormInternalComponentType || (FormInternalComponentType = {}));
-
-    var ValidateStatus;
-
-    (function (ValidateStatus) {
-      ValidateStatus["Init"] = "init";
-      ValidateStatus["Error"] = "error";
-      ValidateStatus["Warning"] = "warning";
-      ValidateStatus["Validating"] = "validating";
-      ValidateStatus["Success"] = "success";
-    })(ValidateStatus || (ValidateStatus = {}));
-
-    var isFieldRequired = function isFieldRequired(rules) {
-      if (rules === void 0) {
-        rules = [];
-      }
-
-      return (rules || []).some(function (rule) {
-        return rule === null || rule === void 0 ? void 0 : rule.required;
-      });
-    };
-    var getErrorAndWarnings = function getErrorAndWarnings(result) {
-      var errors = [];
-      var warnings = [];
-      var errorTypes = [];
-      result.map(function (_a) {
-        var _b = _a.message,
-            message = _b === void 0 ? [] : _b,
-            _c = _a.validateLevel,
-            validateLevel = _c === void 0 ? 'error' : _c,
-            resultErrorTypes = _a.errorTypes;
-
-        if (!(message === null || message === void 0 ? void 0 : message.length)) {
-          return;
-        }
-
-        if (validateLevel === 'warning') {
-          warnings = __spreadArrays$1(warnings, message);
-        } else {
-          errors = __spreadArrays$1(errors, message);
-          errorTypes = __spreadArrays$1(errorTypes, resultErrorTypes);
-        }
-      });
-      return {
-        warnings: warnings,
-        errors: errors,
-        errorTypes: errorTypes
-      };
-    };
-
     function DefaultPickerLinkedContainer(_a) {
       var value = _a.value;
 
@@ -18150,6 +20761,10 @@
 
       var className = prefixCls + "-form-picker-link-container";
       var dateTimeStr = React.useMemo(function () {
+        if (ts === undefined) {
+          return '';
+        }
+
         if (typeof ts === 'number') {
           return formatDateTimeStr(ts, types);
         }
@@ -18186,14 +20801,12 @@
       __extends$1(FormItemInner, _super);
 
       function FormItemInner(props, context) {
-        var _a;
-
         var _this = _super.call(this, props) || this;
 
         _this._errors = [];
         _this._touched = false;
 
-        _this.onValueChange = function (curValue, preValue) {
+        _this.onValueChange = function (curValue, preValue, info) {
           _this._touched = true;
           var shouldUpdate = _this.props.shouldUpdate;
 
@@ -18205,9 +20818,33 @@
             return;
           }
 
+          if ((info === null || info === void 0 ? void 0 : info.changeType) === ValueChangeType.Reset) {
+            _this.props.onValidateStatusChange({
+              errors: [],
+              warnings: [],
+              errorTypes: []
+            });
+
+            _this._errors = [];
+          }
+
           _this.forceUpdate();
         };
 
+        _this.getInitialValue = function () {
+          var _a, _b;
+
+          var _c = _this.props,
+              children = _c.children,
+              displayType = _c.displayType;
+
+          var getInitialValue = _this.context.form.getInternalHooks().getInitialValue;
+
+          var childrenType = displayType || ((_a = children.type) === null || _a === void 0 ? void 0 : _a.displayName); // get user-defined initialValue or if not defined
+
+          return (_b = getInitialValue(_this.props.field)) !== null && _b !== void 0 ? _b : getDefaultValueForInterComponent(childrenType);
+        };
+
         _this.getFieldError = function () {
           return _this._errors;
         };
@@ -18216,7 +20853,17 @@
           return _this._touched;
         };
 
-        _this.validateField = function () {
+        _this.getAllRuleValidateTriggers = function () {
+          var _a;
+
+          return ((_a = _this.props.rules) === null || _a === void 0 ? void 0 : _a.map(function (rule) {
+            return rule.validateTrigger;
+          }).flat().filter(function (v) {
+            return !!v;
+          })) || [];
+        };
+
+        _this.validateField = function (validateTrigger) {
           var _a;
 
           var validateMessages = _this.context.validateMessages;
@@ -18225,12 +20872,18 @@
               field = _b.field,
               rules = _b.rules,
               onValidateStatusChange = _b.onValidateStatusChange;
-          var value = getFieldValue(field);
+          var value = getFieldValue(field); // rules: if validateTrigger is not defined, all rules will be validated
+          // if validateTrigger is defined, only rules  with validateTrigger  or  without rule.validateTrigger  will be validated
+
+          var curRules = validateTrigger ? rules === null || rules === void 0 ? void 0 : rules.filter(function (rule) {
+            var triggerList = [].concat(rule.validateTrigger || validateTrigger);
+            return triggerList.includes(validateTrigger);
+          }) : rules;
 
-          if ((rules === null || rules === void 0 ? void 0 : rules.length) && field) {
+          if ((curRules === null || curRules === void 0 ? void 0 : curRules.length) && field) {
             var fieldDom_1 = _this.props.getFormItemRef();
 
-            var fieldValidator_1 = new Validator((_a = {}, _a[field] = rules, _a), {
+            var fieldValidator_1 = new Validator((_a = {}, _a[field] = curRules, _a), {
               validateMessages: validateMessages
             });
             return new es6Promise.Promise(function (resolve) {
@@ -18269,20 +20922,25 @@
         };
 
         _this.setFieldData = function (value) {
-          var field = _this.props.field;
-          var setFieldValue = _this.context.form.setFieldValue;
-          setFieldValue(field, value);
+          var _a = _this.props,
+              field = _a.field,
+              _b = _a.trigger,
+              trigger = _b === void 0 ? 'onChange' : _b;
+
+          var innerSetFieldValue = _this.context.form.getInternalHooks().innerSetFieldValue;
+
+          innerSetFieldValue(field, value);
 
-          _this.validateField();
+          _this.validateField(trigger);
         };
 
-        _this.innerTriggerFunction = function (_, value) {
+        _this.innerTriggerFunctionWithValueFirst = function (value) {
           var _a, _b;
 
           var args = [];
 
-          for (var _i = 2; _i < arguments.length; _i++) {
-            args[_i - 2] = arguments[_i];
+          for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
           }
 
           _this.setFieldData(value);
@@ -18293,29 +20951,23 @@
               trigger = _d === void 0 ? 'onChange' : _d;
 
           if (trigger && ((_a = children.props) === null || _a === void 0 ? void 0 : _a[trigger])) {
-            (_b = children.props) === null || _b === void 0 ? void 0 : _b[trigger].apply(_b, __spreadArrays$1([_, value], args));
+            (_b = children.props) === null || _b === void 0 ? void 0 : _b[trigger].apply(_b, __spreadArrays$1([value], args));
           }
         };
 
-        _this.innerTriggerFunctionWithValueFirst = function (value) {
+        _this.innerOnInputFunction = function (_, value) {
           var _a, _b;
 
           var args = [];
 
-          for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
+          for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
           }
 
           _this.setFieldData(value);
 
-          var _c = _this.props,
-              children = _c.children,
-              _d = _c.trigger,
-              trigger = _d === void 0 ? 'onChange' : _d;
-
-          if (trigger && ((_a = children.props) === null || _a === void 0 ? void 0 : _a[trigger])) {
-            (_b = children.props) === null || _b === void 0 ? void 0 : _b[trigger].apply(_b, __spreadArrays$1([value], args));
-          }
+          var children = _this.props.children;
+          (_b = (_a = children.props) === null || _a === void 0 ? void 0 : _a.onInput) === null || _b === void 0 ? void 0 : _b.call.apply(_b, __spreadArrays$1([_a, _, value], args));
         };
 
         _this.innerClearFunction = function () {
@@ -18339,8 +20991,8 @@
         _this.destroyField = function () {};
 
         if ((props === null || props === void 0 ? void 0 : props.initialValue) && props.field) {
-          var setInitialValues = context.form.getInternalHooks().setInitialValues;
-          setInitialValues((_a = {}, _a[props.field] = props.initialValue, _a));
+          var setInitialValue = context.form.getInternalHooks().setInitialValue;
+          setInitialValue(props.field, props.initialValue);
         }
 
         return _this;
@@ -18356,110 +21008,89 @@
       };
 
       FormItemInner.prototype.renderChildren = function () {
-        var _a;
-
         var _this = this;
 
-        var _b, _c, _d;
+        var _a, _b, _c;
 
-        var _e = this.props,
-            children = _e.children,
-            field = _e.field,
-            _f = _e.trigger,
-            trigger = _f === void 0 ? 'onChange' : _f,
-            _g = _e.triggerPropsField,
-            triggerPropsField = _g === void 0 ? 'value' : _g,
-            displayType = _e.displayType;
+        var _d = this.props,
+            children = _d.children,
+            field = _d.field,
+            _e = _d.trigger,
+            trigger = _e === void 0 ? 'onChange' : _e,
+            _f = _d.triggerPropsField,
+            triggerPropsField = _f === void 0 ? 'value' : _f,
+            displayType = _d.displayType,
+            disabled = _d.disabled;
         var getFieldValue = this.context.form.getFieldValue;
-        var props = (_a = {}, _a[triggerPropsField] = getFieldValue(field), _a.disabled = this.props.disabled, _a);
-        var childrenType = displayType || ((_b = children.type) === null || _b === void 0 ? void 0 : _b.displayName);
+        var childrenProps = {
+          disabled: disabled
+        }; // inject validateTriggers of rules
+
+        this.getAllRuleValidateTriggers().forEach(function (triggerName) {
+          childrenProps[triggerName] = function (e) {
+            var _a, _b;
+
+            _this.validateField(triggerName);
+
+            (_b = (_a = children === null || children === void 0 ? void 0 : children.props) === null || _a === void 0 ? void 0 : _a[triggerName]) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+          };
+        });
+        var childrenType = displayType || ((_a = children.type) === null || _a === void 0 ? void 0 : _a.displayName);
 
         switch (childrenType) {
           case FormInternalComponentType.Input:
           case FormInternalComponentType.Textarea:
-            props = {
-              value: getFieldValue(field) || '',
-              onInput: this.innerTriggerFunction,
-              onClear: this.innerClearFunction,
-              disabled: this.props.disabled
-            };
-            break;
-
-          case FormInternalComponentType.Checkbox:
-          case FormInternalComponentType.Radio:
-          case FormInternalComponentType.Slider:
-          case FormInternalComponentType.RadioGroup:
-          case FormInternalComponentType.CheckboxGroup:
-            props = {
-              value: getFieldValue(field),
-              onChange: this.innerTriggerFunctionWithValueFirst,
-              disabled: this.props.disabled
-            };
+            childrenProps.value = getFieldValue(field) || '';
+            childrenProps.onInput = this.innerOnInputFunction;
+            childrenProps.onClear = this.innerClearFunction;
             break;
 
           case FormInternalComponentType.DatePicker:
-            props = {
-              currentTs: getFieldValue(field),
-              onChange: this.innerTriggerFunctionWithValueFirst,
-              disabled: this.props.disabled,
-              renderLinkedContainer: ((_c = children.props) === null || _c === void 0 ? void 0 : _c.renderLinkedContainer) || function (ts, types) {
-                return /*#__PURE__*/React__default["default"].createElement(DefaultDatePickerLinkedContainer, {
-                  ts: ts,
-                  types: types
-                });
-              }
+            childrenProps.currentTs = getFieldValue(field);
+            childrenProps.onChange = this.innerTriggerFunctionWithValueFirst;
+
+            childrenProps.renderLinkedContainer = ((_b = children.props) === null || _b === void 0 ? void 0 : _b.renderLinkedContainer) || function (ts, types) {
+              return /*#__PURE__*/React__default["default"].createElement(DefaultDatePickerLinkedContainer, {
+                ts: ts,
+                types: types
+              });
             };
+
             break;
 
           case FormInternalComponentType.Picker:
-            props = {
-              value: getFieldValue(field),
-              onChange: this.innerTriggerFunctionWithValueFirst,
-              disabled: this.props.disabled,
-              renderLinkedContainer: ((_d = children.props) === null || _d === void 0 ? void 0 : _d.renderLinkedContainer) || function (val) {
-                return /*#__PURE__*/React__default["default"].createElement(DefaultPickerLinkedContainer, {
-                  value: val
-                });
-              }
+            childrenProps.value = getFieldValue(field) || '';
+            childrenProps.onChange = this.innerTriggerFunctionWithValueFirst;
+
+            childrenProps.renderLinkedContainer = ((_c = children.props) === null || _c === void 0 ? void 0 : _c.renderLinkedContainer) || function (val) {
+              return /*#__PURE__*/React__default["default"].createElement(DefaultPickerLinkedContainer, {
+                value: val
+              });
             };
+
             break;
 
           case FormInternalComponentType.Switch:
-            props = {
-              checked: Boolean(getFieldValue(field)),
-              onChange: this.innerTriggerFunctionWithValueFirst,
-              disabled: this.props.disabled
-            };
+            childrenProps.checked = Boolean(getFieldValue(field));
+            childrenProps.onChange = this.innerTriggerFunctionWithValueFirst;
             break;
 
           case FormInternalComponentType.ImagePicker:
-            props = {
-              images: getFieldValue(field),
-              onChange: this.innerTriggerFunctionWithValueFirst,
-              disabled: this.props.disabled
-            };
+            childrenProps.images = getFieldValue(field);
+            childrenProps.onChange = this.innerTriggerFunctionWithValueFirst;
             break;
 
           default:
-            var originTrigger_1 = children.props[trigger]; // inject the validated result
-
-            props.error = this._errors;
-
-            props[trigger] = function (newValue) {
-              var args = [];
+            if (triggerPropsField) {
+              childrenProps[triggerPropsField] = getFieldValue(field);
+            } // inject the validated result
 
-              for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-              }
-
-              _this.setFieldData(newValue);
-
-              originTrigger_1 && originTrigger_1.apply(void 0, __spreadArrays$1([newValue], args));
-            };
 
+            childrenProps.error = this._errors;
+            childrenProps[trigger] = this.innerTriggerFunctionWithValueFirst;
         }
 
-        return /*#__PURE__*/React__default["default"].cloneElement(children, props);
+        return /*#__PURE__*/React__default["default"].cloneElement(children, childrenProps);
       };
 
       FormItemInner.prototype.render = function () {
@@ -18570,6 +21201,7 @@
           formInstance = props.form,
           children = props.children,
           onValuesChange = props.onValuesChange,
+          onChange = props.onChange,
           onSubmit = props.onSubmit,
           onSubmitFailed = props.onSubmitFailed,
           disabled = props.disabled;
@@ -18584,7 +21216,8 @@
       setCallbacks({
         onValuesChange: onValuesChange,
         onSubmit: onSubmit,
-        onSubmitFailed: onSubmitFailed
+        onSubmitFailed: onSubmitFailed,
+        onChange: onChange
       });
 
       if (!initRef.current) {
@@ -23115,7 +25748,7 @@
       function renderInput(_a) {
         var prefixCls = _a.prefixCls;
         var prefix = prefixCls + "-input";
-        return renderWrapper(prefix, type, /*#__PURE__*/React__default["default"].createElement("input", __assign$3({}, nativeProps, {
+        return renderWrapper(prefix, type + " single-line", /*#__PURE__*/React__default["default"].createElement("input", __assign$3({}, nativeProps, {
           id: id,
           name: name,
           maxLength: maxLength,
@@ -24734,10 +27367,10 @@
           setDirectionState = _k[2];
 
       var getOffset = React.useCallback(function (dir) {
-        return getDefaultValue(isObject$2(edgeOffset) ? edgeOffset[dir] : edgeOffset, defaultEdgeOffset[dir]);
+        return getDefaultValue(isObject$3(edgeOffset) ? edgeOffset[dir] : edgeOffset, defaultEdgeOffset[dir]);
       }, [edgeOffset]);
       var getAutoDirection = React.useCallback(function (dir) {
-        return getDefaultValue(isObject$2(useAutoDirection) ? useAutoDirection[dir] : useAutoDirection, defaultAutoDirection);
+        return getDefaultValue(isObject$3(useAutoDirection) ? useAutoDirection[dir] : useAutoDirection, defaultAutoDirection);
       }, [useAutoDirection]);
       React.useEffect(function () {
         setDirectionState(direction);
@@ -24851,20 +27484,38 @@
 
 
         if (verticalAuto) {
-          var popoverTop = childRect.bottom - (newConfig.bottom && newConfig.height ? newConfig.bottom + newConfig.height : 0);
-          var popoverBottom = childRect.top + (newConfig.top && newConfig.height ? newConfig.top + newConfig.height : 0); // 顶部安全距离不够，调整到底部
-          // @en The top safety distance is not enough, adjust to the bottom
-
-          if (directionState.indexOf('top') !== -1 && popoverTop < topOffset) {
+          var setToBottom = function setToBottom() {
             newConfig.top = verticalOffset + childRect.height;
             newConfig.bottom = null;
             onAdjustDirection('bottom');
-          } else if (directionState.indexOf('bottom') !== -1 && popoverBottom + bottomOffset > window.innerHeight) {
-            // 底部安全距离不够，调整到顶部
-            // @en The bottom safety distance is not enough, adjust to the top
+          };
+
+          var setToTop = function setToTop() {
             newConfig.top = null;
             newConfig.bottom = verticalOffset + childRect.height;
             onAdjustDirection('top');
+          }; // 判断上下空间是否都不足以展示气泡内容
+          // @en Determine whether there is insufficient space both above and below to display content
+
+
+          var isPopoverTooTall = window.innerHeight - topOffset - bottomOffset < 2 * (newConfig.height || 0) + 2 * verticalOffset + childRect.height;
+
+          if (isPopoverTooTall) {
+            var spaceAbove = childRect.top;
+            var spaceBelow = window.innerHeight - childRect.bottom;
+            spaceAbove > spaceBelow ? setToTop() : setToBottom();
+          } else {
+            var popoverTop = childRect.bottom - (newConfig.bottom && newConfig.height ? newConfig.bottom + newConfig.height : 0);
+            var popoverBottom = childRect.top + (newConfig.top && newConfig.height ? newConfig.top + newConfig.height : 0); // 顶部安全距离不够，调整到底部
+            // @en The top safety distance is not enough, adjust to the bottom
+
+            if (directionState.indexOf('top') !== -1 && popoverTop < topOffset) {
+              setToBottom();
+            } else if ( // 底部安全距离不够，调整到顶部
+            // @en The bottom safety distance is not enough, adjust to the top
+            directionState.indexOf('bottom') !== -1 && popoverBottom + bottomOffset > window.innerHeight) {
+              setToTop();
+            }
           }
         } // 挂载在全局的气泡需要计算相对屏幕的位置
         // @en Bubble mounted in the global needs to calculate the position relative to the screen
@@ -25179,7 +27830,7 @@
       var closeTimer = React.useRef(0);
       /** 垂直方向自适应 */
 
-      var autoVerticalDirection = getDefaultValue(isObject$2(useAutoDirection) ? useAutoDirection.vertical : useAutoDirection, defaultAutoDirection);
+      var autoVerticalDirection = getDefaultValue(isObject$3(useAutoDirection) ? useAutoDirection.vertical : useAutoDirection, defaultAutoDirection);
 
       var popoverDisappear = function popoverDisappear() {
         onVisibleChange(false);
@@ -26645,7 +29296,7 @@
               layout: layout,
               disabled: disabled,
               icons: icons,
-              value: groupValue === void 0 ? [] : [groupValue],
+              value: groupValue === void 0 || groupValue === null ? [] : [groupValue],
               onChange: handleChange
             }
           }, children, !children && options && options.map(function (option) {
@@ -27907,7 +30558,7 @@
       });
 
       var getWidth = function getWidth(idx) {
-        if (isArray$1(width)) {
+        if (isArray$2(width)) {
           return width[idx];
         }