| /** |
| * lodash (Custom Build) <https://lodash.com/> |
| * Build: `lodash modularize exports="npm" -o ./` |
| * Copyright jQuery Foundation and other contributors <https://jquery.org/> |
| * Released under MIT license <https://lodash.com/license> |
| * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE> |
| * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| */ |
| |
| /** Used as the `TypeError` message for "Functions" methods. */ |
| var FUNC_ERROR_TEXT = 'Expected a function'; |
| |
| /** Used to stand-in for `undefined` hash values. */ |
| var HASH_UNDEFINED = '__lodash_hash_undefined__'; |
| |
| /** Used as references for various `Number` constants. */ |
| var INFINITY = 1 / 0; |
| |
| /** `Object#toString` result references. */ |
| var funcTag = '[object Function]', |
| genTag = '[object GeneratorFunction]', |
| symbolTag = '[object Symbol]'; |
| |
| /** Used to match property names within property paths. */ |
| var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, |
| reIsPlainProp = /^\w*$/, |
| reLeadingDot = /^\./, |
| rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; |
| |
| /** |
| * Used to match `RegExp` |
| * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). |
| */ |
| var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; |
| |
| /** Used to match backslashes in property paths. */ |
| var reEscapeChar = /\\(\\)?/g; |
| |
| /** Used to detect host constructors (Safari). */ |
| var reIsHostCtor = /^\[object .+?Constructor\]$/; |
| |
| /** Detect free variable `global` from Node.js. */ |
| var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; |
| |
| /** Detect free variable `self`. */ |
| var freeSelf = typeof self == 'object' && self && self.Object === Object && self; |
| |
| /** Used as a reference to the global object. */ |
| var root = freeGlobal || freeSelf || Function('return this')(); |
| |
| /** |
| * Gets the value at `key` of `object`. |
| * |
| * @private |
| * @param {Object} [object] The object to query. |
| * @param {string} key The key of the property to get. |
| * @returns {*} Returns the property value. |
| */ |
| function getValue(object, key) { |
| return object == null ? undefined : object[key]; |
| } |
| |
| /** |
| * Checks if `value` is a host object in IE < 9. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a host object, else `false`. |
| */ |
| function isHostObject(value) { |
| // Many host objects are `Object` objects that can coerce to strings |
| // despite having improperly defined `toString` methods. |
| var result = false; |
| if (value != null && typeof value.toString != 'function') { |
| try { |
| result = !!(value + ''); |
| } catch (e) {} |
| } |
| return result; |
| } |
| |
| /** Used for built-in method references. */ |
| var arrayProto = Array.prototype, |
| funcProto = Function.prototype, |
| objectProto = Object.prototype; |
| |
| /** Used to detect overreaching core-js shims. */ |
| var coreJsData = root['__core-js_shared__']; |
| |
| /** Used to detect methods masquerading as native. */ |
| var maskSrcKey = (function() { |
| var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); |
| return uid ? ('Symbol(src)_1.' + uid) : ''; |
| }()); |
| |
| /** Used to resolve the decompiled source of functions. */ |
| var funcToString = funcProto.toString; |
| |
| /** Used to check objects for own properties. */ |
| var hasOwnProperty = objectProto.hasOwnProperty; |
| |
| /** |
| * Used to resolve the |
| * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) |
| * of values. |
| */ |
| var objectToString = objectProto.toString; |
| |
| /** Used to detect if a method is native. */ |
| var reIsNative = RegExp('^' + |
| funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') |
| .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' |
| ); |
| |
| /** Built-in value references. */ |
| var Symbol = root.Symbol, |
| splice = arrayProto.splice; |
| |
| /* Built-in method references that are verified to be native. */ |
| var Map = getNative(root, 'Map'), |
| nativeCreate = getNative(Object, 'create'); |
| |
| /** Used to convert symbols to primitives and strings. */ |
| var symbolProto = Symbol ? Symbol.prototype : undefined, |
| symbolToString = symbolProto ? symbolProto.toString : undefined; |
| |
| /** |
| * Creates a hash object. |
| * |
| * @private |
| * @constructor |
| * @param {Array} [entries] The key-value pairs to cache. |
| */ |
| function Hash(entries) { |
| var index = -1, |
| length = entries ? entries.length : 0; |
| |
| this.clear(); |
| while (++index < length) { |
| var entry = entries[index]; |
| this.set(entry[0], entry[1]); |
| } |
| } |
| |
| /** |
| * Removes all key-value entries from the hash. |
| * |
| * @private |
| * @name clear |
| * @memberOf Hash |
| */ |
| function hashClear() { |
| this.__data__ = nativeCreate ? nativeCreate(null) : {}; |
| } |
| |
| /** |
| * Removes `key` and its value from the hash. |
| * |
| * @private |
| * @name delete |
| * @memberOf Hash |
| * @param {Object} hash The hash to modify. |
| * @param {string} key The key of the value to remove. |
| * @returns {boolean} Returns `true` if the entry was removed, else `false`. |
| */ |
| function hashDelete(key) { |
| return this.has(key) && delete this.__data__[key]; |
| } |
| |
| /** |
| * Gets the hash value for `key`. |
| * |
| * @private |
| * @name get |
| * @memberOf Hash |
| * @param {string} key The key of the value to get. |
| * @returns {*} Returns the entry value. |
| */ |
| function hashGet(key) { |
| var data = this.__data__; |
| if (nativeCreate) { |
| var result = data[key]; |
| return result === HASH_UNDEFINED ? undefined : result; |
| } |
| return hasOwnProperty.call(data, key) ? data[key] : undefined; |
| } |
| |
| /** |
| * Checks if a hash value for `key` exists. |
| * |
| * @private |
| * @name has |
| * @memberOf Hash |
| * @param {string} key The key of the entry to check. |
| * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. |
| */ |
| function hashHas(key) { |
| var data = this.__data__; |
| return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key); |
| } |
| |
| /** |
| * Sets the hash `key` to `value`. |
| * |
| * @private |
| * @name set |
| * @memberOf Hash |
| * @param {string} key The key of the value to set. |
| * @param {*} value The value to set. |
| * @returns {Object} Returns the hash instance. |
| */ |
| function hashSet(key, value) { |
| var data = this.__data__; |
| data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; |
| return this; |
| } |
| |
| // Add methods to `Hash`. |
| Hash.prototype.clear = hashClear; |
| Hash.prototype['delete'] = hashDelete; |
| Hash.prototype.get = hashGet; |
| Hash.prototype.has = hashHas; |
| Hash.prototype.set = hashSet; |
| |
| /** |
| * Creates an list cache object. |
| * |
| * @private |
| * @constructor |
| * @param {Array} [entries] The key-value pairs to cache. |
| */ |
| function ListCache(entries) { |
| var index = -1, |
| length = entries ? entries.length : 0; |
| |
| this.clear(); |
| while (++index < length) { |
| var entry = entries[index]; |
| this.set(entry[0], entry[1]); |
| } |
| } |
| |
| /** |
| * Removes all key-value entries from the list cache. |
| * |
| * @private |
| * @name clear |
| * @memberOf ListCache |
| */ |
| function listCacheClear() { |
| this.__data__ = []; |
| } |
| |
| /** |
| * Removes `key` and its value from the list cache. |
| * |
| * @private |
| * @name delete |
| * @memberOf ListCache |
| * @param {string} key The key of the value to remove. |
| * @returns {boolean} Returns `true` if the entry was removed, else `false`. |
| */ |
| function listCacheDelete(key) { |
| var data = this.__data__, |
| index = assocIndexOf(data, key); |
| |
| if (index < 0) { |
| return false; |
| } |
| var lastIndex = data.length - 1; |
| if (index == lastIndex) { |
| data.pop(); |
| } else { |
| splice.call(data, index, 1); |
| } |
| return true; |
| } |
| |
| /** |
| * Gets the list cache value for `key`. |
| * |
| * @private |
| * @name get |
| * @memberOf ListCache |
| * @param {string} key The key of the value to get. |
| * @returns {*} Returns the entry value. |
| */ |
| function listCacheGet(key) { |
| var data = this.__data__, |
| index = assocIndexOf(data, key); |
| |
| return index < 0 ? undefined : data[index][1]; |
| } |
| |
| /** |
| * Checks if a list cache value for `key` exists. |
| * |
| * @private |
| * @name has |
| * @memberOf ListCache |
| * @param {string} key The key of the entry to check. |
| * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. |
| */ |
| function listCacheHas(key) { |
| return assocIndexOf(this.__data__, key) > -1; |
| } |
| |
| /** |
| * Sets the list cache `key` to `value`. |
| * |
| * @private |
| * @name set |
| * @memberOf ListCache |
| * @param {string} key The key of the value to set. |
| * @param {*} value The value to set. |
| * @returns {Object} Returns the list cache instance. |
| */ |
| function listCacheSet(key, value) { |
| var data = this.__data__, |
| index = assocIndexOf(data, key); |
| |
| if (index < 0) { |
| data.push([key, value]); |
| } else { |
| data[index][1] = value; |
| } |
| return this; |
| } |
| |
| // Add methods to `ListCache`. |
| ListCache.prototype.clear = listCacheClear; |
| ListCache.prototype['delete'] = listCacheDelete; |
| ListCache.prototype.get = listCacheGet; |
| ListCache.prototype.has = listCacheHas; |
| ListCache.prototype.set = listCacheSet; |
| |
| /** |
| * Creates a map cache object to store key-value pairs. |
| * |
| * @private |
| * @constructor |
| * @param {Array} [entries] The key-value pairs to cache. |
| */ |
| function MapCache(entries) { |
| var index = -1, |
| length = entries ? entries.length : 0; |
| |
| this.clear(); |
| while (++index < length) { |
| var entry = entries[index]; |
| this.set(entry[0], entry[1]); |
| } |
| } |
| |
| /** |
| * Removes all key-value entries from the map. |
| * |
| * @private |
| * @name clear |
| * @memberOf MapCache |
| */ |
| function mapCacheClear() { |
| this.__data__ = { |
| 'hash': new Hash, |
| 'map': new (Map || ListCache), |
| 'string': new Hash |
| }; |
| } |
| |
| /** |
| * Removes `key` and its value from the map. |
| * |
| * @private |
| * @name delete |
| * @memberOf MapCache |
| * @param {string} key The key of the value to remove. |
| * @returns {boolean} Returns `true` if the entry was removed, else `false`. |
| */ |
| function mapCacheDelete(key) { |
| return getMapData(this, key)['delete'](key); |
| } |
| |
| /** |
| * Gets the map value for `key`. |
| * |
| * @private |
| * @name get |
| * @memberOf MapCache |
| * @param {string} key The key of the value to get. |
| * @returns {*} Returns the entry value. |
| */ |
| function mapCacheGet(key) { |
| return getMapData(this, key).get(key); |
| } |
| |
| /** |
| * Checks if a map value for `key` exists. |
| * |
| * @private |
| * @name has |
| * @memberOf MapCache |
| * @param {string} key The key of the entry to check. |
| * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. |
| */ |
| function mapCacheHas(key) { |
| return getMapData(this, key).has(key); |
| } |
| |
| /** |
| * Sets the map `key` to `value`. |
| * |
| * @private |
| * @name set |
| * @memberOf MapCache |
| * @param {string} key The key of the value to set. |
| * @param {*} value The value to set. |
| * @returns {Object} Returns the map cache instance. |
| */ |
| function mapCacheSet(key, value) { |
| getMapData(this, key).set(key, value); |
| return this; |
| } |
| |
| // Add methods to `MapCache`. |
| MapCache.prototype.clear = mapCacheClear; |
| MapCache.prototype['delete'] = mapCacheDelete; |
| MapCache.prototype.get = mapCacheGet; |
| MapCache.prototype.has = mapCacheHas; |
| MapCache.prototype.set = mapCacheSet; |
| |
| /** |
| * Gets the index at which the `key` is found in `array` of key-value pairs. |
| * |
| * @private |
| * @param {Array} array The array to inspect. |
| * @param {*} key The key to search for. |
| * @returns {number} Returns the index of the matched value, else `-1`. |
| */ |
| function assocIndexOf(array, key) { |
| var length = array.length; |
| while (length--) { |
| if (eq(array[length][0], key)) { |
| return length; |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * The base implementation of `_.get` without support for default values. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @param {Array|string} path The path of the property to get. |
| * @returns {*} Returns the resolved value. |
| */ |
| function baseGet(object, path) { |
| path = isKey(path, object) ? [path] : castPath(path); |
| |
| var index = 0, |
| length = path.length; |
| |
| while (object != null && index < length) { |
| object = object[toKey(path[index++])]; |
| } |
| return (index && index == length) ? object : undefined; |
| } |
| |
| /** |
| * The base implementation of `_.isNative` without bad shim checks. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a native function, |
| * else `false`. |
| */ |
| function baseIsNative(value) { |
| if (!isObject(value) || isMasked(value)) { |
| return false; |
| } |
| var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor; |
| return pattern.test(toSource(value)); |
| } |
| |
| /** |
| * The base implementation of `_.toString` which doesn't convert nullish |
| * values to empty strings. |
| * |
| * @private |
| * @param {*} value The value to process. |
| * @returns {string} Returns the string. |
| */ |
| function baseToString(value) { |
| // Exit early for strings to avoid a performance hit in some environments. |
| if (typeof value == 'string') { |
| return value; |
| } |
| if (isSymbol(value)) { |
| return symbolToString ? symbolToString.call(value) : ''; |
| } |
| var result = (value + ''); |
| return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; |
| } |
| |
| /** |
| * Casts `value` to a path array if it's not one. |
| * |
| * @private |
| * @param {*} value The value to inspect. |
| * @returns {Array} Returns the cast property path array. |
| */ |
| function castPath(value) { |
| return isArray(value) ? value : stringToPath(value); |
| } |
| |
| /** |
| * Gets the data for `map`. |
| * |
| * @private |
| * @param {Object} map The map to query. |
| * @param {string} key The reference key. |
| * @returns {*} Returns the map data. |
| */ |
| function getMapData(map, key) { |
| var data = map.__data__; |
| return isKeyable(key) |
| ? data[typeof key == 'string' ? 'string' : 'hash'] |
| : data.map; |
| } |
| |
| /** |
| * Gets the native function at `key` of `object`. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @param {string} key The key of the method to get. |
| * @returns {*} Returns the function if it's native, else `undefined`. |
| */ |
| function getNative(object, key) { |
| var value = getValue(object, key); |
| return baseIsNative(value) ? value : undefined; |
| } |
| |
| /** |
| * Checks if `value` is a property name and not a property path. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @param {Object} [object] The object to query keys on. |
| * @returns {boolean} Returns `true` if `value` is a property name, else `false`. |
| */ |
| function isKey(value, object) { |
| if (isArray(value)) { |
| return false; |
| } |
| var type = typeof value; |
| if (type == 'number' || type == 'symbol' || type == 'boolean' || |
| value == null || isSymbol(value)) { |
| return true; |
| } |
| return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || |
| (object != null && value in Object(object)); |
| } |
| |
| /** |
| * Checks if `value` is suitable for use as unique object key. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is suitable, else `false`. |
| */ |
| function isKeyable(value) { |
| var type = typeof value; |
| return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') |
| ? (value !== '__proto__') |
| : (value === null); |
| } |
| |
| /** |
| * Checks if `func` has its source masked. |
| * |
| * @private |
| * @param {Function} func The function to check. |
| * @returns {boolean} Returns `true` if `func` is masked, else `false`. |
| */ |
| function isMasked(func) { |
| return !!maskSrcKey && (maskSrcKey in func); |
| } |
| |
| /** |
| * Converts `string` to a property path array. |
| * |
| * @private |
| * @param {string} string The string to convert. |
| * @returns {Array} Returns the property path array. |
| */ |
| var stringToPath = memoize(function(string) { |
| string = toString(string); |
| |
| var result = []; |
| if (reLeadingDot.test(string)) { |
| result.push(''); |
| } |
| string.replace(rePropName, function(match, number, quote, string) { |
| result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match)); |
| }); |
| return result; |
| }); |
| |
| /** |
| * Converts `value` to a string key if it's not a string or symbol. |
| * |
| * @private |
| * @param {*} value The value to inspect. |
| * @returns {string|symbol} Returns the key. |
| */ |
| function toKey(value) { |
| if (typeof value == 'string' || isSymbol(value)) { |
| return value; |
| } |
| var result = (value + ''); |
| return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; |
| } |
| |
| /** |
| * Converts `func` to its source code. |
| * |
| * @private |
| * @param {Function} func The function to process. |
| * @returns {string} Returns the source code. |
| */ |
| function toSource(func) { |
| if (func != null) { |
| try { |
| return funcToString.call(func); |
| } catch (e) {} |
| try { |
| return (func + ''); |
| } catch (e) {} |
| } |
| return ''; |
| } |
| |
| /** |
| * Creates a function that memoizes the result of `func`. If `resolver` is |
| * provided, it determines the cache key for storing the result based on the |
| * arguments provided to the memoized function. By default, the first argument |
| * provided to the memoized function is used as the map cache key. The `func` |
| * is invoked with the `this` binding of the memoized function. |
| * |
| * **Note:** The cache is exposed as the `cache` property on the memoized |
| * function. Its creation may be customized by replacing the `_.memoize.Cache` |
| * constructor with one whose instances implement the |
| * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) |
| * method interface of `delete`, `get`, `has`, and `set`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Function |
| * @param {Function} func The function to have its output memoized. |
| * @param {Function} [resolver] The function to resolve the cache key. |
| * @returns {Function} Returns the new memoized function. |
| * @example |
| * |
| * var object = { 'a': 1, 'b': 2 }; |
| * var other = { 'c': 3, 'd': 4 }; |
| * |
| * var values = _.memoize(_.values); |
| * values(object); |
| * // => [1, 2] |
| * |
| * values(other); |
| * // => [3, 4] |
| * |
| * object.a = 2; |
| * values(object); |
| * // => [1, 2] |
| * |
| * // Modify the result cache. |
| * values.cache.set(object, ['a', 'b']); |
| * values(object); |
| * // => ['a', 'b'] |
| * |
| * // Replace `_.memoize.Cache`. |
| * _.memoize.Cache = WeakMap; |
| */ |
| function memoize(func, resolver) { |
| if (typeof func != 'function' || (resolver && typeof resolver != 'function')) { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| var memoized = function() { |
| var args = arguments, |
| key = resolver ? resolver.apply(this, args) : args[0], |
| cache = memoized.cache; |
| |
| if (cache.has(key)) { |
| return cache.get(key); |
| } |
| var result = func.apply(this, args); |
| memoized.cache = cache.set(key, result); |
| return result; |
| }; |
| memoized.cache = new (memoize.Cache || MapCache); |
| return memoized; |
| } |
| |
| // Assign cache to `_.memoize`. |
| memoize.Cache = MapCache; |
| |
| /** |
| * Performs a |
| * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) |
| * comparison between two values to determine if they are equivalent. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @returns {boolean} Returns `true` if the values are equivalent, else `false`. |
| * @example |
| * |
| * var object = { 'a': 1 }; |
| * var other = { 'a': 1 }; |
| * |
| * _.eq(object, object); |
| * // => true |
| * |
| * _.eq(object, other); |
| * // => false |
| * |
| * _.eq('a', 'a'); |
| * // => true |
| * |
| * _.eq('a', Object('a')); |
| * // => false |
| * |
| * _.eq(NaN, NaN); |
| * // => true |
| */ |
| function eq(value, other) { |
| return value === other || (value !== value && other !== other); |
| } |
| |
| /** |
| * Checks if `value` is classified as an `Array` object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is an array, else `false`. |
| * @example |
| * |
| * _.isArray([1, 2, 3]); |
| * // => true |
| * |
| * _.isArray(document.body.children); |
| * // => false |
| * |
| * _.isArray('abc'); |
| * // => false |
| * |
| * _.isArray(_.noop); |
| * // => false |
| */ |
| var isArray = Array.isArray; |
| |
| /** |
| * Checks if `value` is classified as a `Function` object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a function, else `false`. |
| * @example |
| * |
| * _.isFunction(_); |
| * // => true |
| * |
| * _.isFunction(/abc/); |
| * // => false |
| */ |
| function isFunction(value) { |
| // The use of `Object#toString` avoids issues with the `typeof` operator |
| // in Safari 8-9 which returns 'object' for typed array and other constructors. |
| var tag = isObject(value) ? objectToString.call(value) : ''; |
| return tag == funcTag || tag == genTag; |
| } |
| |
| /** |
| * Checks if `value` is the |
| * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) |
| * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is an object, else `false`. |
| * @example |
| * |
| * _.isObject({}); |
| * // => true |
| * |
| * _.isObject([1, 2, 3]); |
| * // => true |
| * |
| * _.isObject(_.noop); |
| * // => true |
| * |
| * _.isObject(null); |
| * // => false |
| */ |
| function isObject(value) { |
| var type = typeof value; |
| return !!value && (type == 'object' || type == 'function'); |
| } |
| |
| /** |
| * Checks if `value` is object-like. A value is object-like if it's not `null` |
| * and has a `typeof` result of "object". |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is object-like, else `false`. |
| * @example |
| * |
| * _.isObjectLike({}); |
| * // => true |
| * |
| * _.isObjectLike([1, 2, 3]); |
| * // => true |
| * |
| * _.isObjectLike(_.noop); |
| * // => false |
| * |
| * _.isObjectLike(null); |
| * // => false |
| */ |
| function isObjectLike(value) { |
| return !!value && typeof value == 'object'; |
| } |
| |
| /** |
| * Checks if `value` is classified as a `Symbol` primitive or object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. |
| * @example |
| * |
| * _.isSymbol(Symbol.iterator); |
| * // => true |
| * |
| * _.isSymbol('abc'); |
| * // => false |
| */ |
| function isSymbol(value) { |
| return typeof value == 'symbol' || |
| (isObjectLike(value) && objectToString.call(value) == symbolTag); |
| } |
| |
| /** |
| * Converts `value` to a string. An empty string is returned for `null` |
| * and `undefined` values. The sign of `-0` is preserved. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to process. |
| * @returns {string} Returns the string. |
| * @example |
| * |
| * _.toString(null); |
| * // => '' |
| * |
| * _.toString(-0); |
| * // => '-0' |
| * |
| * _.toString([1, 2, 3]); |
| * // => '1,2,3' |
| */ |
| function toString(value) { |
| return value == null ? '' : baseToString(value); |
| } |
| |
| /** |
| * Gets the value at `path` of `object`. If the resolved value is |
| * `undefined`, the `defaultValue` is returned in its place. |
| * |
| * @static |
| * @memberOf _ |
| * @since 3.7.0 |
| * @category Object |
| * @param {Object} object The object to query. |
| * @param {Array|string} path The path of the property to get. |
| * @param {*} [defaultValue] The value returned for `undefined` resolved values. |
| * @returns {*} Returns the resolved value. |
| * @example |
| * |
| * var object = { 'a': [{ 'b': { 'c': 3 } }] }; |
| * |
| * _.get(object, 'a[0].b.c'); |
| * // => 3 |
| * |
| * _.get(object, ['a', '0', 'b', 'c']); |
| * // => 3 |
| * |
| * _.get(object, 'a.b.c', 'default'); |
| * // => 'default' |
| */ |
| function get(object, path, defaultValue) { |
| var result = object == null ? undefined : baseGet(object, path); |
| return result === undefined ? defaultValue : result; |
| } |
| |
| module.exports = get; |