{“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 to stand-in for `undefined` hash values. */nnvar HASH_UNDEFINED = 'lodash_hash_undefined';n/** Used as references for various `Number` constants. */nnvar MAX_SAFE_INTEGER = 9007199254740991;n/** `Object#toString` result references. */nnvar argsTag = '[object Arguments]',n funcTag = '[object Function]',n genTag = '[object GeneratorFunction]';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 detect host constructors (Safari). */nnvar reIsHostCtor = /^\[object .+?Constructor\]$/;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/**n * A faster alternative to `Function#apply`, this function invokes `func`n * with the `this` binding of `thisArg` and the arguments of `args`.n *n * @privaten * @param {Function} func The function to invoke.n * @param {*} thisArg The `this` binding of `func`.n * @param {Array} args The arguments to invoke `func` with.n * @returns {*} Returns the result of `func`.n */nnfunction apply(func, thisArg, args) {n switch (args.length) {n case 0:n return func.call(thisArg);nn case 1:n return func.call(thisArg, args);nn case 2:n return func.call(thisArg, args, args);nn case 3:n return func.call(thisArg, args, args, args);n }nn return func.apply(thisArg, args);n}n/**n * A specialized version of `_.includes` for arrays without support forn * specifying an index to search from.n *n * @privaten * @param {Array} [array] The array to inspect.n * @param {*} target The value to search for.n * @returns {boolean} Returns `true` if `target` is found, else `false`.n */nnnfunction arrayIncludes(array, value) {n var length = array ? array.length : 0;n return !!length && baseIndexOf(array, value, 0) > -1;n}n/**n * This function is like `arrayIncludes` except that it accepts a comparator.n *n * @privaten * @param {Array} [array] The array to inspect.n * @param {*} target The value to search for.n * @param {Function} comparator The comparator invoked per element.n * @returns {boolean} Returns `true` if `target` is found, else `false`.n */nnnfunction arrayIncludesWith(array, value, comparator) {n var index = -1,n length = array ? array.length : 0;nn while (++index < length) {n if (comparator(value, array)) {n return true;n }n }nn return false;n}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 */nnnfunction 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 * The base implementation of `_.findIndex` and `_.findLastIndex` withoutn * support for iteratee shorthands.n *n * @privaten * @param {Array} array The array to inspect.n * @param {Function} predicate The function invoked per iteration.n * @param {number} fromIndex The index to search from.n * @param {boolean} [fromRight] Specify iterating from right to left.n * @returns {number} Returns the index of the matched value, else `-1`.n */nnnfunction baseFindIndex(array, predicate, fromIndex, fromRight) {n var length = array.length,n index = fromIndex + (fromRight ? 1 : -1);nn while (fromRight ? index– : ++index < length) {n if (predicate(array, index, array)) {n return index;n }n }nn return -1;n}n/**n * The base implementation of `_.indexOf` without `fromIndex` bounds checks.n *n * @privaten * @param {Array} array The array to inspect.n * @param {*} value The value to search for.n * @param {number} fromIndex The index to search from.n * @returns {number} Returns the index of the matched value, else `-1`.n */nnnfunction baseIndexOf(array, value, fromIndex) {n if (value !== value) {n return baseFindIndex(array, baseIsNaN, fromIndex);n }nn var index = fromIndex - 1,n length = array.length;nn while (++index < length) {n if (array === value) {n return index;n }n }nn return -1;n}n/**n * The base implementation of `_.isNaN` without support for number objects.n *n * @privaten * @param {*} value The value to check.n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.n */nnnfunction baseIsNaN(value) {n return value !== value;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 * Checks if a cache value for `key` exists.n *n * @privaten * @param {Object} cache The cache to query.n * @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 cacheHas(cache, key) {n return cache.has(key);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/** 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 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 nativeMax = Math.max;n/* Built-in method references that are verified to be native. */nnvar Map = getNative(root, 'Map'),n nativeCreate = getNative(Object
, 'create');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 * 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 */nnfunction 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 methods like `_.difference` without supportn * for excluding multiple arrays or iteratee shorthands.n *n * @privaten * @param {Array} array The array to inspect.n * @param {Array} values The values to exclude.n * @param {Function} [iteratee] The iteratee invoked per element.n * @param {Function} [comparator] The comparator invoked per element.n * @returns {Array} Returns the new array of filtered values.n */nnnfunction baseDifference(array, values, iteratee, comparator) {n var index = -1,n includes = arrayIncludes,n isCommon = true,n length = array.length,n result = [],n valuesLength = values.length;nn if (!length) {n return result;n }nn if (iteratee) {n values = arrayMap(values, baseUnary(iteratee));n }nn if (comparator) {n includes = arrayIncludesWith;n isCommon = false;n } else if (values.length >= LARGE_ARRAY_SIZE) {n includes = cacheHas;n isCommon = false;n values = new SetCache(values);n }nn outer: while (++index < length) {n var value = array,n computed = iteratee ? iteratee(value) : value;n value = comparator || value !== 0 ? value : 0;nn if (isCommon && computed === computed) {n var valuesIndex = valuesLength;nn while (valuesIndex–) {n if (values === computed) {n continue outer;n }n }nn result.push(value);n } else if (!includes(values, computed, comparator)) {n result.push(value);n }n }nn return result;n}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 */nnnfunction 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 `_.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 `_.rest` which doesn't validate or coerce arguments.n *n * @privaten * @param {Function} func The function to apply a rest parameter to.n * @param {number} [start=func.length-1] The start position of the rest parameter.n * @returns {Function} Returns the new function.n */nnnfunction baseRest(func, start) {n start = nativeMax(start === undefined ? func.length - 1 : start, 0);n return function () {n var args = arguments,n index = -1,n length = nativeMax(args.length - start, 0),n array = Array(length);nn while (++index < length) {n array = args[start + index];n }nn index = -1;n var otherArgs = Array(start + 1);nn while (++index < start) {n otherArgs = args;n }nn otherArgs = array;n return apply(func, this, otherArgs);n };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 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 * 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 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 * 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 an array of `array` values not included in the other given arraysn * using [`SameValueZero`](ecma-international.org/ecma-262/7.0/#sec-samevaluezero)n * for equality comparisons. The order of result values is determined by then * order they occur in the first array.n *n * Note: Unlike `_.pullAll`, this method returns a new array.n *n * @staticn * @memberOf _n * @since 0.1.0n * @category Arrayn * @param {Array} array The array to inspect.n * @param {…Array} [values] The values to exclude.n * @returns {Array} Returns the new array of filtered values.n * @see _.without, _.xorn * @examplen *n * _.difference([2, 1], [2, 3]);n * // => [1]n */nnnvar difference = baseRest(function (array, values) {n return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true)) : [];n});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}nnmodule.exports = difference;”,“map”:null,“metadata”:{},“sourceType”:“module”}