@bpmn-io/form-js-playground 1.6.1 → 1.6.2

package/dist/form-playground.umd.js

@@ -1110,16 +1110,16 @@
   function isNil$1(obj) {
     return obj == null;
   }
-  function isArray$4(obj) {
+  function isArray$8(obj) {
     return nativeToString$1.call(obj) === '[object Array]';
   }
-  function isObject$1(obj) {
+  function isObject$4(obj) {
     return nativeToString$1.call(obj) === '[object Object]';
   }
   function isNumber$4(obj) {
     return nativeToString$1.call(obj) === '[object Number]';
   }
-  function isFunction$1(obj) {
+  function isFunction$4(obj) {
     const tag = nativeToString$1.call(obj);
     return tag === '[object Function]' || tag === '[object AsyncFunction]' || tag === '[object GeneratorFunction]' || tag === '[object AsyncGeneratorFunction]' || tag === '[object Proxy]';
   }
@@ -1169,7 +1169,7 @@
    */
   function findIndex$1(collection, matcher) {
     matcher = toMatcher$1(matcher);
-    let idx = isArray$4(collection) ? -1 : undefined;
+    let idx = isArray$8(collection) ? -1 : undefined;
     forEach$1(collection, function (val, key) {
       if (matcher(val, key)) {
         idx = key;
@@ -1193,7 +1193,7 @@
     if (isUndefined$2(collection)) {
       return;
     }
-    const convertKey = isArray$4(collection) ? toNum$1 : identity$1;
+    const convertKey = isArray$8(collection) ? toNum$1 : identity$1;
     for (let key in collection) {
       if (has$1(collection, key)) {
         val = collection[key];
@@ -1276,12 +1276,12 @@
     return result;
   }
   function toExtractor$1(extractor) {
-    return isFunction$1(extractor) ? extractor : e => {
+    return isFunction$4(extractor) ? extractor : e => {
       return e[extractor];
     };
   }
   function toMatcher$1(matcher) {
-    return isFunction$1(matcher) ? matcher : e => {
+    return isFunction$4(matcher) ? matcher : e => {
       return e === matcher;
     };
   }
@@ -2332,6 +2332,2265 @@
     return l$3.vnode && l$3.vnode(a), a;
   }
 
+  /**
+   * Removes all key-value entries from the list cache.
+   *
+   * @private
+   * @name clear
+   * @memberOf ListCache
+   */
+
+  function listCacheClear$1() {
+    this.__data__ = [];
+    this.size = 0;
+  }
+  var _listCacheClear = listCacheClear$1;
+
+  /**
+   * 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$2(value, other) {
+    return value === other || value !== value && other !== other;
+  }
+  var eq_1 = eq$2;
+
+  var eq$1 = eq_1;
+
+  /**
+   * 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$4(array, key) {
+    var length = array.length;
+    while (length--) {
+      if (eq$1(array[length][0], key)) {
+        return length;
+      }
+    }
+    return -1;
+  }
+  var _assocIndexOf = assocIndexOf$4;
+
+  var assocIndexOf$3 = _assocIndexOf;
+
+  /** Used for built-in method references. */
+  var arrayProto = Array.prototype;
+
+  /** Built-in value references. */
+  var splice = arrayProto.splice;
+
+  /**
+   * 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$1(key) {
+    var data = this.__data__,
+      index = assocIndexOf$3(data, key);
+    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;
+  }
+  var _listCacheDelete = listCacheDelete$1;
+
+  var assocIndexOf$2 = _assocIndexOf;
+
+  /**
+   * 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$1(key) {
+    var data = this.__data__,
+      index = assocIndexOf$2(data, key);
+    return index < 0 ? undefined : data[index][1];
+  }
+  var _listCacheGet = listCacheGet$1;
+
+  var assocIndexOf$1 = _assocIndexOf;
+
+  /**
+   * 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$1(key) {
+    return assocIndexOf$1(this.__data__, key) > -1;
+  }
+  var _listCacheHas = listCacheHas$1;
+
+  var assocIndexOf = _assocIndexOf;
+
+  /**
+   * 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$1(key, value) {
+    var data = this.__data__,
+      index = assocIndexOf(data, key);
+    if (index < 0) {
+      ++this.size;
+      data.push([key, value]);
+    } else {
+      data[index][1] = value;
+    }
+    return this;
+  }
+  var _listCacheSet = listCacheSet$1;
+
+  var listCacheClear = _listCacheClear,
+    listCacheDelete = _listCacheDelete,
+    listCacheGet = _listCacheGet,
+    listCacheHas = _listCacheHas,
+    listCacheSet = _listCacheSet;
+
+  /**
+   * Creates an list cache object.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function ListCache$4(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 `ListCache`.
+  ListCache$4.prototype.clear = listCacheClear;
+  ListCache$4.prototype['delete'] = listCacheDelete;
+  ListCache$4.prototype.get = listCacheGet;
+  ListCache$4.prototype.has = listCacheHas;
+  ListCache$4.prototype.set = listCacheSet;
+  var _ListCache = ListCache$4;
+
+  var ListCache$3 = _ListCache;
+
+  /**
+   * Removes all key-value entries from the stack.
+   *
+   * @private
+   * @name clear
+   * @memberOf Stack
+   */
+  function stackClear$1() {
+    this.__data__ = new ListCache$3();
+    this.size = 0;
+  }
+  var _stackClear = stackClear$1;
+
+  /**
+   * 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$1(key) {
+    var data = this.__data__,
+      result = data['delete'](key);
+    this.size = data.size;
+    return result;
+  }
+  var _stackDelete = stackDelete$1;
+
+  /**
+   * 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$1(key) {
+    return this.__data__.get(key);
+  }
+  var _stackGet = stackGet$1;
+
+  /**
+   * 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$1(key) {
+    return this.__data__.has(key);
+  }
+  var _stackHas = stackHas$1;
+
+  /** Detect free variable `global` from Node.js. */
+
+  var freeGlobal$1 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+  var _freeGlobal = freeGlobal$1;
+
+  var freeGlobal = _freeGlobal;
+
+  /** Detect free variable `self`. */
+  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+  /** Used as a reference to the global object. */
+  var root$8 = freeGlobal || freeSelf || Function('return this')();
+  var _root = root$8;
+
+  var root$7 = _root;
+
+  /** Built-in value references. */
+  var Symbol$4 = root$7.Symbol;
+  var _Symbol = Symbol$4;
+
+  var Symbol$3 = _Symbol;
+
+  /** Used for built-in method references. */
+  var objectProto$b = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$9 = objectProto$b.hasOwnProperty;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var nativeObjectToString$1 = objectProto$b.toString;
+
+  /** Built-in value references. */
+  var symToStringTag$1 = Symbol$3 ? Symbol$3.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$1(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$1;
+
+  /** Used for built-in method references. */
+
+  var objectProto$a = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var nativeObjectToString = objectProto$a.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$1(value) {
+    return nativeObjectToString.call(value);
+  }
+  var _objectToString = objectToString$1;
+
+  var Symbol$2 = _Symbol,
+    getRawTag = _getRawTag,
+    objectToString = _objectToString;
+
+  /** `Object#toString` result references. */
+  var nullTag = '[object Null]',
+    undefinedTag = '[object Undefined]';
+
+  /** Built-in value references. */
+  var symToStringTag = Symbol$2 ? Symbol$2.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$4(value) {
+    if (value == null) {
+      return value === undefined ? undefinedTag : nullTag;
+    }
+    return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+  }
+  var _baseGetTag = baseGetTag$4;
+
+  /**
+   * 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$3(value) {
+    var type = typeof value;
+    return value != null && (type == 'object' || type == 'function');
+  }
+  var isObject_1 = isObject$3;
+
+  var baseGetTag$3 = _baseGetTag,
+    isObject$2 = isObject_1;
+
+  /** `Object#toString` result references. */
+  var asyncTag = '[object AsyncFunction]',
+    funcTag$1 = '[object Function]',
+    genTag = '[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$3(value) {
+    if (!isObject$2(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$3(value);
+    return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
+  }
+  var isFunction_1 = isFunction$3;
+
+  var root$6 = _root;
+
+  /** Used to detect overreaching core-js shims. */
+  var coreJsData$1 = root$6['__core-js_shared__'];
+  var _coreJsData = coreJsData$1;
+
+  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$1(func) {
+    return !!maskSrcKey && maskSrcKey in func;
+  }
+  var _isMasked = isMasked$1;
+
+  /** 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$2(func) {
+    if (func != null) {
+      try {
+        return funcToString$1.call(func);
+      } catch (e) {}
+      try {
+        return func + '';
+      } catch (e) {}
+    }
+    return '';
+  }
+  var _toSource = toSource$2;
+
+  var isFunction$2 = isFunction_1,
+    isMasked = _isMasked,
+    isObject$1 = isObject_1,
+    toSource$1 = _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$9 = 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$9.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$1(value) {
+    if (!isObject$1(value) || isMasked(value)) {
+      return false;
+    }
+    var pattern = isFunction$2(value) ? reIsNative : reIsHostCtor;
+    return pattern.test(toSource$1(value));
+  }
+  var _baseIsNative = baseIsNative$1;
+
+  /**
+   * 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$1(object, key) {
+    return object == null ? undefined : object[key];
+  }
+  var _getValue = getValue$1;
+
+  var baseIsNative = _baseIsNative,
+    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$6(object, key) {
+    var value = getValue(object, key);
+    return baseIsNative(value) ? value : undefined;
+  }
+  var _getNative = getNative$6;
+
+  var getNative$5 = _getNative,
+    root$5 = _root;
+
+  /* Built-in method references that are verified to be native. */
+  var Map$4 = getNative$5(root$5, 'Map');
+  var _Map = Map$4;
+
+  var getNative$4 = _getNative;
+
+  /* Built-in method references that are verified to be native. */
+  var nativeCreate$4 = getNative$4(Object, 'create');
+  var _nativeCreate = nativeCreate$4;
+
+  var nativeCreate$3 = _nativeCreate;
+
+  /**
+   * Removes all key-value entries from the hash.
+   *
+   * @private
+   * @name clear
+   * @memberOf Hash
+   */
+  function hashClear$1() {
+    this.__data__ = nativeCreate$3 ? nativeCreate$3(null) : {};
+    this.size = 0;
+  }
+  var _hashClear = hashClear$1;
+
+  /**
+   * 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$1(key) {
+    var result = this.has(key) && delete this.__data__[key];
+    this.size -= result ? 1 : 0;
+    return result;
+  }
+  var _hashDelete = hashDelete$1;
+
+  var nativeCreate$2 = _nativeCreate;
+
+  /** Used to stand-in for `undefined` hash values. */
+  var HASH_UNDEFINED$2 = '__lodash_hash_undefined__';
+
+  /** Used for built-in method references. */
+  var objectProto$8 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$7 = objectProto$8.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$1(key) {
+    var data = this.__data__;
+    if (nativeCreate$2) {
+      var result = data[key];
+      return result === HASH_UNDEFINED$2 ? undefined : result;
+    }
+    return hasOwnProperty$7.call(data, key) ? data[key] : undefined;
+  }
+  var _hashGet = hashGet$1;
+
+  var nativeCreate$1 = _nativeCreate;
+
+  /** Used for built-in method references. */
+  var objectProto$7 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$6 = objectProto$7.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$1(key) {
+    var data = this.__data__;
+    return nativeCreate$1 ? data[key] !== undefined : hasOwnProperty$6.call(data, key);
+  }
+  var _hashHas = hashHas$1;
+
+  var nativeCreate = _nativeCreate;
+
+  /** Used to stand-in for `undefined` hash values. */
+  var HASH_UNDEFINED$1 = '__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$1(key, value) {
+    var data = this.__data__;
+    this.size += this.has(key) ? 0 : 1;
+    data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED$1 : value;
+    return this;
+  }
+  var _hashSet = hashSet$1;
+
+  var hashClear = _hashClear,
+    hashDelete = _hashDelete,
+    hashGet = _hashGet,
+    hashHas = _hashHas,
+    hashSet = _hashSet;
+
+  /**
+   * Creates a hash object.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function Hash$1(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$1.prototype.clear = hashClear;
+  Hash$1.prototype['delete'] = hashDelete;
+  Hash$1.prototype.get = hashGet;
+  Hash$1.prototype.has = hashHas;
+  Hash$1.prototype.set = hashSet;
+  var _Hash = Hash$1;
+
+  var Hash = _Hash,
+    ListCache$2 = _ListCache,
+    Map$3 = _Map;
+
+  /**
+   * Removes all key-value entries from the map.
+   *
+   * @private
+   * @name clear
+   * @memberOf MapCache
+   */
+  function mapCacheClear$1() {
+    this.size = 0;
+    this.__data__ = {
+      'hash': new Hash(),
+      'map': new (Map$3 || ListCache$2)(),
+      'string': new Hash()
+    };
+  }
+  var _mapCacheClear = mapCacheClear$1;
+
+  /**
+   * 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$1(value) {
+    var type = typeof value;
+    return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null;
+  }
+  var _isKeyable = isKeyable$1;
+
+  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$4(map, key) {
+    var data = map.__data__;
+    return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
+  }
+  var _getMapData = getMapData$4;
+
+  var getMapData$3 = _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$1(key) {
+    var result = getMapData$3(this, key)['delete'](key);
+    this.size -= result ? 1 : 0;
+    return result;
+  }
+  var _mapCacheDelete = mapCacheDelete$1;
+
+  var getMapData$2 = _getMapData;
+
+  /**
+   * 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$1(key) {
+    return getMapData$2(this, key).get(key);
+  }
+  var _mapCacheGet = mapCacheGet$1;
+
+  var getMapData$1 = _getMapData;
+
+  /**
+   * 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$1(key) {
+    return getMapData$1(this, key).has(key);
+  }
+  var _mapCacheHas = mapCacheHas$1;
+
+  var getMapData = _getMapData;
+
+  /**
+   * 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$1(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$1;
+
+  var mapCacheClear = _mapCacheClear,
+    mapCacheDelete = _mapCacheDelete,
+    mapCacheGet = _mapCacheGet,
+    mapCacheHas = _mapCacheHas,
+    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$2(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$2.prototype.clear = mapCacheClear;
+  MapCache$2.prototype['delete'] = mapCacheDelete;
+  MapCache$2.prototype.get = mapCacheGet;
+  MapCache$2.prototype.has = mapCacheHas;
+  MapCache$2.prototype.set = mapCacheSet;
+  var _MapCache = MapCache$2;
+
+  var ListCache$1 = _ListCache,
+    Map$2 = _Map,
+    MapCache$1 = _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$1(key, value) {
+    var data = this.__data__;
+    if (data instanceof ListCache$1) {
+      var pairs = data.__data__;
+      if (!Map$2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+        pairs.push([key, value]);
+        this.size = ++data.size;
+        return this;
+      }
+      data = this.__data__ = new MapCache$1(pairs);
+    }
+    data.set(key, value);
+    this.size = data.size;
+    return this;
+  }
+  var _stackSet = stackSet$1;
+
+  var ListCache = _ListCache,
+    stackClear = _stackClear,
+    stackDelete = _stackDelete,
+    stackGet = _stackGet,
+    stackHas = _stackHas,
+    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$2(entries) {
+    var data = this.__data__ = new ListCache(entries);
+    this.size = data.size;
+  }
+
+  // Add methods to `Stack`.
+  Stack$2.prototype.clear = stackClear;
+  Stack$2.prototype['delete'] = stackDelete;
+  Stack$2.prototype.get = stackGet;
+  Stack$2.prototype.has = stackHas;
+  Stack$2.prototype.set = stackSet;
+  var _Stack = Stack$2;
+
+  /** Used to stand-in for `undefined` hash values. */
+
+  var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+  /**
+   * Adds `value` to the array cache.
+   *
+   * @private
+   * @name add
+   * @memberOf SetCache
+   * @alias push
+   * @param {*} value The value to cache.
+   * @returns {Object} Returns the cache instance.
+   */
+  function setCacheAdd$1(value) {
+    this.__data__.set(value, HASH_UNDEFINED);
+    return this;
+  }
+  var _setCacheAdd = setCacheAdd$1;
+
+  /**
+   * Checks if `value` is in the array cache.
+   *
+   * @private
+   * @name has
+   * @memberOf SetCache
+   * @param {*} value The value to search for.
+   * @returns {number} Returns `true` if `value` is found, else `false`.
+   */
+
+  function setCacheHas$1(value) {
+    return this.__data__.has(value);
+  }
+  var _setCacheHas = setCacheHas$1;
+
+  var MapCache = _MapCache,
+    setCacheAdd = _setCacheAdd,
+    setCacheHas = _setCacheHas;
+
+  /**
+   *
+   * Creates an array cache object to store unique values.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [values] The values to cache.
+   */
+  function SetCache$1(values) {
+    var index = -1,
+      length = values == null ? 0 : values.length;
+    this.__data__ = new MapCache();
+    while (++index < length) {
+      this.add(values[index]);
+    }
+  }
+
+  // Add methods to `SetCache`.
+  SetCache$1.prototype.add = SetCache$1.prototype.push = setCacheAdd;
+  SetCache$1.prototype.has = setCacheHas;
+  var _SetCache = SetCache$1;
+
+  /**
+   * A specialized version of `_.some` 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 {boolean} Returns `true` if any element passes the predicate check,
+   *  else `false`.
+   */
+
+  function arraySome$1(array, predicate) {
+    var index = -1,
+      length = array == null ? 0 : array.length;
+    while (++index < length) {
+      if (predicate(array[index], index, array)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  var _arraySome = arraySome$1;
+
+  /**
+   * Checks if a `cache` value for `key` exists.
+   *
+   * @private
+   * @param {Object} cache The cache to query.
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+   */
+
+  function cacheHas$1(cache, key) {
+    return cache.has(key);
+  }
+  var _cacheHas = cacheHas$1;
+
+  var SetCache = _SetCache,
+    arraySome = _arraySome,
+    cacheHas = _cacheHas;
+
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG$3 = 1,
+    COMPARE_UNORDERED_FLAG$1 = 2;
+
+  /**
+   * A specialized version of `baseIsEqualDeep` for arrays with support for
+   * partial deep comparisons.
+   *
+   * @private
+   * @param {Array} array The array to compare.
+   * @param {Array} other The other array to compare.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+   * @param {Function} customizer The function to customize comparisons.
+   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {Object} stack Tracks traversed `array` and `other` objects.
+   * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+   */
+  function equalArrays$2(array, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3,
+      arrLength = array.length,
+      othLength = other.length;
+    if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+      return false;
+    }
+    // Check that cyclic values are equal.
+    var arrStacked = stack.get(array);
+    var othStacked = stack.get(other);
+    if (arrStacked && othStacked) {
+      return arrStacked == other && othStacked == array;
+    }
+    var index = -1,
+      result = true,
+      seen = bitmask & COMPARE_UNORDERED_FLAG$1 ? new SetCache() : undefined;
+    stack.set(array, other);
+    stack.set(other, array);
+
+    // Ignore non-index properties.
+    while (++index < arrLength) {
+      var arrValue = array[index],
+        othValue = other[index];
+      if (customizer) {
+        var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+      }
+      if (compared !== undefined) {
+        if (compared) {
+          continue;
+        }
+        result = false;
+        break;
+      }
+      // Recursively compare arrays (susceptible to call stack limits).
+      if (seen) {
+        if (!arraySome(other, function (othValue, othIndex) {
+          if (!cacheHas(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+            return seen.push(othIndex);
+          }
+        })) {
+          result = false;
+          break;
+        }
+      } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+        result = false;
+        break;
+      }
+    }
+    stack['delete'](array);
+    stack['delete'](other);
+    return result;
+  }
+  var _equalArrays = equalArrays$2;
+
+  var root$4 = _root;
+
+  /** Built-in value references. */
+  var Uint8Array$2 = root$4.Uint8Array;
+  var _Uint8Array = Uint8Array$2;
+
+  /**
+   * Converts `map` to its key-value pairs.
+   *
+   * @private
+   * @param {Object} map The map to convert.
+   * @returns {Array} Returns the key-value pairs.
+   */
+
+  function mapToArray$1(map) {
+    var index = -1,
+      result = Array(map.size);
+    map.forEach(function (value, key) {
+      result[++index] = [key, value];
+    });
+    return result;
+  }
+  var _mapToArray = mapToArray$1;
+
+  /**
+   * Converts `set` to an array of its values.
+   *
+   * @private
+   * @param {Object} set The set to convert.
+   * @returns {Array} Returns the values.
+   */
+
+  function setToArray$1(set) {
+    var index = -1,
+      result = Array(set.size);
+    set.forEach(function (value) {
+      result[++index] = value;
+    });
+    return result;
+  }
+  var _setToArray = setToArray$1;
+
+  var Symbol$1 = _Symbol,
+    Uint8Array$1 = _Uint8Array,
+    eq = eq_1,
+    equalArrays$1 = _equalArrays,
+    mapToArray = _mapToArray,
+    setToArray = _setToArray;
+
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG$2 = 1,
+    COMPARE_UNORDERED_FLAG = 2;
+
+  /** `Object#toString` result references. */
+  var boolTag$1 = '[object Boolean]',
+    dateTag$1 = '[object Date]',
+    errorTag$1 = '[object Error]',
+    mapTag$2 = '[object Map]',
+    numberTag$1 = '[object Number]',
+    regexpTag$1 = '[object RegExp]',
+    setTag$2 = '[object Set]',
+    stringTag$1 = '[object String]',
+    symbolTag = '[object Symbol]';
+  var arrayBufferTag$1 = '[object ArrayBuffer]',
+    dataViewTag$2 = '[object DataView]';
+
+  /** Used to convert symbols to primitives and strings. */
+  var symbolProto = Symbol$1 ? Symbol$1.prototype : undefined,
+    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+  /**
+   * A specialized version of `baseIsEqualDeep` for comparing objects of
+   * the same `toStringTag`.
+   *
+   * **Note:** This function only supports comparing values with tags of
+   * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+   *
+   * @private
+   * @param {Object} object The object to compare.
+   * @param {Object} other The other object to compare.
+   * @param {string} tag The `toStringTag` of the objects to compare.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+   * @param {Function} customizer The function to customize comparisons.
+   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {Object} stack Tracks traversed `object` and `other` objects.
+   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+   */
+  function equalByTag$1(object, other, tag, bitmask, customizer, equalFunc, stack) {
+    switch (tag) {
+      case dataViewTag$2:
+        if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+          return false;
+        }
+        object = object.buffer;
+        other = other.buffer;
+      case arrayBufferTag$1:
+        if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array$1(object), new Uint8Array$1(other))) {
+          return false;
+        }
+        return true;
+      case boolTag$1:
+      case dateTag$1:
+      case numberTag$1:
+        // Coerce booleans to `1` or `0` and dates to milliseconds.
+        // Invalid dates are coerced to `NaN`.
+        return eq(+object, +other);
+      case errorTag$1:
+        return object.name == other.name && object.message == other.message;
+      case regexpTag$1:
+      case stringTag$1:
+        // Coerce regexes to strings and treat strings, primitives and objects,
+        // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+        // for more details.
+        return object == other + '';
+      case mapTag$2:
+        var convert = mapToArray;
+      case setTag$2:
+        var isPartial = bitmask & COMPARE_PARTIAL_FLAG$2;
+        convert || (convert = setToArray);
+        if (object.size != other.size && !isPartial) {
+          return false;
+        }
+        // Assume cyclic values are equal.
+        var stacked = stack.get(object);
+        if (stacked) {
+          return stacked == other;
+        }
+        bitmask |= COMPARE_UNORDERED_FLAG;
+
+        // Recursively compare objects (susceptible to call stack limits).
+        stack.set(object, other);
+        var result = equalArrays$1(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+        stack['delete'](object);
+        return result;
+      case symbolTag:
+        if (symbolValueOf) {
+          return symbolValueOf.call(object) == symbolValueOf.call(other);
+        }
+    }
+    return false;
+  }
+  var _equalByTag = equalByTag$1;
+
+  /**
+   * 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$1(array, values) {
+    var index = -1,
+      length = values.length,
+      offset = array.length;
+    while (++index < length) {
+      array[offset + index] = values[index];
+    }
+    return array;
+  }
+  var _arrayPush = arrayPush$1;
+
+  /**
+   * 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$7 = Array.isArray;
+  var isArray_1 = isArray$7;
+
+  var arrayPush = _arrayPush,
+    isArray$6 = isArray_1;
+
+  /**
+   * 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$1(object, keysFunc, symbolsFunc) {
+    var result = keysFunc(object);
+    return isArray$6(object) ? result : arrayPush(result, symbolsFunc(object));
+  }
+  var _baseGetAllKeys = baseGetAllKeys$1;
+
+  /**
+   * 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$1(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$1;
+
+  /**
+   * 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$1() {
+    return [];
+  }
+  var stubArray_1 = stubArray$1;
+
+  var arrayFilter = _arrayFilter,
+    stubArray = stubArray_1;
+
+  /** Used for built-in method references. */
+  var objectProto$6 = Object.prototype;
+
+  /** Built-in value references. */
+  var propertyIsEnumerable$1 = objectProto$6.propertyIsEnumerable;
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeGetSymbols = 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$1 = !nativeGetSymbols ? stubArray : function (object) {
+    if (object == null) {
+      return [];
+    }
+    object = Object(object);
+    return arrayFilter(nativeGetSymbols(object), function (symbol) {
+      return propertyIsEnumerable$1.call(object, symbol);
+    });
+  };
+  var _getSymbols = getSymbols$1;
+
+  /**
+   * 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$1(n, iteratee) {
+    var index = -1,
+      result = Array(n);
+    while (++index < n) {
+      result[index] = iteratee(index);
+    }
+    return result;
+  }
+  var _baseTimes = baseTimes$1;
+
+  /**
+   * 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$4(value) {
+    return value != null && typeof value == 'object';
+  }
+  var isObjectLike_1 = isObjectLike$4;
+
+  var baseGetTag$2 = _baseGetTag,
+    isObjectLike$3 = isObjectLike_1;
+
+  /** `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$1(value) {
+    return isObjectLike$3(value) && baseGetTag$2(value) == argsTag$2;
+  }
+  var _baseIsArguments = baseIsArguments$1;
+
+  var baseIsArguments = _baseIsArguments,
+    isObjectLike$2 = isObjectLike_1;
+
+  /** Used for built-in method references. */
+  var objectProto$5 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$5 = objectProto$5.hasOwnProperty;
+
+  /** Built-in value references. */
+  var propertyIsEnumerable = objectProto$5.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$1 = baseIsArguments(function () {
+    return arguments;
+  }()) ? baseIsArguments : function (value) {
+    return isObjectLike$2(value) && hasOwnProperty$5.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
+  };
+  var isArguments_1 = isArguments$1;
+
+  var isBuffer$2 = {exports: {}};
+
+  /**
+   * 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;
+
+  isBuffer$2.exports;
+
+  (function (module, exports) {
+  	var root = _root,
+  	  stubFalse = stubFalse_1;
+
+  	/** 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;
+  	module.exports = isBuffer; 
+  } (isBuffer$2, isBuffer$2.exports));
+
+  var isBufferExports = isBuffer$2.exports;
+
+  /** 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$1(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$1;
+
+  /** 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$2(value) {
+    return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+  }
+  var isLength_1 = isLength$2;
+
+  var baseGetTag$1 = _baseGetTag,
+    isLength$1 = isLength_1,
+    isObjectLike$1 = isObjectLike_1;
+
+  /** `Object#toString` result references. */
+  var argsTag$1 = '[object Arguments]',
+    arrayTag$1 = '[object Array]',
+    boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    funcTag = '[object Function]',
+    mapTag$1 = '[object Map]',
+    numberTag = '[object Number]',
+    objectTag$2 = '[object Object]',
+    regexpTag = '[object RegExp]',
+    setTag$1 = '[object Set]',
+    stringTag = '[object String]',
+    weakMapTag$1 = '[object WeakMap]';
+  var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag$1 = '[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 of typed arrays. */
+  var typedArrayTags = {};
+  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+  typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag$1] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag$1] = typedArrayTags[numberTag] = typedArrayTags[objectTag$2] = typedArrayTags[regexpTag] = typedArrayTags[setTag$1] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag$1] = 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$1(value) {
+    return isObjectLike$1(value) && isLength$1(value.length) && !!typedArrayTags[baseGetTag$1(value)];
+  }
+  var _baseIsTypedArray = baseIsTypedArray$1;
+
+  /**
+   * 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$1(func) {
+    return function (value) {
+      return func(value);
+    };
+  }
+  var _baseUnary = baseUnary$1;
+
+  var _nodeUtil = {exports: {}};
+
+  _nodeUtil.exports;
+
+  (function (module, exports) {
+  	var freeGlobal = _freeGlobal;
+
+  	/** 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; 
+  } (_nodeUtil, _nodeUtil.exports));
+
+  var _nodeUtilExports = _nodeUtil.exports;
+
+  var baseIsTypedArray = _baseIsTypedArray,
+    baseUnary = _baseUnary,
+    nodeUtil = _nodeUtilExports;
+
+  /* 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$2 = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+  var isTypedArray_1 = isTypedArray$2;
+
+  var baseTimes = _baseTimes,
+    isArguments = isArguments_1,
+    isArray$5 = isArray_1,
+    isBuffer$1 = isBufferExports,
+    isIndex = _isIndex,
+    isTypedArray$1 = isTypedArray_1;
+
+  /** Used for built-in method references. */
+  var objectProto$4 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$4 = objectProto$4.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$1(value, inherited) {
+    var isArr = isArray$5(value),
+      isArg = !isArr && isArguments(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$4.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$1;
+
+  /** Used for built-in method references. */
+
+  var objectProto$3 = 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$1(value) {
+    var Ctor = value && value.constructor,
+      proto = typeof Ctor == 'function' && Ctor.prototype || objectProto$3;
+    return value === proto;
+  }
+  var _isPrototype = isPrototype$1;
+
+  /**
+   * 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$1(func, transform) {
+    return function (arg) {
+      return func(transform(arg));
+    };
+  }
+  var _overArg = overArg$1;
+
+  var overArg = _overArg;
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeKeys$1 = overArg(Object.keys, Object);
+  var _nativeKeys = nativeKeys$1;
+
+  var isPrototype = _isPrototype,
+    nativeKeys = _nativeKeys;
+
+  /** Used for built-in method references. */
+  var objectProto$2 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$3 = objectProto$2.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$1(object) {
+    if (!isPrototype(object)) {
+      return nativeKeys(object);
+    }
+    var result = [];
+    for (var key in Object(object)) {
+      if (hasOwnProperty$3.call(object, key) && key != 'constructor') {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+  var _baseKeys = baseKeys$1;
+
+  var isFunction$1 = isFunction_1,
+    isLength = isLength_1;
+
+  /**
+   * 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$1(value) {
+    return value != null && isLength(value.length) && !isFunction$1(value);
+  }
+  var isArrayLike_1 = isArrayLike$1;
+
+  var arrayLikeKeys = _arrayLikeKeys,
+    baseKeys = _baseKeys,
+    isArrayLike = isArrayLike_1;
+
+  /**
+   * 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$2(object) {
+    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+  }
+  var keys_1 = keys$2;
+
+  var baseGetAllKeys = _baseGetAllKeys,
+    getSymbols = _getSymbols,
+    keys$1 = keys_1;
+
+  /**
+   * 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$1(object) {
+    return baseGetAllKeys(object, keys$1, getSymbols);
+  }
+  var _getAllKeys = getAllKeys$1;
+
+  var getAllKeys = _getAllKeys;
+
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG$1 = 1;
+
+  /** Used for built-in method references. */
+  var objectProto$1 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$2 = objectProto$1.hasOwnProperty;
+
+  /**
+   * A specialized version of `baseIsEqualDeep` for objects with support for
+   * partial deep comparisons.
+   *
+   * @private
+   * @param {Object} object The object to compare.
+   * @param {Object} other The other object to compare.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+   * @param {Function} customizer The function to customize comparisons.
+   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {Object} stack Tracks traversed `object` and `other` objects.
+   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+   */
+  function equalObjects$1(object, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG$1,
+      objProps = getAllKeys(object),
+      objLength = objProps.length,
+      othProps = getAllKeys(other),
+      othLength = othProps.length;
+    if (objLength != othLength && !isPartial) {
+      return false;
+    }
+    var index = objLength;
+    while (index--) {
+      var key = objProps[index];
+      if (!(isPartial ? key in other : hasOwnProperty$2.call(other, key))) {
+        return false;
+      }
+    }
+    // Check that cyclic values are equal.
+    var objStacked = stack.get(object);
+    var othStacked = stack.get(other);
+    if (objStacked && othStacked) {
+      return objStacked == other && othStacked == object;
+    }
+    var result = true;
+    stack.set(object, other);
+    stack.set(other, object);
+    var skipCtor = isPartial;
+    while (++index < objLength) {
+      key = objProps[index];
+      var objValue = object[key],
+        othValue = other[key];
+      if (customizer) {
+        var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+      }
+      // Recursively compare objects (susceptible to call stack limits).
+      if (!(compared === undefined ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+        result = false;
+        break;
+      }
+      skipCtor || (skipCtor = key == 'constructor');
+    }
+    if (result && !skipCtor) {
+      var objCtor = object.constructor,
+        othCtor = other.constructor;
+
+      // Non `Object` object instances with different constructors are not equal.
+      if (objCtor != othCtor && 'constructor' in object && 'constructor' in other && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+        result = false;
+      }
+    }
+    stack['delete'](object);
+    stack['delete'](other);
+    return result;
+  }
+  var _equalObjects = equalObjects$1;
+
+  var getNative$3 = _getNative,
+    root$3 = _root;
+
+  /* Built-in method references that are verified to be native. */
+  var DataView$1 = getNative$3(root$3, 'DataView');
+  var _DataView = DataView$1;
+
+  var getNative$2 = _getNative,
+    root$2 = _root;
+
+  /* Built-in method references that are verified to be native. */
+  var Promise$2 = getNative$2(root$2, 'Promise');
+  var _Promise = Promise$2;
+
+  var getNative$1 = _getNative,
+    root$1 = _root;
+
+  /* Built-in method references that are verified to be native. */
+  var Set$2 = getNative$1(root$1, 'Set');
+  var _Set = Set$2;
+
+  var getNative = _getNative,
+    root = _root;
+
+  /* Built-in method references that are verified to be native. */
+  var WeakMap$2 = getNative(root, 'WeakMap');
+  var _WeakMap = WeakMap$2;
+
+  var DataView = _DataView,
+    Map$1 = _Map,
+    Promise$1 = _Promise,
+    Set$1 = _Set,
+    WeakMap$1 = _WeakMap,
+    baseGetTag = _baseGetTag,
+    toSource = _toSource;
+
+  /** `Object#toString` result references. */
+  var mapTag = '[object Map]',
+    objectTag$1 = '[object Object]',
+    promiseTag = '[object Promise]',
+    setTag = '[object Set]',
+    weakMapTag = '[object WeakMap]';
+  var dataViewTag = '[object DataView]';
+
+  /** Used to detect maps, sets, and weakmaps. */
+  var dataViewCtorString = toSource(DataView),
+    mapCtorString = toSource(Map$1),
+    promiseCtorString = toSource(Promise$1),
+    setCtorString = toSource(Set$1),
+    weakMapCtorString = toSource(WeakMap$1);
+
+  /**
+   * Gets the `toStringTag` of `value`.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the `toStringTag`.
+   */
+  var getTag$1 = baseGetTag;
+
+  // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+  if (DataView && getTag$1(new DataView(new ArrayBuffer(1))) != dataViewTag || Map$1 && getTag$1(new Map$1()) != mapTag || Promise$1 && getTag$1(Promise$1.resolve()) != promiseTag || Set$1 && getTag$1(new Set$1()) != setTag || WeakMap$1 && getTag$1(new WeakMap$1()) != weakMapTag) {
+    getTag$1 = 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;
+          case mapCtorString:
+            return mapTag;
+          case promiseCtorString:
+            return promiseTag;
+          case setCtorString:
+            return setTag;
+          case weakMapCtorString:
+            return weakMapTag;
+        }
+      }
+      return result;
+    };
+  }
+  var _getTag = getTag$1;
+
+  var Stack$1 = _Stack,
+    equalArrays = _equalArrays,
+    equalByTag = _equalByTag,
+    equalObjects = _equalObjects,
+    getTag = _getTag,
+    isArray$4 = isArray_1,
+    isBuffer = isBufferExports,
+    isTypedArray = isTypedArray_1;
+
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1;
+
+  /** `Object#toString` result references. */
+  var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    objectTag = '[object Object]';
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$1 = objectProto.hasOwnProperty;
+
+  /**
+   * A specialized version of `baseIsEqual` for arrays and objects which performs
+   * deep comparisons and tracks traversed objects enabling objects with circular
+   * references to be compared.
+   *
+   * @private
+   * @param {Object} object The object to compare.
+   * @param {Object} other The other object to compare.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+   * @param {Function} customizer The function to customize comparisons.
+   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+   */
+  function baseIsEqualDeep$1(object, other, bitmask, customizer, equalFunc, stack) {
+    var objIsArr = isArray$4(object),
+      othIsArr = isArray$4(other),
+      objTag = objIsArr ? arrayTag : getTag(object),
+      othTag = othIsArr ? arrayTag : getTag(other);
+    objTag = objTag == argsTag ? objectTag : objTag;
+    othTag = othTag == argsTag ? objectTag : othTag;
+    var objIsObj = objTag == objectTag,
+      othIsObj = othTag == objectTag,
+      isSameTag = objTag == othTag;
+    if (isSameTag && isBuffer(object)) {
+      if (!isBuffer(other)) {
+        return false;
+      }
+      objIsArr = true;
+      objIsObj = false;
+    }
+    if (isSameTag && !objIsObj) {
+      stack || (stack = new Stack$1());
+      return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+    }
+    if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+      var objIsWrapped = objIsObj && hasOwnProperty$1.call(object, '__wrapped__'),
+        othIsWrapped = othIsObj && hasOwnProperty$1.call(other, '__wrapped__');
+      if (objIsWrapped || othIsWrapped) {
+        var objUnwrapped = objIsWrapped ? object.value() : object,
+          othUnwrapped = othIsWrapped ? other.value() : other;
+        stack || (stack = new Stack$1());
+        return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+      }
+    }
+    if (!isSameTag) {
+      return false;
+    }
+    stack || (stack = new Stack$1());
+    return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+  }
+  var _baseIsEqualDeep = baseIsEqualDeep$1;
+
+  var baseIsEqualDeep = _baseIsEqualDeep,
+    isObjectLike = isObjectLike_1;
+
+  /**
+   * The base implementation of `_.isEqual` which supports partial comparisons
+   * and tracks traversed objects.
+   *
+   * @private
+   * @param {*} value The value to compare.
+   * @param {*} other The other value to compare.
+   * @param {boolean} bitmask The bitmask flags.
+   *  1 - Unordered comparison
+   *  2 - Partial comparison
+   * @param {Function} [customizer] The function to customize comparisons.
+   * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+   */
+  function baseIsEqual$1(value, other, bitmask, customizer, stack) {
+    if (value === other) {
+      return true;
+    }
+    if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+      return value !== value && other !== other;
+    }
+    return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual$1, stack);
+  }
+  var _baseIsEqual = baseIsEqual$1;
+
+  var baseIsEqual = _baseIsEqual;
+
+  /**
+   * Performs a deep comparison between two values to determine if they are
+   * equivalent.
+   *
+   * **Note:** This method supports comparing arrays, array buffers, booleans,
+   * date objects, error objects, maps, numbers, `Object` objects, regexes,
+   * sets, strings, symbols, and typed arrays. `Object` objects are compared
+   * by their own, not inherited, enumerable properties. Functions and DOM
+   * nodes are compared by strict equality, i.e. `===`.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.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 };
+   *
+   * _.isEqual(object, other);
+   * // => true
+   *
+   * object === other;
+   * // => false
+   */
+  function isEqual(value, other) {
+    return baseIsEqual(value, other);
+  }
+  var isEqual_1 = isEqual;
+
+  var isEqual$1 = /*@__PURE__*/getDefaultExportFromCjs(isEqual_1);
+
   var HOOKS = ["onChange", "onClose", "onDayCreate", "onDestroy", "onKeyDown", "onMonthChange", "onOpen", "onParseConfig", "onReady", "onValueUpdate", "onYearChange", "onPreCalendarPosition"];
   var defaults$2 = {
     _disable: [],
@@ -51424,39 +53683,58 @@
 
   // transforms the provided options into a normalized format, trimming invalid options
   function normalizeOptionsData(optionsData) {
-    return optionsData.filter(_isOptionSomething).map(v => _normalizeOptionsData(v)).filter(v => v);
+    return optionsData.filter(_isAllowedValue).map(_normalizeOption).filter(o => !isNil$1(o));
   }
-  function _normalizeOptionsData(optionData) {
-    if (_isAllowedOption(optionData)) {
-      // if a primitive is provided, use it as label and value
+
+  /**
+   * Converts the provided option to a normalized format.
+   * If the option is not valid, null is returned.
+   *
+   * @param {object} option
+   * @param {string} option.label
+   * @param {*} option.value
+   *
+   * @returns
+   */
+  function _normalizeOption(option) {
+    // (1) simple primitive case, use it as both label and value
+    if (_isAllowedPrimitive(option)) {
       return {
-        value: optionData,
-        label: `${optionData}`
+        value: option,
+        label: `${option}`
       };
     }
-    if (typeof optionData === 'object') {
-      if (!optionData.label && _isAllowedOption(optionData.value)) {
-        // if no label is provided, use the value as label
+    if (isObject$4(option)) {
+      const isValidLabel = _isValidLabel(option.label);
+
+      // (2) no label provided, but value is a simple primitive, use it as label and value
+      if (!isValidLabel && _isAllowedPrimitive(option.value)) {
         return {
-          value: optionData.value,
-          label: `${optionData.value}`
+          value: option.value,
+          label: `${option.value}`
         };
       }
-      if (_isOptionSomething(optionData.value) && _isAllowedOption(optionData.label)) {
-        // if both value and label are provided, use them as is, in this scenario, the value may also be an object
-        return optionData;
+
+      // (3) both label and value are provided, use them as is
+      if (isValidLabel && _isAllowedValue(option.value)) {
+        return option;
       }
     }
     return null;
   }
-  function _isAllowedOption(option) {
-    return _isReadableType(option) && _isOptionSomething(option);
+  function _isAllowedPrimitive(value) {
+    const isAllowedPrimitiveType = ['number', 'string', 'boolean'].includes(typeof value);
+    const isValid = value || value === 0 || value === false;
+    return isAllowedPrimitiveType && isValid;
   }
-  function _isReadableType(option) {
-    return ['number', 'string', 'boolean'].includes(typeof option);
+  function _isValidLabel(label) {
+    return label && isString$4(label);
   }
-  function _isOptionSomething(option) {
-    return option || option === 0 || option === false;
+  function _isAllowedValue(value) {
+    if (isObject$4(value)) {
+      return Object.keys(value).length > 0;
+    }
+    return _isAllowedPrimitive(value);
   }
   function createEmptyOptions(options = {}) {
     const defaults = {};
@@ -51549,29 +53827,6 @@
     error: undefined,
     loadState: LOAD_STATES.LOADED
   });
-  function useCleanupMultiSelectValues(props) {
-    const {
-      field,
-      options,
-      loadState,
-      onChange,
-      values
-    } = props;
-
-    // Ensures that the values are always a subset of the possible options
-    y(() => {
-      if (loadState !== LOAD_STATES.LOADED) {
-        return;
-      }
-      const hasValuesNotInOptions = values.some(v => !options.map(o => o.value).includes(v));
-      if (hasValuesNotInOptions) {
-        onChange({
-          field,
-          value: values.filter(v => options.map(o => o.value).includes(v))
-        });
-      }
-    }, [field, options, onChange, JSON.stringify(values), loadState]);
-  }
   const ENTER_KEYDOWN_EVENT = new KeyboardEvent('keydown', {
     code: 'Enter',
     key: 'Enter',
@@ -51746,6 +54001,12 @@
     if (subtype === DATETIME_SUBTYPES.DATETIME && (isInvalidDateString(value) || !isDateTimeInputInformationSufficient(value))) return null;
     return value;
   }
+  function hasEqualValue(value, array) {
+    if (!Array.isArray(array)) {
+      return false;
+    }
+    return array.some(element => isEqual$1(value, element));
+  }
   function sanitizeSingleSelectValue(options) {
     const {
       formField,
@@ -51754,7 +54015,7 @@
     } = options;
     try {
       const validValues = normalizeOptionsData(getOptionsData(formField, data)).map(v => v.value);
-      return validValues.includes(value) ? value : null;
+      return hasEqualValue(value, validValues) ? value : null;
     } catch (error) {
       // use default value in case of formatting error
       // TODO(@Skaiir): log a warning when this happens - https://github.com/bpmn-io/form-js/issues/289
@@ -51769,13 +54030,37 @@
     } = options;
     try {
       const validValues = normalizeOptionsData(getOptionsData(formField, data)).map(v => v.value);
-      return value.filter(v => validValues.includes(v));
+      return value.filter(v => hasEqualValue(v, validValues));
     } catch (error) {
       // use default value in case of formatting error
       // TODO(@Skaiir): log a warning when this happens - https://github.com/bpmn-io/form-js/issues/289
       return [];
     }
   }
+  function useCleanupMultiSelectValues(props) {
+    const {
+      field,
+      options,
+      loadState,
+      onChange,
+      values
+    } = props;
+
+    // Ensures that the values are always a subset of the possible options
+    y(() => {
+      if (loadState !== LOAD_STATES.LOADED) {
+        return;
+      }
+      const optionValues = options.map(o => o.value);
+      const hasValuesNotInOptions = values.some(v => !hasEqualValue(v, optionValues));
+      if (hasValuesNotInOptions) {
+        onChange({
+          field,
+          value: values.filter(v => hasEqualValue(v, optionValues))
+        });
+      }
+    }, [field, options, onChange, JSON.stringify(values), loadState]);
+  }
   const type$d = 'checklist';
   function Checklist(props) {
     const {
@@ -51798,16 +54083,11 @@
     const {
       required
     } = validate;
-    const toggleCheckbox = v => {
-      let newValue = [...values];
-      if (!newValue.includes(v)) {
-        newValue.push(v);
-      } else {
-        newValue = newValue.filter(x => x != v);
-      }
+    const toggleCheckbox = toggledValue => {
+      const newValues = hasEqualValue(toggledValue, values) ? values.filter(value => !isEqual$1(value, toggledValue)) : [...values, toggledValue];
       props.onChange({
         field,
-        value: newValue
+        value: newValues
       });
     };
     const onCheckboxBlur = e => {
@@ -51845,15 +54125,16 @@
         required: required
       }), loadState == LOAD_STATES.LOADED && options.map((o, index) => {
         const itemDomId = `${domId}-${index}`;
+        const isChecked = hasEqualValue(o.value, values);
         return e$1(Label$3, {
           id: itemDomId,
           label: o.label,
           class: classNames({
-            'fjs-checked': values.includes(o.value)
+            'fjs-checked': isChecked
           }),
           required: false,
           children: e$1("input", {
-            checked: values.includes(o.value),
+            checked: isChecked,
             class: "fjs-input",
             disabled: disabled,
             readOnly: readonly,
@@ -53394,6 +55675,39 @@
       ...options
     })
   };
+  function useFlushDebounce(func, additionalDeps = []) {
+    const timeoutRef = s$1(null);
+    const lastArgsRef = s$1(null);
+    const config = useService$2('config', false);
+    const debounce = config && config.debounce;
+    const shouldDebounce = debounce !== false && debounce !== 0;
+    const delay = typeof debounce === 'number' ? debounce : 300;
+    const debounceFunc = A$1((...args) => {
+      if (!shouldDebounce) {
+        func(...args);
+        return;
+      }
+      lastArgsRef.current = args;
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      timeoutRef.current = setTimeout(() => {
+        func(...lastArgsRef.current);
+        lastArgsRef.current = null;
+      }, delay);
+    }, [func, delay, shouldDebounce, ...additionalDeps]);
+    const flushFunc = A$1(() => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+        if (lastArgsRef.current !== null) {
+          func(...lastArgsRef.current);
+          lastArgsRef.current = null;
+        }
+        timeoutRef.current = null;
+      }
+    }, [func, ...additionalDeps]);
+    return [debounceFunc, flushFunc];
+  }
   function TemplatedInputAdorner(props) {
     const {
       pre,
@@ -53506,8 +55820,7 @@
       onFocus,
       field,
       value,
-      readonly,
-      onChange
+      readonly
     } = props;
     const {
       description,
@@ -53527,6 +55840,16 @@
     } = validate;
     const inputRef = s$1();
     const [stringValueCache, setStringValueCache] = l$2('');
+    const [onChangeDebounced, flushOnChange] = useFlushDebounce(params => {
+      props.onChange(params);
+    }, [props.onChange]);
+    const onInputBlur = () => {
+      flushOnChange && flushOnChange();
+      onBlur && onBlur();
+    };
+    const onInputFocus = () => {
+      onFocus && onFocus();
+    };
 
     // checks whether the value currently in the form data is practically different from the one in the input field cache
     // this allows us to guarantee the field always displays valid form data, but without auto-simplifying values like 1.000 to 1
@@ -53550,7 +55873,7 @@
     const setValue = A$1(stringValue => {
       if (isNullEquivalentValue(stringValue)) {
         setStringValueCache('');
-        onChange({
+        onChangeDebounced({
           field,
           value: null
         });
@@ -53565,18 +55888,18 @@
       }
       if (isNaN(Number(stringValue))) {
         setStringValueCache('NaN');
-        onChange({
+        onChangeDebounced({
           field,
           value: 'NaN'
         });
         return;
       }
       setStringValueCache(stringValue);
-      onChange({
+      onChangeDebounced({
         field,
         value: serializeToString ? stringValue : Number(stringValue)
       });
-    }, [field, onChange, serializeToString]);
+    }, [field, onChangeDebounced, serializeToString]);
     const increment = () => {
       if (readonly) {
         return;
@@ -53660,8 +55983,8 @@
             id: domId,
             onKeyDown: onKeyDown,
             onKeyPress: onKeyPress,
-            onBlur: () => onBlur && onBlur(),
-            onFocus: () => onFocus && onFocus()
+            onBlur: onInputBlur,
+            onFocus: onInputFocus
 
             // @ts-ignore
             ,
@@ -53738,7 +56061,8 @@
       if (loadState !== LOAD_STATES.LOADED) {
         return;
       }
-      const hasValueNotInOptions = value && !options.map(o => o.value).includes(value);
+      const optionValues = options.map(o => o.value);
+      const hasValueNotInOptions = value && !hasEqualValue(value, optionValues);
       if (hasValueNotInOptions) {
         onChange({
           field,
@@ -53810,15 +56134,16 @@
         required: required
       }), loadState == LOAD_STATES.LOADED && options.map((option, index) => {
         const itemDomId = `${domId}-${index}`;
+        const isChecked = isEqual$1(option.value, value);
         return e$1(Label$3, {
           id: itemDomId,
           label: option.label,
           class: classNames({
-            'fjs-checked': option.value === value
+            'fjs-checked': isChecked
           }),
           required: false,
           children: e$1("input", {
-            checked: option.value === value,
+            checked: isChecked,
             class: "fjs-input",
             disabled: disabled,
             readOnly: readonly,
@@ -53847,6 +56172,21 @@
     sanitizeValue: sanitizeSingleSelectValue,
     create: createEmptyOptions
   };
+
+  /**
+   * This hook allows us to retrieve the label from a value in linear time by caching it in a map
+   * @param {Array} options
+   */
+  function useGetLabelCorrelation(options) {
+    // This allows us to retrieve the label from a value in linear time
+    const labelMap = d(() => Object.assign({}, ...options.map(o => ({
+      [_getValueHash(o.value)]: o.label
+    }))), [options]);
+    return A$1(value => labelMap[_getValueHash(value)], [labelMap]);
+  }
+  const _getValueHash = value => {
+    return isObject$4(value) ? JSON.stringify(value) : value;
+  };
   var _path$q;
   function _extends$r() {
     _extends$r = Object.assign ? Object.assign.bind() : function (target) {
@@ -53890,7 +56230,7 @@
     } = props;
     const [filter, setFilter] = l$2('');
     const [isDropdownExpanded, setIsDropdownExpanded] = l$2(false);
-    const [shouldApplyFilter, setShouldApplyFilter] = l$2(true);
+    const [isFilterActive, setIsFilterActive] = l$2(true);
     const [isEscapeClosed, setIsEscapeClose] = l$2(false);
     const searchbarRef = s$1();
     const eventBus = useService$2('eventBus');
@@ -53905,23 +56245,22 @@
       value,
       onChange: props.onChange
     });
-
-    // We cache a map of option values to their index so that we don't need to search the whole options array every time to correlate the label
-    const valueToOptionMap = d(() => Object.assign({}, ...options.map((o, x) => ({
-      [o.value]: options[x]
-    }))), [options]);
-    const valueLabel = d(() => value && valueToOptionMap[value] && valueToOptionMap[value].label || '', [value, valueToOptionMap]);
+    const getLabelCorrelation = useGetLabelCorrelation(options);
+    const label = d(() => value && getLabelCorrelation(value), [value, getLabelCorrelation]);
 
     // whenever we change the underlying value, set the label to it
     y(() => {
-      setFilter(valueLabel);
-    }, [valueLabel]);
+      setFilter(label);
+    }, [label]);
     const filteredOptions = d(() => {
-      if (loadState === LOAD_STATES.LOADED) {
-        return shouldApplyFilter ? options.filter(o => o.label && o.value && o.label.toLowerCase().includes(filter.toLowerCase())) : options;
+      if (loadState !== LOAD_STATES.LOADED) {
+        return [];
       }
-      return [];
-    }, [filter, loadState, options, shouldApplyFilter]);
+      if (!filter || !isFilterActive) {
+        return options;
+      }
+      return options.filter(o => o.label && o.value && o.label.toLowerCase().includes(filter.toLowerCase()));
+    }, [filter, loadState, options, isFilterActive]);
     const setValue = A$1(option => {
       setFilter(option && option.label || '');
       props.onChange({
@@ -53948,7 +56287,7 @@
     }) => {
       setIsEscapeClose(false);
       setIsDropdownExpanded(true);
-      setShouldApplyFilter(true);
+      setIsFilterActive(true);
       setFilter(target.value || '');
       eventBus.fire('formField.search', {
         formField: field,
@@ -53964,7 +56303,7 @@
           {
             if (!isDropdownExpanded) {
               setIsDropdownExpanded(true);
-              setShouldApplyFilter(false);
+              setIsFilterActive(false);
             }
             keyDownEvent.preventDefault();
             break;
@@ -53982,7 +56321,7 @@
     const onInputMouseDown = A$1(() => {
       setIsEscapeClose(false);
       setIsDropdownExpanded(true);
-      setShouldApplyFilter(false);
+      setIsFilterActive(false);
     }, []);
     const onInputFocus = A$1(() => {
       setIsEscapeClose(false);
@@ -53991,9 +56330,9 @@
     }, [onFocus]);
     const onInputBlur = A$1(() => {
       setIsDropdownExpanded(false);
-      setFilter(valueLabel);
+      setFilter(label);
       onBlur && onBlur();
-    }, [onBlur, valueLabel]);
+    }, [onBlur, label]);
     return e$1(d$1, {
       children: [e$1("div", {
         class: classNames('fjs-input-group', {
@@ -54069,12 +56408,8 @@
       value,
       onChange: props.onChange
     });
-
-    // We cache a map of option values to their index so that we don't need to search the whole options array every time to correlate the label
-    const valueToOptionMap = d(() => Object.assign({}, ...options.map((o, x) => ({
-      [o.value]: options[x]
-    }))), [options]);
-    const valueLabel = d(() => value && valueToOptionMap[value] && valueToOptionMap[value].label || '', [value, valueToOptionMap]);
+    const getLabelCorrelation = useGetLabelCorrelation(options);
+    const valueLabel = d(() => value && getLabelCorrelation(value), [value, getLabelCorrelation]);
     const setValue = A$1(option => {
       props.onChange({
         value: option && option.value || null,
@@ -54383,11 +56718,7 @@
       values,
       onChange: props.onChange
     });
-
-    // We cache a map of option values to their index so that we don't need to search the whole options array every time to correlate the label
-    const valueToOptionMap = d(() => Object.assign({}, ...options.map((o, x) => ({
-      [o.value]: options[x]
-    }))), [options]);
+    const getLabelCorrelation = useGetLabelCorrelation(options);
     const hasOptionsLeft = d(() => options.length > values.length, [options.length, values.length]);
 
     // Usage of stringify is necessary here because we want this effect to only trigger when there is a value change to the array
@@ -54395,12 +56726,14 @@
       if (loadState !== LOAD_STATES.LOADED) {
         return [];
       }
-      return options.filter(o => o.label && o.value && o.label.toLowerCase().includes(filter.toLowerCase()) && !values.includes(o.value));
+      const isValidFilteredOption = option => {
+        const filterMatches = option.label.toLowerCase().includes(filter.toLowerCase());
+        return filterMatches && !hasEqualValue(option.value, values);
+      };
+      return options.filter(isValidFilteredOption);
     }, [filter, options, JSON.stringify(values), loadState]);
     const selectValue = value => {
-      if (filter) {
-        setFilter('');
-      }
+      setFilter('');
 
       // Ensure values cannot be double selected due to latency
       if (values.at(-1) === value) {
@@ -54412,8 +56745,9 @@
       });
     };
     const deselectValue = value => {
+      const newValues = values.filter(v => !isEqual$1(v, value));
       props.onChange({
-        value: values.filter(v => v != value),
+        value: newValues,
         field
       });
     };
@@ -54523,7 +56857,7 @@
               onMouseDown: e => e.preventDefault(),
               children: [e$1("span", {
                 class: "fjs-taglist-tag-label",
-                children: valueToOptionMap[v] ? valueToOptionMap[v].label : undefined
+                children: getLabelCorrelation(v)
               }), !disabled && !readonly && e$1("button", {
                 type: "button",
                 title: "Remove tag",
@@ -54687,13 +57021,20 @@
     const {
       required
     } = validate;
-    const onChange = ({
+    const [onInputChange, flushOnChange] = useFlushDebounce(({
       target
     }) => {
       props.onChange({
         field,
         value: target.value
       });
+    }, [props.onChange]);
+    const onInputBlur = () => {
+      flushOnChange && flushOnChange();
+      onBlur && onBlur();
+    };
+    const onInputFocus = () => {
+      onFocus && onFocus();
     };
     return e$1("div", {
       class: formFieldClasses(type$2, {
@@ -54715,9 +57056,9 @@
           disabled: disabled,
           readOnly: readonly,
           id: domId,
-          onInput: onChange,
-          onBlur: () => onBlur && onBlur(),
-          onFocus: () => onFocus && onFocus(),
+          onInput: onInputChange,
+          onBlur: onInputBlur,
+          onFocus: onInputFocus,
           type: "text",
           value: value,
           "aria-describedby": errorMessageId
@@ -54739,7 +57080,7 @@
     sanitizeValue: ({
       value
     }) => {
-      if (isArray$4(value) || isObject$1(value) || isNil$1(value)) {
+      if (isArray$8(value) || isObject$4(value) || isNil$1(value)) {
         return '';
       }
 
@@ -54775,13 +57116,20 @@
       required
     } = validate;
     const textareaRef = s$1();
-    const onInput = ({
+    const [onInputChange, flushOnChange] = useFlushDebounce(({
       target
     }) => {
       props.onChange({
         field,
         value: target.value
       });
+    }, [props.onChange]);
+    const onInputBlur = () => {
+      flushOnChange && flushOnChange();
+      onBlur && onBlur();
+    };
+    const onInputFocus = () => {
+      onFocus && onFocus();
     };
     h$1(() => {
       autoSizeTextarea(textareaRef.current);
@@ -54804,9 +57152,9 @@
         disabled: disabled,
         readonly: readonly,
         id: domId,
-        onInput: onInput,
-        onBlur: () => onBlur && onBlur(),
-        onFocus: () => onFocus && onFocus(),
+        onInput: onInputChange,
+        onBlur: onInputBlur,
+        onFocus: onInputFocus,
         value: value,
         ref: textareaRef,
         "aria-describedby": errorMessageId
@@ -54826,7 +57174,7 @@
     emptyValue: '',
     sanitizeValue: ({
       value
-    }) => isArray$4(value) || isObject$1(value) || isNil$1(value) ? '' : String(value),
+    }) => isArray$8(value) || isObject$4(value) || isNil$1(value) ? '' : String(value),
     create: (options = {}) => ({
       ...options
     })
@@ -55200,7 +57548,7 @@
    * @returns {column is Column}
    */
   function isColumn(column) {
-    return isObject$1(column) && isString$4(column['label']) && isString$4(column['key']);
+    return isObject$4(column) && isString$4(column['label']) && isString$4(column['key']);
   }
 
   /**
@@ -55227,7 +57575,7 @@
    */
   function sortByColumn(array, key, direction) {
     return [...array].sort((a, b) => {
-      if (!isObject$1(a) || !isObject$1(b)) {
+      if (!isObject$4(a) || !isObject$4(b)) {
         return 0;
       }
       if (direction === 'asc') {
@@ -56128,7 +58476,7 @@
       } while (recurse);
     }
     _isEmptyObject(parentObject) {
-      return isObject$1(parentObject) && !values(parentObject).length;
+      return isObject$4(parentObject) && !values(parentObject).length;
     }
     _isEmptyArray(parentObject) {
       return Array.isArray(parentObject) && (!parentObject.length || parentObject.every(item => item === undefined));
@@ -56605,7 +58953,7 @@
     if (!elements) {
       return;
     }
-    elements = isArray$4(elements) ? elements : [elements];
+    elements = isArray$8(elements) ? elements : [elements];
     execution.dirty = execution.dirty.concat(elements);
   };
   CommandStack$1.prototype._executedAction = function (action, redo) {
@@ -57145,8 +59493,8 @@
    * @param {any} [that] callback context
    */
   EventBus$1.prototype.on = function (events, priority, callback, that) {
-    events = isArray$4(events) ? events : [events];
-    if (isFunction$1(priority)) {
+    events = isArray$8(events) ? events : [events];
+    if (isFunction$4(priority)) {
       that = callback;
       callback = priority;
       priority = DEFAULT_PRIORITY$4;
@@ -57185,7 +59533,7 @@
    */
   EventBus$1.prototype.once = function (events, priority, callback, that) {
     var self = this;
-    if (isFunction$1(priority)) {
+    if (isFunction$4(priority)) {
       that = callback;
       callback = priority;
       priority = DEFAULT_PRIORITY$4;
@@ -57216,7 +59564,7 @@
    * @param {EventBusEventCallback} [callback]
    */
   EventBus$1.prototype.off = function (events, callback) {
-    events = isArray$4(events) ? events : [events];
+    events = isArray$8(events) ? events : [events];
     var self = this;
     events.forEach(function (event) {
       self._removeListener(event, callback);
@@ -58083,7 +60431,7 @@
     }
   }
   const _getNextSegment = (node, segment) => {
-    if (isArray$4(node.children)) {
+    if (isArray$8(node.children)) {
       return node.children.find(node => node.segment === segment) || null;
     }
     return null;
@@ -58652,16 +61000,18 @@
      */
     _createInjector(options, container) {
       const {
+        modules = this._getModules(),
         additionalModules = [],
-        modules = this._getModules()
+        ...config
       } = options;
-      const config = {
+      const enrichedConfig = {
+        ...config,
         renderer: {
           container
         }
       };
       return createInjector([{
-        config: ['value', config]
+        config: ['value', enrichedConfig]
       }, {
         form: ['value', this]
       }, core$1, ...modules, ...additionalModules]);
@@ -58849,7 +61199,7 @@
           }
 
           // (b) Ensure all elements of the array are objects
-          valueData = valueData.map(val => isObject$1(val) ? val : {});
+          valueData = valueData.map(val => isObject$4(val) ? val : {});
 
           // (c) Initialize field value in output data
           set$3(initializedData, valuePath, valueData);
@@ -76370,19 +78720,20 @@
      */
     _createInjector(options, container) {
       const {
-        additionalModules = [],
         modules = this._getModules(),
-        renderer = {}
+        additionalModules = [],
+        renderer = {},
+        ...config
       } = options;
-      const config = {
-        ...options,
+      const enrichedConfig = {
+        ...config,
         renderer: {
           ...renderer,
           container
         }
       };
       return createInjector([{
-        config: ['value', config]
+        config: ['value', enrichedConfig]
       }, {
         formEditor: ['value', this]
       }, core, ...modules, ...additionalModules]);