{“ast”:null,“code”:“function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }nn/**n * lodash (Custom Build) <n“>jquery.org/>n * Released under MIT license <n“>underscorejs.org/LICENSE>n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editorsn */nn/** Used as the size to enable large array optimizations. */nvar LARGE_ARRAY_SIZE = 200;n/** Used as the `TypeError` message for "Functions" methods. */nnvar FUNC_ERROR_TEXT = 'Expected a function';n/** Used to stand-in for `undefined` hash values. */nnvar HASH_UNDEFINED = 'lodash_hash_undefined';n/** Used to compose bitmasks for comparison styles. */nnvar UNORDERED_COMPARE_FLAG = 1,n PARTIAL_COMPARE_FLAG = 2;n/** Used as references for various `Number` constants. */nnvar INFINITY = 1 / 0,n MAX_SAFE_INTEGER = 9007199254740991;n/** `Object#toString` result references. */nnvar argsTag = '[object Arguments]',n arrayTag = '[object Array]',n boolTag = '[object Boolean]',n dateTag = '[object Date]',n errorTag = '[object Error]',n funcTag = '[object Function]',n genTag = '[object GeneratorFunction]',n mapTag = '[object Map]',n numberTag = '[object Number]',n objectTag = '[object Object]',n promiseTag = '[object Promise]',n regexpTag = '[object RegExp]',n setTag = '[object Set]',n stringTag = '[object String]',n symbolTag = '[object Symbol]',n weakMapTag = '[object WeakMap]';nvar arrayBufferTag = '[object ArrayBuffer]',n dataViewTag = '[object DataView]',n float32Tag = '[object Float32Array]',n float64Tag = '[object Float64Array]',n int8Tag = '[object Int8Array]',n int16Tag = '[object Int16Array]',n int32Tag = '[object Int32Array]',n uint8Tag = '[object Uint8Array]',n uint8ClampedTag = '[object Uint8ClampedArray]',n uint16Tag = '[object Uint16Array]',n uint32Tag = '[object Uint32Array]';n/** Used to match property names within property paths. */nnvar reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)|\\.)*?\1)\]/,n reIsPlainProp = /^\w*$/,n reLeadingDot = /^\./,n rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|()((?:(?!\2)|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;n/**n * Used to match `RegExp`n * [syntax characters](ecma-international.org/ecma-262/7.0/#sec-patterns).n */nnvar reRegExpChar = /[\\^$.*+?()[\]{}|]/g;n/** Used to match backslashes in property paths. */nnvar reEscapeChar = /\\(\\)?/g;n/** Used to detect host constructors (Safari). */nnvar reIsHostCtor = /^\[object .+?Constructor\]$/;n/** Used to detect unsigned integer values. */nnvar reIsUint = /^(?:0|\d*)$/;n/** Used to identify `toStringTag` values of typed arrays. */nnvar typedArrayTags = {};ntypedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = true;ntypedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = false;n/** Detect free variable `global` from Node.js. */nnvar freeGlobal = (typeof global === "undefined" ? "undefined" : _typeof(global)) == 'object' && global && global.Object === Object && global;n/** Detect free variable `self`. */nnvar freeSelf = (typeof self === "undefined" ? "undefined" : _typeof(self)) == 'object' && self && self.Object === Object && self;n/** Used as a reference to the global object. */nnvar root = freeGlobal || freeSelf || Function('return this')();n/** Detect free variable `exports`. */nnvar freeExports = (typeof exports === "undefined" ? "undefined" : _typeof(exports)) == 'object' && exports && !exports.nodeType && exports;n/** Detect free variable `module`. */nnvar freeModule = freeExports && (typeof module === "undefined" ? "undefined" : _typeof(module)) == 'object' && module && !module.nodeType && module;n/** Detect the popular CommonJS extension `module.exports`. */nnvar moduleExports = freeModule && freeModule.exports === freeExports;n/** Detect free variable `process` from Node.js. */nnvar freeProcess = moduleExports && freeGlobal.process;n/** Used to access faster Node.js helpers. */nnvar nodeUtil = function () {n try {n return freeProcess && freeProcess.binding('util');n } catch (e) {}n}();n/* Node.js helper references. */nnnvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;n/**n * A specialized version of `_.map` for arrays without support for iterateen * shorthands.n *n * @privaten * @param {Array} [array] The array to iterate over.n * @param {Function} iteratee The function invoked per iteration.n * @returns {Array} Returns the new mapped array.n */nnfunction arrayMap(array, iteratee) {n var index = -1,n length = array ? array.length : 0,n result = Array(length);nn while (++index < length) {n result = iteratee(array, index, array);n }nn return result;n}n/**n * Appends the elements of `values` to `array`.n *n * @privaten * @param {Array} array The array to modify.n * @param {Array} values The values to append.n * @returns {Array} Returns `array`.n */nnnfunction arrayPush(array, values) {n var index = -1,n length = values.length,n offset = array.length;nn while (++index < length) {n array[offset + index] = values;n }nn return array;n}n/**n * A specialized version of `_.some` for arrays without support for iterateen * shorthands.n *n * @privaten * @param {Array} [array] The array to iterate over.n * @param {Function} predicate The function invoked per iteration.n * @returns {boolean} Returns `true` if any element passes the predicate check,n * else `false`.n */nnnfunction arraySome(array, predicate) {n var index = -1,n length = array ? array.length : 0;nn while (++index < length) {n if (predicate(array, index, array)) {n return true;n }n }nn return false;n}n/**n * The base implementation of `_.property` without support for deep paths.n *n * @privaten * @param {string} key The key of the property to get.n * @returns {Function} Returns the new accessor function.n */nnnfunction baseProperty(key) {n return function (object) {n return object == null ? undefined : object;n };n}n/**n * The base implementation of `_.times` without support for iteratee shorthandsn * or max array length checks.n *n * @privaten * @param {number} n The number of times to invoke `iteratee`.n * @param {Function} iteratee The function invoked per iteration.n * @returns {Array} Returns the array of results.n */nnnfunction baseTimes(n, iteratee) {n var index = -1,n result = Array(n);nn while (++index < n) {n result = iteratee(index);n }nn return result;n}n/**n * The base implementation of `_.unary` without support for storing metadata.n *n * @privaten * @param {Function} func The function to cap arguments for.n * @returns {Function} Returns the new capped function.n */nnnfunction baseUnary(func) {n return function (value) {n return func(value);n };n}n/**n * Gets the value at `key` of `object`.n *n * @privaten * @param {Object} [object] The object to query.n * @param {string} key The key of the property to get.n * @returns {*} Returns the property value.n */nnnfunction getValue(object, key) {n return object == null ? undefined : object;n}n/**n * Checks if `value` is a host object in IE < 9.n *n * @privaten * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is a host object, else `false`.n */nnnfunction isHostObject(value) {n // Many host objects are `Object` objects that can coerce to stringsn // despite having improperly defined `toString` methods.n var result = false;nn if (value != null && typeof value.toString != 'function') {n try {n result = !!(value + '');n } catch (e) {}n }nn return result;n}n/**n * Converts `map` to its key-value pairs.n *n * @privaten * @param {Object} map The map to convert.n * @returns {Array} Returns the key-value pairs.n */nnnfunction mapToArray(map) {n var index = -1,n result = Array(map.size);n map.forEach(function (value, key) {n result = [key, value];n });n return result;n}n/**n * Creates a unary function that invokes `func` with its argument transformed.n *n * @privaten * @param {Function} func The function to wrap.n * @param {Function} transform The argument transform.n * @returns {Function} Returns the new function.n */nnnfunction overArg(func, transform) {n return function (arg) {n return func(transform(arg));n };n}n/**n * Converts `set` to an array of its values.n *n * @privaten * @param {Object} set The set to convert.n * @returns {Array} Returns the values.n */nnnfunction setToArray(set) {n var index = -1,n result = Array(set.size);n set.forEach(function (value) {n result = value;n });n return result;n}n/** Used for built-in method references. */nnnvar arrayProto = Array.prototype,n funcProto = Function.prototype,n objectProto = Object.prototype;n/** Used to detect overreaching core-js shims. */nnvar coreJsData = root[‘core-js_shared’];n/** Used to detect methods masquerading as native. */nnvar maskSrcKey = function () {n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');n return uid ? 'Symbol(src)_1.' + uid : '';n}();n/** Used to resolve the decompiled source of functions. */nnnvar funcToString = funcProto.toString;n/** Used to check objects for own properties. */nnvar hasOwnProperty = objectProto.hasOwnProperty;n/**n * Used to resolve then * [`toStringTag`](ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)n * of values.n */nnvar objectToString = objectProto.toString;n/** Used to detect if a method is native. */nnvar reIsNative = RegExp('^' + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');n/** Built-in value references. */nnvar _Symbol = root.Symbol,n Uint8Array = root.Uint8Array,n propertyIsEnumerable = objectProto.propertyIsEnumerable,n splice = arrayProto.splice,n spreadableSymbol = _Symbol ? _Symbol.isConcatSpreadable : undefined;n/* Built-in method references for those with the same name as other `lodash` methods. */nnvar nativeKeys = overArg(Object.keys, Object);n/* Built-in method references that are verified to be native. */nnvar DataView = getNative(root, 'DataView'),n Map = getNative(root, 'Map'),n Promise = getNative(root, 'Promise'),n Set = getNative(root, 'Set'),n WeakMap = getNative(root, 'WeakMap'),n nativeCreate = getNative(Object, 'create');n/** Used to detect maps, sets, and weakmaps. */nnvar dataViewCtorString = toSource(DataView),n mapCtorString = toSource(Map),n promiseCtorString = toSource(Promise),n setCtorString = toSource(Set),n weakMapCtorString = toSource(WeakMap);n/** Used to convert symbols to primitives and strings. */nnvar symbolProto = _Symbol ? _Symbol.prototype : undefined,n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,n symbolToString = symbolProto ? symbolProto.toString : undefined;n/**n * Creates a hash object.n *n * @privaten * @constructorn * @param {Array} [entries] The key-value pairs to cache.n */nnfunction Hash(entries) {n var index = -1,n length = entries ? entries.length : 0;n this.clear();nn while (++index < length) {n var entry = entries;n this.set(entry, entry);n }n}n/**n * Removes all key-value entries from the hash.n *n * @privaten * @name clearn * @memberOf Hashn */nnnfunction hashClear() {n this.__data__ = nativeCreate ? nativeCreate(null) : {};n}n/**n * Removes `key` and its value from the hash.n *n * @privaten * @name deleten * @memberOf Hashn * @param {Object} hash The hash to modify.n * @param {string} key The key of the value to remove.n * @returns {boolean} Returns `true` if the entry was removed, else `false`.n */nnnfunction hashDelete(key) {n return this.has(key) && delete this.__data__;n}n/**n * Gets the hash value for `key`.n *n * @privaten * @name getn * @memberOf Hashn * @param {string} key The key of the value to get.n * @returns {*} Returns the entry value.n */nnnfunction hashGet(key) {n var data = this.__data__;nn if (nativeCreate) {n var result = data;n return result === HASH_UNDEFINED ? undefined : result;n }nn return hasOwnProperty.call(data, key) ? data : undefined;n}n/**n * Checks if a hash value for `key` exists.n *n * @privaten * @name hasn * @memberOf Hashn * @param {string} key The key of the entry to check.n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.n */nnnfunction hashHas(key) {n var data = this.__data__;n return nativeCreate ? data !== undefined : hasOwnProperty.call(data, key);n}n/**n * Sets the hash `key` to `value`.n *n * @privaten * @name setn * @memberOf Hashn * @param {string} key The key of the value to set.n * @param {*} value The value to set.n * @returns {Object} Returns the hash instance.n */nnnfunction hashSet(key, value) {n var data = this.__data__;n data = nativeCreate && value === undefined ? HASH_UNDEFINED : value;n return this;n} // Add methods to `Hash`.nnnHash.prototype.clear = hashClear;nHash.prototype = hashDelete;nHash.prototype.get = hashGet;nHash.prototype.has = hashHas;nHash.prototype.set = hashSet;n/**n * Creates an list cache object.n *n * @privaten * @constructorn * @param {Array} [entries] The key-value pairs to cache.n */nnfunction ListCache(entries) {n var index = -1,n length = entries ? entries.length : 0;n this.clear();nn while (++index < length) {n var entry = entries;n this.set(entry, entry);n }n}n/**n * Removes all key-value entries from the list cache.n *n * @privaten * @name clearn * @memberOf ListCachen */nnnfunction listCacheClear() {n this.__data__ = [];n}n/**n * Removes `key` and its value from the list cache.n *n * @privaten * @name deleten * @memberOf ListCachen * @param {string} key The key of the value to remove.n * @returns {boolean} Returns `true` if the entry was removed, else `false`.n */nnnfunction listCacheDelete(key) {n var data = this.__data__,n index = assocIndexOf(data, key);nn if (index < 0) {n return false;n }nn var lastIndex = data.length - 1;nn if (index == lastIndex) {n data.pop();n } else {n splice.call(data, index, 1);n }nn return true;n}n/**n * Gets the list cache value for `key`.n *n * @privaten * @name getn * @memberOf ListCachen * @param {string} key The key of the value to get.n * @returns {*} Returns the entry value.n */nnnfunction listCacheGet(key) {n var data = this.__data__,n index = assocIndexOf(data, key);n return index < 0 ? undefined : data[1];n}n/**n * Checks if a list cache value for `key` exists.n *n * @privaten * @name hasn * @memberOf ListCachen * @param {string} key The key of the entry to check.n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.n */nnnfunction listCacheHas(key) {n return assocIndexOf(this.__data__, key) > -1;n}n/**n * Sets the list cache `key` to `value`.n *n * @privaten * @name setn * @memberOf ListCachen * @param {string} key The key of the value to set.n * @param {*} value The value to set.n * @returns {Object} Returns the list cache instance.n */nnnfunction listCacheSet(key, value) {n var data = this.__data__,n index = assocIndexOf(data, key);nn if (index < 0) {n data.push([key, value]);n } else {n data[1] = value;n }nn return this;n} // Add methods to `ListCache`.nnnListCache.prototype.clear = listCacheClear;nListCache.prototype = listCacheDelete;nListCache.prototype.get = listCacheGet;nListCache.prototype.has = listCacheHas;nListCache.prototype.set = listCacheSet;n/**n * Creates a map cache object to store key-value pairs.n *n * @privaten * @constructorn * @param {Array} [entries] The key-value pairs to cache.n */nnfunction MapCache(entries) {n var index = -1,n length = entries ? entries.length : 0;n this.clear();nn while (++index < length) {n var entry = entries;n this.set(entry, entry);n }n}n/**n * Removes all key-value entries from the map.n *n * @privaten * @name clearn * @memberOf MapCachen */nnnfunction mapCacheClear() {n this.__data__ = {n 'hash': new Hash(),n 'map': new (Map || ListCache)(),n 'string': new Hash()n };n}n/**n * Removes `key` and its value from the map.n *n * @privaten * @name deleten * @memberOf MapCachen * @param {string} key The key of the value to remove.n * @returns {boolean} Returns `true` if the entry was removed, else `false`.n */nnnfunction mapCacheDelete(key) {n return getMapData(this, key)(key);n}n/**n * Gets the map value for `key`.n *n * @privaten * @name getn * @memberOf MapCachen * @param {string} key The key of the value to get.n * @returns {*} Returns the entry value.n */nnnfunction mapCacheGet(key) {n return getMapData(this, key).get(key);n}n/**n * Checks if a map value for `key` exists.n *n * @privaten * @name hasn * @memberOf MapCachen * @param {string} key The key of the entry to check.n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.n */nnnfunction mapCacheHas(key) {n return getMapData(this, key).has(key);n}n/**n * Sets the map `key` to `value`.n *n * @privaten * @name setn * @memberOf MapCachen * @param {string} key The key of the value to set.n * @param {*} value The value to set.n * @returns {Object} Returns the map cache instance.n */nnnfunction mapCacheSet(key, value) {n getMapData(this, key).set(key, value);n return this;n} // Add methods to `MapCache`.nnnMapCache.prototype.clear = mapCacheClear;nMapCache.prototype = mapCacheDelete;nMapCache.prototype.get = mapCacheGet;nMapCache.prototype.has = mapCacheHas;nMapCache.prototype.set = mapCacheSet;n/**n *n * Creates an array cache object to store unique values.n *n * @privaten * @constructorn * @param {Array} [values] The values to cache.n */nnfunction SetCache(values) {n var index = -1,n length = values ? values.length : 0;n this.__data__ = new MapCache();nn while (++index < length) {n this.add(values);n }n}n/**n * Adds `value` to the array cache.n *n * @privaten * @name addn * @memberOf SetCachen * @alias pushn * @param {*} value The value to cache.n * @returns {Object} Returns the cache instance.n */nnnfunction setCacheAdd(value) {n this.__data__.set(value, HASH_UNDEFINED);nn return this;n}n/**n * Checks if `value` is in the array cache.n *n * @privaten * @name hasn * @memberOf SetCachen * @param {*} value The value to search for.n * @returns {number} Returns `true` if `value` is found, else `false`.n */nnnfunction setCacheHas(value) {n return this.__data__.has(value);n} // Add methods to `SetCache`.nnnSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;nSetCache.prototype.has = setCacheHas;n/**n * Creates a stack cache object to store key-value pairs.n *n * @privaten * @constructorn * @param {Array} [entries] The key-value pairs to cache.n */nnfunction Stack(entries) {n this.__data__ = new ListCache(entries);n}n/**n * Removes all key-value entries from the stack.n *n * @privaten * @name clearn * @memberOf Stackn */nnnfunction stackClear() {n this.__data__ = new ListCache();n}n/**n * Removes `key` and its value from the stack.n *n * @privaten * @name deleten * @memberOf Stackn * @param {string} key The key of the value to remove.n * @returns {boolean} Returns `true` if the entry was removed, else `false`.n */nnnfunction stackDelete(key) {n return this.__data__(key);n}n/**n * Gets the stack value for `key`.n *n * @privaten * @name getn * @memberOf Stackn * @param {string} key The key of the value to get.n * @returns {*} Returns the entry value.n */nnnfunction stackGet(key) {n return this.__data__.get(key);n}n/**n * Checks if a stack value for `key` exists.n *n * @privaten * @name hasn * @memberOf Stackn * @param {string} key The key of the entry to check.n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.n */nnnfunction stackHas(key) {n return this.__data__.has(key);n}n/**n * Sets the stack `key` to `value`.n *n * @privaten * @name setn * @memberOf Stackn * @param {string} key The key of the value to set.n * @param {*} value The value to set.n * @returns {Object} Returns the stack cache instance.n */nnnfunction stackSet(key, value) {n var cache = this.__data__;nn if (cache instanceof ListCache) {n var pairs = cache.__data__;nn if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {n pairs.push([key, value]);n return this;n }nn cache = this.__data__ = new MapCache(pairs);n }nn cache.set(key, value);n return this;n} // Add methods to `Stack`.nnnStack.prototype.clear = stackClear;nStack.prototype = stackDelete;nStack.prototype.get = stackGet;nStack.prototype.has = stackHas;nStack.prototype.set = stackSet;n/**n * Creates an array of the enumerable property names of the array-like `value`.n *n * @privaten * @param {*} value The value to query.n * @param {boolean} inherited Specify returning inherited property names.n * @returns {Array} Returns the array of property names.n */nnfunction arrayLikeKeys(value, inherited) {n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.n // Safari 9 makes `arguments.length` enumerable in strict mode.n var result = isArray(value) || isArguments(value) ? baseTimes(value.length, String) : [];n var length = result.length,n skipIndexes = !!length;nn for (var key in value) {n if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (key == 'length' || isIndex(key, length)))) {n result.push(key);n }n }nn return result;n}n/**n * Gets the index at which the `key` is found in `array` of key-value pairs.n *n * @privaten * @param {Array} array The array to inspect.n * @param {*} key The key to search for.n * @returns {number} Returns the index of the matched value, else `-1`.n */nnnfunction assocIndexOf(array, key) {n var length = array.length;nn while (length–) {n if (eq(array[0], key)) {n return length;n }n }nn return -1;n}n/**n * The base implementation of `_.forEach` without support for iteratee shorthands.n *n * @privaten * @param {Array|Object} collection The collection to iterate over.n * @param {Function} iteratee The function invoked per iteration.n * @returns {Array|Object} Returns `collection`.n */nnnvar baseEach = createBaseEach(baseForOwn);n/**n * The base implementation of `_.flatten` with support for restricting flattening.n *n * @privaten * @param {Array} array The array to flatten.n * @param {number} depth The maximum recursion depth.n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.n * @param {Array} [result= The initial result value.n * @returns {Array} Returns the new flattened array.n */nnfunction baseFlatten(array, depth, predicate, isStrict, result) {n var index = -1,n length = array.length;n predicate || (predicate = isFlattenable);n result || (result = []);nn while (++index < length) {n var value = array;nn if (depth > 0 && predicate(value)) {n if (depth > 1) {n // Recursively flatten arrays (susceptible to call stack limits).n baseFlatten(value, depth - 1, predicate, isStrict, result);n } else {n arrayPush(result, value);n }n } else if (!isStrict) {n result = value;n }n }nn return result;n}n/**n * The base implementation of `baseForOwn` which iterates over `object`n * properties returned by `keysFunc` and invokes `iteratee` for each property.n * Iteratee functions may exit iteration early by explicitly returning `false`.n *n * @privaten * @param {Object} object The object to iterate over.n * @param {Function} iteratee The function invoked per iteration.n * @param {Function} keysFunc The function to get the keys of `object`.n * @returns {Object} Returns `object`.n */nnnvar baseFor = createBaseFor();n/**n * The base implementation of `_.forOwn` without support for iteratee shorthands.n *n * @privaten * @param {Object} object The object to iterate over.n * @param {Function} iteratee The function invoked per iteration.n * @returns {Object} Returns `object`.n */nnfunction baseForOwn(object, iteratee) {n return object && baseFor(object, iteratee, keys);n}n/**n * The base implementation of `_.get` without support for default values.n *n * @privaten * @param {Object} object The object to query.n * @param {Array|string} path The path of the property to get.n * @returns {*} Returns the resolved value.n */nnnfunction baseGet(object, path) {n path = isKey(path, object) ? [path] : castPath(path);n var index = 0,n length = path.length;nn while (object != null && index < length) {n object = object[toKey(path)];n }nn return index && index == length ? object : undefined;n}n/**n * The base implementation of `getTag`.n *n * @privaten * @param {*} value The value to query.n * @returns {string} Returns the `toStringTag`.n */nnnfunction baseGetTag(value) {n return objectToString.call(value);n}n/**n * The base implementation of `_.hasIn` without support for deep paths.n *n * @privaten * @param {Object} [object] The object to query.n * @param {Array|string} key The key to check.n * @returns {boolean} Returns `true` if `key` exists, else `false`.n */nnnfunction baseHasIn(object, key) {n return object != null && key in Object(object);n}n/**n * The base implementation of `_.isEqual` which supports partial comparisonsn * and tracks traversed objects.n *n * @privaten * @param {*} value The value to compare.n * @param {*} other The other value to compare.n * @param {Function} [customizer] The function to customize comparisons.n * @param {boolean} [bitmask] The bitmask of comparison flags.n * The bitmask may be composed of the following flags:n * 1 - Unordered comparisonn * 2 - Partial comparisonn * @param {Object} [stack] Tracks traversed `value` and `other` objects.n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.n */nnnfunction baseIsEqual(value, other, customizer, bitmask, stack) {n if (value === other) {n return true;n }nn if (value == null || other == null || !isObject(value) && !isObjectLike(other)) {n return value !== value && other !== other;n }nn return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack);n}n/**n * A specialized version of `baseIsEqual` for arrays and objects which performsn * deep comparisons and tracks traversed objects enabling objects with circularn * references to be compared.n *n * @privaten * @param {Object} object The object to compare.n * @param {Object} other The other object to compare.n * @param {Function} equalFunc The function to determine equivalents of values.n * @param {Function} [customizer] The function to customize comparisons.n * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual`n * for more details.n * @param {Object} [stack] Tracks traversed `object` and `other` objects.n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.n */nnnfunction baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {n var objIsArr = isArray(object),n othIsArr = isArray(other),n objTag = arrayTag,n othTag = arrayTag;nn if (!objIsArr) {n objTag = getTag(object);n objTag = objTag == argsTag ? objectTag : objTag;n }nn if (!othIsArr) {n othTag = getTag(other);n othTag = othTag == argsTag ? objectTag : othTag;n }nn var objIsObj = objTag == objectTag && !isHostObject(object),n othIsObj = othTag == objectTag && !isHostObject(other),n isSameTag = objTag == othTag;nn if (isSameTag && !objIsObj) {n stack || (stack = new Stack());n return objIsArr || isTypedArray(object) ? equalArrays(object, other, equalFunc, customizer, bitmask, stack) : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);n }nn if (!(bitmask & PARTIAL_COMPARE_FLAG)) {n var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),n othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');nn if (objIsWrapped || othIsWrapped) {n var objUnwrapped = objIsWrapped ? object.value() : object,n othUnwrapped = othIsWrapped ? other.value() : other;n stack || (stack = new Stack());n return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack);n }n }nn if (!isSameTag) {n return false;n }nn stack || (stack = new Stack());n return equalObjects(object, other, equalFunc, customizer, bitmask, stack);n}n/**n * The base implementation of `_.isMatch` without support for iteratee shorthands.n *n * @privaten * @param {Object} object The object to inspect.n * @param {Object} source The object of property values to match.n * @param {Array} matchData The property names, values, and compare flags to match.n * @param {Function} [customizer] The function to customize comparisons.n * @returns {boolean} Returns `true` if `object` is a match, else `false`.n */nnnfunction baseIsMatch(object, source, matchData, customizer) {n var index = matchData.length,n length = index,n noCustomizer = !customizer;nn if (object == null) {n return !length;n }nn object = Object(object);nn while (index–) {n var data = matchData;nn if (noCustomizer && data ? data !== object[data] : !(data in object)) {n return false;n }n }nn while (++index < length) {n data = matchData;n var key = data,n objValue = object,n srcValue = data;nn if (noCustomizer && data) {n if (objValue === undefined && !(key in object)) {n return false;n }n } else {n var stack = new Stack();nn if (customizer) {n var result = customizer(objValue, srcValue, key, object, source, stack);n }nn if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack) : result)) {n return false;n }n }n }nn return true;n}n/**n * The base implementation of `_.isNative` without bad shim checks.n *n * @privaten * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is a native function,n * else `false`.n */nnnfunction baseIsNative(value) {n if (!isObject(value) || isMasked(value)) {n return false;n }nn var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;n return pattern.test(toSource(value));n}n/**n * The base implementation of `_.isTypedArray` without Node.js optimizations.n *n * @privaten * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.n */nnnfunction baseIsTypedArray(value) {n return isObjectLike(value) && isLength(value.length) && !!typedArrayTags;n}n/**n * The base implementation of `_.iteratee`.n *n * @privaten * @param {*} [value=_.identity] The value to convert to an iteratee.n * @returns {Function} Returns the iteratee.n */nnnfunction baseIteratee(value) {n // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.n // See bugs.webkit.org/show_bug.cgi?id=156034 for more details.n if (typeof value == 'function') {n return value;n }nn if (value == null) {n return identity;n }nn if (_typeof(value) == 'object') {n return isArray(value) ? baseMatchesProperty(value, value) : baseMatches(value);n }nn return property(value);n}n/**n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.n *n * @privaten * @param {Object} object The object to query.n * @returns {Array} Returns the array of property names.n */nnnfunction baseKeys(object) {n if (!isPrototype(object)) {n return nativeKeys(object);n }nn var result = [];nn for (var key in Object(object)) {n if (hasOwnProperty.call(object, key) && key != 'constructor') {n result.push(key);n }n }nn return result;n}n/**n * The base implementation of `_.map` without support for iteratee shorthands.n *n * @privaten * @param {Array|Object} collection The collection to iterate over.n * @param {Function} iteratee The function invoked per iteration.n * @returns {Array} Returns the new mapped array.n */nnnfunction baseMap(collection, iteratee) {n var index = -1,n result = isArrayLike(collection) ? Array(collection.length) : [];n baseEach(collection, function (value, key, collection) {n result = iteratee(value, key, collection);n });n return result;n}n/**n * The base implementation of `_.matches` which doesn't clone `source`.n *n * @privaten * @param {Object} source The object of property values to match.n * @returns {Function} Returns the new spec function.n */nnnfunction baseMatches(source) {n var matchData = getMatchData(source);nn if (matchData.length == 1 && matchData[2]) {n return matchesStrictComparable(matchData[0], matchData[1]);n }nn return function (object) {n return object === source || baseIsMatch(object, source, matchData);n };n}n/**n * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.n *n * @privaten * @param {string} path The path of the property to get.n * @param {*} srcValue The value to match.n * @returns {Function} Returns the new spec function.n */nnnfunction baseMatchesProperty(path, srcValue) {n if (isKey(path) && isStrictComparable(srcValue)) {n return matchesStrictComparable(toKey(path), srcValue);n }nn return function (object) {n var objValue = get(object, path);n return objValue === undefined && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);n };n}n/**n * A specialized version of `baseProperty` which supports deep paths.n *n * @privaten * @param {Array|string} path The path of the property to get.n * @returns {Function} Returns the new accessor function.n */nnnfunction basePropertyDeep(path) {n return function (object) {n return baseGet(object, path);n };n}n/**n * The base implementation of `_.toString` which doesn't convert nullishn * values to empty strings.n *n * @privaten * @param {*} value The value to process.n * @returns {string} Returns the string.n */nnnfunction baseToString(value) {n // Exit early for strings to avoid a performance hit in some environments.n if (typeof value == 'string') {n return value;n }nn if (isSymbol(value)) {n return symbolToString ? symbolToString.call(value) : '';n }nn var result = value + '';n return result == '0' && 1 / value == -INFINITY ? '-0' : result;n}n/**n * Casts `value` to a path array if it's not one.n *n * @privaten * @param {*} value The value to inspect.n * @returns {Array} Returns the cast property path array.n */nnnfunction castPath(value) {n return isArray(value) ? value : stringToPath(value);n}n/**n * Creates a `baseEach` or `baseEachRight` function.n *n * @privaten * @param {Function} eachFunc The function to iterate over a collection.n * @param {boolean} [fromRight] Specify iterating from right to left.n * @returns {Function} Returns the new base function.n */nnnfunction createBaseEach(eachFunc, fromRight) {n return function (collection, iteratee) {n if (collection == null) {n return collection;n }nn if (!isArrayLike(collection)) {n return eachFunc(collection, iteratee);n }nn var length = collection.length,n index = fromRight ? length : -1,n iterable = Object(collection);nn while (fromRight ? index– : ++index < length) {n if (iteratee(iterable, index, iterable) === false) {n break;n }n }nn return collection;n };n}n/**n * Creates a base function for methods like `_.forIn` and `_.forOwn`.n *n * @privaten * @param {boolean} [fromRight] Specify iterating from right to left.n * @returns {Function} Returns the new base function.n */nnnfunction createBaseFor(fromRight) {n return function (object, iteratee, keysFunc) {n var index = -1,n iterable = Object(object),n props = keysFunc(object),n length = props.length;nn while (length–) {n var key = props[fromRight ? length : ++index];nn if (iteratee(iterable, key, iterable) === false) {n break;n }n }nn return object;n };n}n/**n * A specialized version of `baseIsEqualDeep` for arrays with support forn * partial deep comparisons.n *n * @privaten * @param {Array} array The array to compare.n * @param {Array} other The other array to compare.n * @param {Function} equalFunc The function to determine equivalents of values.n * @param {Function} customizer The function to customize comparisons.n * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`n * for more details.n * @param {Object} stack Tracks traversed `array` and `other` objects.n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.n */nnnfunction equalArrays(array, other, equalFunc, customizer, bitmask, stack) {n var isPartial = bitmask & PARTIAL_COMPARE_FLAG,n arrLength = array.length,n othLength = other.length;nn if (arrLength != othLength && !(isPartial && othLength > arrLength)) {n return false;n } // Assume cyclic values are equal.nnn var stacked = stack.get(array);nn if (stacked && stack.get(other)) {n return stacked == other;n }nn var index = -1,n result = true,n seen = bitmask & UNORDERED_COMPARE_FLAG ? new SetCache() : undefined;n stack.set(array, other);n stack.set(other, array); // Ignore non-index properties.nn while (++index < arrLength) {n var arrValue = array,n othValue = other;nn if (customizer) {n var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);n }nn if (compared !== undefined) {n if (compared) {n continue;n }nn result = false;n break;n } // Recursively compare arrays (susceptible to call stack limits).nnn if (seen) {n if (!arraySome(other, function (othValue, othIndex) {n if (!seen.has(othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {n return seen.add(othIndex);n }n })) {n result = false;n break;n }n } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {n result = false;n break;n }n }nn stack(array);n stack(other);n return result;n}n/**n * A specialized version of `baseIsEqualDeep` for comparing objects ofn * the same `toStringTag`.n *n * Note: This function only supports comparing values with tags ofn * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.n *n * @privaten * @param {Object} object The object to compare.n * @param {Object} other The other object to compare.n * @param {string} tag The `toStringTag` of the objects to compare.n * @param {Function} equalFunc The function to determine equivalents of values.n * @param {Function} customizer The function to customize comparisons.n * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`n * for more details.n * @param {Object} stack Tracks traversed `object` and `other` objects.n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.n */nnnfunction equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {n switch (tag) {n case dataViewTag:n if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {n return false;n }nn object = object.buffer;n other = other.buffer;nn case arrayBufferTag:n if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {n return false;n }nn return true;nn case boolTag:n case dateTag:n case numberTag:n // Coerce booleans to `1` or `0` and dates to milliseconds.n // Invalid dates are coerced to `NaN`.n return eq(+object, +other);nn case errorTag:n return object.name == other.name && object.message == other.message;nn case regexpTag:n case stringTag:n // Coerce regexes to strings and treat strings, primitives and objects,n // as equal. See www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostringn // for more details.n return object == other + '';nn case mapTag:n var convert = mapToArray;nn case setTag:n var isPartial = bitmask & PARTIAL_COMPARE_FLAG;n convert || (convert = setToArray);nn if (object.size != other.size && !isPartial) {n return false;n } // Assume cyclic values are equal.nnn var stacked = stack.get(object);nn if (stacked) {n return stacked == other;n }nn bitmask |= UNORDERED_COMPARE_FLAG; // Recursively compare objects (susceptible to call stack limits).nn stack.set(object, other);n var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);n stack(object);n return result;nn case symbolTag:n if (symbolValueOf) {n return symbolValueOf.call(object) == symbolValueOf.call(other);n }nn }nn return false;n}n/**n * A specialized version of `baseIsEqualDeep` for objects with support forn * partial deep comparisons.n *n * @privaten * @param {Object} object The object to compare.n * @param {Object} other The other object to compare.n * @param {Function} equalFunc The function to determine equivalents of values.n * @param {Function} customizer The function to customize comparisons.n * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`n * for more details.n * @param {Object} stack Tracks traversed `object` and `other` objects.n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.n */nnnfunction equalObjects(object, other, equalFunc, customizer, bitmask, stack) {n var isPartial = bitmask & PARTIAL_COMPARE_FLAG,n objProps = keys(object),n objLength = objProps.length,n othProps = keys(other),n othLength = othProps.length;nn if (objLength != othLength && !isPartial) {n return false;n }nn var index = objLength;nn while (index–) {n var key = objProps;nn if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {n return false;n }n } // Assume cyclic values are equal.nnn var stacked = stack.get(object);nn if (stacked && stack.get(other)) {n return stacked == other;n }nn var result = true;n stack.set(object, other);n stack.set(other, object);n var skipCtor = isPartial;nn while (++index < objLength) {n key = objProps;n var objValue = object,n othValue = other;nn if (customizer) {n var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);n } // Recursively compare objects (susceptible to call stack limits).nnn if (!(compared === undefined ? objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack) : compared)) {n result = false;n break;n }nn skipCtor || (skipCtor = key == 'constructor');n }nn if (result && !skipCtor) {n var objCtor = object.constructor,n othCtor = other.constructor; // Non `Object` object instances with different constructors are not equal.nn if (objCtor != othCtor && 'constructor' in object && 'constructor' in other && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) {n result = false;n }n }nn stack(object);n stack(other);n return result;n}n/**n * Gets the data for `map`.n *n * @privaten * @param {Object} map The map to query.n * @param {string} key The reference key.n * @returns {*} Returns the map data.n */nnnfunction getMapData(map, key) {n var data = map.__data__;n return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;n}n/**n * Gets the property names, values, and compare flags of `object`.n *n * @privaten * @param {Object} object The object to query.n * @returns {Array} Returns the match data of `object`.n */nnnfunction getMatchData(object) {n var result = keys(object),n length = result.length;nn while (length–) {n var key = result,n value = object;n result = [key, value, isStrictComparable(value)];n }nn return result;n}n/**n * Gets the native function at `key` of `object`.n *n * @privaten * @param {Object} object The object to query.n * @param {string} key The key of the method to get.n * @returns {*} Returns the function if it's native, else `undefined`.n */nnnfunction getNative(object, key) {n var value = getValue(object, key);n return baseIsNative(value) ? value : undefined;n}n/**n * Gets the `toStringTag` of `value`.n *n * @privaten * @param {*} value The value to query.n * @returns {string} Returns the `toStringTag`.n */nnnvar getTag = baseGetTag; // Fallback for data views, maps, sets, and weak maps in IE 11,n// for data views in Edge < 14, and promises in Node.js.nnif (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise && getTag(Promise.resolve()) != promiseTag || Set && getTag(new Set()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {n getTag = function getTag(value) {n var result = objectToString.call(value),n Ctor = result == objectTag ? value.constructor : undefined,n ctorString = Ctor ? toSource(Ctor) : undefined;nn if (ctorString) {n switch (ctorString) {n case dataViewCtorString:n return dataViewTag;nn case mapCtorString:n return mapTag;nn case promiseCtorString:n return promiseTag;nn case setCtorString:n return setTag;nn case weakMapCtorString:n return weakMapTag;n }n }nn return result;n };n}n/**n * Checks if `path` exists on `object`.n *n * @privaten * @param {Object} object The object to query.n * @param {Array|string} path The path to check.n * @param {Function} hasFunc The function to check properties.n * @returns {boolean} Returns `true` if `path` exists, else `false`.n */nnnfunction hasPath(object, path, hasFunc) {n path = isKey(path, object) ? [path] : castPath(path);n var result,n index = -1,n length = path.length;nn while (++index < length) {n var key = toKey(path);nn if (!(result = object != null && hasFunc(object, key))) {n break;n }nn object = object;n }nn if (result) {n return result;n }nn var length = object ? object.length : 0;n return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));n}n/**n * Checks if `value` is a flattenable `arguments` object or array.n *n * @privaten * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.n */nnnfunction isFlattenable(value) {n return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value);n}n/**n * Checks if `value` is a valid array-like index.n *n * @privaten * @param {*} value The value to check.n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.n */nnnfunction isIndex(value, length) {n length = length == null ? MAX_SAFE_INTEGER : length;n return !!length && (typeof value == 'number' || reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;n}n/**n * Checks if `value` is a property name and not a property path.n *n * @privaten * @param {*} value The value to check.n * @param {Object} [object] The object to query keys on.n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.n */nnnfunction isKey(value, object) {n if (isArray(value)) {n return false;n }nn var type = _typeof(value);nn if (type == 'number' || type == 'symbol' || type == 'boolean' || value == null || isSymbol(value)) {n return true;n }nn return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);n}n/**n * Checks if `value` is suitable for use as unique object key.n *n * @privaten * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.n */nnnfunction isKeyable(value) {n var type = _typeof(value);nn return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null;n}n/**n * Checks if `func` has its source masked.n *n * @privaten * @param {Function} func The function to check.n * @returns {boolean} Returns `true` if `func` is masked, else `false`.n */nnnfunction isMasked(func) {n return !!maskSrcKey && maskSrcKey in func;n}n/**n * Checks if `value` is likely a prototype object.n *n * @privaten * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.n */nnnfunction isPrototype(value) {n var Ctor = value && value.constructor,n proto = typeof Ctor == 'function' && Ctor.prototype || objectProto;n return value === proto;n}n/**n * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.n *n * @privaten * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` if suitable for strictn * equality comparisons, else `false`.n */nnnfunction isStrictComparable(value) {n return value === value && !isObject(value);n}n/**n * A specialized version of `matchesProperty` for source values suitablen * for strict equality comparisons, i.e. `===`.n *n * @privaten * @param {string} key The key of the property to get.n * @param {*} srcValue The value to match.n * @returns {Function} Returns the new spec function.n */nnnfunction matchesStrictComparable(key, srcValue) {n return function (object) {n if (object == null) {n return false;n }nn return object === srcValue && (srcValue !== undefined || key in Object(object));n };n}n/**n * Converts `string` to a property path array.n *n * @privaten * @param {string} string The string to convert.n * @returns {Array} Returns the property path array.n */nnnvar stringToPath = memoize(function (string) {n string = toString(string);n var result = [];nn if (reLeadingDot.test(string)) {n result.push('');n }nn string.replace(rePropName, function (match, number, quote, string) {n result.push(quote ? string.replace(reEscapeChar, '$1') : number || match);n });n return result;n});n/**n * Converts `value` to a string key if it's not a string or symbol.n *n * @privaten * @param {*} value The value to inspect.n * @returns {string|symbol} Returns the key.n */nnfunction toKey(value) {n if (typeof value == 'string' || isSymbol(value)) {n return value;n }nn var result = value + '';n return result == '0' && 1 / value == -INFINITY ? '-0' : result;n}n/**n * Converts `func` to its source code.n *n * @privaten * @param {Function} func The function to process.n * @returns {string} Returns the source code.n */nnnfunction toSource(func) {n if (func != null) {n try {n return funcToString.call(func);n } catch (e) {}nn try {n return func + '';n } catch (e) {}n }nn return '';n}n/**n * Creates a flattened array of values by running each element in `collection`n * thru `iteratee` and flattening the mapped results. The iteratee is invokedn * with three arguments: (value, index|key, collection).n *n * @staticn * @memberOf _n * @since 4.0.0n * @category Collectionn * @param {Array|Object} collection The collection to iterate over.n * @param {Function} [iteratee=_.identity]n * The function invoked per iteration.n * @returns {Array} Returns the new flattened array.n * @examplen *n * function duplicate(n) {n * return [n, n];n * }n *n * _.flatMap([1, 2], duplicate);n * // => [1, 1, 2, 2]n */nnnfunction flatMap(collection, iteratee) {n return baseFlatten(map(collection, iteratee), 1);n}n/**n * Creates an array of values by running each element in `collection` thrun * `iteratee`. The iteratee is invoked with three arguments:n * (value, index|key, collection).n *n * Many lodash methods are guarded to work as iteratees for methods liken * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.n *n * The guarded methods are:n * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,n * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,n * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,n * `template`, `trim`, `trimEnd`, `trimStart`, and `words`n *n * @staticn * @memberOf _n * @since 0.1.0n * @category Collectionn * @param {Array|Object} collection The collection to iterate over.n * @param {Function} [iteratee=_.identity] The function invoked per iteration.n * @returns {Array} Returns the new mapped array.n * @examplen *n * function square(n) {n * return n * n;n * }n *n * _.map([4, 8], square);n * // => [16, 64]n *n * _.map({ 'a': 4, 'b': 8 }, square);n * // => [16, 64] (iteration order is not guaranteed)n *n * var users = [n * { 'user': 'barney' },n * { 'user': 'fred' }n * ];n *n * // The `_.property` iteratee shorthand.n * _.map(users, 'user');n * // => ['barney', 'fred']n */nnnfunction map(collection, iteratee) {n var func = isArray(collection) ? arrayMap : baseMap;n return func(collection, baseIteratee(iteratee, 3));n}n/**n * Creates a function that memoizes the result of `func`. If `resolver` isn * provided, it determines the cache key for storing the result based on then * arguments provided to the memoized function. By default, the first argumentn * provided to the memoized function is used as the map cache key. The `func`n * is invoked with the `this` binding of the memoized function.n *n * Note: The cache is exposed as the `cache` property on the memoizedn * function. Its creation may be customized by replacing the `_.memoize.Cache`n * constructor with one whose instances implement then * [`Map`](ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)n * method interface of `delete`, `get`, `has`, and `set`.n *n * @staticn * @memberOf _n * @since 0.1.0n * @category Functionn * @param {Function} func The function to have its output memoized.n * @param {Function} [resolver] The function to resolve the cache key.n * @returns {Function} Returns the new memoized function.n * @examplen *n * var object = { 'a': 1, 'b': 2 };n * var other = { 'c': 3, 'd': 4 };n *n * var values = .memoize(.values);n * values(object);n * // => [1, 2]n *n * values(other);n * // => [3, 4]n *n * object.a = 2;n * values(object);n * // => [1, 2]n *n * // Modify the result cache.n * values.cache.set(object, ['a', 'b']);n * values(object);n * // => ['a', 'b']n *n * // Replace `_.memoize.Cache`.n * _.memoize.Cache = WeakMap;n */nnnfunction memoize(func, resolver) {n if (typeof func != 'function' || resolver && typeof resolver != 'function') {n throw new TypeError(FUNC_ERROR_TEXT);n }nn var memoized = function memoized() {n var args = arguments,n key = resolver ? resolver.apply(this, args) : args,n cache = memoized.cache;nn if (cache.has(key)) {n return cache.get(key);n }nn var result = func.apply(this, args);n memoized.cache = cache.set(key, result);n return result;n };nn memoized.cache = new (memoize.Cache || MapCache)();n return memoized;n} // Assign cache to `_.memoize`.nnnmemoize.Cache = MapCache;n/**n * Performs an * [`SameValueZero`](ecma-international.org/ecma-262/7.0/#sec-samevaluezero)n * comparison between two values to determine if they are equivalent.n *n * @staticn * @memberOf _n * @since 4.0.0n * @category Langn * @param {*} value The value to compare.n * @param {*} other The other value to compare.n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.n * @examplen *n * var object = { 'a': 1 };n * var other = { 'a': 1 };n *n * _.eq(object, object);n * // => truen *n * _.eq(object, other);n * // => falsen *n * _.eq('a', 'a');n * // => truen *n * _.eq('a', Object('a'));n * // => falsen *n * _.eq(NaN, NaN);n * // => truen */nnfunction eq(value, other) {n return value === other || value !== value && other !== other;n}n/**n * Checks if `value` is likely an `arguments` object.n *n * @staticn * @memberOf _n * @since 0.1.0n * @category Langn * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is an `arguments` object,n * else `false`.n * @examplen *n * _.isArguments(function() { return arguments; }());n * // => truen *n * _.isArguments([1, 2, 3]);n * // => falsen */nnnfunction isArguments(value) {n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.n return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') && (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);n}n/**n * Checks if `value` is classified as an `Array` object.n *n * @staticn * @memberOf _n * @since 0.1.0n * @category Langn * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is an array, else `false`.n * @examplen *n * _.isArray([1, 2, 3]);n * // => truen *n * _.isArray(document.body.children);n * // => falsen *n * _.isArray('abc');n * // => falsen *n * .isArray(.noop);n * // => falsen */nnnvar isArray = Array.isArray;n/**n * Checks if `value` is array-like. A value is considered array-like if it'sn * not a function and has a `value.length` that's an integer greater than orn * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.n *n * @staticn * @memberOf _n * @since 4.0.0n * @category Langn * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.n * @examplen *n * _.isArrayLike([1, 2, 3]);n * // => truen *n * _.isArrayLike(document.body.children);n * // => truen *n * _.isArrayLike('abc');n * // => truen *n * .isArrayLike(.noop);n * // => falsen */nnfunction isArrayLike(value) {n return value != null && isLength(value.length) && !isFunction(value);n}n/**n * This method is like `_.isArrayLike` except that it also checks if `value`n * is an object.n *n * @staticn * @memberOf _n * @since 4.0.0n * @category Langn * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is an array-like object,n * else `false`.n * @examplen *n * _.isArrayLikeObject([1, 2, 3]);n * // => truen *n * _.isArrayLikeObject(document.body.children);n * // => truen *n * _.isArrayLikeObject('abc');n * // => falsen *n * .isArrayLikeObject(.noop);n * // => falsen */nnnfunction isArrayLikeObject(value) {n return isObjectLike(value) && isArrayLike(value);n}n/**n * Checks if `value` is classified as a `Function` object.n *n * @staticn * @memberOf _n * @since 0.1.0n * @category Langn * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is a function, else `false`.n * @examplen *n * .isFunction();n * // => truen *n * _.isFunction(/abc/);n * // => falsen */nnnfunction isFunction(value) {n // The use of `Object#toString` avoids issues with the `typeof` operatorn // in Safari 8-9 which returns 'object' for typed array and other constructors.n var tag = isObject(value) ? objectToString.call(value) : '';n return tag == funcTag || tag == genTag;n}n/**n * Checks if `value` is a valid array-like length.n *n * Note: This method is loosely based onn * [`ToLength`](ecma-international.org/ecma-262/7.0/#sec-tolength).n *n * @staticn * @memberOf _n * @since 4.0.0n * @category Langn * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.n * @examplen *n * _.isLength(3);n * // => truen *n * _.isLength(Number.MIN_VALUE);n * // => falsen *n * _.isLength(Infinity);n * // => falsen *n * _.isLength('3');n * // => falsen */nnnfunction isLength(value) {n return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;n}n/**n * Checks if `value` is then * [language type](www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)n *n * @staticn * @memberOf _n * @since 0.1.0n * @category Langn * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is an object, else `false`.n * @examplen *n * _.isObject({});n * // => truen *n * _.isObject([1, 2, 3]);n * // => truen *n * .isObject(.noop);n * // => truen *n * _.isObject(null);n * // => falsen */nnnfunction isObject(value) {n var type = _typeof(value);nn return !!value && (type == 'object' || type == 'function');n}n/**n * Checks if `value` is object-like. A value is object-like if it's not `null`n * and has a `typeof` result of "object".n *n * @staticn * @memberOf _n * @since 4.0.0n * @category Langn * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.n * @examplen *n * _.isObjectLike({});n * // => truen *n * _.isObjectLike([1, 2, 3]);n * // => truen *n * .isObjectLike(.noop);n * // => falsen *n * _.isObjectLike(null);n * // => falsen */nnnfunction isObjectLike(value) {n return !!value && _typeof(value) == 'object';n}n/**n * Checks if `value` is classified as a `Symbol` primitive or object.n *n * @staticn * @memberOf _n * @since 4.0.0n * @category Langn * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.n * @examplen *n * _.isSymbol(Symbol.iterator);n * // => truen *n * _.isSymbol('abc');n * // => falsen */nnnfunction isSymbol(value) {n return _typeof(value) == 'symbol' || isObjectLike(value) && objectToString.call(value) == symbolTag;n}n/**n * Checks if `value` is classified as a typed array.n *n * @staticn * @memberOf _n * @since 3.0.0n * @category Langn * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.n * @examplen *n * _.isTypedArray(new Uint8Array);n * // => truen *n * _.isTypedArray([]);n * // => falsen */nnnvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;n/**n * Converts `value` to a string. An empty string is returned for `null`n * and `undefined` values. The sign of `-0` is preserved.n *n * @staticn * @memberOf _n * @since 4.0.0n * @category Langn * @param {*} value The value to process.n * @returns {string} Returns the string.n * @examplen *n * _.toString(null);n * // => ''n *n * _.toString(-0);n * // => '-0'n *n * _.toString([1, 2, 3]);n * // => '1,2,3'n */nnfunction toString(value) {n return value == null ? '' : baseToString(value);n}n/**n * Gets the value at `path` of `object`. If the resolved value isn * `undefined`, the `defaultValue` is returned in its place.n *n * @staticn * @memberOf _n * @since 3.7.0n * @category Objectn * @param {Object} object The object to query.n * @param {Array|string} path The path of the property to get.n * @param {*} [defaultValue] The value returned for `undefined` resolved values.n * @returns {*} Returns the resolved value.n * @examplen *n * var object = { 'a': [{ 'b': { 'c': 3 } }] };n *n * _.get(object, 'a.b.c');n * // => 3n *n * _.get(object, ['a', '0', 'b', 'c']);n * // => 3n *n * _.get(object, 'a.b.c', 'default');n * // => 'default'n */nnnfunction get(object, path, defaultValue) {n var result = object == null ? undefined : baseGet(object, path);n return result === undefined ? defaultValue : result;n}n/**n * Checks if `path` is a direct or inherited property of `object`.n *n * @staticn * @memberOf _n * @since 4.0.0n * @category Objectn * @param {Object} object The object to query.n * @param {Array|string} path The path to check.n * @returns {boolean} Returns `true` if `path` exists, else `false`.n * @examplen *n * var object = _.create({ 'a': _.create({ 'b': 2 }) });n *n * _.hasIn(object, 'a');n * // => truen *n * _.hasIn(object, 'a.b');n * // => truen *n * _.hasIn(object, ['a', 'b']);n * // => truen *n * _.hasIn(object, 'b');n * // => falsen */nnnfunction hasIn(object, path) {n return object != null && hasPath(object, path, baseHasIn);n}n/**n * Creates an array of the own enumerable property names of `object`.n *n * Note: Non-object values are coerced to objects. See then * [ES spec](ecma-international.org/ecma-262/7.0/#sec-object.keys)n * for more details.n *n * @staticn * @since 0.1.0n * @memberOf _n * @category Objectn * @param {Object} object The object to query.n * @returns {Array} Returns the array of property names.n * @examplen *n * function Foo() {n * this.a = 1;n * this.b = 2;n * }n *n * Foo.prototype.c = 3;n *n * _.keys(new Foo);n * // => ['a', 'b'] (iteration order is not guaranteed)n *n * _.keys('hi');n * // => ['0', '1']n */nnnfunction keys(object) {n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);n}n/**n * This method returns the first argument it receives.n *n * @staticn * @since 0.1.0n * @memberOf _n * @category Utiln * @param {*} value Any value.n * @returns {*} Returns `value`.n * @examplen *n * var object = { 'a': 1 };n *n * console.log(_.identity(object) === object);n * // => truen */nnnfunction identity(value) {n return value;n}n/**n * Creates a function that returns the value at `path` of a given object.n *n * @staticn * @memberOf _n * @since 2.4.0n * @category Utiln * @param {Array|string} path The path of the property to get.n * @returns {Function} Returns the new accessor function.n * @examplen *n * var objects = [n * { 'a': { 'b': 2 } },n * { 'a': { 'b': 1 } }n * ];n *n * _.map(objects, _.property('a.b'));n * // => [2, 1]n *n * .map(.sortBy(objects, _.property(['a', 'b'])), 'a.b');n * // => [1, 2]n */nnnfunction property(path) {n return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);n}nnmodule.exports = flatMap;”,“map”:null,“metadata”:{},“sourceType”:“module”}