' + func(text) + '
';\r\n * });\r\n *\r\n * p('fred, barney, & pebbles');\r\n * // => 'fred, barney, & pebbles
'\r\n */\r\n function wrap(value, wrapper) {\r\n return partial(castFunction(wrapper), value);\r\n }\r\n\r\n /*------------------------------------------------------------------------*/\r\n\r\n /**\r\n * Casts `value` as an array if it's not one.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.4.0\r\n * @category Lang\r\n * @param {*} value The value to inspect.\r\n * @returns {Array} Returns the cast array.\r\n * @example\r\n *\r\n * _.castArray(1);\r\n * // => [1]\r\n *\r\n * _.castArray({ 'a': 1 });\r\n * // => [{ 'a': 1 }]\r\n *\r\n * _.castArray('abc');\r\n * // => ['abc']\r\n *\r\n * _.castArray(null);\r\n * // => [null]\r\n *\r\n * _.castArray(undefined);\r\n * // => [undefined]\r\n *\r\n * _.castArray();\r\n * // => []\r\n *\r\n * var array = [1, 2, 3];\r\n * console.log(_.castArray(array) === array);\r\n * // => true\r\n */\r\n function castArray() {\r\n if (!arguments.length) {\r\n return [];\r\n }\r\n var value = arguments[0];\r\n return isArray(value) ? value : [value];\r\n }\r\n\r\n /**\r\n * Creates a shallow clone of `value`.\r\n *\r\n * **Note:** This method is loosely based on the\r\n * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\r\n * and supports cloning arrays, array buffers, booleans, date objects, maps,\r\n * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\r\n * arrays. The own enumerable properties of `arguments` objects are cloned\r\n * as plain objects. An empty object is returned for uncloneable values such\r\n * as error objects, functions, DOM nodes, and WeakMaps.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to clone.\r\n * @returns {*} Returns the cloned value.\r\n * @see _.cloneDeep\r\n * @example\r\n *\r\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\r\n *\r\n * var shallow = _.clone(objects);\r\n * console.log(shallow[0] === objects[0]);\r\n * // => true\r\n */\r\n function clone(value) {\r\n return baseClone(value, CLONE_SYMBOLS_FLAG);\r\n }\r\n\r\n /**\r\n * This method is like `_.clone` except that it accepts `customizer` which\r\n * is invoked to produce the cloned value. If `customizer` returns `undefined`,\r\n * cloning is handled by the method instead. The `customizer` is invoked with\r\n * up to four arguments; (value [, index|key, object, stack]).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to clone.\r\n * @param {Function} [customizer] The function to customize cloning.\r\n * @returns {*} Returns the cloned value.\r\n * @see _.cloneDeepWith\r\n * @example\r\n *\r\n * function customizer(value) {\r\n * if (_.isElement(value)) {\r\n * return value.cloneNode(false);\r\n * }\r\n * }\r\n *\r\n * var el = _.cloneWith(document.body, customizer);\r\n *\r\n * console.log(el === document.body);\r\n * // => false\r\n * console.log(el.nodeName);\r\n * // => 'BODY'\r\n * console.log(el.childNodes.length);\r\n * // => 0\r\n */\r\n function cloneWith(value, customizer) {\r\n customizer = typeof customizer == 'function' ? customizer : undefined;\r\n return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);\r\n }\r\n\r\n /**\r\n * This method is like `_.clone` except that it recursively clones `value`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 1.0.0\r\n * @category Lang\r\n * @param {*} value The value to recursively clone.\r\n * @returns {*} Returns the deep cloned value.\r\n * @see _.clone\r\n * @example\r\n *\r\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\r\n *\r\n * var deep = _.cloneDeep(objects);\r\n * console.log(deep[0] === objects[0]);\r\n * // => false\r\n */\r\n function cloneDeep(value) {\r\n return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\r\n }\r\n\r\n /**\r\n * This method is like `_.cloneWith` except that it recursively clones `value`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to recursively clone.\r\n * @param {Function} [customizer] The function to customize cloning.\r\n * @returns {*} Returns the deep cloned value.\r\n * @see _.cloneWith\r\n * @example\r\n *\r\n * function customizer(value) {\r\n * if (_.isElement(value)) {\r\n * return value.cloneNode(true);\r\n * }\r\n * }\r\n *\r\n * var el = _.cloneDeepWith(document.body, customizer);\r\n *\r\n * console.log(el === document.body);\r\n * // => false\r\n * console.log(el.nodeName);\r\n * // => 'BODY'\r\n * console.log(el.childNodes.length);\r\n * // => 20\r\n */\r\n function cloneDeepWith(value, customizer) {\r\n customizer = typeof customizer == 'function' ? customizer : undefined;\r\n return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);\r\n }\r\n\r\n /**\r\n * Checks if `object` conforms to `source` by invoking the predicate\r\n * properties of `source` with the corresponding property values of `object`.\r\n *\r\n * **Note:** This method is equivalent to `_.conforms` when `source` is\r\n * partially applied.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.14.0\r\n * @category Lang\r\n * @param {Object} object The object to inspect.\r\n * @param {Object} source The object of property predicates to conform to.\r\n * @returns {boolean} Returns `true` if `object` conforms, else `false`.\r\n * @example\r\n *\r\n * var object = { 'a': 1, 'b': 2 };\r\n *\r\n * _.conformsTo(object, { 'b': function(n) { return n > 1; } });\r\n * // => true\r\n *\r\n * _.conformsTo(object, { 'b': function(n) { return n > 2; } });\r\n * // => false\r\n */\r\n function conformsTo(object, source) {\r\n return source == null || baseConformsTo(object, source, keys(source));\r\n }\r\n\r\n /**\r\n * Performs a\r\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\r\n * comparison between two values to determine if they are equivalent.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to compare.\r\n * @param {*} other The other value to compare.\r\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\r\n * @example\r\n *\r\n * var object = { 'a': 1 };\r\n * var other = { 'a': 1 };\r\n *\r\n * _.eq(object, object);\r\n * // => true\r\n *\r\n * _.eq(object, other);\r\n * // => false\r\n *\r\n * _.eq('a', 'a');\r\n * // => true\r\n *\r\n * _.eq('a', Object('a'));\r\n * // => false\r\n *\r\n * _.eq(NaN, NaN);\r\n * // => true\r\n */\r\n function eq(value, other) {\r\n return value === other || (value !== value && other !== other);\r\n }\r\n\r\n /**\r\n * Checks if `value` is greater than `other`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.9.0\r\n * @category Lang\r\n * @param {*} value The value to compare.\r\n * @param {*} other The other value to compare.\r\n * @returns {boolean} Returns `true` if `value` is greater than `other`,\r\n * else `false`.\r\n * @see _.lt\r\n * @example\r\n *\r\n * _.gt(3, 1);\r\n * // => true\r\n *\r\n * _.gt(3, 3);\r\n * // => false\r\n *\r\n * _.gt(1, 3);\r\n * // => false\r\n */\r\n var gt = createRelationalOperation(baseGt);\r\n\r\n /**\r\n * Checks if `value` is greater than or equal to `other`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.9.0\r\n * @category Lang\r\n * @param {*} value The value to compare.\r\n * @param {*} other The other value to compare.\r\n * @returns {boolean} Returns `true` if `value` is greater than or equal to\r\n * `other`, else `false`.\r\n * @see _.lte\r\n * @example\r\n *\r\n * _.gte(3, 1);\r\n * // => true\r\n *\r\n * _.gte(3, 3);\r\n * // => true\r\n *\r\n * _.gte(1, 3);\r\n * // => false\r\n */\r\n var gte = createRelationalOperation(function(value, other) {\r\n return value >= other;\r\n });\r\n\r\n /**\r\n * Checks if `value` is likely an `arguments` object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\r\n * else `false`.\r\n * @example\r\n *\r\n * _.isArguments(function() { return arguments; }());\r\n * // => true\r\n *\r\n * _.isArguments([1, 2, 3]);\r\n * // => false\r\n */\r\n var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\r\n return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\r\n !propertyIsEnumerable.call(value, 'callee');\r\n };\r\n\r\n /**\r\n * Checks if `value` is classified as an `Array` object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\r\n * @example\r\n *\r\n * _.isArray([1, 2, 3]);\r\n * // => true\r\n *\r\n * _.isArray(document.body.children);\r\n * // => false\r\n *\r\n * _.isArray('abc');\r\n * // => false\r\n *\r\n * _.isArray(_.noop);\r\n * // => false\r\n */\r\n var isArray = Array.isArray;\r\n\r\n /**\r\n * Checks if `value` is classified as an `ArrayBuffer` object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.3.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\r\n * @example\r\n *\r\n * _.isArrayBuffer(new ArrayBuffer(2));\r\n * // => true\r\n *\r\n * _.isArrayBuffer(new Array(2));\r\n * // => false\r\n */\r\n var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;\r\n\r\n /**\r\n * Checks if `value` is array-like. A value is considered array-like if it's\r\n * not a function and has a `value.length` that's an integer greater than or\r\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\r\n * @example\r\n *\r\n * _.isArrayLike([1, 2, 3]);\r\n * // => true\r\n *\r\n * _.isArrayLike(document.body.children);\r\n * // => true\r\n *\r\n * _.isArrayLike('abc');\r\n * // => true\r\n *\r\n * _.isArrayLike(_.noop);\r\n * // => false\r\n */\r\n function isArrayLike(value) {\r\n return value != null && isLength(value.length) && !isFunction(value);\r\n }\r\n\r\n /**\r\n * This method is like `_.isArrayLike` except that it also checks if `value`\r\n * is an object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is an array-like object,\r\n * else `false`.\r\n * @example\r\n *\r\n * _.isArrayLikeObject([1, 2, 3]);\r\n * // => true\r\n *\r\n * _.isArrayLikeObject(document.body.children);\r\n * // => true\r\n *\r\n * _.isArrayLikeObject('abc');\r\n * // => false\r\n *\r\n * _.isArrayLikeObject(_.noop);\r\n * // => false\r\n */\r\n function isArrayLikeObject(value) {\r\n return isObjectLike(value) && isArrayLike(value);\r\n }\r\n\r\n /**\r\n * Checks if `value` is classified as a boolean primitive or object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.\r\n * @example\r\n *\r\n * _.isBoolean(false);\r\n * // => true\r\n *\r\n * _.isBoolean(null);\r\n * // => false\r\n */\r\n function isBoolean(value) {\r\n return value === true || value === false ||\r\n (isObjectLike(value) && baseGetTag(value) == boolTag);\r\n }\r\n\r\n /**\r\n * Checks if `value` is a buffer.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.3.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\r\n * @example\r\n *\r\n * _.isBuffer(new Buffer(2));\r\n * // => true\r\n *\r\n * _.isBuffer(new Uint8Array(2));\r\n * // => false\r\n */\r\n var isBuffer = nativeIsBuffer || stubFalse;\r\n\r\n /**\r\n * Checks if `value` is classified as a `Date` object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\r\n * @example\r\n *\r\n * _.isDate(new Date);\r\n * // => true\r\n *\r\n * _.isDate('Mon April 23 2012');\r\n * // => false\r\n */\r\n var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;\r\n\r\n /**\r\n * Checks if `value` is likely a DOM element.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.\r\n * @example\r\n *\r\n * _.isElement(document.body);\r\n * // => true\r\n *\r\n * _.isElement('');\r\n * // => false\r\n */\r\n function isElement(value) {\r\n return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);\r\n }\r\n\r\n /**\r\n * Checks if `value` is an empty object, collection, map, or set.\r\n *\r\n * Objects are considered empty if they have no own enumerable string keyed\r\n * properties.\r\n *\r\n * Array-like values such as `arguments` objects, arrays, buffers, strings, or\r\n * jQuery-like collections are considered empty if they have a `length` of `0`.\r\n * Similarly, maps and sets are considered empty if they have a `size` of `0`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is empty, else `false`.\r\n * @example\r\n *\r\n * _.isEmpty(null);\r\n * // => true\r\n *\r\n * _.isEmpty(true);\r\n * // => true\r\n *\r\n * _.isEmpty(1);\r\n * // => true\r\n *\r\n * _.isEmpty([1, 2, 3]);\r\n * // => false\r\n *\r\n * _.isEmpty({ 'a': 1 });\r\n * // => false\r\n */\r\n function isEmpty(value) {\r\n if (value == null) {\r\n return true;\r\n }\r\n if (isArrayLike(value) &&\r\n (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||\r\n isBuffer(value) || isTypedArray(value) || isArguments(value))) {\r\n return !value.length;\r\n }\r\n var tag = getTag(value);\r\n if (tag == mapTag || tag == setTag) {\r\n return !value.size;\r\n }\r\n if (isPrototype(value)) {\r\n return !baseKeys(value).length;\r\n }\r\n for (var key in value) {\r\n if (hasOwnProperty.call(value, key)) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n\r\n /**\r\n * Performs a deep comparison between two values to determine if they are\r\n * equivalent.\r\n *\r\n * **Note:** This method supports comparing arrays, array buffers, booleans,\r\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\r\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\r\n * by their own, not inherited, enumerable properties. Functions and DOM\r\n * nodes are compared by strict equality, i.e. `===`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to compare.\r\n * @param {*} other The other value to compare.\r\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\r\n * @example\r\n *\r\n * var object = { 'a': 1 };\r\n * var other = { 'a': 1 };\r\n *\r\n * _.isEqual(object, other);\r\n * // => true\r\n *\r\n * object === other;\r\n * // => false\r\n */\r\n function isEqual(value, other) {\r\n return baseIsEqual(value, other);\r\n }\r\n\r\n /**\r\n * This method is like `_.isEqual` except that it accepts `customizer` which\r\n * is invoked to compare values. If `customizer` returns `undefined`, comparisons\r\n * are handled by the method instead. The `customizer` is invoked with up to\r\n * six arguments: (objValue, othValue [, index|key, object, other, stack]).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to compare.\r\n * @param {*} other The other value to compare.\r\n * @param {Function} [customizer] The function to customize comparisons.\r\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\r\n * @example\r\n *\r\n * function isGreeting(value) {\r\n * return /^h(?:i|ello)$/.test(value);\r\n * }\r\n *\r\n * function customizer(objValue, othValue) {\r\n * if (isGreeting(objValue) && isGreeting(othValue)) {\r\n * return true;\r\n * }\r\n * }\r\n *\r\n * var array = ['hello', 'goodbye'];\r\n * var other = ['hi', 'goodbye'];\r\n *\r\n * _.isEqualWith(array, other, customizer);\r\n * // => true\r\n */\r\n function isEqualWith(value, other, customizer) {\r\n customizer = typeof customizer == 'function' ? customizer : undefined;\r\n var result = customizer ? customizer(value, other) : undefined;\r\n return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;\r\n }\r\n\r\n /**\r\n * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,\r\n * `SyntaxError`, `TypeError`, or `URIError` object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is an error object, else `false`.\r\n * @example\r\n *\r\n * _.isError(new Error);\r\n * // => true\r\n *\r\n * _.isError(Error);\r\n * // => false\r\n */\r\n function isError(value) {\r\n if (!isObjectLike(value)) {\r\n return false;\r\n }\r\n var tag = baseGetTag(value);\r\n return tag == errorTag || tag == domExcTag ||\r\n (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));\r\n }\r\n\r\n /**\r\n * Checks if `value` is a finite primitive number.\r\n *\r\n * **Note:** This method is based on\r\n * [`Number.isFinite`](https://mdn.io/Number/isFinite).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.\r\n * @example\r\n *\r\n * _.isFinite(3);\r\n * // => true\r\n *\r\n * _.isFinite(Number.MIN_VALUE);\r\n * // => true\r\n *\r\n * _.isFinite(Infinity);\r\n * // => false\r\n *\r\n * _.isFinite('3');\r\n * // => false\r\n */\r\n function isFinite(value) {\r\n return typeof value == 'number' && nativeIsFinite(value);\r\n }\r\n\r\n /**\r\n * Checks if `value` is classified as a `Function` object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\r\n * @example\r\n *\r\n * _.isFunction(_);\r\n * // => true\r\n *\r\n * _.isFunction(/abc/);\r\n * // => false\r\n */\r\n function isFunction(value) {\r\n if (!isObject(value)) {\r\n return false;\r\n }\r\n // The use of `Object#toString` avoids issues with the `typeof` operator\r\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\r\n var tag = baseGetTag(value);\r\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\r\n }\r\n\r\n /**\r\n * Checks if `value` is an integer.\r\n *\r\n * **Note:** This method is based on\r\n * [`Number.isInteger`](https://mdn.io/Number/isInteger).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\r\n * @example\r\n *\r\n * _.isInteger(3);\r\n * // => true\r\n *\r\n * _.isInteger(Number.MIN_VALUE);\r\n * // => false\r\n *\r\n * _.isInteger(Infinity);\r\n * // => false\r\n *\r\n * _.isInteger('3');\r\n * // => false\r\n */\r\n function isInteger(value) {\r\n return typeof value == 'number' && value == toInteger(value);\r\n }\r\n\r\n /**\r\n * Checks if `value` is a valid array-like length.\r\n *\r\n * **Note:** This method is loosely based on\r\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\r\n * @example\r\n *\r\n * _.isLength(3);\r\n * // => true\r\n *\r\n * _.isLength(Number.MIN_VALUE);\r\n * // => false\r\n *\r\n * _.isLength(Infinity);\r\n * // => false\r\n *\r\n * _.isLength('3');\r\n * // => false\r\n */\r\n function isLength(value) {\r\n return typeof value == 'number' &&\r\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\r\n }\r\n\r\n /**\r\n * Checks if `value` is the\r\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\r\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\r\n * @example\r\n *\r\n * _.isObject({});\r\n * // => true\r\n *\r\n * _.isObject([1, 2, 3]);\r\n * // => true\r\n *\r\n * _.isObject(_.noop);\r\n * // => true\r\n *\r\n * _.isObject(null);\r\n * // => false\r\n */\r\n function isObject(value) {\r\n var type = typeof value;\r\n return value != null && (type == 'object' || type == 'function');\r\n }\r\n\r\n /**\r\n * Checks if `value` is object-like. A value is object-like if it's not `null`\r\n * and has a `typeof` result of \"object\".\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\r\n * @example\r\n *\r\n * _.isObjectLike({});\r\n * // => true\r\n *\r\n * _.isObjectLike([1, 2, 3]);\r\n * // => true\r\n *\r\n * _.isObjectLike(_.noop);\r\n * // => false\r\n *\r\n * _.isObjectLike(null);\r\n * // => false\r\n */\r\n function isObjectLike(value) {\r\n return value != null && typeof value == 'object';\r\n }\r\n\r\n /**\r\n * Checks if `value` is classified as a `Map` object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.3.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\r\n * @example\r\n *\r\n * _.isMap(new Map);\r\n * // => true\r\n *\r\n * _.isMap(new WeakMap);\r\n * // => false\r\n */\r\n var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\r\n\r\n /**\r\n * Performs a partial deep comparison between `object` and `source` to\r\n * determine if `object` contains equivalent property values.\r\n *\r\n * **Note:** This method is equivalent to `_.matches` when `source` is\r\n * partially applied.\r\n *\r\n * Partial comparisons will match empty array and empty object `source`\r\n * values against any array or object value, respectively. See `_.isEqual`\r\n * for a list of supported value comparisons.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category Lang\r\n * @param {Object} object The object to inspect.\r\n * @param {Object} source The object of property values to match.\r\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\r\n * @example\r\n *\r\n * var object = { 'a': 1, 'b': 2 };\r\n *\r\n * _.isMatch(object, { 'b': 2 });\r\n * // => true\r\n *\r\n * _.isMatch(object, { 'b': 1 });\r\n * // => false\r\n */\r\n function isMatch(object, source) {\r\n return object === source || baseIsMatch(object, source, getMatchData(source));\r\n }\r\n\r\n /**\r\n * This method is like `_.isMatch` except that it accepts `customizer` which\r\n * is invoked to compare values. If `customizer` returns `undefined`, comparisons\r\n * are handled by the method instead. The `customizer` is invoked with five\r\n * arguments: (objValue, srcValue, index|key, object, source).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {Object} object The object to inspect.\r\n * @param {Object} source The object of property values to match.\r\n * @param {Function} [customizer] The function to customize comparisons.\r\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\r\n * @example\r\n *\r\n * function isGreeting(value) {\r\n * return /^h(?:i|ello)$/.test(value);\r\n * }\r\n *\r\n * function customizer(objValue, srcValue) {\r\n * if (isGreeting(objValue) && isGreeting(srcValue)) {\r\n * return true;\r\n * }\r\n * }\r\n *\r\n * var object = { 'greeting': 'hello' };\r\n * var source = { 'greeting': 'hi' };\r\n *\r\n * _.isMatchWith(object, source, customizer);\r\n * // => true\r\n */\r\n function isMatchWith(object, source, customizer) {\r\n customizer = typeof customizer == 'function' ? customizer : undefined;\r\n return baseIsMatch(object, source, getMatchData(source), customizer);\r\n }\r\n\r\n /**\r\n * Checks if `value` is `NaN`.\r\n *\r\n * **Note:** This method is based on\r\n * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as\r\n * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for\r\n * `undefined` and other non-number values.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\r\n * @example\r\n *\r\n * _.isNaN(NaN);\r\n * // => true\r\n *\r\n * _.isNaN(new Number(NaN));\r\n * // => true\r\n *\r\n * isNaN(undefined);\r\n * // => true\r\n *\r\n * _.isNaN(undefined);\r\n * // => false\r\n */\r\n function isNaN(value) {\r\n // An `NaN` primitive is the only value that is not equal to itself.\r\n // Perform the `toStringTag` check first to avoid errors with some\r\n // ActiveX objects in IE.\r\n return isNumber(value) && value != +value;\r\n }\r\n\r\n /**\r\n * Checks if `value` is a pristine native function.\r\n *\r\n * **Note:** This method can't reliably detect native functions in the presence\r\n * of the core-js package because core-js circumvents this kind of detection.\r\n * Despite multiple requests, the core-js maintainer has made it clear: any\r\n * attempt to fix the detection will be obstructed. As a result, we're left\r\n * with little choice but to throw an error. Unfortunately, this also affects\r\n * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),\r\n * which rely on core-js.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a native function,\r\n * else `false`.\r\n * @example\r\n *\r\n * _.isNative(Array.prototype.push);\r\n * // => true\r\n *\r\n * _.isNative(_);\r\n * // => false\r\n */\r\n function isNative(value) {\r\n if (isMaskable(value)) {\r\n throw new Error(CORE_ERROR_TEXT);\r\n }\r\n return baseIsNative(value);\r\n }\r\n\r\n /**\r\n * Checks if `value` is `null`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is `null`, else `false`.\r\n * @example\r\n *\r\n * _.isNull(null);\r\n * // => true\r\n *\r\n * _.isNull(void 0);\r\n * // => false\r\n */\r\n function isNull(value) {\r\n return value === null;\r\n }\r\n\r\n /**\r\n * Checks if `value` is `null` or `undefined`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\r\n * @example\r\n *\r\n * _.isNil(null);\r\n * // => true\r\n *\r\n * _.isNil(void 0);\r\n * // => true\r\n *\r\n * _.isNil(NaN);\r\n * // => false\r\n */\r\n function isNil(value) {\r\n return value == null;\r\n }\r\n\r\n /**\r\n * Checks if `value` is classified as a `Number` primitive or object.\r\n *\r\n * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are\r\n * classified as numbers, use the `_.isFinite` method.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a number, else `false`.\r\n * @example\r\n *\r\n * _.isNumber(3);\r\n * // => true\r\n *\r\n * _.isNumber(Number.MIN_VALUE);\r\n * // => true\r\n *\r\n * _.isNumber(Infinity);\r\n * // => true\r\n *\r\n * _.isNumber('3');\r\n * // => false\r\n */\r\n function isNumber(value) {\r\n return typeof value == 'number' ||\r\n (isObjectLike(value) && baseGetTag(value) == numberTag);\r\n }\r\n\r\n /**\r\n * Checks if `value` is a plain object, that is, an object created by the\r\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.8.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * }\r\n *\r\n * _.isPlainObject(new Foo);\r\n * // => false\r\n *\r\n * _.isPlainObject([1, 2, 3]);\r\n * // => false\r\n *\r\n * _.isPlainObject({ 'x': 0, 'y': 0 });\r\n * // => true\r\n *\r\n * _.isPlainObject(Object.create(null));\r\n * // => true\r\n */\r\n function isPlainObject(value) {\r\n if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\r\n return false;\r\n }\r\n var proto = getPrototype(value);\r\n if (proto === null) {\r\n return true;\r\n }\r\n var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\r\n return typeof Ctor == 'function' && Ctor instanceof Ctor &&\r\n funcToString.call(Ctor) == objectCtorString;\r\n }\r\n\r\n /**\r\n * Checks if `value` is classified as a `RegExp` object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.1.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\r\n * @example\r\n *\r\n * _.isRegExp(/abc/);\r\n * // => true\r\n *\r\n * _.isRegExp('/abc/');\r\n * // => false\r\n */\r\n var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\r\n\r\n /**\r\n * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754\r\n * double precision number which isn't the result of a rounded unsafe integer.\r\n *\r\n * **Note:** This method is based on\r\n * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.\r\n * @example\r\n *\r\n * _.isSafeInteger(3);\r\n * // => true\r\n *\r\n * _.isSafeInteger(Number.MIN_VALUE);\r\n * // => false\r\n *\r\n * _.isSafeInteger(Infinity);\r\n * // => false\r\n *\r\n * _.isSafeInteger('3');\r\n * // => false\r\n */\r\n function isSafeInteger(value) {\r\n return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;\r\n }\r\n\r\n /**\r\n * Checks if `value` is classified as a `Set` object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.3.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\r\n * @example\r\n *\r\n * _.isSet(new Set);\r\n * // => true\r\n *\r\n * _.isSet(new WeakSet);\r\n * // => false\r\n */\r\n var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\r\n\r\n /**\r\n * Checks if `value` is classified as a `String` primitive or object.\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a string, else `false`.\r\n * @example\r\n *\r\n * _.isString('abc');\r\n * // => true\r\n *\r\n * _.isString(1);\r\n * // => false\r\n */\r\n function isString(value) {\r\n return typeof value == 'string' ||\r\n (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\r\n }\r\n\r\n /**\r\n * Checks if `value` is classified as a `Symbol` primitive or object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\r\n * @example\r\n *\r\n * _.isSymbol(Symbol.iterator);\r\n * // => true\r\n *\r\n * _.isSymbol('abc');\r\n * // => false\r\n */\r\n function isSymbol(value) {\r\n return typeof value == 'symbol' ||\r\n (isObjectLike(value) && baseGetTag(value) == symbolTag);\r\n }\r\n\r\n /**\r\n * Checks if `value` is classified as a typed array.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\r\n * @example\r\n *\r\n * _.isTypedArray(new Uint8Array);\r\n * // => true\r\n *\r\n * _.isTypedArray([]);\r\n * // => false\r\n */\r\n var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\r\n\r\n /**\r\n * Checks if `value` is `undefined`.\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.\r\n * @example\r\n *\r\n * _.isUndefined(void 0);\r\n * // => true\r\n *\r\n * _.isUndefined(null);\r\n * // => false\r\n */\r\n function isUndefined(value) {\r\n return value === undefined;\r\n }\r\n\r\n /**\r\n * Checks if `value` is classified as a `WeakMap` object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.3.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.\r\n * @example\r\n *\r\n * _.isWeakMap(new WeakMap);\r\n * // => true\r\n *\r\n * _.isWeakMap(new Map);\r\n * // => false\r\n */\r\n function isWeakMap(value) {\r\n return isObjectLike(value) && getTag(value) == weakMapTag;\r\n }\r\n\r\n /**\r\n * Checks if `value` is classified as a `WeakSet` object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.3.0\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.\r\n * @example\r\n *\r\n * _.isWeakSet(new WeakSet);\r\n * // => true\r\n *\r\n * _.isWeakSet(new Set);\r\n * // => false\r\n */\r\n function isWeakSet(value) {\r\n return isObjectLike(value) && baseGetTag(value) == weakSetTag;\r\n }\r\n\r\n /**\r\n * Checks if `value` is less than `other`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.9.0\r\n * @category Lang\r\n * @param {*} value The value to compare.\r\n * @param {*} other The other value to compare.\r\n * @returns {boolean} Returns `true` if `value` is less than `other`,\r\n * else `false`.\r\n * @see _.gt\r\n * @example\r\n *\r\n * _.lt(1, 3);\r\n * // => true\r\n *\r\n * _.lt(3, 3);\r\n * // => false\r\n *\r\n * _.lt(3, 1);\r\n * // => false\r\n */\r\n var lt = createRelationalOperation(baseLt);\r\n\r\n /**\r\n * Checks if `value` is less than or equal to `other`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.9.0\r\n * @category Lang\r\n * @param {*} value The value to compare.\r\n * @param {*} other The other value to compare.\r\n * @returns {boolean} Returns `true` if `value` is less than or equal to\r\n * `other`, else `false`.\r\n * @see _.gte\r\n * @example\r\n *\r\n * _.lte(1, 3);\r\n * // => true\r\n *\r\n * _.lte(3, 3);\r\n * // => true\r\n *\r\n * _.lte(3, 1);\r\n * // => false\r\n */\r\n var lte = createRelationalOperation(function(value, other) {\r\n return value <= other;\r\n });\r\n\r\n /**\r\n * Converts `value` to an array.\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category Lang\r\n * @param {*} value The value to convert.\r\n * @returns {Array} Returns the converted array.\r\n * @example\r\n *\r\n * _.toArray({ 'a': 1, 'b': 2 });\r\n * // => [1, 2]\r\n *\r\n * _.toArray('abc');\r\n * // => ['a', 'b', 'c']\r\n *\r\n * _.toArray(1);\r\n * // => []\r\n *\r\n * _.toArray(null);\r\n * // => []\r\n */\r\n function toArray(value) {\r\n if (!value) {\r\n return [];\r\n }\r\n if (isArrayLike(value)) {\r\n return isString(value) ? stringToArray(value) : copyArray(value);\r\n }\r\n if (symIterator && value[symIterator]) {\r\n return iteratorToArray(value[symIterator]());\r\n }\r\n var tag = getTag(value),\r\n func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);\r\n\r\n return func(value);\r\n }\r\n\r\n /**\r\n * Converts `value` to a finite number.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.12.0\r\n * @category Lang\r\n * @param {*} value The value to convert.\r\n * @returns {number} Returns the converted number.\r\n * @example\r\n *\r\n * _.toFinite(3.2);\r\n * // => 3.2\r\n *\r\n * _.toFinite(Number.MIN_VALUE);\r\n * // => 5e-324\r\n *\r\n * _.toFinite(Infinity);\r\n * // => 1.7976931348623157e+308\r\n *\r\n * _.toFinite('3.2');\r\n * // => 3.2\r\n */\r\n function toFinite(value) {\r\n if (!value) {\r\n return value === 0 ? value : 0;\r\n }\r\n value = toNumber(value);\r\n if (value === INFINITY || value === -INFINITY) {\r\n var sign = (value < 0 ? -1 : 1);\r\n return sign * MAX_INTEGER;\r\n }\r\n return value === value ? value : 0;\r\n }\r\n\r\n /**\r\n * Converts `value` to an integer.\r\n *\r\n * **Note:** This method is loosely based on\r\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to convert.\r\n * @returns {number} Returns the converted integer.\r\n * @example\r\n *\r\n * _.toInteger(3.2);\r\n * // => 3\r\n *\r\n * _.toInteger(Number.MIN_VALUE);\r\n * // => 0\r\n *\r\n * _.toInteger(Infinity);\r\n * // => 1.7976931348623157e+308\r\n *\r\n * _.toInteger('3.2');\r\n * // => 3\r\n */\r\n function toInteger(value) {\r\n var result = toFinite(value),\r\n remainder = result % 1;\r\n\r\n return result === result ? (remainder ? result - remainder : result) : 0;\r\n }\r\n\r\n /**\r\n * Converts `value` to an integer suitable for use as the length of an\r\n * array-like object.\r\n *\r\n * **Note:** This method is based on\r\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to convert.\r\n * @returns {number} Returns the converted integer.\r\n * @example\r\n *\r\n * _.toLength(3.2);\r\n * // => 3\r\n *\r\n * _.toLength(Number.MIN_VALUE);\r\n * // => 0\r\n *\r\n * _.toLength(Infinity);\r\n * // => 4294967295\r\n *\r\n * _.toLength('3.2');\r\n * // => 3\r\n */\r\n function toLength(value) {\r\n return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;\r\n }\r\n\r\n /**\r\n * Converts `value` to a number.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to process.\r\n * @returns {number} Returns the number.\r\n * @example\r\n *\r\n * _.toNumber(3.2);\r\n * // => 3.2\r\n *\r\n * _.toNumber(Number.MIN_VALUE);\r\n * // => 5e-324\r\n *\r\n * _.toNumber(Infinity);\r\n * // => Infinity\r\n *\r\n * _.toNumber('3.2');\r\n * // => 3.2\r\n */\r\n function toNumber(value) {\r\n if (typeof value == 'number') {\r\n return value;\r\n }\r\n if (isSymbol(value)) {\r\n return NAN;\r\n }\r\n if (isObject(value)) {\r\n var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\r\n value = isObject(other) ? (other + '') : other;\r\n }\r\n if (typeof value != 'string') {\r\n return value === 0 ? value : +value;\r\n }\r\n value = baseTrim(value);\r\n var isBinary = reIsBinary.test(value);\r\n return (isBinary || reIsOctal.test(value))\r\n ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\r\n : (reIsBadHex.test(value) ? NAN : +value);\r\n }\r\n\r\n /**\r\n * Converts `value` to a plain object flattening inherited enumerable string\r\n * keyed properties of `value` to own properties of the plain object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category Lang\r\n * @param {*} value The value to convert.\r\n * @returns {Object} Returns the converted plain object.\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.b = 2;\r\n * }\r\n *\r\n * Foo.prototype.c = 3;\r\n *\r\n * _.assign({ 'a': 1 }, new Foo);\r\n * // => { 'a': 1, 'b': 2 }\r\n *\r\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\r\n * // => { 'a': 1, 'b': 2, 'c': 3 }\r\n */\r\n function toPlainObject(value) {\r\n return copyObject(value, keysIn(value));\r\n }\r\n\r\n /**\r\n * Converts `value` to a safe integer. A safe integer can be compared and\r\n * represented correctly.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to convert.\r\n * @returns {number} Returns the converted integer.\r\n * @example\r\n *\r\n * _.toSafeInteger(3.2);\r\n * // => 3\r\n *\r\n * _.toSafeInteger(Number.MIN_VALUE);\r\n * // => 0\r\n *\r\n * _.toSafeInteger(Infinity);\r\n * // => 9007199254740991\r\n *\r\n * _.toSafeInteger('3.2');\r\n * // => 3\r\n */\r\n function toSafeInteger(value) {\r\n return value\r\n ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)\r\n : (value === 0 ? value : 0);\r\n }\r\n\r\n /**\r\n * Converts `value` to a string. An empty string is returned for `null`\r\n * and `undefined` values. The sign of `-0` is preserved.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Lang\r\n * @param {*} value The value to convert.\r\n * @returns {string} Returns the converted string.\r\n * @example\r\n *\r\n * _.toString(null);\r\n * // => ''\r\n *\r\n * _.toString(-0);\r\n * // => '-0'\r\n *\r\n * _.toString([1, 2, 3]);\r\n * // => '1,2,3'\r\n */\r\n function toString(value) {\r\n return value == null ? '' : baseToString(value);\r\n }\r\n\r\n /*------------------------------------------------------------------------*/\r\n\r\n /**\r\n * Assigns own enumerable string keyed properties of source objects to the\r\n * destination object. Source objects are applied from left to right.\r\n * Subsequent sources overwrite property assignments of previous sources.\r\n *\r\n * **Note:** This method mutates `object` and is loosely based on\r\n * [`Object.assign`](https://mdn.io/Object/assign).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.10.0\r\n * @category Object\r\n * @param {Object} object The destination object.\r\n * @param {...Object} [sources] The source objects.\r\n * @returns {Object} Returns `object`.\r\n * @see _.assignIn\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * }\r\n *\r\n * function Bar() {\r\n * this.c = 3;\r\n * }\r\n *\r\n * Foo.prototype.b = 2;\r\n * Bar.prototype.d = 4;\r\n *\r\n * _.assign({ 'a': 0 }, new Foo, new Bar);\r\n * // => { 'a': 1, 'c': 3 }\r\n */\r\n var assign = createAssigner(function(object, source) {\r\n if (isPrototype(source) || isArrayLike(source)) {\r\n copyObject(source, keys(source), object);\r\n return;\r\n }\r\n for (var key in source) {\r\n if (hasOwnProperty.call(source, key)) {\r\n assignValue(object, key, source[key]);\r\n }\r\n }\r\n });\r\n\r\n /**\r\n * This method is like `_.assign` except that it iterates over own and\r\n * inherited source properties.\r\n *\r\n * **Note:** This method mutates `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @alias extend\r\n * @category Object\r\n * @param {Object} object The destination object.\r\n * @param {...Object} [sources] The source objects.\r\n * @returns {Object} Returns `object`.\r\n * @see _.assign\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * }\r\n *\r\n * function Bar() {\r\n * this.c = 3;\r\n * }\r\n *\r\n * Foo.prototype.b = 2;\r\n * Bar.prototype.d = 4;\r\n *\r\n * _.assignIn({ 'a': 0 }, new Foo, new Bar);\r\n * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }\r\n */\r\n var assignIn = createAssigner(function(object, source) {\r\n copyObject(source, keysIn(source), object);\r\n });\r\n\r\n /**\r\n * This method is like `_.assignIn` except that it accepts `customizer`\r\n * which is invoked to produce the assigned values. If `customizer` returns\r\n * `undefined`, assignment is handled by the method instead. The `customizer`\r\n * is invoked with five arguments: (objValue, srcValue, key, object, source).\r\n *\r\n * **Note:** This method mutates `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @alias extendWith\r\n * @category Object\r\n * @param {Object} object The destination object.\r\n * @param {...Object} sources The source objects.\r\n * @param {Function} [customizer] The function to customize assigned values.\r\n * @returns {Object} Returns `object`.\r\n * @see _.assignWith\r\n * @example\r\n *\r\n * function customizer(objValue, srcValue) {\r\n * return _.isUndefined(objValue) ? srcValue : objValue;\r\n * }\r\n *\r\n * var defaults = _.partialRight(_.assignInWith, customizer);\r\n *\r\n * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\r\n * // => { 'a': 1, 'b': 2 }\r\n */\r\n var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {\r\n copyObject(source, keysIn(source), object, customizer);\r\n });\r\n\r\n /**\r\n * This method is like `_.assign` except that it accepts `customizer`\r\n * which is invoked to produce the assigned values. If `customizer` returns\r\n * `undefined`, assignment is handled by the method instead. The `customizer`\r\n * is invoked with five arguments: (objValue, srcValue, key, object, source).\r\n *\r\n * **Note:** This method mutates `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Object\r\n * @param {Object} object The destination object.\r\n * @param {...Object} sources The source objects.\r\n * @param {Function} [customizer] The function to customize assigned values.\r\n * @returns {Object} Returns `object`.\r\n * @see _.assignInWith\r\n * @example\r\n *\r\n * function customizer(objValue, srcValue) {\r\n * return _.isUndefined(objValue) ? srcValue : objValue;\r\n * }\r\n *\r\n * var defaults = _.partialRight(_.assignWith, customizer);\r\n *\r\n * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\r\n * // => { 'a': 1, 'b': 2 }\r\n */\r\n var assignWith = createAssigner(function(object, source, srcIndex, customizer) {\r\n copyObject(source, keys(source), object, customizer);\r\n });\r\n\r\n /**\r\n * Creates an array of values corresponding to `paths` of `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 1.0.0\r\n * @category Object\r\n * @param {Object} object The object to iterate over.\r\n * @param {...(string|string[])} [paths] The property paths to pick.\r\n * @returns {Array} Returns the picked values.\r\n * @example\r\n *\r\n * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\r\n *\r\n * _.at(object, ['a[0].b.c', 'a[1]']);\r\n * // => [3, 4]\r\n */\r\n var at = flatRest(baseAt);\r\n\r\n /**\r\n * Creates an object that inherits from the `prototype` object. If a\r\n * `properties` object is given, its own enumerable string keyed properties\r\n * are assigned to the created object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 2.3.0\r\n * @category Object\r\n * @param {Object} prototype The object to inherit from.\r\n * @param {Object} [properties] The properties to assign to the object.\r\n * @returns {Object} Returns the new object.\r\n * @example\r\n *\r\n * function Shape() {\r\n * this.x = 0;\r\n * this.y = 0;\r\n * }\r\n *\r\n * function Circle() {\r\n * Shape.call(this);\r\n * }\r\n *\r\n * Circle.prototype = _.create(Shape.prototype, {\r\n * 'constructor': Circle\r\n * });\r\n *\r\n * var circle = new Circle;\r\n * circle instanceof Circle;\r\n * // => true\r\n *\r\n * circle instanceof Shape;\r\n * // => true\r\n */\r\n function create(prototype, properties) {\r\n var result = baseCreate(prototype);\r\n return properties == null ? result : baseAssign(result, properties);\r\n }\r\n\r\n /**\r\n * Assigns own and inherited enumerable string keyed properties of source\r\n * objects to the destination object for all destination properties that\r\n * resolve to `undefined`. Source objects are applied from left to right.\r\n * Once a property is set, additional values of the same property are ignored.\r\n *\r\n * **Note:** This method mutates `object`.\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The destination object.\r\n * @param {...Object} [sources] The source objects.\r\n * @returns {Object} Returns `object`.\r\n * @see _.defaultsDeep\r\n * @example\r\n *\r\n * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\r\n * // => { 'a': 1, 'b': 2 }\r\n */\r\n var defaults = baseRest(function(object, sources) {\r\n object = Object(object);\r\n\r\n var index = -1;\r\n var length = sources.length;\r\n var guard = length > 2 ? sources[2] : undefined;\r\n\r\n if (guard && isIterateeCall(sources[0], sources[1], guard)) {\r\n length = 1;\r\n }\r\n\r\n while (++index < length) {\r\n var source = sources[index];\r\n var props = keysIn(source);\r\n var propsIndex = -1;\r\n var propsLength = props.length;\r\n\r\n while (++propsIndex < propsLength) {\r\n var key = props[propsIndex];\r\n var value = object[key];\r\n\r\n if (value === undefined ||\r\n (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {\r\n object[key] = source[key];\r\n }\r\n }\r\n }\r\n\r\n return object;\r\n });\r\n\r\n /**\r\n * This method is like `_.defaults` except that it recursively assigns\r\n * default properties.\r\n *\r\n * **Note:** This method mutates `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.10.0\r\n * @category Object\r\n * @param {Object} object The destination object.\r\n * @param {...Object} [sources] The source objects.\r\n * @returns {Object} Returns `object`.\r\n * @see _.defaults\r\n * @example\r\n *\r\n * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });\r\n * // => { 'a': { 'b': 2, 'c': 3 } }\r\n */\r\n var defaultsDeep = baseRest(function(args) {\r\n args.push(undefined, customDefaultsMerge);\r\n return apply(mergeWith, undefined, args);\r\n });\r\n\r\n /**\r\n * This method is like `_.find` except that it returns the key of the first\r\n * element `predicate` returns truthy for instead of the element itself.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 1.1.0\r\n * @category Object\r\n * @param {Object} object The object to inspect.\r\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\r\n * @returns {string|undefined} Returns the key of the matched element,\r\n * else `undefined`.\r\n * @example\r\n *\r\n * var users = {\r\n * 'barney': { 'age': 36, 'active': true },\r\n * 'fred': { 'age': 40, 'active': false },\r\n * 'pebbles': { 'age': 1, 'active': true }\r\n * };\r\n *\r\n * _.findKey(users, function(o) { return o.age < 40; });\r\n * // => 'barney' (iteration order is not guaranteed)\r\n *\r\n * // The `_.matches` iteratee shorthand.\r\n * _.findKey(users, { 'age': 1, 'active': true });\r\n * // => 'pebbles'\r\n *\r\n * // The `_.matchesProperty` iteratee shorthand.\r\n * _.findKey(users, ['active', false]);\r\n * // => 'fred'\r\n *\r\n * // The `_.property` iteratee shorthand.\r\n * _.findKey(users, 'active');\r\n * // => 'barney'\r\n */\r\n function findKey(object, predicate) {\r\n return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);\r\n }\r\n\r\n /**\r\n * This method is like `_.findKey` except that it iterates over elements of\r\n * a collection in the opposite order.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 2.0.0\r\n * @category Object\r\n * @param {Object} object The object to inspect.\r\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\r\n * @returns {string|undefined} Returns the key of the matched element,\r\n * else `undefined`.\r\n * @example\r\n *\r\n * var users = {\r\n * 'barney': { 'age': 36, 'active': true },\r\n * 'fred': { 'age': 40, 'active': false },\r\n * 'pebbles': { 'age': 1, 'active': true }\r\n * };\r\n *\r\n * _.findLastKey(users, function(o) { return o.age < 40; });\r\n * // => returns 'pebbles' assuming `_.findKey` returns 'barney'\r\n *\r\n * // The `_.matches` iteratee shorthand.\r\n * _.findLastKey(users, { 'age': 36, 'active': true });\r\n * // => 'barney'\r\n *\r\n * // The `_.matchesProperty` iteratee shorthand.\r\n * _.findLastKey(users, ['active', false]);\r\n * // => 'fred'\r\n *\r\n * // The `_.property` iteratee shorthand.\r\n * _.findLastKey(users, 'active');\r\n * // => 'pebbles'\r\n */\r\n function findLastKey(object, predicate) {\r\n return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);\r\n }\r\n\r\n /**\r\n * Iterates over own and inherited enumerable string keyed properties of an\r\n * object and invokes `iteratee` for each property. The iteratee is invoked\r\n * with three arguments: (value, key, object). Iteratee functions may exit\r\n * iteration early by explicitly returning `false`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.3.0\r\n * @category Object\r\n * @param {Object} object The object to iterate over.\r\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\r\n * @returns {Object} Returns `object`.\r\n * @see _.forInRight\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * this.b = 2;\r\n * }\r\n *\r\n * Foo.prototype.c = 3;\r\n *\r\n * _.forIn(new Foo, function(value, key) {\r\n * console.log(key);\r\n * });\r\n * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).\r\n */\r\n function forIn(object, iteratee) {\r\n return object == null\r\n ? object\r\n : baseFor(object, getIteratee(iteratee, 3), keysIn);\r\n }\r\n\r\n /**\r\n * This method is like `_.forIn` except that it iterates over properties of\r\n * `object` in the opposite order.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 2.0.0\r\n * @category Object\r\n * @param {Object} object The object to iterate over.\r\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\r\n * @returns {Object} Returns `object`.\r\n * @see _.forIn\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * this.b = 2;\r\n * }\r\n *\r\n * Foo.prototype.c = 3;\r\n *\r\n * _.forInRight(new Foo, function(value, key) {\r\n * console.log(key);\r\n * });\r\n * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.\r\n */\r\n function forInRight(object, iteratee) {\r\n return object == null\r\n ? object\r\n : baseForRight(object, getIteratee(iteratee, 3), keysIn);\r\n }\r\n\r\n /**\r\n * Iterates over own enumerable string keyed properties of an object and\r\n * invokes `iteratee` for each property. The iteratee is invoked with three\r\n * arguments: (value, key, object). Iteratee functions may exit iteration\r\n * early by explicitly returning `false`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.3.0\r\n * @category Object\r\n * @param {Object} object The object to iterate over.\r\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\r\n * @returns {Object} Returns `object`.\r\n * @see _.forOwnRight\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * this.b = 2;\r\n * }\r\n *\r\n * Foo.prototype.c = 3;\r\n *\r\n * _.forOwn(new Foo, function(value, key) {\r\n * console.log(key);\r\n * });\r\n * // => Logs 'a' then 'b' (iteration order is not guaranteed).\r\n */\r\n function forOwn(object, iteratee) {\r\n return object && baseForOwn(object, getIteratee(iteratee, 3));\r\n }\r\n\r\n /**\r\n * This method is like `_.forOwn` except that it iterates over properties of\r\n * `object` in the opposite order.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 2.0.0\r\n * @category Object\r\n * @param {Object} object The object to iterate over.\r\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\r\n * @returns {Object} Returns `object`.\r\n * @see _.forOwn\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * this.b = 2;\r\n * }\r\n *\r\n * Foo.prototype.c = 3;\r\n *\r\n * _.forOwnRight(new Foo, function(value, key) {\r\n * console.log(key);\r\n * });\r\n * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.\r\n */\r\n function forOwnRight(object, iteratee) {\r\n return object && baseForOwnRight(object, getIteratee(iteratee, 3));\r\n }\r\n\r\n /**\r\n * Creates an array of function property names from own enumerable properties\r\n * of `object`.\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The object to inspect.\r\n * @returns {Array} Returns the function names.\r\n * @see _.functionsIn\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = _.constant('a');\r\n * this.b = _.constant('b');\r\n * }\r\n *\r\n * Foo.prototype.c = _.constant('c');\r\n *\r\n * _.functions(new Foo);\r\n * // => ['a', 'b']\r\n */\r\n function functions(object) {\r\n return object == null ? [] : baseFunctions(object, keys(object));\r\n }\r\n\r\n /**\r\n * Creates an array of function property names from own and inherited\r\n * enumerable properties of `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Object\r\n * @param {Object} object The object to inspect.\r\n * @returns {Array} Returns the function names.\r\n * @see _.functions\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = _.constant('a');\r\n * this.b = _.constant('b');\r\n * }\r\n *\r\n * Foo.prototype.c = _.constant('c');\r\n *\r\n * _.functionsIn(new Foo);\r\n * // => ['a', 'b', 'c']\r\n */\r\n function functionsIn(object) {\r\n return object == null ? [] : baseFunctions(object, keysIn(object));\r\n }\r\n\r\n /**\r\n * Gets the value at `path` of `object`. If the resolved value is\r\n * `undefined`, the `defaultValue` is returned in its place.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.7.0\r\n * @category Object\r\n * @param {Object} object The object to query.\r\n * @param {Array|string} path The path of the property to get.\r\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\r\n * @returns {*} Returns the resolved value.\r\n * @example\r\n *\r\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\r\n *\r\n * _.get(object, 'a[0].b.c');\r\n * // => 3\r\n *\r\n * _.get(object, ['a', '0', 'b', 'c']);\r\n * // => 3\r\n *\r\n * _.get(object, 'a.b.c', 'default');\r\n * // => 'default'\r\n */\r\n function get(object, path, defaultValue) {\r\n var result = object == null ? undefined : baseGet(object, path);\r\n return result === undefined ? defaultValue : result;\r\n }\r\n\r\n /**\r\n * Checks if `path` is a direct property of `object`.\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The object to query.\r\n * @param {Array|string} path The path to check.\r\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\r\n * @example\r\n *\r\n * var object = { 'a': { 'b': 2 } };\r\n * var other = _.create({ 'a': _.create({ 'b': 2 }) });\r\n *\r\n * _.has(object, 'a');\r\n * // => true\r\n *\r\n * _.has(object, 'a.b');\r\n * // => true\r\n *\r\n * _.has(object, ['a', 'b']);\r\n * // => true\r\n *\r\n * _.has(other, 'a');\r\n * // => false\r\n */\r\n function has(object, path) {\r\n return object != null && hasPath(object, path, baseHas);\r\n }\r\n\r\n /**\r\n * Checks if `path` is a direct or inherited property of `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Object\r\n * @param {Object} object The object to query.\r\n * @param {Array|string} path The path to check.\r\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\r\n * @example\r\n *\r\n * var object = _.create({ 'a': _.create({ 'b': 2 }) });\r\n *\r\n * _.hasIn(object, 'a');\r\n * // => true\r\n *\r\n * _.hasIn(object, 'a.b');\r\n * // => true\r\n *\r\n * _.hasIn(object, ['a', 'b']);\r\n * // => true\r\n *\r\n * _.hasIn(object, 'b');\r\n * // => false\r\n */\r\n function hasIn(object, path) {\r\n return object != null && hasPath(object, path, baseHasIn);\r\n }\r\n\r\n /**\r\n * Creates an object composed of the inverted keys and values of `object`.\r\n * If `object` contains duplicate values, subsequent values overwrite\r\n * property assignments of previous values.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.7.0\r\n * @category Object\r\n * @param {Object} object The object to invert.\r\n * @returns {Object} Returns the new inverted object.\r\n * @example\r\n *\r\n * var object = { 'a': 1, 'b': 2, 'c': 1 };\r\n *\r\n * _.invert(object);\r\n * // => { '1': 'c', '2': 'b' }\r\n */\r\n var invert = createInverter(function(result, value, key) {\r\n if (value != null &&\r\n typeof value.toString != 'function') {\r\n value = nativeObjectToString.call(value);\r\n }\r\n\r\n result[value] = key;\r\n }, constant(identity));\r\n\r\n /**\r\n * This method is like `_.invert` except that the inverted object is generated\r\n * from the results of running each element of `object` thru `iteratee`. The\r\n * corresponding inverted value of each inverted key is an array of keys\r\n * responsible for generating the inverted value. The iteratee is invoked\r\n * with one argument: (value).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.1.0\r\n * @category Object\r\n * @param {Object} object The object to invert.\r\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\r\n * @returns {Object} Returns the new inverted object.\r\n * @example\r\n *\r\n * var object = { 'a': 1, 'b': 2, 'c': 1 };\r\n *\r\n * _.invertBy(object);\r\n * // => { '1': ['a', 'c'], '2': ['b'] }\r\n *\r\n * _.invertBy(object, function(value) {\r\n * return 'group' + value;\r\n * });\r\n * // => { 'group1': ['a', 'c'], 'group2': ['b'] }\r\n */\r\n var invertBy = createInverter(function(result, value, key) {\r\n if (value != null &&\r\n typeof value.toString != 'function') {\r\n value = nativeObjectToString.call(value);\r\n }\r\n\r\n if (hasOwnProperty.call(result, value)) {\r\n result[value].push(key);\r\n } else {\r\n result[value] = [key];\r\n }\r\n }, getIteratee);\r\n\r\n /**\r\n * Invokes the method at `path` of `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Object\r\n * @param {Object} object The object to query.\r\n * @param {Array|string} path The path of the method to invoke.\r\n * @param {...*} [args] The arguments to invoke the method with.\r\n * @returns {*} Returns the result of the invoked method.\r\n * @example\r\n *\r\n * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };\r\n *\r\n * _.invoke(object, 'a[0].b.c.slice', 1, 3);\r\n * // => [2, 3]\r\n */\r\n var invoke = baseRest(baseInvoke);\r\n\r\n /**\r\n * Creates an array of the own enumerable property names of `object`.\r\n *\r\n * **Note:** Non-object values are coerced to objects. See the\r\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\r\n * for more details.\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The object to query.\r\n * @returns {Array} Returns the array of property names.\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * this.b = 2;\r\n * }\r\n *\r\n * Foo.prototype.c = 3;\r\n *\r\n * _.keys(new Foo);\r\n * // => ['a', 'b'] (iteration order is not guaranteed)\r\n *\r\n * _.keys('hi');\r\n * // => ['0', '1']\r\n */\r\n function keys(object) {\r\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\r\n }\r\n\r\n /**\r\n * Creates an array of the own and inherited enumerable property names of `object`.\r\n *\r\n * **Note:** Non-object values are coerced to objects.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category Object\r\n * @param {Object} object The object to query.\r\n * @returns {Array} Returns the array of property names.\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * this.b = 2;\r\n * }\r\n *\r\n * Foo.prototype.c = 3;\r\n *\r\n * _.keysIn(new Foo);\r\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\r\n */\r\n function keysIn(object) {\r\n return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\r\n }\r\n\r\n /**\r\n * The opposite of `_.mapValues`; this method creates an object with the\r\n * same values as `object` and keys generated by running each own enumerable\r\n * string keyed property of `object` thru `iteratee`. The iteratee is invoked\r\n * with three arguments: (value, key, object).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.8.0\r\n * @category Object\r\n * @param {Object} object The object to iterate over.\r\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\r\n * @returns {Object} Returns the new mapped object.\r\n * @see _.mapValues\r\n * @example\r\n *\r\n * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {\r\n * return key + value;\r\n * });\r\n * // => { 'a1': 1, 'b2': 2 }\r\n */\r\n function mapKeys(object, iteratee) {\r\n var result = {};\r\n iteratee = getIteratee(iteratee, 3);\r\n\r\n baseForOwn(object, function(value, key, object) {\r\n baseAssignValue(result, iteratee(value, key, object), value);\r\n });\r\n return result;\r\n }\r\n\r\n /**\r\n * Creates an object with the same keys as `object` and values generated\r\n * by running each own enumerable string keyed property of `object` thru\r\n * `iteratee`. The iteratee is invoked with three arguments:\r\n * (value, key, object).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 2.4.0\r\n * @category Object\r\n * @param {Object} object The object to iterate over.\r\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\r\n * @returns {Object} Returns the new mapped object.\r\n * @see _.mapKeys\r\n * @example\r\n *\r\n * var users = {\r\n * 'fred': { 'user': 'fred', 'age': 40 },\r\n * 'pebbles': { 'user': 'pebbles', 'age': 1 }\r\n * };\r\n *\r\n * _.mapValues(users, function(o) { return o.age; });\r\n * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\r\n *\r\n * // The `_.property` iteratee shorthand.\r\n * _.mapValues(users, 'age');\r\n * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\r\n */\r\n function mapValues(object, iteratee) {\r\n var result = {};\r\n iteratee = getIteratee(iteratee, 3);\r\n\r\n baseForOwn(object, function(value, key, object) {\r\n baseAssignValue(result, key, iteratee(value, key, object));\r\n });\r\n return result;\r\n }\r\n\r\n /**\r\n * This method is like `_.assign` except that it recursively merges own and\r\n * inherited enumerable string keyed properties of source objects into the\r\n * destination object. Source properties that resolve to `undefined` are\r\n * skipped if a destination value exists. Array and plain object properties\r\n * are merged recursively. Other objects and value types are overridden by\r\n * assignment. Source objects are applied from left to right. Subsequent\r\n * sources overwrite property assignments of previous sources.\r\n *\r\n * **Note:** This method mutates `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.5.0\r\n * @category Object\r\n * @param {Object} object The destination object.\r\n * @param {...Object} [sources] The source objects.\r\n * @returns {Object} Returns `object`.\r\n * @example\r\n *\r\n * var object = {\r\n * 'a': [{ 'b': 2 }, { 'd': 4 }]\r\n * };\r\n *\r\n * var other = {\r\n * 'a': [{ 'c': 3 }, { 'e': 5 }]\r\n * };\r\n *\r\n * _.merge(object, other);\r\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\r\n */\r\n var merge = createAssigner(function(object, source, srcIndex) {\r\n baseMerge(object, source, srcIndex);\r\n });\r\n\r\n /**\r\n * This method is like `_.merge` except that it accepts `customizer` which\r\n * is invoked to produce the merged values of the destination and source\r\n * properties. If `customizer` returns `undefined`, merging is handled by the\r\n * method instead. The `customizer` is invoked with six arguments:\r\n * (objValue, srcValue, key, object, source, stack).\r\n *\r\n * **Note:** This method mutates `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Object\r\n * @param {Object} object The destination object.\r\n * @param {...Object} sources The source objects.\r\n * @param {Function} customizer The function to customize assigned values.\r\n * @returns {Object} Returns `object`.\r\n * @example\r\n *\r\n * function customizer(objValue, srcValue) {\r\n * if (_.isArray(objValue)) {\r\n * return objValue.concat(srcValue);\r\n * }\r\n * }\r\n *\r\n * var object = { 'a': [1], 'b': [2] };\r\n * var other = { 'a': [3], 'b': [4] };\r\n *\r\n * _.mergeWith(object, other, customizer);\r\n * // => { 'a': [1, 3], 'b': [2, 4] }\r\n */\r\n var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\r\n baseMerge(object, source, srcIndex, customizer);\r\n });\r\n\r\n /**\r\n * The opposite of `_.pick`; this method creates an object composed of the\r\n * own and inherited enumerable property paths of `object` that are not omitted.\r\n *\r\n * **Note:** This method is considerably slower than `_.pick`.\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The source object.\r\n * @param {...(string|string[])} [paths] The property paths to omit.\r\n * @returns {Object} Returns the new object.\r\n * @example\r\n *\r\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\r\n *\r\n * _.omit(object, ['a', 'c']);\r\n * // => { 'b': '2' }\r\n */\r\n var omit = flatRest(function(object, paths) {\r\n var result = {};\r\n if (object == null) {\r\n return result;\r\n }\r\n var isDeep = false;\r\n paths = arrayMap(paths, function(path) {\r\n path = castPath(path, object);\r\n isDeep || (isDeep = path.length > 1);\r\n return path;\r\n });\r\n copyObject(object, getAllKeysIn(object), result);\r\n if (isDeep) {\r\n result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);\r\n }\r\n var length = paths.length;\r\n while (length--) {\r\n baseUnset(result, paths[length]);\r\n }\r\n return result;\r\n });\r\n\r\n /**\r\n * The opposite of `_.pickBy`; this method creates an object composed of\r\n * the own and inherited enumerable string keyed properties of `object` that\r\n * `predicate` doesn't return truthy for. The predicate is invoked with two\r\n * arguments: (value, key).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Object\r\n * @param {Object} object The source object.\r\n * @param {Function} [predicate=_.identity] The function invoked per property.\r\n * @returns {Object} Returns the new object.\r\n * @example\r\n *\r\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\r\n *\r\n * _.omitBy(object, _.isNumber);\r\n * // => { 'b': '2' }\r\n */\r\n function omitBy(object, predicate) {\r\n return pickBy(object, negate(getIteratee(predicate)));\r\n }\r\n\r\n /**\r\n * Creates an object composed of the picked `object` properties.\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The source object.\r\n * @param {...(string|string[])} [paths] The property paths to pick.\r\n * @returns {Object} Returns the new object.\r\n * @example\r\n *\r\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\r\n *\r\n * _.pick(object, ['a', 'c']);\r\n * // => { 'a': 1, 'c': 3 }\r\n */\r\n var pick = flatRest(function(object, paths) {\r\n return object == null ? {} : basePick(object, paths);\r\n });\r\n\r\n /**\r\n * Creates an object composed of the `object` properties `predicate` returns\r\n * truthy for. The predicate is invoked with two arguments: (value, key).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Object\r\n * @param {Object} object The source object.\r\n * @param {Function} [predicate=_.identity] The function invoked per property.\r\n * @returns {Object} Returns the new object.\r\n * @example\r\n *\r\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\r\n *\r\n * _.pickBy(object, _.isNumber);\r\n * // => { 'a': 1, 'c': 3 }\r\n */\r\n function pickBy(object, predicate) {\r\n if (object == null) {\r\n return {};\r\n }\r\n var props = arrayMap(getAllKeysIn(object), function(prop) {\r\n return [prop];\r\n });\r\n predicate = getIteratee(predicate);\r\n return basePickBy(object, props, function(value, path) {\r\n return predicate(value, path[0]);\r\n });\r\n }\r\n\r\n /**\r\n * This method is like `_.get` except that if the resolved value is a\r\n * function it's invoked with the `this` binding of its parent object and\r\n * its result is returned.\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The object to query.\r\n * @param {Array|string} path The path of the property to resolve.\r\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\r\n * @returns {*} Returns the resolved value.\r\n * @example\r\n *\r\n * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };\r\n *\r\n * _.result(object, 'a[0].b.c1');\r\n * // => 3\r\n *\r\n * _.result(object, 'a[0].b.c2');\r\n * // => 4\r\n *\r\n * _.result(object, 'a[0].b.c3', 'default');\r\n * // => 'default'\r\n *\r\n * _.result(object, 'a[0].b.c3', _.constant('default'));\r\n * // => 'default'\r\n */\r\n function result(object, path, defaultValue) {\r\n path = castPath(path, object);\r\n\r\n var index = -1,\r\n length = path.length;\r\n\r\n // Ensure the loop is entered when path is empty.\r\n if (!length) {\r\n length = 1;\r\n object = undefined;\r\n }\r\n while (++index < length) {\r\n var value = object == null ? undefined : object[toKey(path[index])];\r\n if (value === undefined) {\r\n index = length;\r\n value = defaultValue;\r\n }\r\n object = isFunction(value) ? value.call(object) : value;\r\n }\r\n return object;\r\n }\r\n\r\n /**\r\n * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,\r\n * it's created. Arrays are created for missing index properties while objects\r\n * are created for all other missing properties. Use `_.setWith` to customize\r\n * `path` creation.\r\n *\r\n * **Note:** This method mutates `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.7.0\r\n * @category Object\r\n * @param {Object} object The object to modify.\r\n * @param {Array|string} path The path of the property to set.\r\n * @param {*} value The value to set.\r\n * @returns {Object} Returns `object`.\r\n * @example\r\n *\r\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\r\n *\r\n * _.set(object, 'a[0].b.c', 4);\r\n * console.log(object.a[0].b.c);\r\n * // => 4\r\n *\r\n * _.set(object, ['x', '0', 'y', 'z'], 5);\r\n * console.log(object.x[0].y.z);\r\n * // => 5\r\n */\r\n function set(object, path, value) {\r\n return object == null ? object : baseSet(object, path, value);\r\n }\r\n\r\n /**\r\n * This method is like `_.set` except that it accepts `customizer` which is\r\n * invoked to produce the objects of `path`. If `customizer` returns `undefined`\r\n * path creation is handled by the method instead. The `customizer` is invoked\r\n * with three arguments: (nsValue, key, nsObject).\r\n *\r\n * **Note:** This method mutates `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Object\r\n * @param {Object} object The object to modify.\r\n * @param {Array|string} path The path of the property to set.\r\n * @param {*} value The value to set.\r\n * @param {Function} [customizer] The function to customize assigned values.\r\n * @returns {Object} Returns `object`.\r\n * @example\r\n *\r\n * var object = {};\r\n *\r\n * _.setWith(object, '[0][1]', 'a', Object);\r\n * // => { '0': { '1': 'a' } }\r\n */\r\n function setWith(object, path, value, customizer) {\r\n customizer = typeof customizer == 'function' ? customizer : undefined;\r\n return object == null ? object : baseSet(object, path, value, customizer);\r\n }\r\n\r\n /**\r\n * Creates an array of own enumerable string keyed-value pairs for `object`\r\n * which can be consumed by `_.fromPairs`. If `object` is a map or set, its\r\n * entries are returned.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @alias entries\r\n * @category Object\r\n * @param {Object} object The object to query.\r\n * @returns {Array} Returns the key-value pairs.\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * this.b = 2;\r\n * }\r\n *\r\n * Foo.prototype.c = 3;\r\n *\r\n * _.toPairs(new Foo);\r\n * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)\r\n */\r\n var toPairs = createToPairs(keys);\r\n\r\n /**\r\n * Creates an array of own and inherited enumerable string keyed-value pairs\r\n * for `object` which can be consumed by `_.fromPairs`. If `object` is a map\r\n * or set, its entries are returned.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @alias entriesIn\r\n * @category Object\r\n * @param {Object} object The object to query.\r\n * @returns {Array} Returns the key-value pairs.\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * this.b = 2;\r\n * }\r\n *\r\n * Foo.prototype.c = 3;\r\n *\r\n * _.toPairsIn(new Foo);\r\n * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)\r\n */\r\n var toPairsIn = createToPairs(keysIn);\r\n\r\n /**\r\n * An alternative to `_.reduce`; this method transforms `object` to a new\r\n * `accumulator` object which is the result of running each of its own\r\n * enumerable string keyed properties thru `iteratee`, with each invocation\r\n * potentially mutating the `accumulator` object. If `accumulator` is not\r\n * provided, a new object with the same `[[Prototype]]` will be used. The\r\n * iteratee is invoked with four arguments: (accumulator, value, key, object).\r\n * Iteratee functions may exit iteration early by explicitly returning `false`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 1.3.0\r\n * @category Object\r\n * @param {Object} object The object to iterate over.\r\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\r\n * @param {*} [accumulator] The custom accumulator value.\r\n * @returns {*} Returns the accumulated value.\r\n * @example\r\n *\r\n * _.transform([2, 3, 4], function(result, n) {\r\n * result.push(n *= n);\r\n * return n % 2 == 0;\r\n * }, []);\r\n * // => [4, 9]\r\n *\r\n * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\r\n * (result[value] || (result[value] = [])).push(key);\r\n * }, {});\r\n * // => { '1': ['a', 'c'], '2': ['b'] }\r\n */\r\n function transform(object, iteratee, accumulator) {\r\n var isArr = isArray(object),\r\n isArrLike = isArr || isBuffer(object) || isTypedArray(object);\r\n\r\n iteratee = getIteratee(iteratee, 4);\r\n if (accumulator == null) {\r\n var Ctor = object && object.constructor;\r\n if (isArrLike) {\r\n accumulator = isArr ? new Ctor : [];\r\n }\r\n else if (isObject(object)) {\r\n accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};\r\n }\r\n else {\r\n accumulator = {};\r\n }\r\n }\r\n (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {\r\n return iteratee(accumulator, value, index, object);\r\n });\r\n return accumulator;\r\n }\r\n\r\n /**\r\n * Removes the property at `path` of `object`.\r\n *\r\n * **Note:** This method mutates `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Object\r\n * @param {Object} object The object to modify.\r\n * @param {Array|string} path The path of the property to unset.\r\n * @returns {boolean} Returns `true` if the property is deleted, else `false`.\r\n * @example\r\n *\r\n * var object = { 'a': [{ 'b': { 'c': 7 } }] };\r\n * _.unset(object, 'a[0].b.c');\r\n * // => true\r\n *\r\n * console.log(object);\r\n * // => { 'a': [{ 'b': {} }] };\r\n *\r\n * _.unset(object, ['a', '0', 'b', 'c']);\r\n * // => true\r\n *\r\n * console.log(object);\r\n * // => { 'a': [{ 'b': {} }] };\r\n */\r\n function unset(object, path) {\r\n return object == null ? true : baseUnset(object, path);\r\n }\r\n\r\n /**\r\n * This method is like `_.set` except that accepts `updater` to produce the\r\n * value to set. Use `_.updateWith` to customize `path` creation. The `updater`\r\n * is invoked with one argument: (value).\r\n *\r\n * **Note:** This method mutates `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.6.0\r\n * @category Object\r\n * @param {Object} object The object to modify.\r\n * @param {Array|string} path The path of the property to set.\r\n * @param {Function} updater The function to produce the updated value.\r\n * @returns {Object} Returns `object`.\r\n * @example\r\n *\r\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\r\n *\r\n * _.update(object, 'a[0].b.c', function(n) { return n * n; });\r\n * console.log(object.a[0].b.c);\r\n * // => 9\r\n *\r\n * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });\r\n * console.log(object.x[0].y.z);\r\n * // => 0\r\n */\r\n function update(object, path, updater) {\r\n return object == null ? object : baseUpdate(object, path, castFunction(updater));\r\n }\r\n\r\n /**\r\n * This method is like `_.update` except that it accepts `customizer` which is\r\n * invoked to produce the objects of `path`. If `customizer` returns `undefined`\r\n * path creation is handled by the method instead. The `customizer` is invoked\r\n * with three arguments: (nsValue, key, nsObject).\r\n *\r\n * **Note:** This method mutates `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.6.0\r\n * @category Object\r\n * @param {Object} object The object to modify.\r\n * @param {Array|string} path The path of the property to set.\r\n * @param {Function} updater The function to produce the updated value.\r\n * @param {Function} [customizer] The function to customize assigned values.\r\n * @returns {Object} Returns `object`.\r\n * @example\r\n *\r\n * var object = {};\r\n *\r\n * _.updateWith(object, '[0][1]', _.constant('a'), Object);\r\n * // => { '0': { '1': 'a' } }\r\n */\r\n function updateWith(object, path, updater, customizer) {\r\n customizer = typeof customizer == 'function' ? customizer : undefined;\r\n return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);\r\n }\r\n\r\n /**\r\n * Creates an array of the own enumerable string keyed property values of `object`.\r\n *\r\n * **Note:** Non-object values are coerced to objects.\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The object to query.\r\n * @returns {Array} Returns the array of property values.\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * this.b = 2;\r\n * }\r\n *\r\n * Foo.prototype.c = 3;\r\n *\r\n * _.values(new Foo);\r\n * // => [1, 2] (iteration order is not guaranteed)\r\n *\r\n * _.values('hi');\r\n * // => ['h', 'i']\r\n */\r\n function values(object) {\r\n return object == null ? [] : baseValues(object, keys(object));\r\n }\r\n\r\n /**\r\n * Creates an array of the own and inherited enumerable string keyed property\r\n * values of `object`.\r\n *\r\n * **Note:** Non-object values are coerced to objects.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category Object\r\n * @param {Object} object The object to query.\r\n * @returns {Array} Returns the array of property values.\r\n * @example\r\n *\r\n * function Foo() {\r\n * this.a = 1;\r\n * this.b = 2;\r\n * }\r\n *\r\n * Foo.prototype.c = 3;\r\n *\r\n * _.valuesIn(new Foo);\r\n * // => [1, 2, 3] (iteration order is not guaranteed)\r\n */\r\n function valuesIn(object) {\r\n return object == null ? [] : baseValues(object, keysIn(object));\r\n }\r\n\r\n /*------------------------------------------------------------------------*/\r\n\r\n /**\r\n * Clamps `number` within the inclusive `lower` and `upper` bounds.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category Number\r\n * @param {number} number The number to clamp.\r\n * @param {number} [lower] The lower bound.\r\n * @param {number} upper The upper bound.\r\n * @returns {number} Returns the clamped number.\r\n * @example\r\n *\r\n * _.clamp(-10, -5, 5);\r\n * // => -5\r\n *\r\n * _.clamp(10, -5, 5);\r\n * // => 5\r\n */\r\n function clamp(number, lower, upper) {\r\n if (upper === undefined) {\r\n upper = lower;\r\n lower = undefined;\r\n }\r\n if (upper !== undefined) {\r\n upper = toNumber(upper);\r\n upper = upper === upper ? upper : 0;\r\n }\r\n if (lower !== undefined) {\r\n lower = toNumber(lower);\r\n lower = lower === lower ? lower : 0;\r\n }\r\n return baseClamp(toNumber(number), lower, upper);\r\n }\r\n\r\n /**\r\n * Checks if `n` is between `start` and up to, but not including, `end`. If\r\n * `end` is not specified, it's set to `start` with `start` then set to `0`.\r\n * If `start` is greater than `end` the params are swapped to support\r\n * negative ranges.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.3.0\r\n * @category Number\r\n * @param {number} number The number to check.\r\n * @param {number} [start=0] The start of the range.\r\n * @param {number} end The end of the range.\r\n * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\r\n * @see _.range, _.rangeRight\r\n * @example\r\n *\r\n * _.inRange(3, 2, 4);\r\n * // => true\r\n *\r\n * _.inRange(4, 8);\r\n * // => true\r\n *\r\n * _.inRange(4, 2);\r\n * // => false\r\n *\r\n * _.inRange(2, 2);\r\n * // => false\r\n *\r\n * _.inRange(1.2, 2);\r\n * // => true\r\n *\r\n * _.inRange(5.2, 4);\r\n * // => false\r\n *\r\n * _.inRange(-3, -2, -6);\r\n * // => true\r\n */\r\n function inRange(number, start, end) {\r\n start = toFinite(start);\r\n if (end === undefined) {\r\n end = start;\r\n start = 0;\r\n } else {\r\n end = toFinite(end);\r\n }\r\n number = toNumber(number);\r\n return baseInRange(number, start, end);\r\n }\r\n\r\n /**\r\n * Produces a random number between the inclusive `lower` and `upper` bounds.\r\n * If only one argument is provided a number between `0` and the given number\r\n * is returned. If `floating` is `true`, or either `lower` or `upper` are\r\n * floats, a floating-point number is returned instead of an integer.\r\n *\r\n * **Note:** JavaScript follows the IEEE-754 standard for resolving\r\n * floating-point values which can produce unexpected results.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 0.7.0\r\n * @category Number\r\n * @param {number} [lower=0] The lower bound.\r\n * @param {number} [upper=1] The upper bound.\r\n * @param {boolean} [floating] Specify returning a floating-point number.\r\n * @returns {number} Returns the random number.\r\n * @example\r\n *\r\n * _.random(0, 5);\r\n * // => an integer between 0 and 5\r\n *\r\n * _.random(5);\r\n * // => also an integer between 0 and 5\r\n *\r\n * _.random(5, true);\r\n * // => a floating-point number between 0 and 5\r\n *\r\n * _.random(1.2, 5.2);\r\n * // => a floating-point number between 1.2 and 5.2\r\n */\r\n function random(lower, upper, floating) {\r\n if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {\r\n upper = floating = undefined;\r\n }\r\n if (floating === undefined) {\r\n if (typeof upper == 'boolean') {\r\n floating = upper;\r\n upper = undefined;\r\n }\r\n else if (typeof lower == 'boolean') {\r\n floating = lower;\r\n lower = undefined;\r\n }\r\n }\r\n if (lower === undefined && upper === undefined) {\r\n lower = 0;\r\n upper = 1;\r\n }\r\n else {\r\n lower = toFinite(lower);\r\n if (upper === undefined) {\r\n upper = lower;\r\n lower = 0;\r\n } else {\r\n upper = toFinite(upper);\r\n }\r\n }\r\n if (lower > upper) {\r\n var temp = lower;\r\n lower = upper;\r\n upper = temp;\r\n }\r\n if (floating || lower % 1 || upper % 1) {\r\n var rand = nativeRandom();\r\n return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);\r\n }\r\n return baseRandom(lower, upper);\r\n }\r\n\r\n /*------------------------------------------------------------------------*/\r\n\r\n /**\r\n * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to convert.\r\n * @returns {string} Returns the camel cased string.\r\n * @example\r\n *\r\n * _.camelCase('Foo Bar');\r\n * // => 'fooBar'\r\n *\r\n * _.camelCase('--foo-bar--');\r\n * // => 'fooBar'\r\n *\r\n * _.camelCase('__FOO_BAR__');\r\n * // => 'fooBar'\r\n */\r\n var camelCase = createCompounder(function(result, word, index) {\r\n word = word.toLowerCase();\r\n return result + (index ? capitalize(word) : word);\r\n });\r\n\r\n /**\r\n * Converts the first character of `string` to upper case and the remaining\r\n * to lower case.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to capitalize.\r\n * @returns {string} Returns the capitalized string.\r\n * @example\r\n *\r\n * _.capitalize('FRED');\r\n * // => 'Fred'\r\n */\r\n function capitalize(string) {\r\n return upperFirst(toString(string).toLowerCase());\r\n }\r\n\r\n /**\r\n * Deburrs `string` by converting\r\n * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\r\n * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)\r\n * letters to basic Latin letters and removing\r\n * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to deburr.\r\n * @returns {string} Returns the deburred string.\r\n * @example\r\n *\r\n * _.deburr('déjà vu');\r\n * // => 'deja vu'\r\n */\r\n function deburr(string) {\r\n string = toString(string);\r\n return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');\r\n }\r\n\r\n /**\r\n * Checks if `string` ends with the given target string.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to inspect.\r\n * @param {string} [target] The string to search for.\r\n * @param {number} [position=string.length] The position to search up to.\r\n * @returns {boolean} Returns `true` if `string` ends with `target`,\r\n * else `false`.\r\n * @example\r\n *\r\n * _.endsWith('abc', 'c');\r\n * // => true\r\n *\r\n * _.endsWith('abc', 'b');\r\n * // => false\r\n *\r\n * _.endsWith('abc', 'b', 2);\r\n * // => true\r\n */\r\n function endsWith(string, target, position) {\r\n string = toString(string);\r\n target = baseToString(target);\r\n\r\n var length = string.length;\r\n position = position === undefined\r\n ? length\r\n : baseClamp(toInteger(position), 0, length);\r\n\r\n var end = position;\r\n position -= target.length;\r\n return position >= 0 && string.slice(position, end) == target;\r\n }\r\n\r\n /**\r\n * Converts the characters \"&\", \"<\", \">\", '\"', and \"'\" in `string` to their\r\n * corresponding HTML entities.\r\n *\r\n * **Note:** No other characters are escaped. To escape additional\r\n * characters use a third-party library like [_he_](https://mths.be/he).\r\n *\r\n * Though the \">\" character is escaped for symmetry, characters like\r\n * \">\" and \"/\" don't need escaping in HTML and have no special meaning\r\n * unless they're part of a tag or unquoted attribute value. See\r\n * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\r\n * (under \"semi-related fun fact\") for more details.\r\n *\r\n * When working with HTML you should always\r\n * [quote attribute values](http://wonko.com/post/html-escaping) to reduce\r\n * XSS vectors.\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category String\r\n * @param {string} [string=''] The string to escape.\r\n * @returns {string} Returns the escaped string.\r\n * @example\r\n *\r\n * _.escape('fred, barney, & pebbles');\r\n * // => 'fred, barney, & pebbles'\r\n */\r\n function escape(string) {\r\n string = toString(string);\r\n return (string && reHasUnescapedHtml.test(string))\r\n ? string.replace(reUnescapedHtml, escapeHtmlChar)\r\n : string;\r\n }\r\n\r\n /**\r\n * Escapes the `RegExp` special characters \"^\", \"$\", \"\\\", \".\", \"*\", \"+\",\r\n * \"?\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", and \"|\" in `string`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to escape.\r\n * @returns {string} Returns the escaped string.\r\n * @example\r\n *\r\n * _.escapeRegExp('[lodash](https://lodash.com/)');\r\n * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\r\n */\r\n function escapeRegExp(string) {\r\n string = toString(string);\r\n return (string && reHasRegExpChar.test(string))\r\n ? string.replace(reRegExpChar, '\\\\$&')\r\n : string;\r\n }\r\n\r\n /**\r\n * Converts `string` to\r\n * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to convert.\r\n * @returns {string} Returns the kebab cased string.\r\n * @example\r\n *\r\n * _.kebabCase('Foo Bar');\r\n * // => 'foo-bar'\r\n *\r\n * _.kebabCase('fooBar');\r\n * // => 'foo-bar'\r\n *\r\n * _.kebabCase('__FOO_BAR__');\r\n * // => 'foo-bar'\r\n */\r\n var kebabCase = createCompounder(function(result, word, index) {\r\n return result + (index ? '-' : '') + word.toLowerCase();\r\n });\r\n\r\n /**\r\n * Converts `string`, as space separated words, to lower case.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to convert.\r\n * @returns {string} Returns the lower cased string.\r\n * @example\r\n *\r\n * _.lowerCase('--Foo-Bar--');\r\n * // => 'foo bar'\r\n *\r\n * _.lowerCase('fooBar');\r\n * // => 'foo bar'\r\n *\r\n * _.lowerCase('__FOO_BAR__');\r\n * // => 'foo bar'\r\n */\r\n var lowerCase = createCompounder(function(result, word, index) {\r\n return result + (index ? ' ' : '') + word.toLowerCase();\r\n });\r\n\r\n /**\r\n * Converts the first character of `string` to lower case.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to convert.\r\n * @returns {string} Returns the converted string.\r\n * @example\r\n *\r\n * _.lowerFirst('Fred');\r\n * // => 'fred'\r\n *\r\n * _.lowerFirst('FRED');\r\n * // => 'fRED'\r\n */\r\n var lowerFirst = createCaseFirst('toLowerCase');\r\n\r\n /**\r\n * Pads `string` on the left and right sides if it's shorter than `length`.\r\n * Padding characters are truncated if they can't be evenly divided by `length`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to pad.\r\n * @param {number} [length=0] The padding length.\r\n * @param {string} [chars=' '] The string used as padding.\r\n * @returns {string} Returns the padded string.\r\n * @example\r\n *\r\n * _.pad('abc', 8);\r\n * // => ' abc '\r\n *\r\n * _.pad('abc', 8, '_-');\r\n * // => '_-abc_-_'\r\n *\r\n * _.pad('abc', 3);\r\n * // => 'abc'\r\n */\r\n function pad(string, length, chars) {\r\n string = toString(string);\r\n length = toInteger(length);\r\n\r\n var strLength = length ? stringSize(string) : 0;\r\n if (!length || strLength >= length) {\r\n return string;\r\n }\r\n var mid = (length - strLength) / 2;\r\n return (\r\n createPadding(nativeFloor(mid), chars) +\r\n string +\r\n createPadding(nativeCeil(mid), chars)\r\n );\r\n }\r\n\r\n /**\r\n * Pads `string` on the right side if it's shorter than `length`. Padding\r\n * characters are truncated if they exceed `length`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to pad.\r\n * @param {number} [length=0] The padding length.\r\n * @param {string} [chars=' '] The string used as padding.\r\n * @returns {string} Returns the padded string.\r\n * @example\r\n *\r\n * _.padEnd('abc', 6);\r\n * // => 'abc '\r\n *\r\n * _.padEnd('abc', 6, '_-');\r\n * // => 'abc_-_'\r\n *\r\n * _.padEnd('abc', 3);\r\n * // => 'abc'\r\n */\r\n function padEnd(string, length, chars) {\r\n string = toString(string);\r\n length = toInteger(length);\r\n\r\n var strLength = length ? stringSize(string) : 0;\r\n return (length && strLength < length)\r\n ? (string + createPadding(length - strLength, chars))\r\n : string;\r\n }\r\n\r\n /**\r\n * Pads `string` on the left side if it's shorter than `length`. Padding\r\n * characters are truncated if they exceed `length`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to pad.\r\n * @param {number} [length=0] The padding length.\r\n * @param {string} [chars=' '] The string used as padding.\r\n * @returns {string} Returns the padded string.\r\n * @example\r\n *\r\n * _.padStart('abc', 6);\r\n * // => ' abc'\r\n *\r\n * _.padStart('abc', 6, '_-');\r\n * // => '_-_abc'\r\n *\r\n * _.padStart('abc', 3);\r\n * // => 'abc'\r\n */\r\n function padStart(string, length, chars) {\r\n string = toString(string);\r\n length = toInteger(length);\r\n\r\n var strLength = length ? stringSize(string) : 0;\r\n return (length && strLength < length)\r\n ? (createPadding(length - strLength, chars) + string)\r\n : string;\r\n }\r\n\r\n /**\r\n * Converts `string` to an integer of the specified radix. If `radix` is\r\n * `undefined` or `0`, a `radix` of `10` is used unless `value` is a\r\n * hexadecimal, in which case a `radix` of `16` is used.\r\n *\r\n * **Note:** This method aligns with the\r\n * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 1.1.0\r\n * @category String\r\n * @param {string} string The string to convert.\r\n * @param {number} [radix=10] The radix to interpret `value` by.\r\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\r\n * @returns {number} Returns the converted integer.\r\n * @example\r\n *\r\n * _.parseInt('08');\r\n * // => 8\r\n *\r\n * _.map(['6', '08', '10'], _.parseInt);\r\n * // => [6, 8, 10]\r\n */\r\n function parseInt(string, radix, guard) {\r\n if (guard || radix == null) {\r\n radix = 0;\r\n } else if (radix) {\r\n radix = +radix;\r\n }\r\n return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);\r\n }\r\n\r\n /**\r\n * Repeats the given string `n` times.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to repeat.\r\n * @param {number} [n=1] The number of times to repeat the string.\r\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\r\n * @returns {string} Returns the repeated string.\r\n * @example\r\n *\r\n * _.repeat('*', 3);\r\n * // => '***'\r\n *\r\n * _.repeat('abc', 2);\r\n * // => 'abcabc'\r\n *\r\n * _.repeat('abc', 0);\r\n * // => ''\r\n */\r\n function repeat(string, n, guard) {\r\n if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {\r\n n = 1;\r\n } else {\r\n n = toInteger(n);\r\n }\r\n return baseRepeat(toString(string), n);\r\n }\r\n\r\n /**\r\n * Replaces matches for `pattern` in `string` with `replacement`.\r\n *\r\n * **Note:** This method is based on\r\n * [`String#replace`](https://mdn.io/String/replace).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to modify.\r\n * @param {RegExp|string} pattern The pattern to replace.\r\n * @param {Function|string} replacement The match replacement.\r\n * @returns {string} Returns the modified string.\r\n * @example\r\n *\r\n * _.replace('Hi Fred', 'Fred', 'Barney');\r\n * // => 'Hi Barney'\r\n */\r\n function replace() {\r\n var args = arguments,\r\n string = toString(args[0]);\r\n\r\n return args.length < 3 ? string : string.replace(args[1], args[2]);\r\n }\r\n\r\n /**\r\n * Converts `string` to\r\n * [snake case](https://en.wikipedia.org/wiki/Snake_case).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to convert.\r\n * @returns {string} Returns the snake cased string.\r\n * @example\r\n *\r\n * _.snakeCase('Foo Bar');\r\n * // => 'foo_bar'\r\n *\r\n * _.snakeCase('fooBar');\r\n * // => 'foo_bar'\r\n *\r\n * _.snakeCase('--FOO-BAR--');\r\n * // => 'foo_bar'\r\n */\r\n var snakeCase = createCompounder(function(result, word, index) {\r\n return result + (index ? '_' : '') + word.toLowerCase();\r\n });\r\n\r\n /**\r\n * Splits `string` by `separator`.\r\n *\r\n * **Note:** This method is based on\r\n * [`String#split`](https://mdn.io/String/split).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 4.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to split.\r\n * @param {RegExp|string} separator The separator pattern to split by.\r\n * @param {number} [limit] The length to truncate results to.\r\n * @returns {Array} Returns the string segments.\r\n * @example\r\n *\r\n * _.split('a-b-c', '-', 2);\r\n * // => ['a', 'b']\r\n */\r\n function split(string, separator, limit) {\r\n if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {\r\n separator = limit = undefined;\r\n }\r\n limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;\r\n if (!limit) {\r\n return [];\r\n }\r\n string = toString(string);\r\n if (string && (\r\n typeof separator == 'string' ||\r\n (separator != null && !isRegExp(separator))\r\n )) {\r\n separator = baseToString(separator);\r\n if (!separator && hasUnicode(string)) {\r\n return castSlice(stringToArray(string), 0, limit);\r\n }\r\n }\r\n return string.split(separator, limit);\r\n }\r\n\r\n /**\r\n * Converts `string` to\r\n * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.1.0\r\n * @category String\r\n * @param {string} [string=''] The string to convert.\r\n * @returns {string} Returns the start cased string.\r\n * @example\r\n *\r\n * _.startCase('--foo-bar--');\r\n * // => 'Foo Bar'\r\n *\r\n * _.startCase('fooBar');\r\n * // => 'Foo Bar'\r\n *\r\n * _.startCase('__FOO_BAR__');\r\n * // => 'FOO BAR'\r\n */\r\n var startCase = createCompounder(function(result, word, index) {\r\n return result + (index ? ' ' : '') + upperFirst(word);\r\n });\r\n\r\n /**\r\n * Checks if `string` starts with the given target string.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @since 3.0.0\r\n * @category String\r\n * @param {string} [string=''] The string to inspect.\r\n * @param {string} [target] The string to search for.\r\n * @param {number} [position=0] The position to search from.\r\n * @returns {boolean} Returns `true` if `string` starts with `target`,\r\n * else `false`.\r\n * @example\r\n *\r\n * _.startsWith('abc', 'a');\r\n * // => true\r\n *\r\n * _.startsWith('abc', 'b');\r\n * // => false\r\n *\r\n * _.startsWith('abc', 'b', 1);\r\n * // => true\r\n */\r\n function startsWith(string, target, position) {\r\n string = toString(string);\r\n position = position == null\r\n ? 0\r\n : baseClamp(toInteger(position), 0, string.length);\r\n\r\n target = baseToString(target);\r\n return string.slice(position, position + target.length) == target;\r\n }\r\n\r\n /**\r\n * Creates a compiled template function that can interpolate data properties\r\n * in \"interpolate\" delimiters, HTML-escape interpolated data properties in\r\n * \"escape\" delimiters, and execute JavaScript in \"evaluate\" delimiters. Data\r\n * properties may be accessed as free variables in the template. If a setting\r\n * object is given, it takes precedence over `_.templateSettings` values.\r\n *\r\n * **Note:** In the development build `_.template` utilizes\r\n * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)\r\n * for easier debugging.\r\n *\r\n * For more information on precompiling templates see\r\n * [lodash's custom builds documentation](https://lodash.com/custom-builds).\r\n *\r\n * For more information on Chrome extension sandboxes see\r\n * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).\r\n *\r\n * @static\r\n * @since 0.1.0\r\n * @memberOf _\r\n * @category String\r\n * @param {string} [string=''] The template string.\r\n * @param {Object} [options={}] The options object.\r\n * @param {RegExp} [options.escape=_.templateSettings.escape]\r\n * The HTML \"escape\" delimiter.\r\n * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]\r\n * The \"evaluate\" delimiter.\r\n * @param {Object} [options.imports=_.templateSettings.imports]\r\n * An object to import into the template as free variables.\r\n * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]\r\n * The \"interpolate\" delimiter.\r\n * @param {string} [options.sourceURL='lodash.templateSources[n]']\r\n * The sourceURL of the compiled template.\r\n * @param {string} [options.variable='obj']\r\n * The data object variable name.\r\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\r\n * @returns {Function} Returns the compiled template function.\r\n * @example\r\n *\r\n * // Use the \"interpolate\" delimiter to create a compiled template.\r\n * var compiled = _.template('hello <%= user %>!');\r\n * compiled({ 'user': 'fred' });\r\n * // => 'hello fred!'\r\n *\r\n * // Use the HTML \"escape\" delimiter to escape data property values.\r\n * var compiled = _.template('<%- value %>');\r\n * compiled({ 'value': '