* Gets the native function at `key` of `object`. * * @private * @param {Object} object The object to query. * @param {string} key The key

* Checks if `value` is object-like. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is

* Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`. * (e.g. arrays, functions, objects, regexes, `new Number(0)`, an

* Converts `value` to an object if it's not one. * * @private * @param {*} value The value to process. * @returns {Object} Returns the obj

* Creates a function that invokes `func` with the `this` binding of the * created function and arguments from `start` and beyond provided as an arr

* Copies the values of `source` to `array`. * * @private * @param {Array} source The array to copy values from. * @param {Array} [array=[]

* Checks if `value` is array-like. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a

* A specialized version of `baseCallback` which only supports `this` binding * and specifying the number of arguments to provide to `func`. *

* Checks if `value` is a valid array-like length. * * **Note:** This function is based on [`ToLength`](https://people.mozilla.org/~jorendorff/es

* Replaces all `placeholder` elements in `array` with an internal placeholder * and returns an array of their indexes. * * @private * @par

* Creates a function that produces an instance of `Ctor` regardless of * whether it was invoked as part of a `new` expression or by `call` or `appl

* Find the differences between two texts. Simplifies the problem by stripping * any common prefix or suffix off the texts before diffing. * @param

* Gets the appropriate "callback" function. If the `_.callback` method is * customized this function returns the custom method, otherwise it return

* Checks if `value` is a valid array-like index. * * @private * @param {*} value The value to check. * @param {number} [length=MAX_SAFE_IN

* Checks if the provided arguments are from an iteratee call. * * @private * @param {*} value The potential iteratee value argument. * @pa

* Checks if `value` is a property name and not a property path. * * @private * @param {*} value The value to check. * @param {Object} [obj

* The base implementation of `_.clone` without support for argument juggling * and `this` binding `customizer` functions. * * @private * @

* The base implementation of `get` without support for string paths * and default values. * * @private * @param {Object} object The object

* The base implementation of `_.isEqual` without support for `this` binding * `customizer` functions. * * @private * @param {*} value The

* Converts `value` to a string if it's not one. An empty string is returned * for `null` or `undefined` values. * * @private * @param {*}

* Creates a function that invokes `func` with the `this` binding of `thisArg` * and arguments of the created function. If `func` is a property name

* Determine the common prefix of two strings. * @param {string} text1 First string. * @param {string} text2 Second string. * @return {number} The n

* Determine the common suffix of two strings. * @param {string} text1 First string. * @param {string} text2 Second string. * @return {number} The n

* Gets the index at which the first occurrence of `value` is found in `array` * using [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-

* Checks if `value` is classified as an `arguments` object. * * @static * @memberOf _ * @category Lang * @param {*} value The value to

* Converts `value` to property path array if it's not one. * * @private * @param {*} value The value to process. * @returns {Array} Return

* The base implementation of `_.assign` without support for argument juggling, * multiple sources, and `customizer` functions. * * @private

* The base implementation of `_.difference` which accepts a single array * of values to exclude. * * @private * @param {Array} array The a

* The base implementation of `_.flatten` with added support for restricting * flattening and specifying the start index. * * @private * @p

* The base implementation of `_.forIn` without support for callback * shorthands and `this` binding. * * @private * @param {Object} object

* The base implementation of `_.isFunction` without support for environments * with incorrect `typeof` results. * * @private * @param {*}

* The base implementation of `_.matches` which does not clone `source`. * * @private * @param {Object} source The object of property values t

* The base implementation of `_.property` without support for deep paths. * * @private * @param {string} key The key of the property to get.

* The base implementation of `_.slice` without an iteratee call guard. * * @private * @param {Array} array The array to slice. * @param {n

* Creates a clone of the given array buffer. * * @private * @param {ArrayBuffer} buffer The array buffer to clone. * @returns {ArrayBuffer

* Checks if `value` is in `cache` mimicking the return signature of * `_.indexOf` by returning `0` if the value is found, else `-1`. * * @pri

* Creates an array that is the composition of partially applied arguments, * placeholders, and provided arguments into a single array of arguments.

* This function is like `composeArgs` except that the arguments composition * is tailored for `_.partialRight`. * * @private * @param {Arr

* Creates a function that returns `value`. * * @static * @memberOf _ * @category Utility * @param {*} value The value to return from th

* Creates a function that either curries or invokes `func` with optional * `this` binding and partially applied arguments. * * @private *

* Given the location of the 'middle snake', split the diff in two parts * and recurse. * @param {string} text1 Old string to be diffed. * @param {s

* Does a substring of shorttext exist within longtext such that the substring * is at least half the length of longtext? * Closure, but does not

* Gets the appropriate "indexOf" function. If the `_.indexOf` method is * customized this function returns the custom method, otherwise it returns

* Checks if `value` is suitable for strict equality comparisons, i.e. `===`. * * @private * @param {*} value The value to check. * @return

* Checks if `value` is classified as a typed array. * * @static * @memberOf _ * @category Lang * @param {*} value The value to check.

* Creates an array of the own and inherited enumerable property names of `object`. * * **Note:** Non-object values are coerced to objects. *

* Gets the last element of `array`. * * @static * @memberOf _ * @category Array * @param {Array} array The array to query. * @return

* A specialized version of `_.forEach` for arrays without support for callback * shorthands and `this` binding. * * @private * @param {Arr

* A specialized version of `_.map` for arrays without support for callback * shorthands and `this` binding. * * @private * @param {Array}

* A specialized version of `_.some` for arrays without support for callback * shorthands and `this` binding. * * @private * @param {Array}

* A specialized version of `_.assign` for customizing assigned values without * support for argument juggling, multiple sources, and `this` binding

* The base implementation of `_.callback` which supports specifying the * number of arguments to provide to `func`. * * @private * @param

* Copies properties of `source` to `object`. * * @private * @param {Object} source The object to copy properties from. * @param {Array} pr

* The base implementation of `_.delay` and `_.defer` which accepts an index * of where to slice the arguments to provide to `func`. * * @priv

* The base implementation of `_.find`, `_.findLast`, `_.findKey`, and `_.findLastKey`, * without support for callback shorthands and `this` binding

* The base implementation of `_.findIndex` and `_.findLastIndex` without * support for callback shorthands and `this` binding. * * @private

* The base implementation of `_.indexOf` without support for binary searches. * * @private * @param {Array} array The array to search. * @

* A specialized version of `baseIsEqual` for arrays and objects which performs * deep comparisons and tracks traversed objects enabling objects wit

* The base implementation of `_.isMatch` without support for callback * shorthands and `this` binding. * * @private * @param {Object} obje

* The base implementation of `_.matchesProperty` which does not clone `srcValue`. * * @private * @param {string} path The path of the propert

* A specialized version of `baseProperty` which supports deep paths. * * @private * @param {Array|string} path The path of the property to ge

* The base implementation of `_.reduce` and `_.reduceRight` without support * for callback shorthands and `this` binding, which iterates over `coll

* The base implementation of `_.values` and `_.valuesIn` which creates an * array of `object` property values corresponding to the property names

* Performs a binary search of `array` to determine the index at which `value` * should be inserted into `array` in order to maintain its sort order

* This function is like `binaryIndex` except that it invokes `iteratee` for * `value` and each element of `array` to compute their sort ranking. Th

* Creates a function that assigns properties of source object(s) to a given * destination object. * * **Note:** This function is used to crea

* Creates a `baseEach` or `baseEachRight` function. * * @private * @param {Function} eachFunc The function to iterate over a collection. *

* Creates a base function for `_.forIn` or `_.forInRight`. * * @private * @param {boolean} [fromRight] Specify iterating from right to left.

* Creates a function that wraps `func` and invokes it with the `this` * binding of `thisArg`. * * @private * @param {Function} func The fu

* Creates a `_.find` or `_.findLast` function. * * @private * @param {Function} eachFunc The function to iterate over a collection. * @par

* Creates a function for `_.forEach` or `_.forEachRight`. * * @private * @param {Function} arrayFunc The function to iterate over an array.

* Creates a `_.partial` or `_.partialRight` function. * * @private * @param {boolean} flag The partial bit flag. * @returns {Function} Ret

* Creates a function for `_.reduce` or `_.reduceRight`. * * @private * @param {Function} arrayFunc The function to iterate over an array.

* Find the 'middle snake' of a diff, split the problem in two * and return the recursively constructed diff. * See Myers 1986 paper: An O(ND) Differ

* Reorder and merge like edit sections. Merge equalities. * Any edit section can move as long as it doesn't cross an equality. * @param {Array} dif

* Find the differences between two texts. Assumes that the texts do not * have any common prefix or suffix. * @param {string} text1 Old string to b

* Do the two texts share a substring which is at least half the length of the * longer text? * This speedup can produce non-minimal diffs. * @param

* A specialized version of `baseIsEqualDeep` for comparing objects of * the same `toStringTag`. * * **Note:** This function only supports com

* Escapes the `RegExp` special characters "\", "/", "^", "$", ".", "|", "?", * "*", "+", "(", ")", "[", "]", "{" and "}" in `string`. * * @st

* Gets the name of `func`. * * @private * @param {Function} func The function to query. * @returns {string} Returns the function name.

* Gets the propery names, values, and compare flags of `object`. * * @private * @param {Object} object The object to query. * @returns {Ar

* Gets the index at which the first occurrence of `NaN` is found in `array`. * * @private * @param {Array} array The array to search. * @p

* Initializes an array clone. * * @private * @param {Array} array The array to clone. * @returns {Array} Returns the initialized clone.

* Initializes an object clone based on its `toStringTag`. * * **Note:** This function only supports cloning values with tags of * `Boolean`,

* Initializes an object clone. * * @private * @param {Object} object The object to clone. * @returns {Object} Returns the initialized clon

* Invokes the method at `path` on `object`. * * @private * @param {Object} object The object to query. * @param {Array|string} path The pa

* Checks if `func` has a lazy counterpart. * * @private * @param {Function} func The function to check. * @returns {boolean} Returns `true

* Checks if `value` is a native function. * * @static * @memberOf _ * @category Lang * @param {*} value The value to check. * @retur

* Creates a function that performs a deep comparison between a given object * and `source`, returning `true` if the given object has equivalent pro

* Merges the function metadata of `source` into `data`. * * Merging metadata reduces the number of wrappers required to invoke a function. *

* Creates a two dimensional array of the key-value pairs for `object`, * e.g. `[[key1, value1], [key2, value2]]`. * * @static * @memberOf

* A specialized version of `_.pick` which picks `object` properties specified * by `props`. * * @private * @param {Object} object The sour

* A specialized version of `_.pick` which picks `object` properties `predicate` * returns truthy for. * * @private * @param {Object} objec

* Creates a function that returns the property value at `path` on a * given object. * * @static * @memberOf _ * @category Utility *

* Reorder `array` according to the specified indexes where the element at * the first index is assigned as the first element, the element at * t

* A fallback implementation of `_.isPlainObject` which checks if `value` * is an object created by the `Object` constructor or has a `[[Prototype]]

* A fallback implementation of `Object.keys` which creates an array of the * own enumerable property names of `object`. * * @private * @pa