' + 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 wrapper = wrapper == null ? identity : wrapper;\r\n return createWrapper(wrapper, PARTIAL_FLAG, undefined, [value], []);\r\n }\r\n\r\n /*------------------------------------------------------------------------*/\r\n\r\n /**\r\n * Creates a clone of `value`. If `isDeep` is `true` nested objects are cloned,\r\n * otherwise they are assigned by reference. If `customizer` is provided it's\r\n * invoked to produce the cloned values. If `customizer` returns `undefined`\r\n * cloning is handled by the method instead. The `customizer` is bound to\r\n * `thisArg` and invoked with up to three argument; (value [, index|key, object]).\r\n *\r\n * **Note:** This method is loosely based on the\r\n * [structured clone algorithm](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm).\r\n * The enumerable properties of `arguments` objects and objects created by\r\n * constructors other than `Object` are cloned to plain `Object` objects. An\r\n * empty object is returned for uncloneable values such as functions, DOM nodes,\r\n * Maps, Sets, and WeakMaps.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Lang\r\n * @param {*} value The value to clone.\r\n * @param {boolean} [isDeep] Specify a deep clone.\r\n * @param {Function} [customizer] The function to customize cloning values.\r\n * @param {*} [thisArg] The `this` binding of `customizer`.\r\n * @returns {*} Returns the cloned value.\r\n * @example\r\n *\r\n * var users = [\r\n * { 'user': 'barney' },\r\n * { 'user': 'fred' }\r\n * ];\r\n *\r\n * var shallow = _.clone(users);\r\n * shallow[0] === users[0];\r\n * // => true\r\n *\r\n * var deep = _.clone(users, true);\r\n * deep[0] === users[0];\r\n * // => false\r\n *\r\n * // using a customizer callback\r\n * var el = _.clone(document.body, function(value) {\r\n * if (_.isElement(value)) {\r\n * return value.cloneNode(false);\r\n * }\r\n * });\r\n *\r\n * el === document.body\r\n * // => false\r\n * el.nodeName\r\n * // => BODY\r\n * el.childNodes.length;\r\n * // => 0\r\n */\r\n function clone(value, isDeep, customizer, thisArg) {\r\n if (isDeep && typeof isDeep != 'boolean' && isIterateeCall(value, isDeep, customizer)) {\r\n isDeep = false;\r\n }\r\n else if (typeof isDeep == 'function') {\r\n thisArg = customizer;\r\n customizer = isDeep;\r\n isDeep = false;\r\n }\r\n return typeof customizer == 'function'\r\n ? baseClone(value, isDeep, bindCallback(customizer, thisArg, 3))\r\n : baseClone(value, isDeep);\r\n }\r\n\r\n /**\r\n * Creates a deep clone of `value`. If `customizer` is provided it's invoked\r\n * to produce the cloned values. If `customizer` returns `undefined` cloning\r\n * is handled by the method instead. The `customizer` is bound to `thisArg`\r\n * and invoked with up to three argument; (value [, index|key, object]).\r\n *\r\n * **Note:** This method is loosely based on the\r\n * [structured clone algorithm](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm).\r\n * The enumerable properties of `arguments` objects and objects created by\r\n * constructors other than `Object` are cloned to plain `Object` objects. An\r\n * empty object is returned for uncloneable values such as functions, DOM nodes,\r\n * Maps, Sets, and WeakMaps.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Lang\r\n * @param {*} value The value to deep clone.\r\n * @param {Function} [customizer] The function to customize cloning values.\r\n * @param {*} [thisArg] The `this` binding of `customizer`.\r\n * @returns {*} Returns the deep cloned value.\r\n * @example\r\n *\r\n * var users = [\r\n * { 'user': 'barney' },\r\n * { 'user': 'fred' }\r\n * ];\r\n *\r\n * var deep = _.cloneDeep(users);\r\n * deep[0] === users[0];\r\n * // => false\r\n *\r\n * // using a customizer callback\r\n * var el = _.cloneDeep(document.body, function(value) {\r\n * if (_.isElement(value)) {\r\n * return value.cloneNode(true);\r\n * }\r\n * });\r\n *\r\n * el === document.body\r\n * // => false\r\n * el.nodeName\r\n * // => BODY\r\n * el.childNodes.length;\r\n * // => 20\r\n */\r\n function cloneDeep(value, customizer, thisArg) {\r\n return typeof customizer == 'function'\r\n ? baseClone(value, true, bindCallback(customizer, thisArg, 3))\r\n : baseClone(value, true);\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 * @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`, else `false`.\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 function gt(value, other) {\r\n return value > other;\r\n }\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 * @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 `other`, else `false`.\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 function gte(value, other) {\r\n return value >= other;\r\n }\r\n\r\n /**\r\n * Checks if `value` is classified as an `arguments` object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 function isArguments(value) {\r\n return isObjectLike(value) && isArrayLike(value) &&\r\n hasOwnProperty.call(value, 'callee') && !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 * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\r\n * @example\r\n *\r\n * _.isArray([1, 2, 3]);\r\n * // => true\r\n *\r\n * _.isArray(function() { return arguments; }());\r\n * // => false\r\n */\r\n var isArray = nativeIsArray || function(value) {\r\n return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;\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 * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 || (isObjectLike(value) && objToString.call(value) == boolTag);\r\n }\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 * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 function isDate(value) {\r\n return isObjectLike(value) && objToString.call(value) == dateTag;\r\n }\r\n\r\n /**\r\n * Checks if `value` is a DOM element.\r\n *\r\n * @static\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 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 !!value && value.nodeType === 1 && isObjectLike(value) && !isPlainObject(value);\r\n }\r\n\r\n /**\r\n * Checks if `value` is empty. A value is considered empty unless it's an\r\n * `arguments` object, array, string, or jQuery-like collection with a length\r\n * greater than `0` or an object with own enumerable properties.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Lang\r\n * @param {Array|Object|string} value The value to inspect.\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) && (isArray(value) || isString(value) || isArguments(value) ||\r\n (isObjectLike(value) && isFunction(value.splice)))) {\r\n return !value.length;\r\n }\r\n return !keys(value).length;\r\n }\r\n\r\n /**\r\n * Performs a deep comparison between two values to determine if they are\r\n * equivalent. If `customizer` is provided it's invoked to compare values.\r\n * If `customizer` returns `undefined` comparisons are handled by the method\r\n * instead. The `customizer` is bound to `thisArg` and invoked with up to\r\n * three arguments: (value, other [, index|key]).\r\n *\r\n * **Note:** This method supports comparing arrays, booleans, `Date` objects,\r\n * numbers, `Object` objects, regexes, and strings. Objects are compared by\r\n * their own, not inherited, enumerable properties. Functions and DOM nodes\r\n * are **not** supported. Provide a customizer function to extend support\r\n * for comparing other values.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @alias eq\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 value comparisons.\r\n * @param {*} [thisArg] The `this` binding of `customizer`.\r\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\r\n * @example\r\n *\r\n * var object = { 'user': 'fred' };\r\n * var other = { 'user': 'fred' };\r\n *\r\n * object == other;\r\n * // => false\r\n *\r\n * _.isEqual(object, other);\r\n * // => true\r\n *\r\n * // using a customizer callback\r\n * var array = ['hello', 'goodbye'];\r\n * var other = ['hi', 'goodbye'];\r\n *\r\n * _.isEqual(array, other, function(value, other) {\r\n * if (_.every([value, other], RegExp.prototype.test, /^h(?:i|ello)$/)) {\r\n * return true;\r\n * }\r\n * });\r\n * // => true\r\n */\r\n function isEqual(value, other, customizer, thisArg) {\r\n customizer = typeof customizer == 'function' ? bindCallback(customizer, thisArg, 3) : undefined;\r\n var result = customizer ? customizer(value, other) : undefined;\r\n return result === undefined ? baseIsEqual(value, other, 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 * @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 return isObjectLike(value) && typeof value.message == 'string' && objToString.call(value) == errorTag;\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 [`Number.isFinite`](http://ecma-international.org/ecma-262/6.0/#sec-number.isfinite).\r\n *\r\n * @static\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 finite number, else `false`.\r\n * @example\r\n *\r\n * _.isFinite(10);\r\n * // => true\r\n *\r\n * _.isFinite('10');\r\n * // => false\r\n *\r\n * _.isFinite(true);\r\n * // => false\r\n *\r\n * _.isFinite(Object(10));\r\n * // => false\r\n *\r\n * _.isFinite(Infinity);\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 * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 // The use of `Object#toString` avoids issues with the `typeof` operator\r\n // in older versions of Chrome and Safari which return 'function' for regexes\r\n // and Safari 8 which returns 'object' for typed array constructors.\r\n return isObject(value) && objToString.call(value) == funcTag;\r\n }\r\n\r\n /**\r\n * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.\r\n * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\r\n *\r\n * @static\r\n * @memberOf _\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(1);\r\n * // => false\r\n */\r\n function isObject(value) {\r\n // Avoid a V8 JIT bug in Chrome 19-20.\r\n // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.\r\n var type = typeof value;\r\n return !!value && (type == 'object' || type == 'function');\r\n }\r\n\r\n /**\r\n * Performs a deep comparison between `object` and `source` to determine if\r\n * `object` contains equivalent property values. If `customizer` is provided\r\n * it's invoked to compare values. If `customizer` returns `undefined`\r\n * comparisons are handled by the method instead. The `customizer` is bound\r\n * to `thisArg` and invoked with three arguments: (value, other, index|key).\r\n *\r\n * **Note:** This method supports comparing properties of arrays, booleans,\r\n * `Date` objects, numbers, `Object` objects, regexes, and strings. Functions\r\n * and DOM nodes are **not** supported. Provide a customizer function to extend\r\n * support for comparing other values.\r\n *\r\n * @static\r\n * @memberOf _\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 value comparisons.\r\n * @param {*} [thisArg] The `this` binding of `customizer`.\r\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\r\n * @example\r\n *\r\n * var object = { 'user': 'fred', 'age': 40 };\r\n *\r\n * _.isMatch(object, { 'age': 40 });\r\n * // => true\r\n *\r\n * _.isMatch(object, { 'age': 36 });\r\n * // => false\r\n *\r\n * // using a customizer callback\r\n * var object = { 'greeting': 'hello' };\r\n * var source = { 'greeting': 'hi' };\r\n *\r\n * _.isMatch(object, source, function(value, other) {\r\n * return _.every([value, other], RegExp.prototype.test, /^h(?:i|ello)$/) || undefined;\r\n * });\r\n * // => true\r\n */\r\n function isMatch(object, source, customizer, thisArg) {\r\n customizer = typeof customizer == 'function' ? bindCallback(customizer, thisArg, 3) : undefined;\r\n return baseIsMatch(object, getMatchData(source), customizer);\r\n }\r\n\r\n /**\r\n * Checks if `value` is `NaN`.\r\n *\r\n * **Note:** This method is not the same as [`isNaN`](https://es5.github.io/#x15.1.2.4)\r\n * which returns `true` for `undefined` and other non-numeric values.\r\n *\r\n * @static\r\n * @memberOf _\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 host objects in IE.\r\n return isNumber(value) && value != +value;\r\n }\r\n\r\n /**\r\n * Checks if `value` is a native function.\r\n *\r\n * @static\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 native function, 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 (value == null) {\r\n return false;\r\n }\r\n if (isFunction(value)) {\r\n return reIsNative.test(fnToString.call(value));\r\n }\r\n return isObjectLike(value) && reIsHostCtor.test(value);\r\n }\r\n\r\n /**\r\n * Checks if `value` is `null`.\r\n *\r\n * @static\r\n * @memberOf _\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 classified as a `Number` primitive or object.\r\n *\r\n * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are classified\r\n * as numbers, use the `_.isFinite` method.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\r\n * @example\r\n *\r\n * _.isNumber(8.4);\r\n * // => true\r\n *\r\n * _.isNumber(NaN);\r\n * // => true\r\n *\r\n * _.isNumber('8.4');\r\n * // => false\r\n */\r\n function isNumber(value) {\r\n return typeof value == 'number' || (isObjectLike(value) && objToString.call(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 * **Note:** This method assumes objects created by the `Object` constructor\r\n * have no inherited enumerable properties.\r\n *\r\n * @static\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 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 var Ctor;\r\n\r\n // Exit early for non `Object` objects.\r\n if (!(isObjectLike(value) && objToString.call(value) == objectTag && !isArguments(value)) ||\r\n (!hasOwnProperty.call(value, 'constructor') && (Ctor = value.constructor, typeof Ctor == 'function' && !(Ctor instanceof Ctor)))) {\r\n return false;\r\n }\r\n // IE < 9 iterates inherited properties before own properties. If the first\r\n // iterated property is an object's own property then there are no inherited\r\n // enumerable properties.\r\n var result;\r\n // In most environments an object's own properties are iterated before\r\n // its inherited properties. If the last iterated property is an object's\r\n // own property then there are no inherited enumerable properties.\r\n baseForIn(value, function(subValue, key) {\r\n result = key;\r\n });\r\n return result === undefined || hasOwnProperty.call(value, result);\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 * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 function isRegExp(value) {\r\n return isObject(value) && objToString.call(value) == regexpTag;\r\n }\r\n\r\n /**\r\n * Checks if `value` is classified as a `String` primitive or object.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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' || (isObjectLike(value) && objToString.call(value) == stringTag);\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 * @category Lang\r\n * @param {*} value The value to check.\r\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 function isTypedArray(value) {\r\n return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];\r\n }\r\n\r\n /**\r\n * Checks if `value` is `undefined`.\r\n *\r\n * @static\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 less than `other`.\r\n *\r\n * @static\r\n * @memberOf _\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`, else `false`.\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 function lt(value, other) {\r\n return value < other;\r\n }\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 * @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 `other`, else `false`.\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 function lte(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 * @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 * (function() {\r\n * return _.toArray(arguments).slice(1);\r\n * }(1, 2, 3));\r\n * // => [2, 3]\r\n */\r\n function toArray(value) {\r\n var length = value ? getLength(value) : 0;\r\n if (!isLength(length)) {\r\n return values(value);\r\n }\r\n if (!length) {\r\n return [];\r\n }\r\n return arrayCopy(value);\r\n }\r\n\r\n /**\r\n * Converts `value` to a plain object flattening inherited enumerable\r\n * properties of `value` to own properties of the plain object.\r\n *\r\n * @static\r\n * @memberOf _\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 baseCopy(value, keysIn(value));\r\n }\r\n\r\n /*------------------------------------------------------------------------*/\r\n\r\n /**\r\n * Recursively merges own enumerable properties of the source object(s), that\r\n * don't resolve to `undefined` into the destination object. Subsequent sources\r\n * overwrite property assignments of previous sources. If `customizer` is\r\n * provided it's invoked to produce the merged values of the destination and\r\n * source properties. If `customizer` returns `undefined` merging is handled\r\n * by the method instead. The `customizer` is bound to `thisArg` and invoked\r\n * with five arguments: (objectValue, sourceValue, key, object, source).\r\n *\r\n * @static\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 * @param {Function} [customizer] The function to customize assigned values.\r\n * @param {*} [thisArg] The `this` binding of `customizer`.\r\n * @returns {Object} Returns `object`.\r\n * @example\r\n *\r\n * var users = {\r\n * 'data': [{ 'user': 'barney' }, { 'user': 'fred' }]\r\n * };\r\n *\r\n * var ages = {\r\n * 'data': [{ 'age': 36 }, { 'age': 40 }]\r\n * };\r\n *\r\n * _.merge(users, ages);\r\n * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }\r\n *\r\n * // using a customizer callback\r\n * var object = {\r\n * 'fruits': ['apple'],\r\n * 'vegetables': ['beet']\r\n * };\r\n *\r\n * var other = {\r\n * 'fruits': ['banana'],\r\n * 'vegetables': ['carrot']\r\n * };\r\n *\r\n * _.merge(object, other, function(a, b) {\r\n * if (_.isArray(a)) {\r\n * return a.concat(b);\r\n * }\r\n * });\r\n * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] }\r\n */\r\n var merge = createAssigner(baseMerge);\r\n\r\n /**\r\n * Assigns own enumerable properties of source object(s) to the destination\r\n * object. Subsequent sources overwrite property assignments of previous sources.\r\n * If `customizer` is provided it's invoked to produce the assigned values.\r\n * The `customizer` is bound to `thisArg` and invoked with five arguments:\r\n * (objectValue, sourceValue, key, object, source).\r\n *\r\n * **Note:** This method mutates `object` and is based on\r\n * [`Object.assign`](http://ecma-international.org/ecma-262/6.0/#sec-object.assign).\r\n *\r\n * @static\r\n * @memberOf _\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 * @param {Function} [customizer] The function to customize assigned values.\r\n * @param {*} [thisArg] The `this` binding of `customizer`.\r\n * @returns {Object} Returns `object`.\r\n * @example\r\n *\r\n * _.assign({ 'user': 'barney' }, { 'age': 40 }, { 'user': 'fred' });\r\n * // => { 'user': 'fred', 'age': 40 }\r\n *\r\n * // using a customizer callback\r\n * var defaults = _.partialRight(_.assign, function(value, other) {\r\n * return _.isUndefined(value) ? other : value;\r\n * });\r\n *\r\n * defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });\r\n * // => { 'user': 'barney', 'age': 36 }\r\n */\r\n var assign = createAssigner(function(object, source, customizer) {\r\n return customizer\r\n ? assignWith(object, source, customizer)\r\n : baseAssign(object, source);\r\n });\r\n\r\n /**\r\n * Creates an object that inherits from the given `prototype` object. If a\r\n * `properties` object is provided its own enumerable properties are assigned\r\n * to the created object.\r\n *\r\n * @static\r\n * @memberOf _\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 * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\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, guard) {\r\n var result = baseCreate(prototype);\r\n if (guard && isIterateeCall(prototype, properties, guard)) {\r\n properties = undefined;\r\n }\r\n return properties ? baseAssign(result, properties) : result;\r\n }\r\n\r\n /**\r\n * Assigns own enumerable properties of source object(s) to the destination\r\n * object for all destination properties that resolve to `undefined`. Once a\r\n * 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 * @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 * @example\r\n *\r\n * _.defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });\r\n * // => { 'user': 'barney', 'age': 36 }\r\n */\r\n var defaults = createDefaults(assign, assignDefaults);\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 * @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 * _.defaultsDeep({ 'user': { 'name': 'barney' } }, { 'user': { 'name': 'fred', 'age': 36 } });\r\n * // => { 'user': { 'name': 'barney', 'age': 36 } }\r\n *\r\n */\r\n var defaultsDeep = createDefaults(merge, mergeDefaults);\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 * If a property name is provided for `predicate` the created `_.property`\r\n * style callback returns the property value of the given element.\r\n *\r\n * If a value is also provided for `thisArg` the created `_.matchesProperty`\r\n * style callback returns `true` for elements that have a matching property\r\n * value, else `false`.\r\n *\r\n * If an object is provided for `predicate` the created `_.matches` style\r\n * callback returns `true` for elements that have the properties of the given\r\n * object, else `false`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The object to search.\r\n * @param {Function|Object|string} [predicate=_.identity] The function invoked\r\n * per iteration.\r\n * @param {*} [thisArg] The `this` binding of `predicate`.\r\n * @returns {string|undefined} Returns the key of the matched element, 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(chr) {\r\n * return chr.age < 40;\r\n * });\r\n * // => 'barney' (iteration order is not guaranteed)\r\n *\r\n * // using the `_.matches` callback shorthand\r\n * _.findKey(users, { 'age': 1, 'active': true });\r\n * // => 'pebbles'\r\n *\r\n * // using the `_.matchesProperty` callback shorthand\r\n * _.findKey(users, 'active', false);\r\n * // => 'fred'\r\n *\r\n * // using the `_.property` callback shorthand\r\n * _.findKey(users, 'active');\r\n * // => 'barney'\r\n */\r\n var findKey = createFindKey(baseForOwn);\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 * If a property name is provided for `predicate` the created `_.property`\r\n * style callback returns the property value of the given element.\r\n *\r\n * If a value is also provided for `thisArg` the created `_.matchesProperty`\r\n * style callback returns `true` for elements that have a matching property\r\n * value, else `false`.\r\n *\r\n * If an object is provided for `predicate` the created `_.matches` style\r\n * callback returns `true` for elements that have the properties of the given\r\n * object, else `false`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The object to search.\r\n * @param {Function|Object|string} [predicate=_.identity] The function invoked\r\n * per iteration.\r\n * @param {*} [thisArg] The `this` binding of `predicate`.\r\n * @returns {string|undefined} Returns the key of the matched element, 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(chr) {\r\n * return chr.age < 40;\r\n * });\r\n * // => returns `pebbles` assuming `_.findKey` returns `barney`\r\n *\r\n * // using the `_.matches` callback shorthand\r\n * _.findLastKey(users, { 'age': 36, 'active': true });\r\n * // => 'barney'\r\n *\r\n * // using the `_.matchesProperty` callback shorthand\r\n * _.findLastKey(users, 'active', false);\r\n * // => 'fred'\r\n *\r\n * // using the `_.property` callback shorthand\r\n * _.findLastKey(users, 'active');\r\n * // => 'pebbles'\r\n */\r\n var findLastKey = createFindKey(baseForOwnRight);\r\n\r\n /**\r\n * Iterates over own and inherited enumerable properties of an object invoking\r\n * `iteratee` for each property. The `iteratee` is bound to `thisArg` and 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 * @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 {*} [thisArg] The `this` binding of `iteratee`.\r\n * @returns {Object} Returns `object`.\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', and 'c' (iteration order is not guaranteed)\r\n */\r\n var forIn = createForIn(baseFor);\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 * @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 {*} [thisArg] The `this` binding of `iteratee`.\r\n * @returns {Object} Returns `object`.\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', and 'a' assuming `_.forIn ` logs 'a', 'b', and 'c'\r\n */\r\n var forInRight = createForIn(baseForRight);\r\n\r\n /**\r\n * Iterates over own enumerable properties of an object invoking `iteratee`\r\n * for each property. The `iteratee` is bound to `thisArg` and invoked with\r\n * three 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 * @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 {*} [thisArg] The `this` binding of `iteratee`.\r\n * @returns {Object} Returns `object`.\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' and 'b' (iteration order is not guaranteed)\r\n */\r\n var forOwn = createForOwn(baseForOwn);\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 * @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 {*} [thisArg] The `this` binding of `iteratee`.\r\n * @returns {Object} Returns `object`.\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' and 'a' assuming `_.forOwn` logs 'a' and 'b'\r\n */\r\n var forOwnRight = createForOwn(baseForOwnRight);\r\n\r\n /**\r\n * Creates an array of function property names from all enumerable properties,\r\n * own and inherited, of `object`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @alias methods\r\n * @category Object\r\n * @param {Object} object The object to inspect.\r\n * @returns {Array} Returns the new array of property names.\r\n * @example\r\n *\r\n * _.functions(_);\r\n * // => ['after', 'ary', 'assign', ...]\r\n */\r\n function functions(object) {\r\n return baseFunctions(object, keysIn(object));\r\n }\r\n\r\n /**\r\n * Gets the property value at `path` of `object`. If the resolved value is\r\n * `undefined` the `defaultValue` is used in its place.\r\n *\r\n * @static\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 get.\r\n * @param {*} [defaultValue] The value returned if the resolved value is `undefined`.\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, toPath(path), (path + ''));\r\n return result === undefined ? defaultValue : result;\r\n }\r\n\r\n /**\r\n * Checks if `path` is a direct property.\r\n *\r\n * @static\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` is a direct property, else `false`.\r\n * @example\r\n *\r\n * var object = { 'a': { 'b': { 'c': 3 } } };\r\n *\r\n * _.has(object, 'a');\r\n * // => true\r\n *\r\n * _.has(object, 'a.b.c');\r\n * // => true\r\n *\r\n * _.has(object, ['a', 'b', 'c']);\r\n * // => true\r\n */\r\n function has(object, path) {\r\n if (object == null) {\r\n return false;\r\n }\r\n var result = hasOwnProperty.call(object, path);\r\n if (!result && !isKey(path)) {\r\n path = toPath(path);\r\n object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));\r\n if (object == null) {\r\n return false;\r\n }\r\n path = last(path);\r\n result = hasOwnProperty.call(object, path);\r\n }\r\n return result || (isLength(object.length) && isIndex(path, object.length) &&\r\n (isArray(object) || isArguments(object)));\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 property\r\n * assignments of previous values unless `multiValue` is `true`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The object to invert.\r\n * @param {boolean} [multiValue] Allow multiple values per key.\r\n * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\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 * // with `multiValue`\r\n * _.invert(object, true);\r\n * // => { '1': ['a', 'c'], '2': ['b'] }\r\n */\r\n function invert(object, multiValue, guard) {\r\n if (guard && isIterateeCall(object, multiValue, guard)) {\r\n multiValue = undefined;\r\n }\r\n var index = -1,\r\n props = keys(object),\r\n length = props.length,\r\n result = {};\r\n\r\n while (++index < length) {\r\n var key = props[index],\r\n value = object[key];\r\n\r\n if (multiValue) {\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 }\r\n else {\r\n result[value] = key;\r\n }\r\n }\r\n return result;\r\n }\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/6.0/#sec-object.keys)\r\n * for more details.\r\n *\r\n * @static\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 var keys = !nativeKeys ? shimKeys : function(object) {\r\n var Ctor = object == null ? undefined : object.constructor;\r\n if ((typeof Ctor == 'function' && Ctor.prototype === object) ||\r\n (typeof object != 'function' && isArrayLike(object))) {\r\n return shimKeys(object);\r\n }\r\n return isObject(object) ? nativeKeys(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 * @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 if (object == null) {\r\n return [];\r\n }\r\n if (!isObject(object)) {\r\n object = Object(object);\r\n }\r\n var length = object.length;\r\n length = (length && isLength(length) &&\r\n (isArray(object) || isArguments(object)) && length) || 0;\r\n\r\n var Ctor = object.constructor,\r\n index = -1,\r\n isProto = typeof Ctor == 'function' && Ctor.prototype === object,\r\n result = Array(length),\r\n skipIndexes = length > 0;\r\n\r\n while (++index < length) {\r\n result[index] = (index + '');\r\n }\r\n for (var key in object) {\r\n if (!(skipIndexes && isIndex(key, length)) &&\r\n !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\r\n result.push(key);\r\n }\r\n }\r\n return result;\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 * property of `object` through `iteratee`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The object to iterate over.\r\n * @param {Function|Object|string} [iteratee=_.identity] The function invoked\r\n * per iteration.\r\n * @param {*} [thisArg] The `this` binding of `iteratee`.\r\n * @returns {Object} Returns the new mapped object.\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 var mapKeys = createObjectMapper(true);\r\n\r\n /**\r\n * Creates an object with the same keys as `object` and values generated by\r\n * running each own enumerable property of `object` through `iteratee`. The\r\n * iteratee function is bound to `thisArg` and invoked with three arguments:\r\n * (value, key, object).\r\n *\r\n * If a property name is provided for `iteratee` the created `_.property`\r\n * style callback returns the property value of the given element.\r\n *\r\n * If a value is also provided for `thisArg` the created `_.matchesProperty`\r\n * style callback returns `true` for elements that have a matching property\r\n * value, else `false`.\r\n *\r\n * If an object is provided for `iteratee` the created `_.matches` style\r\n * callback returns `true` for elements that have the properties of the given\r\n * object, else `false`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The object to iterate over.\r\n * @param {Function|Object|string} [iteratee=_.identity] The function invoked\r\n * per iteration.\r\n * @param {*} [thisArg] The `this` binding of `iteratee`.\r\n * @returns {Object} Returns the new mapped object.\r\n * @example\r\n *\r\n * _.mapValues({ 'a': 1, 'b': 2 }, function(n) {\r\n * return n * 3;\r\n * });\r\n * // => { 'a': 3, 'b': 6 }\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 * // using the `_.property` callback shorthand\r\n * _.mapValues(users, 'age');\r\n * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\r\n */\r\n var mapValues = createObjectMapper();\r\n\r\n /**\r\n * The opposite of `_.pick`; this method creates an object composed of the\r\n * own and inherited enumerable properties of `object` that are not omitted.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The source object.\r\n * @param {Function|...(string|string[])} [predicate] The function invoked per\r\n * iteration or property names to omit, specified as individual property\r\n * names or arrays of property names.\r\n * @param {*} [thisArg] The `this` binding of `predicate`.\r\n * @returns {Object} Returns the new object.\r\n * @example\r\n *\r\n * var object = { 'user': 'fred', 'age': 40 };\r\n *\r\n * _.omit(object, 'age');\r\n * // => { 'user': 'fred' }\r\n *\r\n * _.omit(object, _.isNumber);\r\n * // => { 'user': 'fred' }\r\n */\r\n var omit = restParam(function(object, props) {\r\n if (object == null) {\r\n return {};\r\n }\r\n if (typeof props[0] != 'function') {\r\n var props = arrayMap(baseFlatten(props), String);\r\n return pickByArray(object, baseDifference(keysIn(object), props));\r\n }\r\n var predicate = bindCallback(props[0], props[1], 3);\r\n return pickByCallback(object, function(value, key, object) {\r\n return !predicate(value, key, object);\r\n });\r\n });\r\n\r\n /**\r\n * Creates a two dimensional array of the key-value pairs for `object`,\r\n * e.g. `[[key1, value1], [key2, value2]]`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The object to query.\r\n * @returns {Array} Returns the new array of key-value pairs.\r\n * @example\r\n *\r\n * _.pairs({ 'barney': 36, 'fred': 40 });\r\n * // => [['barney', 36], ['fred', 40]] (iteration order is not guaranteed)\r\n */\r\n function pairs(object) {\r\n object = toObject(object);\r\n\r\n var index = -1,\r\n props = keys(object),\r\n length = props.length,\r\n result = Array(length);\r\n\r\n while (++index < length) {\r\n var key = props[index];\r\n result[index] = [key, object[key]];\r\n }\r\n return result;\r\n }\r\n\r\n /**\r\n * Creates an object composed of the picked `object` properties. Property\r\n * names may be specified as individual arguments or as arrays of property\r\n * names. If `predicate` is provided it's invoked for each property of `object`\r\n * picking the properties `predicate` returns truthy for. The predicate is\r\n * bound to `thisArg` and invoked with three arguments: (value, key, object).\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The source object.\r\n * @param {Function|...(string|string[])} [predicate] The function invoked per\r\n * iteration or property names to pick, specified as individual property\r\n * names or arrays of property names.\r\n * @param {*} [thisArg] The `this` binding of `predicate`.\r\n * @returns {Object} Returns the new object.\r\n * @example\r\n *\r\n * var object = { 'user': 'fred', 'age': 40 };\r\n *\r\n * _.pick(object, 'user');\r\n * // => { 'user': 'fred' }\r\n *\r\n * _.pick(object, _.isString);\r\n * // => { 'user': 'fred' }\r\n */\r\n var pick = restParam(function(object, props) {\r\n if (object == null) {\r\n return {};\r\n }\r\n return typeof props[0] == 'function'\r\n ? pickByCallback(object, bindCallback(props[0], props[1], 3))\r\n : pickByArray(object, baseFlatten(props));\r\n });\r\n\r\n /**\r\n * This method is like `_.get` except that if the resolved value is a function\r\n * it's invoked with the `this` binding of its parent object and its result\r\n * is returned.\r\n *\r\n * @static\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 if the resolved value is `undefined`.\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.b.c', 'default');\r\n * // => 'default'\r\n *\r\n * _.result(object, 'a.b.c', _.constant('default'));\r\n * // => 'default'\r\n */\r\n function result(object, path, defaultValue) {\r\n var result = object == null ? undefined : object[path];\r\n if (result === undefined) {\r\n if (object != null && !isKey(path, object)) {\r\n path = toPath(path);\r\n object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));\r\n result = object == null ? undefined : object[last(path)];\r\n }\r\n result = result === undefined ? defaultValue : result;\r\n }\r\n return isFunction(result) ? result.call(object) : result;\r\n }\r\n\r\n /**\r\n * Sets the property value of `path` on `object`. If a portion of `path`\r\n * does not exist it's created.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Object\r\n * @param {Object} object The object to augment.\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 if (object == null) {\r\n return object;\r\n }\r\n var pathKey = (path + '');\r\n path = (object[pathKey] != null || isKey(path, object)) ? [pathKey] : toPath(path);\r\n\r\n var index = -1,\r\n length = path.length,\r\n lastIndex = length - 1,\r\n nested = object;\r\n\r\n while (nested != null && ++index < length) {\r\n var key = path[index];\r\n if (isObject(nested)) {\r\n if (index == lastIndex) {\r\n nested[key] = value;\r\n } else if (nested[key] == null) {\r\n nested[key] = isIndex(path[index + 1]) ? [] : {};\r\n }\r\n }\r\n nested = nested[key];\r\n }\r\n return object;\r\n }\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 enumerable\r\n * properties through `iteratee`, with each invocation potentially mutating\r\n * the `accumulator` object. The `iteratee` is bound to `thisArg` and invoked\r\n * with four arguments: (accumulator, value, key, object). Iteratee functions\r\n * may exit iteration early by explicitly returning `false`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Object\r\n * @param {Array|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 * @param {*} [thisArg] The `this` binding of `iteratee`.\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 }, function(result, n, key) {\r\n * result[key] = n * 3;\r\n * });\r\n * // => { 'a': 3, 'b': 6 }\r\n */\r\n function transform(object, iteratee, accumulator, thisArg) {\r\n var isArr = isArray(object) || isTypedArray(object);\r\n iteratee = getCallback(iteratee, thisArg, 4);\r\n\r\n if (accumulator == null) {\r\n if (isArr || isObject(object)) {\r\n var Ctor = object.constructor;\r\n if (isArr) {\r\n accumulator = isArray(object) ? new Ctor : [];\r\n } else {\r\n accumulator = baseCreate(isFunction(Ctor) ? Ctor.prototype : undefined);\r\n }\r\n } else {\r\n accumulator = {};\r\n }\r\n }\r\n (isArr ? 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 * Creates an array of the own enumerable property 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 * @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 baseValues(object, keys(object));\r\n }\r\n\r\n /**\r\n * Creates an array of the own and inherited enumerable property values\r\n * of `object`.\r\n *\r\n * **Note:** Non-object values are coerced to objects.\r\n *\r\n * @static\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 * _.valuesIn(new Foo);\r\n * // => [1, 2, 3] (iteration order is not guaranteed)\r\n */\r\n function valuesIn(object) {\r\n return baseValues(object, keysIn(object));\r\n }\r\n\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 *\r\n * @static\r\n * @memberOf _\r\n * @category Number\r\n * @param {number} n 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 `n` is in the range, else `false`.\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 function inRange(value, start, end) {\r\n start = +start || 0;\r\n if (end === undefined) {\r\n end = start;\r\n start = 0;\r\n } else {\r\n end = +end || 0;\r\n }\r\n return value >= nativeMin(start, end) && value < nativeMax(start, end);\r\n }\r\n\r\n /**\r\n * Produces a random number between `min` and `max` (inclusive). If only one\r\n * argument is provided a number between `0` and the given number is returned.\r\n * If `floating` is `true`, or either `min` or `max` are floats, a floating-point\r\n * number is returned instead of an integer.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category Number\r\n * @param {number} [min=0] The minimum possible value.\r\n * @param {number} [max=1] The maximum possible value.\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(min, max, floating) {\r\n if (floating && isIterateeCall(min, max, floating)) {\r\n max = floating = undefined;\r\n }\r\n var noMin = min == null,\r\n noMax = max == null;\r\n\r\n if (floating == null) {\r\n if (noMax && typeof min == 'boolean') {\r\n floating = min;\r\n min = 1;\r\n }\r\n else if (typeof max == 'boolean') {\r\n floating = max;\r\n noMax = true;\r\n }\r\n }\r\n if (noMin && noMax) {\r\n max = 1;\r\n noMax = false;\r\n }\r\n min = +min || 0;\r\n if (noMax) {\r\n max = min;\r\n min = 0;\r\n } else {\r\n max = +max || 0;\r\n }\r\n if (floating || min % 1 || max % 1) {\r\n var rand = nativeRandom();\r\n return nativeMin(min + (rand * (max - min + parseFloat('1e-' + ((rand + '').length - 1)))), max);\r\n }\r\n return baseRandom(min, max);\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 * @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 ? (word.charAt(0).toUpperCase() + word.slice(1)) : word);\r\n });\r\n\r\n /**\r\n * Capitalizes the first character of `string`.\r\n *\r\n * @static\r\n * @memberOf _\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 string = baseToString(string);\r\n return string && (string.charAt(0).toUpperCase() + string.slice(1));\r\n }\r\n\r\n /**\r\n * Deburrs `string` by converting [latin-1 supplementary letters](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\r\n * to basic latin letters and removing [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\r\n *\r\n * @static\r\n * @memberOf _\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 = baseToString(string);\r\n return string && string.replace(reLatin1, 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 * @category String\r\n * @param {string} [string=''] The string to search.\r\n * @param {string} [target] The string to search for.\r\n * @param {number} [position=string.length] The position to search from.\r\n * @returns {boolean} Returns `true` if `string` ends with `target`, 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 = baseToString(string);\r\n target = (target + '');\r\n\r\n var length = string.length;\r\n position = position === undefined\r\n ? length\r\n : nativeMin(position < 0 ? 0 : (+position || 0), length);\r\n\r\n position -= target.length;\r\n return position >= 0 && string.indexOf(target, position) == position;\r\n }\r\n\r\n /**\r\n * Converts the characters \"&\", \"<\", \">\", '\"', \"'\", and \"\\`\", in `string` to\r\n * their corresponding HTML entities.\r\n *\r\n * **Note:** No other characters are escaped. To escape additional characters\r\n * 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.\r\n * See [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\r\n * (under \"semi-related fun fact\") for more details.\r\n *\r\n * Backticks are escaped because in Internet Explorer < 9, they can break out\r\n * of attribute values or HTML comments. See [#59](https://html5sec.org/#59),\r\n * [#102](https://html5sec.org/#102), [#108](https://html5sec.org/#108), and\r\n * [#133](https://html5sec.org/#133) of the [HTML5 Security Cheatsheet](https://html5sec.org/)\r\n * for more details.\r\n *\r\n * When working with HTML you should always [quote attribute values](http://wonko.com/post/html-escaping)\r\n * to reduce XSS vectors.\r\n *\r\n * @static\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 // Reset `lastIndex` because in IE < 9 `String#replace` does not.\r\n string = baseToString(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 * @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 = baseToString(string);\r\n return (string && reHasRegExpChars.test(string))\r\n ? string.replace(reRegExpChars, escapeRegExpChar)\r\n : (string || '(?:)');\r\n }\r\n\r\n /**\r\n * Converts `string` to [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).\r\n *\r\n * @static\r\n * @memberOf _\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 * 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 * @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 = baseToString(string);\r\n length = +length;\r\n\r\n var strLength = string.length;\r\n if (strLength >= length || !nativeIsFinite(length)) {\r\n return string;\r\n }\r\n var mid = (length - strLength) / 2,\r\n leftLength = nativeFloor(mid),\r\n rightLength = nativeCeil(mid);\r\n\r\n chars = createPadding('', rightLength, chars);\r\n return chars.slice(0, leftLength) + string + chars;\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 * @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 * _.padLeft('abc', 6);\r\n * // => ' abc'\r\n *\r\n * _.padLeft('abc', 6, '_-');\r\n * // => '_-_abc'\r\n *\r\n * _.padLeft('abc', 3);\r\n * // => 'abc'\r\n */\r\n var padLeft = createPadDir();\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 * @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 * _.padRight('abc', 6);\r\n * // => 'abc '\r\n *\r\n * _.padRight('abc', 6, '_-');\r\n * // => 'abc_-_'\r\n *\r\n * _.padRight('abc', 3);\r\n * // => 'abc'\r\n */\r\n var padRight = createPadDir(true);\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 hexadecimal,\r\n * in which case a `radix` of `16` is used.\r\n *\r\n * **Note:** This method aligns with the [ES5 implementation](https://es5.github.io/#E)\r\n * of `parseInt`.\r\n *\r\n * @static\r\n * @memberOf _\r\n * @category String\r\n * @param {string} string The string to convert.\r\n * @param {number} [radix] The radix to interpret `value` by.\r\n * @param- {Object} [guard] Enables use as a callback for functions 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 // Firefox < 21 and Opera < 15 follow ES3 for `parseInt`.\r\n // Chrome fails to trim leading