[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/dist/vendor/ -> lodash.js (summary)

(no description)

License:
File Size: 17161 lines (543 kb)
Included or required:0 times
Referenced: 0 times
Includes or requires: 0 files

Defines 488 functions

  apply()
  arrayAggregator()
  arrayEach()
  arrayEachRight()
  arrayEvery()
  arrayFilter()
  arrayIncludes()
  arrayIncludesWith()
  arrayMap()
  arrayPush()
  arrayReduce()
  arrayReduceRight()
  arraySome()
  asciiToArray()
  asciiWords()
  baseFindKey()
  baseFindIndex()
  baseIndexOf()
  baseIndexOfWith()
  baseIsNaN()
  baseMean()
  baseProperty()
  basePropertyOf()
  baseReduce()
  baseSortBy()
  baseSum()
  baseTimes()
  baseToPairs()
  baseUnary()
  baseValues()
  cacheHas()
  charsStartIndex()
  charsEndIndex()
  countHolders()
  escapeStringChar()
  getValue()
  hasUnicode()
  hasUnicodeWord()
  iteratorToArray()
  mapToArray()
  overArg()
  replaceHolders()
  setToArray()
  setToPairs()
  strictIndexOf()
  strictLastIndexOf()
  stringSize()
  stringToArray()
  unicodeSize()
  unicodeToArray()
  unicodeWords()
  lodash()
  object()
  baseLodash()
  LodashWrapper()
  LazyWrapper()
  lazyClone()
  lazyReverse()
  lazyValue()
  Hash()
  hashClear()
  hashDelete()
  hashGet()
  hashHas()
  hashSet()
  ListCache()
  listCacheClear()
  listCacheDelete()
  listCacheGet()
  listCacheHas()
  listCacheSet()
  MapCache()
  mapCacheClear()
  mapCacheDelete()
  mapCacheGet()
  mapCacheHas()
  mapCacheSet()
  SetCache()
  setCacheAdd()
  setCacheHas()
  Stack()
  stackClear()
  stackDelete()
  stackGet()
  stackHas()
  stackSet()
  arrayLikeKeys()
  arraySample()
  arraySampleSize()
  arrayShuffle()
  assignMergeValue()
  assignValue()
  assocIndexOf()
  baseAggregator()
  baseAssign()
  baseAssignIn()
  baseAssignValue()
  baseAt()
  baseClamp()
  baseClone()
  baseConforms()
  baseConformsTo()
  baseDelay()
  baseDifference()
  baseEvery()
  baseExtremum()
  baseFill()
  baseFilter()
  baseFlatten()
  baseForOwn()
  baseForOwnRight()
  baseFunctions()
  baseGet()
  baseGetAllKeys()
  baseGetTag()
  baseGt()
  baseHas()
  baseHasIn()
  baseInRange()
  baseIntersection()
  baseInverter()
  baseInvoke()
  baseIsArguments()
  baseIsArrayBuffer()
  baseIsDate()
  baseIsEqual()
  baseIsEqualDeep()
  baseIsMap()
  baseIsMatch()
  baseIsNative()
  baseIsRegExp()
  baseIsSet()
  baseIsTypedArray()
  baseIteratee()
  baseKeys()
  baseKeysIn()
  baseLt()
  baseMap()
  baseMatches()
  baseMatchesProperty()
  baseMerge()
  baseMergeDeep()
  baseNth()
  baseOrderBy()
  basePick()
  basePickBy()
  basePropertyDeep()
  basePullAll()
  basePullAt()
  baseRandom()
  baseRange()
  baseRepeat()
  baseRest()
  baseSample()
  baseSampleSize()
  baseSet()
  baseShuffle()
  baseSlice()
  baseSome()
  baseSortedIndex()
  baseSortedIndexBy()
  baseSortedUniq()
  baseToNumber()
  baseToString()
  baseUniq()
  baseUnset()
  baseUpdate()
  baseWhile()
  baseWrapperValue()
  baseXor()
  baseZipObject()
  castArrayLikeObject()
  castFunction()
  castPath()
  castSlice()
  cloneBuffer()
  cloneArrayBuffer()
  cloneDataView()
  cloneRegExp()
  cloneSymbol()
  cloneTypedArray()
  compareAscending()
  compareMultiple()
  composeArgs()
  composeArgsRight()
  copyArray()
  copyObject()
  copySymbols()
  copySymbolsIn()
  createAggregator()
  createAssigner()
  createBaseEach()
  createBaseFor()
  createBind()
  wrapper()
  createCaseFirst()
  createCompounder()
  createCtor()
  createCurry()
  wrapper()
  createFind()
  createFlow()
  createHybrid()
  wrapper()
  createInverter()
  createMathOperation()
  createOver()
  createPadding()
  createPartial()
  wrapper()
  createRange()
  createRelationalOperation()
  createRecurry()
  createRound()
  createToPairs()
  createWrap()
  customDefaultsAssignIn()
  customDefaultsMerge()
  customOmitClone()
  equalArrays()
  equalByTag()
  equalObjects()
  flatRest()
  getAllKeys()
  getAllKeysIn()
  getFuncName()
  getHolder()
  getIteratee()
  getMapData()
  getMatchData()
  getNative()
  getRawTag()
  getView()
  getWrapDetails()
  hasPath()
  initCloneArray()
  initCloneObject()
  initCloneByTag()
  insertWrapDetails()
  isFlattenable()
  isIndex()
  isIterateeCall()
  isKey()
  isKeyable()
  isLaziable()
  isMasked()
  isPrototype()
  isStrictComparable()
  matchesStrictComparable()
  memoizeCapped()
  mergeData()
  nativeKeysIn()
  objectToString()
  overRest()
  parent()
  reorder()
  safeGet()
  setWrapToString()
  shortOut()
  shuffleSelf()
  toKey()
  toSource()
  updateWrapDetails()
  wrapperClone()
  chunk()
  compact()
  concat()
  drop()
  dropRight()
  dropRightWhile()
  dropWhile()
  fill()
  findIndex()
  findLastIndex()
  flatten()
  flattenDeep()
  flattenDepth()
  fromPairs()
  head()
  indexOf()
  initial()
  join()
  last()
  lastIndexOf()
  nth()
  pullAll()
  pullAllBy()
  pullAllWith()
  remove()
  reverse()
  slice()
  sortedIndex()
  sortedIndexBy()
  sortedIndexOf()
  sortedLastIndex()
  sortedLastIndexBy()
  sortedLastIndexOf()
  sortedUniq()
  sortedUniqBy()
  tail()
  take()
  takeRight()
  takeRightWhile()
  takeWhile()
  uniq()
  uniqBy()
  uniqWith()
  unzip()
  unzipWith()
  zipObject()
  zipObjectDeep()
  chain()
  tap()
  thru()
  wrapperChain()
  wrapperCommit()
  wrapperNext()
  wrapperToIterator()
  wrapperPlant()
  wrapperReverse()
  wrapperValue()
  every()
  filter()
  flatMap()
  flatMapDeep()
  flatMapDepth()
  forEach()
  forEachRight()
  includes()
  map()
  orderBy()
  reduce()
  reduceRight()
  reject()
  sample()
  sampleSize()
  shuffle()
  size()
  some()
  after()
  ary()
  before()
  curry()
  curryRight()
  debounce()
  invokeFunc()
  leadingEdge()
  remainingWait()
  shouldInvoke()
  timerExpired()
  trailingEdge()
  cancel()
  flush()
  debounced()
  flip()
  memoize()
  negate()
  once()
  rest()
  spread()
  throttle()
  unary()
  wrap()
  castArray()
  clone()
  cloneWith()
  cloneDeep()
  cloneDeepWith()
  conformsTo()
  eq()
  isArrayLike()
  isArrayLikeObject()
  isBoolean()
  isElement()
  isEmpty()
  isEqual()
  isEqualWith()
  isError()
  isFinite()
  isFunction()
  isInteger()
  isLength()
  isObject()
  isObjectLike()
  isMatch()
  isMatchWith()
  isNaN()
  isNative()
  isNull()
  isNil()
  isNumber()
  isPlainObject()
  isSafeInteger()
  isString()
  isSymbol()
  isUndefined()
  isWeakMap()
  isWeakSet()
  toArray()
  toFinite()
  toInteger()
  toLength()
  toNumber()
  toPlainObject()
  toSafeInteger()
  toString()
  create()
  findKey()
  findLastKey()
  forIn()
  forInRight()
  forOwn()
  forOwnRight()
  functions()
  functionsIn()
  get()
  has()
  hasIn()
  keys()
  keysIn()
  mapKeys()
  mapValues()
  omitBy()
  pickBy()
  result()
  set()
  setWith()
  transform()
  unset()
  update()
  updateWith()
  values()
  valuesIn()
  clamp()
  inRange()
  random()
  capitalize()
  deburr()
  endsWith()
  escape()
  escapeRegExp()
  pad()
  padEnd()
  padStart()
  parseInt()
  repeat()
  replace()
  split()
  startsWith()
  template()
  toLower()
  toUpper()
  trim()
  trimEnd()
  trimStart()
  truncate()
  unescape()
  words()
  cond()
  conforms()
  constant()
  defaultTo()
  identity()
  iteratee()
  matches()
  matchesProperty()
  mixin()
  noConflict()
  noop()
  nthArg()
  property()
  propertyOf()
  stubArray()
  stubFalse()
  stubObject()
  stubString()
  stubTrue()
  times()
  toPath()
  uniqueId()
  max()
  maxBy()
  mean()
  meanBy()
  min()
  minBy()
  sum()
  sumBy()

Functions
Functions that are not part of a class:

apply(func, thisArg, args)   X-Ref
A faster alternative to `Function#apply`, this function invokes `func`
with the `this` binding of `thisArg` and the arguments of `args`.

returns: {*} Returns the result of `func`.
param: {Function} func The function to invoke.
param: {*} thisArg The `this` binding of `func`.
param: {Array} args The arguments to invoke `func` with.

arrayAggregator(array, setter, iteratee, accumulator)   X-Ref
A specialized version of `baseAggregator` for arrays.

returns: {Function} Returns `accumulator`.
param: {Array} [array] The array to iterate over.
param: {Function} setter The function to set `accumulator` values.
param: {Function} iteratee The iteratee to transform keys.
param: {Object} accumulator The initial aggregated object.

arrayEach(array, iteratee)   X-Ref
A specialized version of `_.forEach` for arrays without support for
iteratee shorthands.

returns: {Array} Returns `array`.
param: {Array} [array] The array to iterate over.
param: {Function} iteratee The function invoked per iteration.

arrayEachRight(array, iteratee)   X-Ref
A specialized version of `_.forEachRight` for arrays without support for
iteratee shorthands.

returns: {Array} Returns `array`.
param: {Array} [array] The array to iterate over.
param: {Function} iteratee The function invoked per iteration.

arrayEvery(array, predicate)   X-Ref
A specialized version of `_.every` for arrays without support for
iteratee shorthands.

returns: {boolean} Returns `true` if all elements pass the predicate check,
param: {Array} [array] The array to iterate over.
param: {Function} predicate The function invoked per iteration.

arrayFilter(array, predicate)   X-Ref
A specialized version of `_.filter` for arrays without support for
iteratee shorthands.

returns: {Array} Returns the new filtered array.
param: {Array} [array] The array to iterate over.
param: {Function} predicate The function invoked per iteration.

arrayIncludes(array, value)   X-Ref
A specialized version of `_.includes` for arrays without support for
specifying an index to search from.

returns: {boolean} Returns `true` if `target` is found, else `false`.
param: {Array} [array] The array to inspect.
param: {*} target The value to search for.

arrayIncludesWith(array, value, comparator)   X-Ref
This function is like `arrayIncludes` except that it accepts a comparator.

returns: {boolean} Returns `true` if `target` is found, else `false`.
param: {Array} [array] The array to inspect.
param: {*} target The value to search for.
param: {Function} comparator The comparator invoked per element.

arrayMap(array, iteratee)   X-Ref
A specialized version of `_.map` for arrays without support for iteratee
shorthands.

returns: {Array} Returns the new mapped array.
param: {Array} [array] The array to iterate over.
param: {Function} iteratee The function invoked per iteration.

arrayPush(array, values)   X-Ref
Appends the elements of `values` to `array`.

returns: {Array} Returns `array`.
param: {Array} array The array to modify.
param: {Array} values The values to append.

arrayReduce(array, iteratee, accumulator, initAccum)   X-Ref
A specialized version of `_.reduce` for arrays without support for
iteratee shorthands.

returns: {*} Returns the accumulated value.
param: {Array} [array] The array to iterate over.
param: {Function} iteratee The function invoked per iteration.
param: {*} [accumulator] The initial value.
param: {boolean} [initAccum] Specify using the first element of `array` as

arrayReduceRight(array, iteratee, accumulator, initAccum)   X-Ref
A specialized version of `_.reduceRight` for arrays without support for
iteratee shorthands.

returns: {*} Returns the accumulated value.
param: {Array} [array] The array to iterate over.
param: {Function} iteratee The function invoked per iteration.
param: {*} [accumulator] The initial value.
param: {boolean} [initAccum] Specify using the last element of `array` as

arraySome(array, predicate)   X-Ref
A specialized version of `_.some` for arrays without support for iteratee
shorthands.

returns: {boolean} Returns `true` if any element passes the predicate check,
param: {Array} [array] The array to iterate over.
param: {Function} predicate The function invoked per iteration.

asciiToArray(string)   X-Ref
Converts an ASCII `string` to an array.

returns: {Array} Returns the converted array.
param: {string} string The string to convert.

asciiWords(string)   X-Ref
Splits an ASCII `string` into an array of its words.

returns: {Array} Returns the words of `string`.
param: {string} The string to inspect.

baseFindKey(collection, predicate, eachFunc)   X-Ref
The base implementation of methods like `_.findKey` and `_.findLastKey`,
without support for iteratee shorthands, which iterates over `collection`
using `eachFunc`.

returns: {*} Returns the found element or its key, else `undefined`.
param: {Array|Object} collection The collection to inspect.
param: {Function} predicate The function invoked per iteration.
param: {Function} eachFunc The function to iterate over `collection`.

baseFindIndex(array, predicate, fromIndex, fromRight)   X-Ref
The base implementation of `_.findIndex` and `_.findLastIndex` without
support for iteratee shorthands.

returns: {number} Returns the index of the matched value, else `-1`.
param: {Array} array The array to inspect.
param: {Function} predicate The function invoked per iteration.
param: {number} fromIndex The index to search from.
param: {boolean} [fromRight] Specify iterating from right to left.

baseIndexOf(array, value, fromIndex)   X-Ref
The base implementation of `_.indexOf` without `fromIndex` bounds checks.

returns: {number} Returns the index of the matched value, else `-1`.
param: {Array} array The array to inspect.
param: {*} value The value to search for.
param: {number} fromIndex The index to search from.

baseIndexOfWith(array, value, fromIndex, comparator)   X-Ref
This function is like `baseIndexOf` except that it accepts a comparator.

returns: {number} Returns the index of the matched value, else `-1`.
param: {Array} array The array to inspect.
param: {*} value The value to search for.
param: {number} fromIndex The index to search from.
param: {Function} comparator The comparator invoked per element.

baseIsNaN(value)   X-Ref
The base implementation of `_.isNaN` without support for number objects.

returns: {boolean} Returns `true` if `value` is `NaN`, else `false`.
param: {*} value The value to check.

baseMean(array, iteratee)   X-Ref
The base implementation of `_.mean` and `_.meanBy` without support for
iteratee shorthands.

returns: {number} Returns the mean.
param: {Array} array The array to iterate over.
param: {Function} iteratee The function invoked per iteration.

baseProperty(key)   X-Ref
The base implementation of `_.property` without support for deep paths.

returns: {Function} Returns the new accessor function.
param: {string} key The key of the property to get.

basePropertyOf(object)   X-Ref
The base implementation of `_.propertyOf` without support for deep paths.

returns: {Function} Returns the new accessor function.
param: {Object} object The object to query.

baseReduce(collection, iteratee, accumulator, initAccum, eachFunc)   X-Ref
The base implementation of `_.reduce` and `_.reduceRight`, without support
for iteratee shorthands, which iterates over `collection` using `eachFunc`.

returns: {*} Returns the accumulated value.
param: {Array|Object} collection The collection to iterate over.
param: {Function} iteratee The function invoked per iteration.
param: {*} accumulator The initial value.
param: {boolean} initAccum Specify using the first or last element of
param: {Function} eachFunc The function to iterate over `collection`.

baseSortBy(array, comparer)   X-Ref
The base implementation of `_.sortBy` which uses `comparer` to define the
sort order of `array` and replaces criteria objects with their corresponding
values.

returns: {Array} Returns `array`.
param: {Array} array The array to sort.
param: {Function} comparer The function to define sort order.

baseSum(array, iteratee)   X-Ref
The base implementation of `_.sum` and `_.sumBy` without support for
iteratee shorthands.

returns: {number} Returns the sum.
param: {Array} array The array to iterate over.
param: {Function} iteratee The function invoked per iteration.

baseTimes(n, iteratee)   X-Ref
The base implementation of `_.times` without support for iteratee shorthands
or max array length checks.

returns: {Array} Returns the array of results.
param: {number} n The number of times to invoke `iteratee`.
param: {Function} iteratee The function invoked per iteration.

baseToPairs(object, props)   X-Ref
The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
of key-value pairs for `object` corresponding to the property names of `props`.

returns: {Object} Returns the key-value pairs.
param: {Object} object The object to query.
param: {Array} props The property names to get values for.

baseUnary(func)   X-Ref
The base implementation of `_.unary` without support for storing metadata.

returns: {Function} Returns the new capped function.
param: {Function} func The function to cap arguments for.

baseValues(object, props)   X-Ref
The base implementation of `_.values` and `_.valuesIn` which creates an
array of `object` property values corresponding to the property names
of `props`.

returns: {Object} Returns the array of property values.
param: {Object} object The object to query.
param: {Array} props The property names to get values for.

cacheHas(cache, key)   X-Ref
Checks if a `cache` value for `key` exists.

returns: {boolean} Returns `true` if an entry for `key` exists, else `false`.
param: {Object} cache The cache to query.
param: {string} key The key of the entry to check.

charsStartIndex(strSymbols, chrSymbols)   X-Ref
Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
that is not found in the character symbols.

returns: {number} Returns the index of the first unmatched string symbol.
param: {Array} strSymbols The string symbols to inspect.
param: {Array} chrSymbols The character symbols to find.

charsEndIndex(strSymbols, chrSymbols)   X-Ref
Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
that is not found in the character symbols.

returns: {number} Returns the index of the last unmatched string symbol.
param: {Array} strSymbols The string symbols to inspect.
param: {Array} chrSymbols The character symbols to find.

countHolders(array, placeholder)   X-Ref
Gets the number of `placeholder` occurrences in `array`.

returns: {number} Returns the placeholder count.
param: {Array} array The array to inspect.
param: {*} placeholder The placeholder to search for.

escapeStringChar(chr)   X-Ref
Used by `_.template` to escape characters for inclusion in compiled string literals.

returns: {string} Returns the escaped character.
param: {string} chr The matched character to escape.

getValue(object, key)   X-Ref
Gets the value at `key` of `object`.

returns: {*} Returns the property value.
param: {Object} [object] The object to query.
param: {string} key The key of the property to get.

hasUnicode(string)   X-Ref
Checks if `string` contains Unicode symbols.

returns: {boolean} Returns `true` if a symbol is found, else `false`.
param: {string} string The string to inspect.

hasUnicodeWord(string)   X-Ref
Checks if `string` contains a word composed of Unicode symbols.

returns: {boolean} Returns `true` if a word is found, else `false`.
param: {string} string The string to inspect.

iteratorToArray(iterator)   X-Ref
Converts `iterator` to an array.

returns: {Array} Returns the converted array.
param: {Object} iterator The iterator to convert.

mapToArray(map)   X-Ref
Converts `map` to its key-value pairs.

returns: {Array} Returns the key-value pairs.
param: {Object} map The map to convert.

overArg(func, transform)   X-Ref
Creates a unary function that invokes `func` with its argument transformed.

returns: {Function} Returns the new function.
param: {Function} func The function to wrap.
param: {Function} transform The argument transform.

replaceHolders(array, placeholder)   X-Ref
Replaces all `placeholder` elements in `array` with an internal placeholder
and returns an array of their indexes.

returns: {Array} Returns the new array of placeholder indexes.
param: {Array} array The array to modify.
param: {*} placeholder The placeholder to replace.

setToArray(set)   X-Ref
Converts `set` to an array of its values.

returns: {Array} Returns the values.
param: {Object} set The set to convert.

setToPairs(set)   X-Ref
Converts `set` to its value-value pairs.

returns: {Array} Returns the value-value pairs.
param: {Object} set The set to convert.

strictIndexOf(array, value, fromIndex)   X-Ref
A specialized version of `_.indexOf` which performs strict equality
comparisons of values, i.e. `===`.

returns: {number} Returns the index of the matched value, else `-1`.
param: {Array} array The array to inspect.
param: {*} value The value to search for.
param: {number} fromIndex The index to search from.

strictLastIndexOf(array, value, fromIndex)   X-Ref
A specialized version of `_.lastIndexOf` which performs strict equality
comparisons of values, i.e. `===`.

returns: {number} Returns the index of the matched value, else `-1`.
param: {Array} array The array to inspect.
param: {*} value The value to search for.
param: {number} fromIndex The index to search from.

stringSize(string)   X-Ref
Gets the number of symbols in `string`.

returns: {number} Returns the string size.
param: {string} string The string to inspect.

stringToArray(string)   X-Ref
Converts `string` to an array.

returns: {Array} Returns the converted array.
param: {string} string The string to convert.

unicodeSize(string)   X-Ref
Gets the size of a Unicode `string`.

returns: {number} Returns the string size.
param: {string} string The string inspect.

unicodeToArray(string)   X-Ref
Converts a Unicode `string` to an array.

returns: {Array} Returns the converted array.
param: {string} string The string to convert.

unicodeWords(string)   X-Ref
Splits a Unicode `string` into an array of its words.

returns: {Array} Returns the words of `string`.
param: {string} The string to inspect.

lodash(value)   X-Ref
No description

object()   X-Ref
The base implementation of `_.create` without support for assigning
properties to the created object.

returns: {Object} Returns the new object.
param: {Object} proto The object to inherit from.

baseLodash()   X-Ref
The function whose prototype chain sequence wrappers inherit from.


LodashWrapper(value, chainAll)   X-Ref
The base constructor for creating `lodash` wrapper objects.

param: {*} value The value to wrap.
param: {boolean} [chainAll] Enable explicit method chain sequences.

LazyWrapper(value)   X-Ref
Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.

param: {*} value The value to wrap.

lazyClone()   X-Ref
Creates a clone of the lazy wrapper object.

returns: {Object} Returns the cloned `LazyWrapper` object.

lazyReverse()   X-Ref
Reverses the direction of lazy iteration.

returns: {Object} Returns the new reversed `LazyWrapper` object.

lazyValue()   X-Ref
Extracts the unwrapped value from its lazy wrapper.

returns: {*} Returns the unwrapped value.

Hash(entries)   X-Ref
Creates a hash object.

param: {Array} [entries] The key-value pairs to cache.

hashClear()   X-Ref
Removes all key-value entries from the hash.


hashDelete(key)   X-Ref
Removes `key` and its value from the hash.

returns: {boolean} Returns `true` if the entry was removed, else `false`.
param: {Object} hash The hash to modify.
param: {string} key The key of the value to remove.

hashGet(key)   X-Ref
Gets the hash value for `key`.

returns: {*} Returns the entry value.
param: {string} key The key of the value to get.

hashHas(key)   X-Ref
Checks if a hash value for `key` exists.

returns: {boolean} Returns `true` if an entry for `key` exists, else `false`.
param: {string} key The key of the entry to check.

hashSet(key, value)   X-Ref
Sets the hash `key` to `value`.

returns: {Object} Returns the hash instance.
param: {string} key The key of the value to set.
param: {*} value The value to set.

ListCache(entries)   X-Ref
Creates an list cache object.

param: {Array} [entries] The key-value pairs to cache.

listCacheClear()   X-Ref
Removes all key-value entries from the list cache.


listCacheDelete(key)   X-Ref
Removes `key` and its value from the list cache.

returns: {boolean} Returns `true` if the entry was removed, else `false`.
param: {string} key The key of the value to remove.

listCacheGet(key)   X-Ref
Gets the list cache value for `key`.

returns: {*} Returns the entry value.
param: {string} key The key of the value to get.

listCacheHas(key)   X-Ref
Checks if a list cache value for `key` exists.

returns: {boolean} Returns `true` if an entry for `key` exists, else `false`.
param: {string} key The key of the entry to check.

listCacheSet(key, value)   X-Ref
Sets the list cache `key` to `value`.

returns: {Object} Returns the list cache instance.
param: {string} key The key of the value to set.
param: {*} value The value to set.

MapCache(entries)   X-Ref
Creates a map cache object to store key-value pairs.

param: {Array} [entries] The key-value pairs to cache.

mapCacheClear()   X-Ref
Removes all key-value entries from the map.


mapCacheDelete(key)   X-Ref
Removes `key` and its value from the map.

returns: {boolean} Returns `true` if the entry was removed, else `false`.
param: {string} key The key of the value to remove.

mapCacheGet(key)   X-Ref
Gets the map value for `key`.

returns: {*} Returns the entry value.
param: {string} key The key of the value to get.

mapCacheHas(key)   X-Ref
Checks if a map value for `key` exists.

returns: {boolean} Returns `true` if an entry for `key` exists, else `false`.
param: {string} key The key of the entry to check.

mapCacheSet(key, value)   X-Ref
Sets the map `key` to `value`.

returns: {Object} Returns the map cache instance.
param: {string} key The key of the value to set.
param: {*} value The value to set.

SetCache(values)   X-Ref
Creates an array cache object to store unique values.

param: {Array} [values] The values to cache.

setCacheAdd(value)   X-Ref
Adds `value` to the array cache.

returns: {Object} Returns the cache instance.
param: {*} value The value to cache.

setCacheHas(value)   X-Ref
Checks if `value` is in the array cache.

returns: {number} Returns `true` if `value` is found, else `false`.
param: {*} value The value to search for.

Stack(entries)   X-Ref
Creates a stack cache object to store key-value pairs.

param: {Array} [entries] The key-value pairs to cache.

stackClear()   X-Ref
Removes all key-value entries from the stack.


stackDelete(key)   X-Ref
Removes `key` and its value from the stack.

returns: {boolean} Returns `true` if the entry was removed, else `false`.
param: {string} key The key of the value to remove.

stackGet(key)   X-Ref
Gets the stack value for `key`.

returns: {*} Returns the entry value.
param: {string} key The key of the value to get.

stackHas(key)   X-Ref
Checks if a stack value for `key` exists.

returns: {boolean} Returns `true` if an entry for `key` exists, else `false`.
param: {string} key The key of the entry to check.

stackSet(key, value)   X-Ref
Sets the stack `key` to `value`.

returns: {Object} Returns the stack cache instance.
param: {string} key The key of the value to set.
param: {*} value The value to set.

arrayLikeKeys(value, inherited)   X-Ref
Creates an array of the enumerable property names of the array-like `value`.

returns: {Array} Returns the array of property names.
param: {*} value The value to query.
param: {boolean} inherited Specify returning inherited property names.

arraySample(array)   X-Ref
A specialized version of `_.sample` for arrays.

returns: {*} Returns the random element.
param: {Array} array The array to sample.

arraySampleSize(array, n)   X-Ref
A specialized version of `_.sampleSize` for arrays.

returns: {Array} Returns the random elements.
param: {Array} array The array to sample.
param: {number} n The number of elements to sample.

arrayShuffle(array)   X-Ref
A specialized version of `_.shuffle` for arrays.

returns: {Array} Returns the new shuffled array.
param: {Array} array The array to shuffle.

assignMergeValue(object, key, value)   X-Ref
This function is like `assignValue` except that it doesn't assign
`undefined` values.

param: {Object} object The object to modify.
param: {string} key The key of the property to assign.
param: {*} value The value to assign.

assignValue(object, key, value)   X-Ref
Assigns `value` to `key` of `object` if the existing value is not equivalent
using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
for equality comparisons.

param: {Object} object The object to modify.
param: {string} key The key of the property to assign.
param: {*} value The value to assign.

assocIndexOf(array, key)   X-Ref
Gets the index at which the `key` is found in `array` of key-value pairs.

returns: {number} Returns the index of the matched value, else `-1`.
param: {Array} array The array to inspect.
param: {*} key The key to search for.

baseAggregator(collection, setter, iteratee, accumulator)   X-Ref
Aggregates elements of `collection` on `accumulator` with keys transformed
by `iteratee` and values set by `setter`.

returns: {Function} Returns `accumulator`.
param: {Array|Object} collection The collection to iterate over.
param: {Function} setter The function to set `accumulator` values.
param: {Function} iteratee The iteratee to transform keys.
param: {Object} accumulator The initial aggregated object.

baseAssign(object, source)   X-Ref
The base implementation of `_.assign` without support for multiple sources
or `customizer` functions.

returns: {Object} Returns `object`.
param: {Object} object The destination object.
param: {Object} source The source object.

baseAssignIn(object, source)   X-Ref
The base implementation of `_.assignIn` without support for multiple sources
or `customizer` functions.

returns: {Object} Returns `object`.
param: {Object} object The destination object.
param: {Object} source The source object.

baseAssignValue(object, key, value)   X-Ref
The base implementation of `assignValue` and `assignMergeValue` without
value checks.

param: {Object} object The object to modify.
param: {string} key The key of the property to assign.
param: {*} value The value to assign.

baseAt(object, paths)   X-Ref
The base implementation of `_.at` without support for individual paths.

returns: {Array} Returns the picked elements.
param: {Object} object The object to iterate over.
param: {string[]} paths The property paths to pick.

baseClamp(number, lower, upper)   X-Ref
The base implementation of `_.clamp` which doesn't coerce arguments.

returns: {number} Returns the clamped number.
param: {number} number The number to clamp.
param: {number} [lower] The lower bound.
param: {number} upper The upper bound.

baseClone(value, bitmask, customizer, key, object, stack)   X-Ref
The base implementation of `_.clone` and `_.cloneDeep` which tracks
traversed objects.

returns: {*} Returns the cloned value.
param: {*} value The value to clone.
param: {boolean} bitmask The bitmask flags.
param: {Function} [customizer] The function to customize cloning.
param: {string} [key] The key of `value`.
param: {Object} [object] The parent object of `value`.
param: {Object} [stack] Tracks traversed objects and their clone counterparts.

baseConforms(source)   X-Ref
The base implementation of `_.conforms` which doesn't clone `source`.

returns: {Function} Returns the new spec function.
param: {Object} source The object of property predicates to conform to.

baseConformsTo(object, source, props)   X-Ref
The base implementation of `_.conformsTo` which accepts `props` to check.

returns: {boolean} Returns `true` if `object` conforms, else `false`.
param: {Object} object The object to inspect.
param: {Object} source The object of property predicates to conform to.

baseDelay(func, wait, args)   X-Ref
The base implementation of `_.delay` and `_.defer` which accepts `args`
to provide to `func`.

returns: {number|Object} Returns the timer id or timeout object.
param: {Function} func The function to delay.
param: {number} wait The number of milliseconds to delay invocation.
param: {Array} args The arguments to provide to `func`.

baseDifference(array, values, iteratee, comparator)   X-Ref
The base implementation of methods like `_.difference` without support
for excluding multiple arrays or iteratee shorthands.

returns: {Array} Returns the new array of filtered values.
param: {Array} array The array to inspect.
param: {Array} values The values to exclude.
param: {Function} [iteratee] The iteratee invoked per element.
param: {Function} [comparator] The comparator invoked per element.

baseEvery(collection, predicate)   X-Ref
The base implementation of `_.every` without support for iteratee shorthands.

returns: {boolean} Returns `true` if all elements pass the predicate check,
param: {Array|Object} collection The collection to iterate over.
param: {Function} predicate The function invoked per iteration.

baseExtremum(array, iteratee, comparator)   X-Ref
The base implementation of methods like `_.max` and `_.min` which accepts a
`comparator` to determine the extremum value.

returns: {*} Returns the extremum value.
param: {Array} array The array to iterate over.
param: {Function} iteratee The iteratee invoked per iteration.
param: {Function} comparator The comparator used to compare values.

baseFill(array, value, start, end)   X-Ref
The base implementation of `_.fill` without an iteratee call guard.

returns: {Array} Returns `array`.
param: {Array} array The array to fill.
param: {*} value The value to fill `array` with.
param: {number} [start=0] The start position.
param: {number} [end=array.length] The end position.

baseFilter(collection, predicate)   X-Ref
The base implementation of `_.filter` without support for iteratee shorthands.

returns: {Array} Returns the new filtered array.
param: {Array|Object} collection The collection to iterate over.
param: {Function} predicate The function invoked per iteration.

baseFlatten(array, depth, predicate, isStrict, result)   X-Ref
The base implementation of `_.flatten` with support for restricting flattening.

returns: {Array} Returns the new flattened array.
param: {Array} array The array to flatten.
param: {number} depth The maximum recursion depth.
param: {boolean} [predicate=isFlattenable] The function invoked per iteration.
param: {boolean} [isStrict] Restrict to values that pass `predicate` checks.
param: {Array} [result=[]] The initial result value.

baseForOwn(object, iteratee)   X-Ref
The base implementation of `_.forOwn` without support for iteratee shorthands.

returns: {Object} Returns `object`.
param: {Object} object The object to iterate over.
param: {Function} iteratee The function invoked per iteration.

baseForOwnRight(object, iteratee)   X-Ref
The base implementation of `_.forOwnRight` without support for iteratee shorthands.

returns: {Object} Returns `object`.
param: {Object} object The object to iterate over.
param: {Function} iteratee The function invoked per iteration.

baseFunctions(object, props)   X-Ref
The base implementation of `_.functions` which creates an array of
`object` function property names filtered from `props`.

returns: {Array} Returns the function names.
param: {Object} object The object to inspect.
param: {Array} props The property names to filter.

baseGet(object, path)   X-Ref
The base implementation of `_.get` without support for default values.

returns: {*} Returns the resolved value.
param: {Object} object The object to query.
param: {Array|string} path The path of the property to get.

baseGetAllKeys(object, keysFunc, symbolsFunc)   X-Ref
The base implementation of `getAllKeys` and `getAllKeysIn` which uses
`keysFunc` and `symbolsFunc` to get the enumerable property names and
symbols of `object`.

returns: {Array} Returns the array of property names and symbols.
param: {Object} object The object to query.
param: {Function} keysFunc The function to get the keys of `object`.
param: {Function} symbolsFunc The function to get the symbols of `object`.

baseGetTag(value)   X-Ref
The base implementation of `getTag` without fallbacks for buggy environments.

returns: {string} Returns the `toStringTag`.
param: {*} value The value to query.

baseGt(value, other)   X-Ref
The base implementation of `_.gt` which doesn't coerce arguments.

returns: {boolean} Returns `true` if `value` is greater than `other`,
param: {*} value The value to compare.
param: {*} other The other value to compare.

baseHas(object, key)   X-Ref
The base implementation of `_.has` without support for deep paths.

returns: {boolean} Returns `true` if `key` exists, else `false`.
param: {Object} [object] The object to query.
param: {Array|string} key The key to check.

baseHasIn(object, key)   X-Ref
The base implementation of `_.hasIn` without support for deep paths.

returns: {boolean} Returns `true` if `key` exists, else `false`.
param: {Object} [object] The object to query.
param: {Array|string} key The key to check.

baseInRange(number, start, end)   X-Ref
The base implementation of `_.inRange` which doesn't coerce arguments.

returns: {boolean} Returns `true` if `number` is in the range, else `false`.
param: {number} number The number to check.
param: {number} start The start of the range.
param: {number} end The end of the range.

baseIntersection(arrays, iteratee, comparator)   X-Ref
The base implementation of methods like `_.intersection`, without support
for iteratee shorthands, that accepts an array of arrays to inspect.

returns: {Array} Returns the new array of shared values.
param: {Array} arrays The arrays to inspect.
param: {Function} [iteratee] The iteratee invoked per element.
param: {Function} [comparator] The comparator invoked per element.

baseInverter(object, setter, iteratee, accumulator)   X-Ref
The base implementation of `_.invert` and `_.invertBy` which inverts
`object` with values transformed by `iteratee` and set by `setter`.

returns: {Function} Returns `accumulator`.
param: {Object} object The object to iterate over.
param: {Function} setter The function to set `accumulator` values.
param: {Function} iteratee The iteratee to transform values.
param: {Object} accumulator The initial inverted object.

baseInvoke(object, path, args)   X-Ref
The base implementation of `_.invoke` without support for individual
method arguments.

returns: {*} Returns the result of the invoked method.
param: {Object} object The object to query.
param: {Array|string} path The path of the method to invoke.
param: {Array} args The arguments to invoke the method with.

baseIsArguments(value)   X-Ref
The base implementation of `_.isArguments`.

returns: {boolean} Returns `true` if `value` is an `arguments` object,
param: {*} value The value to check.

baseIsArrayBuffer(value)   X-Ref
The base implementation of `_.isArrayBuffer` without Node.js optimizations.

returns: {boolean} Returns `true` if `value` is an array buffer, else `false`.
param: {*} value The value to check.

baseIsDate(value)   X-Ref
The base implementation of `_.isDate` without Node.js optimizations.

returns: {boolean} Returns `true` if `value` is a date object, else `false`.
param: {*} value The value to check.

baseIsEqual(value, other, bitmask, customizer, stack)   X-Ref
The base implementation of `_.isEqual` which supports partial comparisons
and tracks traversed objects.

returns: {boolean} Returns `true` if the values are equivalent, else `false`.
param: {*} value The value to compare.
param: {*} other The other value to compare.
param: {boolean} bitmask The bitmask flags.
param: {Function} [customizer] The function to customize comparisons.
param: {Object} [stack] Tracks traversed `value` and `other` objects.

baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack)   X-Ref
A specialized version of `baseIsEqual` for arrays and objects which performs
deep comparisons and tracks traversed objects enabling objects with circular
references to be compared.

returns: {boolean} Returns `true` if the objects are equivalent, else `false`.
param: {Object} object The object to compare.
param: {Object} other The other object to compare.
param: {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
param: {Function} customizer The function to customize comparisons.
param: {Function} equalFunc The function to determine equivalents of values.
param: {Object} [stack] Tracks traversed `object` and `other` objects.

baseIsMap(value)   X-Ref
The base implementation of `_.isMap` without Node.js optimizations.

returns: {boolean} Returns `true` if `value` is a map, else `false`.
param: {*} value The value to check.

baseIsMatch(object, source, matchData, customizer)   X-Ref
The base implementation of `_.isMatch` without support for iteratee shorthands.

returns: {boolean} Returns `true` if `object` is a match, else `false`.
param: {Object} object The object to inspect.
param: {Object} source The object of property values to match.
param: {Array} matchData The property names, values, and compare flags to match.
param: {Function} [customizer] The function to customize comparisons.

baseIsNative(value)   X-Ref
The base implementation of `_.isNative` without bad shim checks.

returns: {boolean} Returns `true` if `value` is a native function,
param: {*} value The value to check.

baseIsRegExp(value)   X-Ref
The base implementation of `_.isRegExp` without Node.js optimizations.

returns: {boolean} Returns `true` if `value` is a regexp, else `false`.
param: {*} value The value to check.

baseIsSet(value)   X-Ref
The base implementation of `_.isSet` without Node.js optimizations.

returns: {boolean} Returns `true` if `value` is a set, else `false`.
param: {*} value The value to check.

baseIsTypedArray(value)   X-Ref
The base implementation of `_.isTypedArray` without Node.js optimizations.

returns: {boolean} Returns `true` if `value` is a typed array, else `false`.
param: {*} value The value to check.

baseIteratee(value)   X-Ref
The base implementation of `_.iteratee`.

returns: {Function} Returns the iteratee.
param: {*} [value=_.identity] The value to convert to an iteratee.

baseKeys(object)   X-Ref
The base implementation of `_.keys` which doesn't treat sparse arrays as dense.

returns: {Array} Returns the array of property names.
param: {Object} object The object to query.

baseKeysIn(object)   X-Ref
The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.

returns: {Array} Returns the array of property names.
param: {Object} object The object to query.

baseLt(value, other)   X-Ref
The base implementation of `_.lt` which doesn't coerce arguments.

returns: {boolean} Returns `true` if `value` is less than `other`,
param: {*} value The value to compare.
param: {*} other The other value to compare.

baseMap(collection, iteratee)   X-Ref
The base implementation of `_.map` without support for iteratee shorthands.

returns: {Array} Returns the new mapped array.
param: {Array|Object} collection The collection to iterate over.
param: {Function} iteratee The function invoked per iteration.

baseMatches(source)   X-Ref
The base implementation of `_.matches` which doesn't clone `source`.

returns: {Function} Returns the new spec function.
param: {Object} source The object of property values to match.

baseMatchesProperty(path, srcValue)   X-Ref
The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.

returns: {Function} Returns the new spec function.
param: {string} path The path of the property to get.
param: {*} srcValue The value to match.

baseMerge(object, source, srcIndex, customizer, stack)   X-Ref
The base implementation of `_.merge` without support for multiple sources.

param: {Object} object The destination object.
param: {Object} source The source object.
param: {number} srcIndex The index of `source`.
param: {Function} [customizer] The function to customize merged values.
param: {Object} [stack] Tracks traversed source values and their merged

baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack)   X-Ref
A specialized version of `baseMerge` for arrays and objects which performs
deep merges and tracks traversed objects enabling objects with circular
references to be merged.

param: {Object} object The destination object.
param: {Object} source The source object.
param: {string} key The key of the value to merge.
param: {number} srcIndex The index of `source`.
param: {Function} mergeFunc The function to merge values.
param: {Function} [customizer] The function to customize assigned values.
param: {Object} [stack] Tracks traversed source values and their merged

baseNth(array, n)   X-Ref
The base implementation of `_.nth` which doesn't coerce arguments.

returns: {*} Returns the nth element of `array`.
param: {Array} array The array to query.
param: {number} n The index of the element to return.

baseOrderBy(collection, iteratees, orders)   X-Ref
The base implementation of `_.orderBy` without param guards.

returns: {Array} Returns the new sorted array.
param: {Array|Object} collection The collection to iterate over.
param: {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
param: {string[]} orders The sort orders of `iteratees`.

basePick(object, paths)   X-Ref
The base implementation of `_.pick` without support for individual
property identifiers.

returns: {Object} Returns the new object.
param: {Object} object The source object.
param: {string[]} paths The property paths to pick.

basePickBy(object, paths, predicate)   X-Ref
The base implementation of  `_.pickBy` without support for iteratee shorthands.

returns: {Object} Returns the new object.
param: {Object} object The source object.
param: {string[]} paths The property paths to pick.
param: {Function} predicate The function invoked per property.

basePropertyDeep(path)   X-Ref
A specialized version of `baseProperty` which supports deep paths.

returns: {Function} Returns the new accessor function.
param: {Array|string} path The path of the property to get.

basePullAll(array, values, iteratee, comparator)   X-Ref
The base implementation of `_.pullAllBy` without support for iteratee
shorthands.

returns: {Array} Returns `array`.
param: {Array} array The array to modify.
param: {Array} values The values to remove.
param: {Function} [iteratee] The iteratee invoked per element.
param: {Function} [comparator] The comparator invoked per element.

basePullAt(array, indexes)   X-Ref
The base implementation of `_.pullAt` without support for individual
indexes or capturing the removed elements.

returns: {Array} Returns `array`.
param: {Array} array The array to modify.
param: {number[]} indexes The indexes of elements to remove.

baseRandom(lower, upper)   X-Ref
The base implementation of `_.random` without support for returning
floating-point numbers.

returns: {number} Returns the random number.
param: {number} lower The lower bound.
param: {number} upper The upper bound.

baseRange(start, end, step, fromRight)   X-Ref
The base implementation of `_.range` and `_.rangeRight` which doesn't
coerce arguments.

returns: {Array} Returns the range of numbers.
param: {number} start The start of the range.
param: {number} end The end of the range.
param: {number} step The value to increment or decrement by.
param: {boolean} [fromRight] Specify iterating from right to left.

baseRepeat(string, n)   X-Ref
The base implementation of `_.repeat` which doesn't coerce arguments.

returns: {string} Returns the repeated string.
param: {string} string The string to repeat.
param: {number} n The number of times to repeat the string.

baseRest(func, start)   X-Ref
The base implementation of `_.rest` which doesn't validate or coerce arguments.

returns: {Function} Returns the new function.
param: {Function} func The function to apply a rest parameter to.
param: {number} [start=func.length-1] The start position of the rest parameter.

baseSample(collection)   X-Ref
The base implementation of `_.sample`.

returns: {*} Returns the random element.
param: {Array|Object} collection The collection to sample.

baseSampleSize(collection, n)   X-Ref
The base implementation of `_.sampleSize` without param guards.

returns: {Array} Returns the random elements.
param: {Array|Object} collection The collection to sample.
param: {number} n The number of elements to sample.

baseSet(object, path, value, customizer)   X-Ref
The base implementation of `_.set`.

returns: {Object} Returns `object`.
param: {Object} object The object to modify.
param: {Array|string} path The path of the property to set.
param: {*} value The value to set.
param: {Function} [customizer] The function to customize path creation.

baseShuffle(collection)   X-Ref
The base implementation of `_.shuffle`.

returns: {Array} Returns the new shuffled array.
param: {Array|Object} collection The collection to shuffle.

baseSlice(array, start, end)   X-Ref
The base implementation of `_.slice` without an iteratee call guard.

returns: {Array} Returns the slice of `array`.
param: {Array} array The array to slice.
param: {number} [start=0] The start position.
param: {number} [end=array.length] The end position.

baseSome(collection, predicate)   X-Ref
The base implementation of `_.some` without support for iteratee shorthands.

returns: {boolean} Returns `true` if any element passes the predicate check,
param: {Array|Object} collection The collection to iterate over.
param: {Function} predicate The function invoked per iteration.

baseSortedIndex(array, value, retHighest)   X-Ref
The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
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.

returns: {number} Returns the index at which `value` should be inserted
param: {Array} array The sorted array to inspect.
param: {*} value The value to evaluate.
param: {boolean} [retHighest] Specify returning the highest qualified index.

baseSortedIndexBy(array, value, iteratee, retHighest)   X-Ref
The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
which invokes `iteratee` for `value` and each element of `array` to compute
their sort ranking. The iteratee is invoked with one argument; (value).

returns: {number} Returns the index at which `value` should be inserted
param: {Array} array The sorted array to inspect.
param: {*} value The value to evaluate.
param: {Function} iteratee The iteratee invoked per element.
param: {boolean} [retHighest] Specify returning the highest qualified index.

baseSortedUniq(array, iteratee)   X-Ref
The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
support for iteratee shorthands.

returns: {Array} Returns the new duplicate free array.
param: {Array} array The array to inspect.
param: {Function} [iteratee] The iteratee invoked per element.

baseToNumber(value)   X-Ref
The base implementation of `_.toNumber` which doesn't ensure correct
conversions of binary, hexadecimal, or octal string values.

returns: {number} Returns the number.
param: {*} value The value to process.

baseToString(value)   X-Ref
The base implementation of `_.toString` which doesn't convert nullish
values to empty strings.

returns: {string} Returns the string.
param: {*} value The value to process.

baseUniq(array, iteratee, comparator)   X-Ref
The base implementation of `_.uniqBy` without support for iteratee shorthands.

returns: {Array} Returns the new duplicate free array.
param: {Array} array The array to inspect.
param: {Function} [iteratee] The iteratee invoked per element.
param: {Function} [comparator] The comparator invoked per element.

baseUnset(object, path)   X-Ref
The base implementation of `_.unset`.

returns: {boolean} Returns `true` if the property is deleted, else `false`.
param: {Object} object The object to modify.
param: {Array|string} path The property path to unset.

baseUpdate(object, path, updater, customizer)   X-Ref
The base implementation of `_.update`.

returns: {Object} Returns `object`.
param: {Object} object The object to modify.
param: {Array|string} path The path of the property to update.
param: {Function} updater The function to produce the updated value.
param: {Function} [customizer] The function to customize path creation.

baseWhile(array, predicate, isDrop, fromRight)   X-Ref
The base implementation of methods like `_.dropWhile` and `_.takeWhile`
without support for iteratee shorthands.

returns: {Array} Returns the slice of `array`.
param: {Array} array The array to query.
param: {Function} predicate The function invoked per iteration.
param: {boolean} [isDrop] Specify dropping elements instead of taking them.
param: {boolean} [fromRight] Specify iterating from right to left.

baseWrapperValue(value, actions)   X-Ref
The base implementation of `wrapperValue` which returns the result of
performing a sequence of actions on the unwrapped `value`, where each
successive action is supplied the return value of the previous.

returns: {*} Returns the resolved value.
param: {*} value The unwrapped value.
param: {Array} actions Actions to perform to resolve the unwrapped value.

baseXor(arrays, iteratee, comparator)   X-Ref
The base implementation of methods like `_.xor`, without support for
iteratee shorthands, that accepts an array of arrays to inspect.

returns: {Array} Returns the new array of values.
param: {Array} arrays The arrays to inspect.
param: {Function} [iteratee] The iteratee invoked per element.
param: {Function} [comparator] The comparator invoked per element.

baseZipObject(props, values, assignFunc)   X-Ref
This base implementation of `_.zipObject` which assigns values using `assignFunc`.

returns: {Object} Returns the new object.
param: {Array} props The property identifiers.
param: {Array} values The property values.
param: {Function} assignFunc The function to assign values.

castArrayLikeObject(value)   X-Ref
Casts `value` to an empty array if it's not an array like object.

returns: {Array|Object} Returns the cast array-like object.
param: {*} value The value to inspect.

castFunction(value)   X-Ref
Casts `value` to `identity` if it's not a function.

returns: {Function} Returns cast function.
param: {*} value The value to inspect.

castPath(value, object)   X-Ref
Casts `value` to a path array if it's not one.

returns: {Array} Returns the cast property path array.
param: {*} value The value to inspect.
param: {Object} [object] The object to query keys on.

castSlice(array, start, end)   X-Ref
Casts `array` to a slice if it's needed.

returns: {Array} Returns the cast slice.
param: {Array} array The array to inspect.
param: {number} start The start position.
param: {number} [end=array.length] The end position.

cloneBuffer(buffer, isDeep)   X-Ref
Creates a clone of  `buffer`.

returns: {Buffer} Returns the cloned buffer.
param: {Buffer} buffer The buffer to clone.
param: {boolean} [isDeep] Specify a deep clone.

cloneArrayBuffer(arrayBuffer)   X-Ref
Creates a clone of `arrayBuffer`.

returns: {ArrayBuffer} Returns the cloned array buffer.
param: {ArrayBuffer} arrayBuffer The array buffer to clone.

cloneDataView(dataView, isDeep)   X-Ref
Creates a clone of `dataView`.

returns: {Object} Returns the cloned data view.
param: {Object} dataView The data view to clone.
param: {boolean} [isDeep] Specify a deep clone.

cloneRegExp(regexp)   X-Ref
Creates a clone of `regexp`.

returns: {Object} Returns the cloned regexp.
param: {Object} regexp The regexp to clone.

cloneSymbol(symbol)   X-Ref
Creates a clone of the `symbol` object.

returns: {Object} Returns the cloned symbol object.
param: {Object} symbol The symbol object to clone.

cloneTypedArray(typedArray, isDeep)   X-Ref
Creates a clone of `typedArray`.

returns: {Object} Returns the cloned typed array.
param: {Object} typedArray The typed array to clone.
param: {boolean} [isDeep] Specify a deep clone.

compareAscending(value, other)   X-Ref
Compares values to sort them in ascending order.

returns: {number} Returns the sort order indicator for `value`.
param: {*} value The value to compare.
param: {*} other The other value to compare.

compareMultiple(object, other, orders)   X-Ref
Used by `_.orderBy` to compare multiple properties of a value to another
and stable sort them.

If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
specify an order of "desc" for descending or "asc" for ascending sort order
of corresponding values.

returns: {number} Returns the sort order indicator for `object`.
param: {Object} object The object to compare.
param: {Object} other The other object to compare.
param: {boolean[]|string[]} orders The order to sort by for each property.

composeArgs(args, partials, holders, isCurried)   X-Ref
Creates an array that is the composition of partially applied arguments,
placeholders, and provided arguments into a single array of arguments.

returns: {Array} Returns the new array of composed arguments.
param: {Array} args The provided arguments.
param: {Array} partials The arguments to prepend to those provided.
param: {Array} holders The `partials` placeholder indexes.

composeArgsRight(args, partials, holders, isCurried)   X-Ref
This function is like `composeArgs` except that the arguments composition
is tailored for `_.partialRight`.

returns: {Array} Returns the new array of composed arguments.
param: {Array} args The provided arguments.
param: {Array} partials The arguments to append to those provided.
param: {Array} holders The `partials` placeholder indexes.

copyArray(source, array)   X-Ref
Copies the values of `source` to `array`.

returns: {Array} Returns `array`.
param: {Array} source The array to copy values from.
param: {Array} [array=[]] The array to copy values to.

copyObject(source, props, object, customizer)   X-Ref
Copies properties of `source` to `object`.

returns: {Object} Returns `object`.
param: {Object} source The object to copy properties from.
param: {Array} props The property identifiers to copy.
param: {Object} [object={}] The object to copy properties to.
param: {Function} [customizer] The function to customize copied values.

copySymbols(source, object)   X-Ref
Copies own symbols of `source` to `object`.

returns: {Object} Returns `object`.
param: {Object} source The object to copy symbols from.
param: {Object} [object={}] The object to copy symbols to.

copySymbolsIn(source, object)   X-Ref
Copies own and inherited symbols of `source` to `object`.

returns: {Object} Returns `object`.
param: {Object} source The object to copy symbols from.
param: {Object} [object={}] The object to copy symbols to.

createAggregator(setter, initializer)   X-Ref
Creates a function like `_.groupBy`.

returns: {Function} Returns the new aggregator function.
param: {Function} setter The function to set accumulator values.
param: {Function} [initializer] The accumulator object initializer.

createAssigner(assigner)   X-Ref
Creates a function like `_.assign`.

returns: {Function} Returns the new assigner function.
param: {Function} assigner The function to assign values.

createBaseEach(eachFunc, fromRight)   X-Ref
Creates a `baseEach` or `baseEachRight` function.

returns: {Function} Returns the new base function.
param: {Function} eachFunc The function to iterate over a collection.
param: {boolean} [fromRight] Specify iterating from right to left.

createBaseFor(fromRight)   X-Ref
Creates a base function for methods like `_.forIn` and `_.forOwn`.

returns: {Function} Returns the new base function.
param: {boolean} [fromRight] Specify iterating from right to left.

createBind(func, bitmask, thisArg)   X-Ref
Creates a function that wraps `func` to invoke it with the optional `this`
binding of `thisArg`.

returns: {Function} Returns the new wrapped function.
param: {Function} func The function to wrap.
param: {number} bitmask The bitmask flags. See `createWrap` for more details.
param: {*} [thisArg] The `this` binding of `func`.

wrapper()   X-Ref
No description

createCaseFirst(methodName)   X-Ref
Creates a function like `_.lowerFirst`.

returns: {Function} Returns the new case function.
param: {string} methodName The name of the `String` case method to use.

createCompounder(callback)   X-Ref
Creates a function like `_.camelCase`.

returns: {Function} Returns the new compounder function.
param: {Function} callback The function to combine each word.

createCtor(Ctor)   X-Ref
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 `apply`.

returns: {Function} Returns the new wrapped function.
param: {Function} Ctor The constructor to wrap.

createCurry(func, bitmask, arity)   X-Ref
Creates a function that wraps `func` to enable currying.

returns: {Function} Returns the new wrapped function.
param: {Function} func The function to wrap.
param: {number} bitmask The bitmask flags. See `createWrap` for more details.
param: {number} arity The arity of `func`.

wrapper()   X-Ref
No description

createFind(findIndexFunc)   X-Ref
Creates a `_.find` or `_.findLast` function.

returns: {Function} Returns the new find function.
param: {Function} findIndexFunc The function to find the collection index.

createFlow(fromRight)   X-Ref
Creates a `_.flow` or `_.flowRight` function.

returns: {Function} Returns the new flow function.
param: {boolean} [fromRight] Specify iterating from right to left.

createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity)   X-Ref
Creates a function that wraps `func` to invoke it with optional `this`
binding of `thisArg`, partial application, and currying.

returns: {Function} Returns the new wrapped function.
param: {Function|string} func The function or method name to wrap.
param: {number} bitmask The bitmask flags. See `createWrap` for more details.
param: {*} [thisArg] The `this` binding of `func`.
param: {Array} [partials] The arguments to prepend to those provided to
param: {Array} [holders] The `partials` placeholder indexes.
param: {Array} [partialsRight] The arguments to append to those provided
param: {Array} [holdersRight] The `partialsRight` placeholder indexes.
param: {Array} [argPos] The argument positions of the new function.
param: {number} [ary] The arity cap of `func`.
param: {number} [arity] The arity of `func`.

wrapper()   X-Ref
No description

createInverter(setter, toIteratee)   X-Ref
Creates a function like `_.invertBy`.

returns: {Function} Returns the new inverter function.
param: {Function} setter The function to set accumulator values.
param: {Function} toIteratee The function to resolve iteratees.

createMathOperation(operator, defaultValue)   X-Ref
Creates a function that performs a mathematical operation on two values.

returns: {Function} Returns the new mathematical operation function.
param: {Function} operator The function to perform the operation.
param: {number} [defaultValue] The value used for `undefined` arguments.

createOver(arrayFunc)   X-Ref
Creates a function like `_.over`.

returns: {Function} Returns the new over function.
param: {Function} arrayFunc The function to iterate over iteratees.

createPadding(length, chars)   X-Ref
Creates the padding for `string` based on `length`. The `chars` string
is truncated if the number of characters exceeds `length`.

returns: {string} Returns the padding for `string`.
param: {number} length The padding length.
param: {string} [chars=' '] The string used as padding.

createPartial(func, bitmask, thisArg, partials)   X-Ref
Creates a function that wraps `func` to invoke it with the `this` binding
of `thisArg` and `partials` prepended to the arguments it receives.

returns: {Function} Returns the new wrapped function.
param: {Function} func The function to wrap.
param: {number} bitmask The bitmask flags. See `createWrap` for more details.
param: {*} thisArg The `this` binding of `func`.
param: {Array} partials The arguments to prepend to those provided to

wrapper()   X-Ref
No description

createRange(fromRight)   X-Ref
Creates a `_.range` or `_.rangeRight` function.

returns: {Function} Returns the new range function.
param: {boolean} [fromRight] Specify iterating from right to left.

createRelationalOperation(operator)   X-Ref
Creates a function that performs a relational operation on two values.

returns: {Function} Returns the new relational operation function.
param: {Function} operator The function to perform the operation.

createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity)   X-Ref
Creates a function that wraps `func` to continue currying.

returns: {Function} Returns the new wrapped function.
param: {Function} func The function to wrap.
param: {number} bitmask The bitmask flags. See `createWrap` for more details.
param: {Function} wrapFunc The function to create the `func` wrapper.
param: {*} placeholder The placeholder value.
param: {*} [thisArg] The `this` binding of `func`.
param: {Array} [partials] The arguments to prepend to those provided to
param: {Array} [holders] The `partials` placeholder indexes.
param: {Array} [argPos] The argument positions of the new function.
param: {number} [ary] The arity cap of `func`.
param: {number} [arity] The arity of `func`.

createRound(methodName)   X-Ref
Creates a function like `_.round`.

returns: {Function} Returns the new round function.
param: {string} methodName The name of the `Math` method to use when rounding.

createToPairs(keysFunc)   X-Ref
Creates a `_.toPairs` or `_.toPairsIn` function.

returns: {Function} Returns the new pairs function.
param: {Function} keysFunc The function to get the keys of a given object.

createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity)   X-Ref
Creates a function that either curries or invokes `func` with optional
`this` binding and partially applied arguments.

returns: {Function} Returns the new wrapped function.
param: {Function|string} func The function or method name to wrap.
param: {number} bitmask The bitmask flags.
param: {*} [thisArg] The `this` binding of `func`.
param: {Array} [partials] The arguments to be partially applied.
param: {Array} [holders] The `partials` placeholder indexes.
param: {Array} [argPos] The argument positions of the new function.
param: {number} [ary] The arity cap of `func`.
param: {number} [arity] The arity of `func`.

customDefaultsAssignIn(objValue, srcValue, key, object)   X-Ref
Used by `_.defaults` to customize its `_.assignIn` use to assign properties
of source objects to the destination object for all destination properties
that resolve to `undefined`.

returns: {*} Returns the value to assign.
param: {*} objValue The destination value.
param: {*} srcValue The source value.
param: {string} key The key of the property to assign.
param: {Object} object The parent object of `objValue`.

customDefaultsMerge(objValue, srcValue, key, object, source, stack)   X-Ref
Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
objects into destination objects that are passed thru.

returns: {*} Returns the value to assign.
param: {*} objValue The destination value.
param: {*} srcValue The source value.
param: {string} key The key of the property to merge.
param: {Object} object The parent object of `objValue`.
param: {Object} source The parent object of `srcValue`.
param: {Object} [stack] Tracks traversed source values and their merged

customOmitClone(value)   X-Ref
Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
objects.

returns: {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
param: {*} value The value to inspect.
param: {string} key The key of the property to inspect.

equalArrays(array, other, bitmask, customizer, equalFunc, stack)   X-Ref
A specialized version of `baseIsEqualDeep` for arrays with support for
partial deep comparisons.

returns: {boolean} Returns `true` if the arrays are equivalent, else `false`.
param: {Array} array The array to compare.
param: {Array} other The other array to compare.
param: {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
param: {Function} customizer The function to customize comparisons.
param: {Function} equalFunc The function to determine equivalents of values.
param: {Object} stack Tracks traversed `array` and `other` objects.

equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack)   X-Ref
A specialized version of `baseIsEqualDeep` for comparing objects of
the same `toStringTag`.

**Note:** This function only supports comparing values with tags of
`Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.

returns: {boolean} Returns `true` if the objects are equivalent, else `false`.
param: {Object} object The object to compare.
param: {Object} other The other object to compare.
param: {string} tag The `toStringTag` of the objects to compare.
param: {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
param: {Function} customizer The function to customize comparisons.
param: {Function} equalFunc The function to determine equivalents of values.
param: {Object} stack Tracks traversed `object` and `other` objects.

equalObjects(object, other, bitmask, customizer, equalFunc, stack)   X-Ref
A specialized version of `baseIsEqualDeep` for objects with support for
partial deep comparisons.

returns: {boolean} Returns `true` if the objects are equivalent, else `false`.
param: {Object} object The object to compare.
param: {Object} other The other object to compare.
param: {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
param: {Function} customizer The function to customize comparisons.
param: {Function} equalFunc The function to determine equivalents of values.
param: {Object} stack Tracks traversed `object` and `other` objects.

flatRest(func)   X-Ref
A specialized version of `baseRest` which flattens the rest array.

returns: {Function} Returns the new function.
param: {Function} func The function to apply a rest parameter to.

getAllKeys(object)   X-Ref
Creates an array of own enumerable property names and symbols of `object`.

returns: {Array} Returns the array of property names and symbols.
param: {Object} object The object to query.

getAllKeysIn(object)   X-Ref
Creates an array of own and inherited enumerable property names and
symbols of `object`.

returns: {Array} Returns the array of property names and symbols.
param: {Object} object The object to query.

getFuncName(func)   X-Ref
Gets the name of `func`.

returns: {string} Returns the function name.
param: {Function} func The function to query.

getHolder(func)   X-Ref
Gets the argument placeholder value for `func`.

returns: {*} Returns the placeholder value.
param: {Function} func The function to inspect.

getIteratee()   X-Ref
Gets the appropriate "iteratee" function. If `_.iteratee` is customized,
this function returns the custom method, otherwise it returns `baseIteratee`.
If arguments are provided, the chosen function is invoked with them and
its result is returned.

returns: {Function} Returns the chosen function or its result.
param: {*} [value] The value to convert to an iteratee.
param: {number} [arity] The arity of the created iteratee.

getMapData(map, key)   X-Ref
Gets the data for `map`.

returns: {*} Returns the map data.
param: {Object} map The map to query.
param: {string} key The reference key.

getMatchData(object)   X-Ref
Gets the property names, values, and compare flags of `object`.

returns: {Array} Returns the match data of `object`.
param: {Object} object The object to query.

getNative(object, key)   X-Ref
Gets the native function at `key` of `object`.

returns: {*} Returns the function if it's native, else `undefined`.
param: {Object} object The object to query.
param: {string} key The key of the method to get.

getRawTag(value)   X-Ref
A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.

returns: {string} Returns the raw `toStringTag`.
param: {*} value The value to query.

getView(start, end, transforms)   X-Ref
Gets the view, applying any `transforms` to the `start` and `end` positions.

returns: {Object} Returns an object containing the `start` and `end`
param: {number} start The start of the view.
param: {number} end The end of the view.
param: {Array} transforms The transformations to apply to the view.

getWrapDetails(source)   X-Ref
Extracts wrapper details from the `source` body comment.

returns: {Array} Returns the wrapper details.
param: {string} source The source to inspect.

hasPath(object, path, hasFunc)   X-Ref
Checks if `path` exists on `object`.

returns: {boolean} Returns `true` if `path` exists, else `false`.
param: {Object} object The object to query.
param: {Array|string} path The path to check.
param: {Function} hasFunc The function to check properties.

initCloneArray(array)   X-Ref
Initializes an array clone.

returns: {Array} Returns the initialized clone.
param: {Array} array The array to clone.

initCloneObject(object)   X-Ref
Initializes an object clone.

returns: {Object} Returns the initialized clone.
param: {Object} object The object to clone.

initCloneByTag(object, tag, isDeep)   X-Ref
Initializes an object clone based on its `toStringTag`.

**Note:** This function only supports cloning values with tags of
`Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.

returns: {Object} Returns the initialized clone.
param: {Object} object The object to clone.
param: {string} tag The `toStringTag` of the object to clone.
param: {boolean} [isDeep] Specify a deep clone.

insertWrapDetails(source, details)   X-Ref
Inserts wrapper `details` in a comment at the top of the `source` body.

returns: {Array} details The details to insert.
returns: {string} Returns the modified source.
param: {string} source The source to modify.

isFlattenable(value)   X-Ref
Checks if `value` is a flattenable `arguments` object or array.

returns: {boolean} Returns `true` if `value` is flattenable, else `false`.
param: {*} value The value to check.

isIndex(value, length)   X-Ref
Checks if `value` is a valid array-like index.

returns: {boolean} Returns `true` if `value` is a valid index, else `false`.
param: {*} value The value to check.
param: {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.

isIterateeCall(value, index, object)   X-Ref
Checks if the given arguments are from an iteratee call.

returns: {boolean} Returns `true` if the arguments are from an iteratee call,
param: {*} value The potential iteratee value argument.
param: {*} index The potential iteratee index or key argument.
param: {*} object The potential iteratee object argument.

isKey(value, object)   X-Ref
Checks if `value` is a property name and not a property path.

returns: {boolean} Returns `true` if `value` is a property name, else `false`.
param: {*} value The value to check.
param: {Object} [object] The object to query keys on.

isKeyable(value)   X-Ref
Checks if `value` is suitable for use as unique object key.

returns: {boolean} Returns `true` if `value` is suitable, else `false`.
param: {*} value The value to check.

isLaziable(func)   X-Ref
Checks if `func` has a lazy counterpart.

returns: {boolean} Returns `true` if `func` has a lazy counterpart,
param: {Function} func The function to check.

isMasked(func)   X-Ref
Checks if `func` has its source masked.

returns: {boolean} Returns `true` if `func` is masked, else `false`.
param: {Function} func The function to check.

isPrototype(value)   X-Ref
Checks if `value` is likely a prototype object.

returns: {boolean} Returns `true` if `value` is a prototype, else `false`.
param: {*} value The value to check.

isStrictComparable(value)   X-Ref
Checks if `value` is suitable for strict equality comparisons, i.e. `===`.

returns: {boolean} Returns `true` if `value` if suitable for strict
param: {*} value The value to check.

matchesStrictComparable(key, srcValue)   X-Ref
A specialized version of `matchesProperty` for source values suitable
for strict equality comparisons, i.e. `===`.

returns: {Function} Returns the new spec function.
param: {string} key The key of the property to get.
param: {*} srcValue The value to match.

memoizeCapped(func)   X-Ref
A specialized version of `_.memoize` which clears the memoized function's
cache when it exceeds `MAX_MEMOIZE_SIZE`.

returns: {Function} Returns the new memoized function.
param: {Function} func The function to have its output memoized.

mergeData(data, source)   X-Ref
Merges the function metadata of `source` into `data`.

Merging metadata reduces the number of wrappers used to invoke a function.
This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
may be applied regardless of execution order. Methods like `_.ary` and
`_.rearg` modify function arguments, making the order in which they are
executed important, preventing the merging of metadata. However, we make
an exception for a safe combined case where curried functions have `_.ary`
and or `_.rearg` applied.

returns: {Array} Returns `data`.
param: {Array} data The destination metadata.
param: {Array} source The source metadata.

nativeKeysIn(object)   X-Ref
This function is like
[`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
except that it includes inherited enumerable properties.

returns: {Array} Returns the array of property names.
param: {Object} object The object to query.

objectToString(value)   X-Ref
Converts `value` to a string using `Object.prototype.toString`.

returns: {string} Returns the converted string.
param: {*} value The value to convert.

overRest(func, start, transform)   X-Ref
A specialized version of `baseRest` which transforms the rest array.

returns: {Function} Returns the new function.
param: {Function} func The function to apply a rest parameter to.
param: {number} [start=func.length-1] The start position of the rest parameter.
param: {Function} transform The rest array transform.

parent(object, path)   X-Ref
Gets the parent value at `path` of `object`.

returns: {*} Returns the parent value.
param: {Object} object The object to query.
param: {Array} path The path to get the parent value of.

reorder(array, indexes)   X-Ref
Reorder `array` according to the specified indexes where the element at
the first index is assigned as the first element, the element at
the second index is assigned as the second element, and so on.

returns: {Array} Returns `array`.
param: {Array} array The array to reorder.
param: {Array} indexes The arranged array indexes.

safeGet(object, key)   X-Ref
Gets the value at `key`, unless `key` is "__proto__" or "constructor".

returns: {*} Returns the property value.
param: {Object} object The object to query.
param: {string} key The key of the property to get.

setWrapToString(wrapper, reference, bitmask)   X-Ref
Sets the `toString` method of `wrapper` to mimic the source of `reference`
with wrapper details in a comment at the top of the source body.

returns: {Function} Returns `wrapper`.
param: {Function} wrapper The function to modify.
param: {Function} reference The reference function.
param: {number} bitmask The bitmask flags. See `createWrap` for more details.

shortOut(func)   X-Ref
Creates a function that'll short out and invoke `identity` instead
of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
milliseconds.

returns: {Function} Returns the new shortable function.
param: {Function} func The function to restrict.

shuffleSelf(array, size)   X-Ref
A specialized version of `_.shuffle` which mutates and sets the size of `array`.

returns: {Array} Returns `array`.
param: {Array} array The array to shuffle.
param: {number} [size=array.length] The size of `array`.

toKey(value)   X-Ref
Converts `value` to a string key if it's not a string or symbol.

returns: {string|symbol} Returns the key.
param: {*} value The value to inspect.

toSource(func)   X-Ref
Converts `func` to its source code.

returns: {string} Returns the source code.
param: {Function} func The function to convert.

updateWrapDetails(details, bitmask)   X-Ref
Updates wrapper `details` based on `bitmask` flags.

returns: {Array} details The details to modify.
returns: {Array} Returns `details`.
param: {number} bitmask The bitmask flags. See `createWrap` for more details.

wrapperClone(wrapper)   X-Ref
Creates a clone of `wrapper`.

returns: {Object} Returns the cloned wrapper.
param: {Object} wrapper The wrapper to clone.

chunk(array, size, guard)   X-Ref
Creates an array of elements split into groups the length of `size`.
If `array` can't be split evenly, the final chunk will be the remaining
elements.

since: 3.0.0
returns: {Array} Returns the new array of chunks.
param: {Array} array The array to process.
param: {number} [size=1] The length of each chunk
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

compact(array)   X-Ref
Creates an array with all falsey values removed. The values `false`, `null`,
`0`, `""`, `undefined`, and `NaN` are falsey.

since: 0.1.0
returns: {Array} Returns the new array of filtered values.
param: {Array} array The array to compact.

concat()   X-Ref
Creates a new array concatenating `array` with any additional arrays
and/or values.

since: 4.0.0
returns: {Array} Returns the new concatenated array.
param: {Array} array The array to concatenate.
param: {...*} [values] The values to concatenate.

drop(array, n, guard)   X-Ref
Creates a slice of `array` with `n` elements dropped from the beginning.

since: 0.5.0
returns: {Array} Returns the slice of `array`.
param: {Array} array The array to query.
param: {number} [n=1] The number of elements to drop.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

dropRight(array, n, guard)   X-Ref
Creates a slice of `array` with `n` elements dropped from the end.

since: 3.0.0
returns: {Array} Returns the slice of `array`.
param: {Array} array The array to query.
param: {number} [n=1] The number of elements to drop.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

dropRightWhile(array, predicate)   X-Ref
Creates a slice of `array` excluding elements dropped from the end.
Elements are dropped until `predicate` returns falsey. The predicate is
invoked with three arguments: (value, index, array).

since: 3.0.0
returns: {Array} Returns the slice of `array`.
param: {Array} array The array to query.
param: {Function} [predicate=_.identity] The function invoked per iteration.

dropWhile(array, predicate)   X-Ref
Creates a slice of `array` excluding elements dropped from the beginning.
Elements are dropped until `predicate` returns falsey. The predicate is
invoked with three arguments: (value, index, array).

since: 3.0.0
returns: {Array} Returns the slice of `array`.
param: {Array} array The array to query.
param: {Function} [predicate=_.identity] The function invoked per iteration.

fill(array, value, start, end)   X-Ref
Fills elements of `array` with `value` from `start` up to, but not
including, `end`.

**Note:** This method mutates `array`.

since: 3.2.0
returns: {Array} Returns `array`.
param: {Array} array The array to fill.
param: {*} value The value to fill `array` with.
param: {number} [start=0] The start position.
param: {number} [end=array.length] The end position.

findIndex(array, predicate, fromIndex)   X-Ref
This method is like `_.find` except that it returns the index of the first
element `predicate` returns truthy for instead of the element itself.

since: 1.1.0
returns: {number} Returns the index of the found element, else `-1`.
param: {Array} array The array to inspect.
param: {Function} [predicate=_.identity] The function invoked per iteration.
param: {number} [fromIndex=0] The index to search from.

findLastIndex(array, predicate, fromIndex)   X-Ref
This method is like `_.findIndex` except that it iterates over elements
of `collection` from right to left.

since: 2.0.0
returns: {number} Returns the index of the found element, else `-1`.
param: {Array} array The array to inspect.
param: {Function} [predicate=_.identity] The function invoked per iteration.
param: {number} [fromIndex=array.length-1] The index to search from.

flatten(array)   X-Ref
Flattens `array` a single level deep.

since: 0.1.0
returns: {Array} Returns the new flattened array.
param: {Array} array The array to flatten.

flattenDeep(array)   X-Ref
Recursively flattens `array`.

since: 3.0.0
returns: {Array} Returns the new flattened array.
param: {Array} array The array to flatten.

flattenDepth(array, depth)   X-Ref
Recursively flatten `array` up to `depth` times.

since: 4.4.0
returns: {Array} Returns the new flattened array.
param: {Array} array The array to flatten.
param: {number} [depth=1] The maximum recursion depth.

fromPairs(pairs)   X-Ref
The inverse of `_.toPairs`; this method returns an object composed
from key-value `pairs`.

since: 4.0.0
returns: {Object} Returns the new object.
param: {Array} pairs The key-value pairs.

head(array)   X-Ref
Gets the first element of `array`.

since: 0.1.0
returns: {*} Returns the first element of `array`.
param: {Array} array The array to query.

indexOf(array, value, fromIndex)   X-Ref
Gets the index at which the first occurrence of `value` is found in `array`
using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
for equality comparisons. If `fromIndex` is negative, it's used as the
offset from the end of `array`.

since: 0.1.0
returns: {number} Returns the index of the matched value, else `-1`.
param: {Array} array The array to inspect.
param: {*} value The value to search for.
param: {number} [fromIndex=0] The index to search from.

initial(array)   X-Ref
Gets all but the last element of `array`.

since: 0.1.0
returns: {Array} Returns the slice of `array`.
param: {Array} array The array to query.

join(array, separator)   X-Ref
Converts all elements in `array` into a string separated by `separator`.

since: 4.0.0
returns: {string} Returns the joined string.
param: {Array} array The array to convert.
param: {string} [separator=','] The element separator.

last(array)   X-Ref
Gets the last element of `array`.

since: 0.1.0
returns: {*} Returns the last element of `array`.
param: {Array} array The array to query.

lastIndexOf(array, value, fromIndex)   X-Ref
This method is like `_.indexOf` except that it iterates over elements of
`array` from right to left.

since: 0.1.0
returns: {number} Returns the index of the matched value, else `-1`.
param: {Array} array The array to inspect.
param: {*} value The value to search for.
param: {number} [fromIndex=array.length-1] The index to search from.

nth(array, n)   X-Ref
Gets the element at index `n` of `array`. If `n` is negative, the nth
element from the end is returned.

since: 4.11.0
returns: {*} Returns the nth element of `array`.
param: {Array} array The array to query.
param: {number} [n=0] The index of the element to return.

pullAll(array, values)   X-Ref
This method is like `_.pull` except that it accepts an array of values to remove.

**Note:** Unlike `_.difference`, this method mutates `array`.

since: 4.0.0
returns: {Array} Returns `array`.
param: {Array} array The array to modify.
param: {Array} values The values to remove.

pullAllBy(array, values, iteratee)   X-Ref
This method is like `_.pullAll` except that it accepts `iteratee` which is
invoked for each element of `array` and `values` to generate the criterion
by which they're compared. The iteratee is invoked with one argument: (value).

**Note:** Unlike `_.differenceBy`, this method mutates `array`.

since: 4.0.0
returns: {Array} Returns `array`.
param: {Array} array The array to modify.
param: {Array} values The values to remove.
param: {Function} [iteratee=_.identity] The iteratee invoked per element.

pullAllWith(array, values, comparator)   X-Ref
This method is like `_.pullAll` except that it accepts `comparator` which
is invoked to compare elements of `array` to `values`. The comparator is
invoked with two arguments: (arrVal, othVal).

**Note:** Unlike `_.differenceWith`, this method mutates `array`.

since: 4.6.0
returns: {Array} Returns `array`.
param: {Array} array The array to modify.
param: {Array} values The values to remove.
param: {Function} [comparator] The comparator invoked per element.

remove(array, predicate)   X-Ref
Removes all elements from `array` that `predicate` returns truthy for
and returns an array of the removed elements. The predicate is invoked
with three arguments: (value, index, array).

**Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`
to pull elements from an array by value.

since: 2.0.0
returns: {Array} Returns the new array of removed elements.
param: {Array} array The array to modify.
param: {Function} [predicate=_.identity] The function invoked per iteration.

reverse(array)   X-Ref
Reverses `array` so that the first element becomes the last, the second
element becomes the second to last, and so on.

**Note:** This method mutates `array` and is based on
[`Array#reverse`](https://mdn.io/Array/reverse).

since: 4.0.0
returns: {Array} Returns `array`.
param: {Array} array The array to modify.

slice(array, start, end)   X-Ref
Creates a slice of `array` from `start` up to, but not including, `end`.

**Note:** This method is used instead of
[`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
returned.

since: 3.0.0
returns: {Array} Returns the slice of `array`.
param: {Array} array The array to slice.
param: {number} [start=0] The start position.
param: {number} [end=array.length] The end position.

sortedIndex(array, value)   X-Ref
Uses a binary search to determine the lowest index at which `value`
should be inserted into `array` in order to maintain its sort order.

since: 0.1.0
returns: {number} Returns the index at which `value` should be inserted
param: {Array} array The sorted array to inspect.
param: {*} value The value to evaluate.

sortedIndexBy(array, value, iteratee)   X-Ref
This method is like `_.sortedIndex` except that it accepts `iteratee`
which is invoked for `value` and each element of `array` to compute their
sort ranking. The iteratee is invoked with one argument: (value).

since: 4.0.0
returns: {number} Returns the index at which `value` should be inserted
param: {Array} array The sorted array to inspect.
param: {*} value The value to evaluate.
param: {Function} [iteratee=_.identity] The iteratee invoked per element.

sortedIndexOf(array, value)   X-Ref
This method is like `_.indexOf` except that it performs a binary
search on a sorted `array`.

since: 4.0.0
returns: {number} Returns the index of the matched value, else `-1`.
param: {Array} array The array to inspect.
param: {*} value The value to search for.

sortedLastIndex(array, value)   X-Ref
This method is like `_.sortedIndex` except that it returns the highest
index at which `value` should be inserted into `array` in order to
maintain its sort order.

since: 3.0.0
returns: {number} Returns the index at which `value` should be inserted
param: {Array} array The sorted array to inspect.
param: {*} value The value to evaluate.

sortedLastIndexBy(array, value, iteratee)   X-Ref
This method is like `_.sortedLastIndex` except that it accepts `iteratee`
which is invoked for `value` and each element of `array` to compute their
sort ranking. The iteratee is invoked with one argument: (value).

since: 4.0.0
returns: {number} Returns the index at which `value` should be inserted
param: {Array} array The sorted array to inspect.
param: {*} value The value to evaluate.
param: {Function} [iteratee=_.identity] The iteratee invoked per element.

sortedLastIndexOf(array, value)   X-Ref
This method is like `_.lastIndexOf` except that it performs a binary
search on a sorted `array`.

since: 4.0.0
returns: {number} Returns the index of the matched value, else `-1`.
param: {Array} array The array to inspect.
param: {*} value The value to search for.

sortedUniq(array)   X-Ref
This method is like `_.uniq` except that it's designed and optimized
for sorted arrays.

since: 4.0.0
returns: {Array} Returns the new duplicate free array.
param: {Array} array The array to inspect.

sortedUniqBy(array, iteratee)   X-Ref
This method is like `_.uniqBy` except that it's designed and optimized
for sorted arrays.

since: 4.0.0
returns: {Array} Returns the new duplicate free array.
param: {Array} array The array to inspect.
param: {Function} [iteratee] The iteratee invoked per element.

tail(array)   X-Ref
Gets all but the first element of `array`.

since: 4.0.0
returns: {Array} Returns the slice of `array`.
param: {Array} array The array to query.

take(array, n, guard)   X-Ref
Creates a slice of `array` with `n` elements taken from the beginning.

since: 0.1.0
returns: {Array} Returns the slice of `array`.
param: {Array} array The array to query.
param: {number} [n=1] The number of elements to take.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

takeRight(array, n, guard)   X-Ref
Creates a slice of `array` with `n` elements taken from the end.

since: 3.0.0
returns: {Array} Returns the slice of `array`.
param: {Array} array The array to query.
param: {number} [n=1] The number of elements to take.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

takeRightWhile(array, predicate)   X-Ref
Creates a slice of `array` with elements taken from the end. Elements are
taken until `predicate` returns falsey. The predicate is invoked with
three arguments: (value, index, array).

since: 3.0.0
returns: {Array} Returns the slice of `array`.
param: {Array} array The array to query.
param: {Function} [predicate=_.identity] The function invoked per iteration.

takeWhile(array, predicate)   X-Ref
Creates a slice of `array` with elements taken from the beginning. Elements
are taken until `predicate` returns falsey. The predicate is invoked with
three arguments: (value, index, array).

since: 3.0.0
returns: {Array} Returns the slice of `array`.
param: {Array} array The array to query.
param: {Function} [predicate=_.identity] The function invoked per iteration.

uniq(array)   X-Ref
Creates a duplicate-free version of an array, using
[`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
for equality comparisons, in which only the first occurrence of each element
is kept. The order of result values is determined by the order they occur
in the array.

since: 0.1.0
returns: {Array} Returns the new duplicate free array.
param: {Array} array The array to inspect.

uniqBy(array, iteratee)   X-Ref
This method is like `_.uniq` except that it accepts `iteratee` which is
invoked for each element in `array` to generate the criterion by which
uniqueness is computed. The order of result values is determined by the
order they occur in the array. The iteratee is invoked with one argument:
(value).

since: 4.0.0
returns: {Array} Returns the new duplicate free array.
param: {Array} array The array to inspect.
param: {Function} [iteratee=_.identity] The iteratee invoked per element.

uniqWith(array, comparator)   X-Ref
This method is like `_.uniq` except that it accepts `comparator` which
is invoked to compare elements of `array`. The order of result values is
determined by the order they occur in the array.The comparator is invoked
with two arguments: (arrVal, othVal).

since: 4.0.0
returns: {Array} Returns the new duplicate free array.
param: {Array} array The array to inspect.
param: {Function} [comparator] The comparator invoked per element.

unzip(array)   X-Ref
This method is like `_.zip` except that it accepts an array of grouped
elements and creates an array regrouping the elements to their pre-zip
configuration.

since: 1.2.0
returns: {Array} Returns the new array of regrouped elements.
param: {Array} array The array of grouped elements to process.

unzipWith(array, iteratee)   X-Ref
This method is like `_.unzip` except that it accepts `iteratee` to specify
how regrouped values should be combined. The iteratee is invoked with the
elements of each group: (...group).

since: 3.8.0
returns: {Array} Returns the new array of regrouped elements.
param: {Array} array The array of grouped elements to process.
param: {Function} [iteratee=_.identity] The function to combine

zipObject(props, values)   X-Ref
This method is like `_.fromPairs` except that it accepts two arrays,
one of property identifiers and one of corresponding values.

since: 0.4.0
returns: {Object} Returns the new object.
param: {Array} [props=[]] The property identifiers.
param: {Array} [values=[]] The property values.

zipObjectDeep(props, values)   X-Ref
This method is like `_.zipObject` except that it supports property paths.

since: 4.1.0
returns: {Object} Returns the new object.
param: {Array} [props=[]] The property identifiers.
param: {Array} [values=[]] The property values.

chain(value)   X-Ref
Creates a `lodash` wrapper instance that wraps `value` with explicit method
chain sequences enabled. The result of such sequences must be unwrapped
with `_#value`.

since: 1.3.0
returns: {Object} Returns the new `lodash` wrapper instance.
param: {*} value The value to wrap.

tap(value, interceptor)   X-Ref
This method invokes `interceptor` and returns `value`. The interceptor
is invoked with one argument; (value). The purpose of this method is to
"tap into" a method chain sequence in order to modify intermediate results.

since: 0.1.0
returns: {*} Returns `value`.
param: {*} value The value to provide to `interceptor`.
param: {Function} interceptor The function to invoke.

thru(value, interceptor)   X-Ref
This method is like `_.tap` except that it returns the result of `interceptor`.
The purpose of this method is to "pass thru" values replacing intermediate
results in a method chain sequence.

since: 3.0.0
returns: {*} Returns the result of `interceptor`.
param: {*} value The value to provide to `interceptor`.
param: {Function} interceptor The function to invoke.

wrapperChain()   X-Ref
Creates a `lodash` wrapper instance with explicit method chain sequences enabled.

since: 0.1.0
returns: {Object} Returns the new `lodash` wrapper instance.

wrapperCommit()   X-Ref
Executes the chain sequence and returns the wrapped result.

since: 3.2.0
returns: {Object} Returns the new `lodash` wrapper instance.

wrapperNext()   X-Ref
Gets the next value on a wrapped object following the
[iterator protocol](https://mdn.io/iteration_protocols#iterator).

since: 4.0.0
returns: {Object} Returns the next iterator value.

wrapperToIterator()   X-Ref
Enables the wrapper to be iterable.

since: 4.0.0
returns: {Object} Returns the wrapper object.

wrapperPlant(value)   X-Ref
Creates a clone of the chain sequence planting `value` as the wrapped value.

since: 3.2.0
returns: {Object} Returns the new `lodash` wrapper instance.
param: {*} value The value to plant.

wrapperReverse()   X-Ref
This method is the wrapper version of `_.reverse`.

**Note:** This method mutates the wrapped array.

since: 0.1.0
returns: {Object} Returns the new `lodash` wrapper instance.

wrapperValue()   X-Ref
Executes the chain sequence to resolve the unwrapped value.

since: 0.1.0
returns: {*} Returns the resolved unwrapped value.

every(collection, predicate, guard)   X-Ref
Checks if `predicate` returns truthy for **all** elements of `collection`.
Iteration is stopped once `predicate` returns falsey. The predicate is
invoked with three arguments: (value, index|key, collection).

**Note:** This method returns `true` for
[empty collections](https://en.wikipedia.org/wiki/Empty_set) because
[everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of
elements of empty collections.

since: 0.1.0
returns: {boolean} Returns `true` if all elements pass the predicate check,
param: {Array|Object} collection The collection to iterate over.
param: {Function} [predicate=_.identity] The function invoked per iteration.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

filter(collection, predicate)   X-Ref
Iterates over elements of `collection`, returning an array of all elements
`predicate` returns truthy for. The predicate is invoked with three
arguments: (value, index|key, collection).

**Note:** Unlike `_.remove`, this method returns a new array.

since: 0.1.0
returns: {Array} Returns the new filtered array.
param: {Array|Object} collection The collection to iterate over.
param: {Function} [predicate=_.identity] The function invoked per iteration.

flatMap(collection, iteratee)   X-Ref
Creates a flattened array of values by running each element in `collection`
thru `iteratee` and flattening the mapped results. The iteratee is invoked
with three arguments: (value, index|key, collection).

since: 4.0.0
returns: {Array} Returns the new flattened array.
param: {Array|Object} collection The collection to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.

flatMapDeep(collection, iteratee)   X-Ref
This method is like `_.flatMap` except that it recursively flattens the
mapped results.

since: 4.7.0
returns: {Array} Returns the new flattened array.
param: {Array|Object} collection The collection to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.

flatMapDepth(collection, iteratee, depth)   X-Ref
This method is like `_.flatMap` except that it recursively flattens the
mapped results up to `depth` times.

since: 4.7.0
returns: {Array} Returns the new flattened array.
param: {Array|Object} collection The collection to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.
param: {number} [depth=1] The maximum recursion depth.

forEach(collection, iteratee)   X-Ref
Iterates over elements of `collection` and invokes `iteratee` for each element.
The iteratee is invoked with three arguments: (value, index|key, collection).
Iteratee functions may exit iteration early by explicitly returning `false`.

**Note:** As with other "Collections" methods, objects with a "length"
property are iterated like arrays. To avoid this behavior use `_.forIn`
or `_.forOwn` for object iteration.

since: 0.1.0
returns: {Array|Object} Returns `collection`.
param: {Array|Object} collection The collection to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.

forEachRight(collection, iteratee)   X-Ref
This method is like `_.forEach` except that it iterates over elements of
`collection` from right to left.

since: 2.0.0
returns: {Array|Object} Returns `collection`.
param: {Array|Object} collection The collection to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.

includes(collection, value, fromIndex, guard)   X-Ref
Checks if `value` is in `collection`. If `collection` is a string, it's
checked for a substring of `value`, otherwise
[`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
is used for equality comparisons. If `fromIndex` is negative, it's used as
the offset from the end of `collection`.

since: 0.1.0
returns: {boolean} Returns `true` if `value` is found, else `false`.
param: {Array|Object|string} collection The collection to inspect.
param: {*} value The value to search for.
param: {number} [fromIndex=0] The index to search from.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.

map(collection, iteratee)   X-Ref
Creates an array of values by running each element in `collection` thru
`iteratee`. The iteratee is invoked with three arguments:
(value, index|key, collection).

Many lodash methods are guarded to work as iteratees for methods like
`_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.

The guarded methods are:
`ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
`fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
`sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
`template`, `trim`, `trimEnd`, `trimStart`, and `words`

since: 0.1.0
returns: {Array} Returns the new mapped array.
param: {Array|Object} collection The collection to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.

orderBy(collection, iteratees, orders, guard)   X-Ref
This method is like `_.sortBy` except that it allows specifying the sort
orders of the iteratees to sort by. If `orders` is unspecified, all values
are sorted in ascending order. Otherwise, specify an order of "desc" for
descending or "asc" for ascending sort order of corresponding values.

since: 4.0.0
returns: {Array} Returns the new sorted array.
param: {Array|Object} collection The collection to iterate over.
param: {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
param: {string[]} [orders] The sort orders of `iteratees`.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.

reduce(collection, iteratee, accumulator)   X-Ref
Reduces `collection` to a value which is the accumulated result of running
each element in `collection` thru `iteratee`, where each successive
invocation is supplied the return value of the previous. If `accumulator`
is not given, the first element of `collection` is used as the initial
value. The iteratee is invoked with four arguments:
(accumulator, value, index|key, collection).

Many lodash methods are guarded to work as iteratees for methods like
`_.reduce`, `_.reduceRight`, and `_.transform`.

The guarded methods are:
`assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
and `sortBy`

since: 0.1.0
returns: {*} Returns the accumulated value.
param: {Array|Object} collection The collection to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.
param: {*} [accumulator] The initial value.

reduceRight(collection, iteratee, accumulator)   X-Ref
This method is like `_.reduce` except that it iterates over elements of
`collection` from right to left.

since: 0.1.0
returns: {*} Returns the accumulated value.
param: {Array|Object} collection The collection to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.
param: {*} [accumulator] The initial value.

reject(collection, predicate)   X-Ref
The opposite of `_.filter`; this method returns the elements of `collection`
that `predicate` does **not** return truthy for.

since: 0.1.0
returns: {Array} Returns the new filtered array.
param: {Array|Object} collection The collection to iterate over.
param: {Function} [predicate=_.identity] The function invoked per iteration.

sample(collection)   X-Ref
Gets a random element from `collection`.

since: 2.0.0
returns: {*} Returns the random element.
param: {Array|Object} collection The collection to sample.

sampleSize(collection, n, guard)   X-Ref
Gets `n` random elements at unique keys from `collection` up to the
size of `collection`.

since: 4.0.0
returns: {Array} Returns the random elements.
param: {Array|Object} collection The collection to sample.
param: {number} [n=1] The number of elements to sample.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

shuffle(collection)   X-Ref
Creates an array of shuffled values, using a version of the
[Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).

since: 0.1.0
returns: {Array} Returns the new shuffled array.
param: {Array|Object} collection The collection to shuffle.

size(collection)   X-Ref
Gets the size of `collection` by returning its length for array-like
values or the number of own enumerable string keyed properties for objects.

since: 0.1.0
returns: {number} Returns the collection size.
param: {Array|Object|string} collection The collection to inspect.

some(collection, predicate, guard)   X-Ref
Checks if `predicate` returns truthy for **any** element of `collection`.
Iteration is stopped once `predicate` returns truthy. The predicate is
invoked with three arguments: (value, index|key, collection).

since: 0.1.0
returns: {boolean} Returns `true` if any element passes the predicate check,
param: {Array|Object} collection The collection to iterate over.
param: {Function} [predicate=_.identity] The function invoked per iteration.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

after(n, func)   X-Ref
The opposite of `_.before`; this method creates a function that invokes
`func` once it's called `n` or more times.

since: 0.1.0
returns: {Function} Returns the new restricted function.
param: {number} n The number of calls before `func` is invoked.
param: {Function} func The function to restrict.

ary(func, n, guard)   X-Ref
Creates a function that invokes `func`, with up to `n` arguments,
ignoring any additional arguments.

since: 3.0.0
returns: {Function} Returns the new capped function.
param: {Function} func The function to cap arguments for.
param: {number} [n=func.length] The arity cap.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

before(n, func)   X-Ref
Creates a function that invokes `func`, with the `this` binding and arguments
of the created function, while it's called less than `n` times. Subsequent
calls to the created function return the result of the last `func` invocation.

since: 3.0.0
returns: {Function} Returns the new restricted function.
param: {number} n The number of calls at which `func` is no longer invoked.
param: {Function} func The function to restrict.

curry(func, arity, guard)   X-Ref
Creates a function that accepts arguments of `func` and either invokes
`func` returning its result, if at least `arity` number of arguments have
been provided, or returns a function that accepts the remaining `func`
arguments, and so on. The arity of `func` may be specified if `func.length`
is not sufficient.

The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
may be used as a placeholder for provided arguments.

**Note:** This method doesn't set the "length" property of curried functions.

since: 2.0.0
returns: {Function} Returns the new curried function.
param: {Function} func The function to curry.
param: {number} [arity=func.length] The arity of `func`.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

curryRight(func, arity, guard)   X-Ref
This method is like `_.curry` except that arguments are applied to `func`
in the manner of `_.partialRight` instead of `_.partial`.

The `_.curryRight.placeholder` value, which defaults to `_` in monolithic
builds, may be used as a placeholder for provided arguments.

**Note:** This method doesn't set the "length" property of curried functions.

since: 3.0.0
returns: {Function} Returns the new curried function.
param: {Function} func The function to curry.
param: {number} [arity=func.length] The arity of `func`.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

debounce(func, wait, options)   X-Ref
Creates a debounced function that delays invoking `func` until after `wait`
milliseconds have elapsed since the last time the debounced function was
invoked. The debounced function comes with a `cancel` method to cancel
delayed `func` invocations and a `flush` method to immediately invoke them.
Provide `options` to indicate whether `func` should be invoked on the
leading and/or trailing edge of the `wait` timeout. The `func` is invoked
with the last arguments provided to the debounced function. Subsequent
calls to the debounced function return the result of the last `func`
invocation.

**Note:** If `leading` and `trailing` options are `true`, `func` is
invoked on the trailing edge of the timeout only if the debounced function
is invoked more than once during the `wait` timeout.

If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
until to the next tick, similar to `setTimeout` with a timeout of `0`.

See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
for details over the differences between `_.debounce` and `_.throttle`.

since: 0.1.0
returns: {Function} Returns the new debounced function.
param: {Function} func The function to debounce.
param: {number} [wait=0] The number of milliseconds to delay.
param: {Object} [options={}] The options object.
param: {boolean} [options.leading=false]
param: {number} [options.maxWait]
param: {boolean} [options.trailing=true]

invokeFunc(time)   X-Ref
No description

leadingEdge(time)   X-Ref
No description

remainingWait(time)   X-Ref
No description

shouldInvoke(time)   X-Ref
No description

timerExpired()   X-Ref
No description

trailingEdge(time)   X-Ref
No description

cancel()   X-Ref
No description

flush()   X-Ref
No description

debounced()   X-Ref
No description

flip(func)   X-Ref
Creates a function that invokes `func` with arguments reversed.

since: 4.0.0
returns: {Function} Returns the new flipped function.
param: {Function} func The function to flip arguments for.

memoize(func, resolver)   X-Ref
Creates a function that memoizes the result of `func`. If `resolver` is
provided, it determines the cache key for storing the result based on the
arguments provided to the memoized function. By default, the first argument
provided to the memoized function is used as the map cache key. The `func`
is invoked with the `this` binding of the memoized function.

**Note:** The cache is exposed as the `cache` property on the memoized
function. Its creation may be customized by replacing the `_.memoize.Cache`
constructor with one whose instances implement the
[`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
method interface of `clear`, `delete`, `get`, `has`, and `set`.

since: 0.1.0
returns: {Function} Returns the new memoized function.
param: {Function} func The function to have its output memoized.
param: {Function} [resolver] The function to resolve the cache key.

negate(predicate)   X-Ref
Creates a function that negates the result of the predicate `func`. The
`func` predicate is invoked with the `this` binding and arguments of the
created function.

since: 3.0.0
returns: {Function} Returns the new negated function.
param: {Function} predicate The predicate to negate.

once(func)   X-Ref
Creates a function that is restricted to invoking `func` once. Repeat calls
to the function return the value of the first invocation. The `func` is
invoked with the `this` binding and arguments of the created function.

since: 0.1.0
returns: {Function} Returns the new restricted function.
param: {Function} func The function to restrict.

rest(func, start)   X-Ref
Creates a function that invokes `func` with the `this` binding of the
created function and arguments from `start` and beyond provided as
an array.

**Note:** This method is based on the
[rest parameter](https://mdn.io/rest_parameters).

since: 4.0.0
returns: {Function} Returns the new function.
param: {Function} func The function to apply a rest parameter to.
param: {number} [start=func.length-1] The start position of the rest parameter.

spread(func, start)   X-Ref
Creates a function that invokes `func` with the `this` binding of the
create function and an array of arguments much like
[`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).

**Note:** This method is based on the
[spread operator](https://mdn.io/spread_operator).

since: 3.2.0
returns: {Function} Returns the new function.
param: {Function} func The function to spread arguments over.
param: {number} [start=0] The start position of the spread.

throttle(func, wait, options)   X-Ref
Creates a throttled function that only invokes `func` at most once per
every `wait` milliseconds. The throttled function comes with a `cancel`
method to cancel delayed `func` invocations and a `flush` method to
immediately invoke them. Provide `options` to indicate whether `func`
should be invoked on the leading and/or trailing edge of the `wait`
timeout. The `func` is invoked with the last arguments provided to the
throttled function. Subsequent calls to the throttled function return the
result of the last `func` invocation.

**Note:** If `leading` and `trailing` options are `true`, `func` is
invoked on the trailing edge of the timeout only if the throttled function
is invoked more than once during the `wait` timeout.

If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
until to the next tick, similar to `setTimeout` with a timeout of `0`.

See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
for details over the differences between `_.throttle` and `_.debounce`.

since: 0.1.0
returns: {Function} Returns the new throttled function.
param: {Function} func The function to throttle.
param: {number} [wait=0] The number of milliseconds to throttle invocations to.
param: {Object} [options={}] The options object.
param: {boolean} [options.leading=true]
param: {boolean} [options.trailing=true]

unary(func)   X-Ref
Creates a function that accepts up to one argument, ignoring any
additional arguments.

since: 4.0.0
returns: {Function} Returns the new capped function.
param: {Function} func The function to cap arguments for.

wrap(value, wrapper)   X-Ref
Creates a function that provides `value` to `wrapper` as its first
argument. Any additional arguments provided to the function are appended
to those provided to the `wrapper`. The wrapper is invoked with the `this`
binding of the created function.

since: 0.1.0
returns: {Function} Returns the new function.
param: {*} value The value to wrap.
param: {Function} [wrapper=identity] The wrapper function.

castArray()   X-Ref
Casts `value` as an array if it's not one.

since: 4.4.0
returns: {Array} Returns the cast array.
param: {*} value The value to inspect.

clone(value)   X-Ref
Creates a shallow clone of `value`.

**Note:** This method is loosely based on the
[structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
and supports cloning arrays, array buffers, booleans, date objects, maps,
numbers, `Object` objects, regexes, sets, strings, symbols, and typed
arrays. The own enumerable properties of `arguments` objects are cloned
as plain objects. An empty object is returned for uncloneable values such
as error objects, functions, DOM nodes, and WeakMaps.

since: 0.1.0
returns: {*} Returns the cloned value.
param: {*} value The value to clone.

cloneWith(value, customizer)   X-Ref
This method is like `_.clone` except that it accepts `customizer` which
is invoked to produce the cloned value. If `customizer` returns `undefined`,
cloning is handled by the method instead. The `customizer` is invoked with
up to four arguments; (value [, index|key, object, stack]).

since: 4.0.0
returns: {*} Returns the cloned value.
param: {*} value The value to clone.
param: {Function} [customizer] The function to customize cloning.

cloneDeep(value)   X-Ref
This method is like `_.clone` except that it recursively clones `value`.

since: 1.0.0
returns: {*} Returns the deep cloned value.
param: {*} value The value to recursively clone.

cloneDeepWith(value, customizer)   X-Ref
This method is like `_.cloneWith` except that it recursively clones `value`.

since: 4.0.0
returns: {*} Returns the deep cloned value.
param: {*} value The value to recursively clone.
param: {Function} [customizer] The function to customize cloning.

conformsTo(object, source)   X-Ref
Checks if `object` conforms to `source` by invoking the predicate
properties of `source` with the corresponding property values of `object`.

**Note:** This method is equivalent to `_.conforms` when `source` is
partially applied.

since: 4.14.0
returns: {boolean} Returns `true` if `object` conforms, else `false`.
param: {Object} object The object to inspect.
param: {Object} source The object of property predicates to conform to.

eq(value, other)   X-Ref
Performs a
[`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
comparison between two values to determine if they are equivalent.

since: 4.0.0
returns: {boolean} Returns `true` if the values are equivalent, else `false`.
param: {*} value The value to compare.
param: {*} other The other value to compare.

isArrayLike(value)   X-Ref
Checks if `value` is array-like. A value is considered array-like if it's
not a function and has a `value.length` that's an integer greater than or
equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.

since: 4.0.0
returns: {boolean} Returns `true` if `value` is array-like, else `false`.
param: {*} value The value to check.

isArrayLikeObject(value)   X-Ref
This method is like `_.isArrayLike` except that it also checks if `value`
is an object.

since: 4.0.0
returns: {boolean} Returns `true` if `value` is an array-like object,
param: {*} value The value to check.

isBoolean(value)   X-Ref
Checks if `value` is classified as a boolean primitive or object.

since: 0.1.0
returns: {boolean} Returns `true` if `value` is a boolean, else `false`.
param: {*} value The value to check.

isElement(value)   X-Ref
Checks if `value` is likely a DOM element.

since: 0.1.0
returns: {boolean} Returns `true` if `value` is a DOM element, else `false`.
param: {*} value The value to check.

isEmpty(value)   X-Ref
Checks if `value` is an empty object, collection, map, or set.

Objects are considered empty if they have no own enumerable string keyed
properties.

Array-like values such as `arguments` objects, arrays, buffers, strings, or
jQuery-like collections are considered empty if they have a `length` of `0`.
Similarly, maps and sets are considered empty if they have a `size` of `0`.

since: 0.1.0
returns: {boolean} Returns `true` if `value` is empty, else `false`.
param: {*} value The value to check.

isEqual(value, other)   X-Ref
Performs a deep comparison between two values to determine if they are
equivalent.

**Note:** This method supports comparing arrays, array buffers, booleans,
date objects, error objects, maps, numbers, `Object` objects, regexes,
sets, strings, symbols, and typed arrays. `Object` objects are compared
by their own, not inherited, enumerable properties. Functions and DOM
nodes are compared by strict equality, i.e. `===`.

since: 0.1.0
returns: {boolean} Returns `true` if the values are equivalent, else `false`.
param: {*} value The value to compare.
param: {*} other The other value to compare.

isEqualWith(value, other, customizer)   X-Ref
This method is like `_.isEqual` except that it accepts `customizer` which
is invoked to compare values. If `customizer` returns `undefined`, comparisons
are handled by the method instead. The `customizer` is invoked with up to
six arguments: (objValue, othValue [, index|key, object, other, stack]).

since: 4.0.0
returns: {boolean} Returns `true` if the values are equivalent, else `false`.
param: {*} value The value to compare.
param: {*} other The other value to compare.
param: {Function} [customizer] The function to customize comparisons.

isError(value)   X-Ref
Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,
`SyntaxError`, `TypeError`, or `URIError` object.

since: 3.0.0
returns: {boolean} Returns `true` if `value` is an error object, else `false`.
param: {*} value The value to check.

isFinite(value)   X-Ref
Checks if `value` is a finite primitive number.

**Note:** This method is based on
[`Number.isFinite`](https://mdn.io/Number/isFinite).

since: 0.1.0
returns: {boolean} Returns `true` if `value` is a finite number, else `false`.
param: {*} value The value to check.

isFunction(value)   X-Ref
Checks if `value` is classified as a `Function` object.

since: 0.1.0
returns: {boolean} Returns `true` if `value` is a function, else `false`.
param: {*} value The value to check.

isInteger(value)   X-Ref
Checks if `value` is an integer.

**Note:** This method is based on
[`Number.isInteger`](https://mdn.io/Number/isInteger).

since: 4.0.0
returns: {boolean} Returns `true` if `value` is an integer, else `false`.
param: {*} value The value to check.

isLength(value)   X-Ref
Checks if `value` is a valid array-like length.

**Note:** This method is loosely based on
[`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).

since: 4.0.0
returns: {boolean} Returns `true` if `value` is a valid length, else `false`.
param: {*} value The value to check.

isObject(value)   X-Ref
Checks if `value` is the
[language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)

since: 0.1.0
returns: {boolean} Returns `true` if `value` is an object, else `false`.
param: {*} value The value to check.

isObjectLike(value)   X-Ref
Checks if `value` is object-like. A value is object-like if it's not `null`
and has a `typeof` result of "object".

since: 4.0.0
returns: {boolean} Returns `true` if `value` is object-like, else `false`.
param: {*} value The value to check.

isMatch(object, source)   X-Ref
Performs a partial deep comparison between `object` and `source` to
determine if `object` contains equivalent property values.

**Note:** This method is equivalent to `_.matches` when `source` is
partially applied.

Partial comparisons will match empty array and empty object `source`
values against any array or object value, respectively. See `_.isEqual`
for a list of supported value comparisons.

since: 3.0.0
returns: {boolean} Returns `true` if `object` is a match, else `false`.
param: {Object} object The object to inspect.
param: {Object} source The object of property values to match.

isMatchWith(object, source, customizer)   X-Ref
This method is like `_.isMatch` except that it accepts `customizer` which
is invoked to compare values. If `customizer` returns `undefined`, comparisons
are handled by the method instead. The `customizer` is invoked with five
arguments: (objValue, srcValue, index|key, object, source).

since: 4.0.0
returns: {boolean} Returns `true` if `object` is a match, else `false`.
param: {Object} object The object to inspect.
param: {Object} source The object of property values to match.
param: {Function} [customizer] The function to customize comparisons.

isNaN(value)   X-Ref
Checks if `value` is `NaN`.

**Note:** This method is based on
[`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as
global [`isNaN`](https://mdn.io/isNaN) which returns `true` for
`undefined` and other non-number values.

since: 0.1.0
returns: {boolean} Returns `true` if `value` is `NaN`, else `false`.
param: {*} value The value to check.

isNative(value)   X-Ref
Checks if `value` is a pristine native function.

**Note:** This method can't reliably detect native functions in the presence
of the core-js package because core-js circumvents this kind of detection.
Despite multiple requests, the core-js maintainer has made it clear: any
attempt to fix the detection will be obstructed. As a result, we're left
with little choice but to throw an error. Unfortunately, this also affects
packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),
which rely on core-js.

since: 3.0.0
returns: {boolean} Returns `true` if `value` is a native function,
param: {*} value The value to check.

isNull(value)   X-Ref
Checks if `value` is `null`.

since: 0.1.0
returns: {boolean} Returns `true` if `value` is `null`, else `false`.
param: {*} value The value to check.

isNil(value)   X-Ref
Checks if `value` is `null` or `undefined`.

since: 4.0.0
returns: {boolean} Returns `true` if `value` is nullish, else `false`.
param: {*} value The value to check.

isNumber(value)   X-Ref
Checks if `value` is classified as a `Number` primitive or object.

**Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
classified as numbers, use the `_.isFinite` method.

since: 0.1.0
returns: {boolean} Returns `true` if `value` is a number, else `false`.
param: {*} value The value to check.

isPlainObject(value)   X-Ref
Checks if `value` is a plain object, that is, an object created by the
`Object` constructor or one with a `[[Prototype]]` of `null`.

since: 0.8.0
returns: {boolean} Returns `true` if `value` is a plain object, else `false`.
param: {*} value The value to check.

isSafeInteger(value)   X-Ref
Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
double precision number which isn't the result of a rounded unsafe integer.

**Note:** This method is based on
[`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).

since: 4.0.0
returns: {boolean} Returns `true` if `value` is a safe integer, else `false`.
param: {*} value The value to check.

isString(value)   X-Ref
Checks if `value` is classified as a `String` primitive or object.

since: 0.1.0
returns: {boolean} Returns `true` if `value` is a string, else `false`.
param: {*} value The value to check.

isSymbol(value)   X-Ref
Checks if `value` is classified as a `Symbol` primitive or object.

since: 4.0.0
returns: {boolean} Returns `true` if `value` is a symbol, else `false`.
param: {*} value The value to check.

isUndefined(value)   X-Ref
Checks if `value` is `undefined`.

since: 0.1.0
returns: {boolean} Returns `true` if `value` is `undefined`, else `false`.
param: {*} value The value to check.

isWeakMap(value)   X-Ref
Checks if `value` is classified as a `WeakMap` object.

since: 4.3.0
returns: {boolean} Returns `true` if `value` is a weak map, else `false`.
param: {*} value The value to check.

isWeakSet(value)   X-Ref
Checks if `value` is classified as a `WeakSet` object.

since: 4.3.0
returns: {boolean} Returns `true` if `value` is a weak set, else `false`.
param: {*} value The value to check.

toArray(value)   X-Ref
Converts `value` to an array.

since: 0.1.0
returns: {Array} Returns the converted array.
param: {*} value The value to convert.

toFinite(value)   X-Ref
Converts `value` to a finite number.

since: 4.12.0
returns: {number} Returns the converted number.
param: {*} value The value to convert.

toInteger(value)   X-Ref
Converts `value` to an integer.

**Note:** This method is loosely based on
[`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).

since: 4.0.0
returns: {number} Returns the converted integer.
param: {*} value The value to convert.

toLength(value)   X-Ref
Converts `value` to an integer suitable for use as the length of an
array-like object.

**Note:** This method is based on
[`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).

since: 4.0.0
returns: {number} Returns the converted integer.
param: {*} value The value to convert.

toNumber(value)   X-Ref
Converts `value` to a number.

since: 4.0.0
returns: {number} Returns the number.
param: {*} value The value to process.

toPlainObject(value)   X-Ref
Converts `value` to a plain object flattening inherited enumerable string
keyed properties of `value` to own properties of the plain object.

since: 3.0.0
returns: {Object} Returns the converted plain object.
param: {*} value The value to convert.

toSafeInteger(value)   X-Ref
Converts `value` to a safe integer. A safe integer can be compared and
represented correctly.

since: 4.0.0
returns: {number} Returns the converted integer.
param: {*} value The value to convert.

toString(value)   X-Ref
Converts `value` to a string. An empty string is returned for `null`
and `undefined` values. The sign of `-0` is preserved.

since: 4.0.0
returns: {string} Returns the converted string.
param: {*} value The value to convert.

create(prototype, properties)   X-Ref
Creates an object that inherits from the `prototype` object. If a
`properties` object is given, its own enumerable string keyed properties
are assigned to the created object.

since: 2.3.0
returns: {Object} Returns the new object.
param: {Object} prototype The object to inherit from.
param: {Object} [properties] The properties to assign to the object.

findKey(object, predicate)   X-Ref
This method is like `_.find` except that it returns the key of the first
element `predicate` returns truthy for instead of the element itself.

since: 1.1.0
returns: {string|undefined} Returns the key of the matched element,
param: {Object} object The object to inspect.
param: {Function} [predicate=_.identity] The function invoked per iteration.

findLastKey(object, predicate)   X-Ref
This method is like `_.findKey` except that it iterates over elements of
a collection in the opposite order.

since: 2.0.0
returns: {string|undefined} Returns the key of the matched element,
param: {Object} object The object to inspect.
param: {Function} [predicate=_.identity] The function invoked per iteration.

forIn(object, iteratee)   X-Ref
Iterates over own and inherited enumerable string keyed properties of an
object and invokes `iteratee` for each property. The iteratee is invoked
with three arguments: (value, key, object). Iteratee functions may exit
iteration early by explicitly returning `false`.

since: 0.3.0
returns: {Object} Returns `object`.
param: {Object} object The object to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.

forInRight(object, iteratee)   X-Ref
This method is like `_.forIn` except that it iterates over properties of
`object` in the opposite order.

since: 2.0.0
returns: {Object} Returns `object`.
param: {Object} object The object to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.

forOwn(object, iteratee)   X-Ref
Iterates over own enumerable string keyed properties of an object and
invokes `iteratee` for each property. The iteratee is invoked with three
arguments: (value, key, object). Iteratee functions may exit iteration
early by explicitly returning `false`.

since: 0.3.0
returns: {Object} Returns `object`.
param: {Object} object The object to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.

forOwnRight(object, iteratee)   X-Ref
This method is like `_.forOwn` except that it iterates over properties of
`object` in the opposite order.

since: 2.0.0
returns: {Object} Returns `object`.
param: {Object} object The object to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.

functions(object)   X-Ref
Creates an array of function property names from own enumerable properties
of `object`.

since: 0.1.0
returns: {Array} Returns the function names.
param: {Object} object The object to inspect.

functionsIn(object)   X-Ref
Creates an array of function property names from own and inherited
enumerable properties of `object`.

since: 4.0.0
returns: {Array} Returns the function names.
param: {Object} object The object to inspect.

get(object, path, defaultValue)   X-Ref
Gets the value at `path` of `object`. If the resolved value is
`undefined`, the `defaultValue` is returned in its place.

since: 3.7.0
returns: {*} Returns the resolved value.
param: {Object} object The object to query.
param: {Array|string} path The path of the property to get.
param: {*} [defaultValue] The value returned for `undefined` resolved values.

has(object, path)   X-Ref
Checks if `path` is a direct property of `object`.

since: 0.1.0
returns: {boolean} Returns `true` if `path` exists, else `false`.
param: {Object} object The object to query.
param: {Array|string} path The path to check.

hasIn(object, path)   X-Ref
Checks if `path` is a direct or inherited property of `object`.

since: 4.0.0
returns: {boolean} Returns `true` if `path` exists, else `false`.
param: {Object} object The object to query.
param: {Array|string} path The path to check.

keys(object)   X-Ref
Creates an array of the own enumerable property names of `object`.

**Note:** Non-object values are coerced to objects. See the
[ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
for more details.

since: 0.1.0
returns: {Array} Returns the array of property names.
param: {Object} object The object to query.

keysIn(object)   X-Ref
Creates an array of the own and inherited enumerable property names of `object`.

**Note:** Non-object values are coerced to objects.

since: 3.0.0
returns: {Array} Returns the array of property names.
param: {Object} object The object to query.

mapKeys(object, iteratee)   X-Ref
The opposite of `_.mapValues`; this method creates an object with the
same values as `object` and keys generated by running each own enumerable
string keyed property of `object` thru `iteratee`. The iteratee is invoked
with three arguments: (value, key, object).

since: 3.8.0
returns: {Object} Returns the new mapped object.
param: {Object} object The object to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.

mapValues(object, iteratee)   X-Ref
Creates an object with the same keys as `object` and values generated
by running each own enumerable string keyed property of `object` thru
`iteratee`. The iteratee is invoked with three arguments:
(value, key, object).

since: 2.4.0
returns: {Object} Returns the new mapped object.
param: {Object} object The object to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.

omitBy(object, predicate)   X-Ref
The opposite of `_.pickBy`; this method creates an object composed of
the own and inherited enumerable string keyed properties of `object` that
`predicate` doesn't return truthy for. The predicate is invoked with two
arguments: (value, key).

since: 4.0.0
returns: {Object} Returns the new object.
param: {Object} object The source object.
param: {Function} [predicate=_.identity] The function invoked per property.

pickBy(object, predicate)   X-Ref
Creates an object composed of the `object` properties `predicate` returns
truthy for. The predicate is invoked with two arguments: (value, key).

since: 4.0.0
returns: {Object} Returns the new object.
param: {Object} object The source object.
param: {Function} [predicate=_.identity] The function invoked per property.

result(object, path, defaultValue)   X-Ref
This method is like `_.get` except that if the resolved value is a
function it's invoked with the `this` binding of its parent object and
its result is returned.

since: 0.1.0
returns: {*} Returns the resolved value.
param: {Object} object The object to query.
param: {Array|string} path The path of the property to resolve.
param: {*} [defaultValue] The value returned for `undefined` resolved values.

set(object, path, value)   X-Ref
Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
it's created. Arrays are created for missing index properties while objects
are created for all other missing properties. Use `_.setWith` to customize
`path` creation.

**Note:** This method mutates `object`.

since: 3.7.0
returns: {Object} Returns `object`.
param: {Object} object The object to modify.
param: {Array|string} path The path of the property to set.
param: {*} value The value to set.

setWith(object, path, value, customizer)   X-Ref
This method is like `_.set` except that it accepts `customizer` which is
invoked to produce the objects of `path`.  If `customizer` returns `undefined`
path creation is handled by the method instead. The `customizer` is invoked
with three arguments: (nsValue, key, nsObject).

**Note:** This method mutates `object`.

since: 4.0.0
returns: {Object} Returns `object`.
param: {Object} object The object to modify.
param: {Array|string} path The path of the property to set.
param: {*} value The value to set.
param: {Function} [customizer] The function to customize assigned values.

transform(object, iteratee, accumulator)   X-Ref
An alternative to `_.reduce`; this method transforms `object` to a new
`accumulator` object which is the result of running each of its own
enumerable string keyed properties thru `iteratee`, with each invocation
potentially mutating the `accumulator` object. If `accumulator` is not
provided, a new object with the same `[[Prototype]]` will be used. The
iteratee is invoked with four arguments: (accumulator, value, key, object).
Iteratee functions may exit iteration early by explicitly returning `false`.

since: 1.3.0
returns: {*} Returns the accumulated value.
param: {Object} object The object to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.
param: {*} [accumulator] The custom accumulator value.

unset(object, path)   X-Ref
Removes the property at `path` of `object`.

**Note:** This method mutates `object`.

since: 4.0.0
returns: {boolean} Returns `true` if the property is deleted, else `false`.
param: {Object} object The object to modify.
param: {Array|string} path The path of the property to unset.

update(object, path, updater)   X-Ref
This method is like `_.set` except that accepts `updater` to produce the
value to set. Use `_.updateWith` to customize `path` creation. The `updater`
is invoked with one argument: (value).

**Note:** This method mutates `object`.

since: 4.6.0
returns: {Object} Returns `object`.
param: {Object} object The object to modify.
param: {Array|string} path The path of the property to set.
param: {Function} updater The function to produce the updated value.

updateWith(object, path, updater, customizer)   X-Ref
This method is like `_.update` except that it accepts `customizer` which is
invoked to produce the objects of `path`.  If `customizer` returns `undefined`
path creation is handled by the method instead. The `customizer` is invoked
with three arguments: (nsValue, key, nsObject).

**Note:** This method mutates `object`.

since: 4.6.0
returns: {Object} Returns `object`.
param: {Object} object The object to modify.
param: {Array|string} path The path of the property to set.
param: {Function} updater The function to produce the updated value.
param: {Function} [customizer] The function to customize assigned values.

values(object)   X-Ref
Creates an array of the own enumerable string keyed property values of `object`.

**Note:** Non-object values are coerced to objects.

since: 0.1.0
returns: {Array} Returns the array of property values.
param: {Object} object The object to query.

valuesIn(object)   X-Ref
Creates an array of the own and inherited enumerable string keyed property
values of `object`.

**Note:** Non-object values are coerced to objects.

since: 3.0.0
returns: {Array} Returns the array of property values.
param: {Object} object The object to query.

clamp(number, lower, upper)   X-Ref
Clamps `number` within the inclusive `lower` and `upper` bounds.

since: 4.0.0
returns: {number} Returns the clamped number.
param: {number} number The number to clamp.
param: {number} [lower] The lower bound.
param: {number} upper The upper bound.

inRange(number, start, end)   X-Ref
Checks if `n` is between `start` and up to, but not including, `end`. If
`end` is not specified, it's set to `start` with `start` then set to `0`.
If `start` is greater than `end` the params are swapped to support
negative ranges.

since: 3.3.0
returns: {boolean} Returns `true` if `number` is in the range, else `false`.
param: {number} number The number to check.
param: {number} [start=0] The start of the range.
param: {number} end The end of the range.

random(lower, upper, floating)   X-Ref
Produces a random number between the inclusive `lower` and `upper` bounds.
If only one argument is provided a number between `0` and the given number
is returned. If `floating` is `true`, or either `lower` or `upper` are
floats, a floating-point number is returned instead of an integer.

**Note:** JavaScript follows the IEEE-754 standard for resolving
floating-point values which can produce unexpected results.

since: 0.7.0
returns: {number} Returns the random number.
param: {number} [lower=0] The lower bound.
param: {number} [upper=1] The upper bound.
param: {boolean} [floating] Specify returning a floating-point number.

capitalize(string)   X-Ref
Converts the first character of `string` to upper case and the remaining
to lower case.

since: 3.0.0
returns: {string} Returns the capitalized string.
param: {string} [string=''] The string to capitalize.

deburr(string)   X-Ref
Deburrs `string` by converting
[Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
letters to basic Latin letters and removing
[combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).

since: 3.0.0
returns: {string} Returns the deburred string.
param: {string} [string=''] The string to deburr.

endsWith(string, target, position)   X-Ref
Checks if `string` ends with the given target string.

since: 3.0.0
returns: {boolean} Returns `true` if `string` ends with `target`,
param: {string} [string=''] The string to inspect.
param: {string} [target] The string to search for.
param: {number} [position=string.length] The position to search up to.

escape(string)   X-Ref
Converts the characters "&", "<", ">", '"', and "'" in `string` to their
corresponding HTML entities.

**Note:** No other characters are escaped. To escape additional
characters use a third-party library like [_he_](https://mths.be/he).

Though the ">" character is escaped for symmetry, characters like
">" and "/" don't need escaping in HTML and have no special meaning
unless they're part of a tag or unquoted attribute value. See
[Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
(under "semi-related fun fact") for more details.

When working with HTML you should always
[quote attribute values](http://wonko.com/post/html-escaping) to reduce
XSS vectors.

since: 0.1.0
returns: {string} Returns the escaped string.
param: {string} [string=''] The string to escape.

escapeRegExp(string)   X-Ref
Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
"?", "(", ")", "[", "]", "{", "}", and "|" in `string`.

since: 3.0.0
returns: {string} Returns the escaped string.
param: {string} [string=''] The string to escape.

pad(string, length, chars)   X-Ref
Pads `string` on the left and right sides if it's shorter than `length`.
Padding characters are truncated if they can't be evenly divided by `length`.

since: 3.0.0
returns: {string} Returns the padded string.
param: {string} [string=''] The string to pad.
param: {number} [length=0] The padding length.
param: {string} [chars=' '] The string used as padding.

padEnd(string, length, chars)   X-Ref
Pads `string` on the right side if it's shorter than `length`. Padding
characters are truncated if they exceed `length`.

since: 4.0.0
returns: {string} Returns the padded string.
param: {string} [string=''] The string to pad.
param: {number} [length=0] The padding length.
param: {string} [chars=' '] The string used as padding.

padStart(string, length, chars)   X-Ref
Pads `string` on the left side if it's shorter than `length`. Padding
characters are truncated if they exceed `length`.

since: 4.0.0
returns: {string} Returns the padded string.
param: {string} [string=''] The string to pad.
param: {number} [length=0] The padding length.
param: {string} [chars=' '] The string used as padding.

parseInt(string, radix, guard)   X-Ref
Converts `string` to an integer of the specified radix. If `radix` is
`undefined` or `0`, a `radix` of `10` is used unless `value` is a
hexadecimal, in which case a `radix` of `16` is used.

**Note:** This method aligns with the
[ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.

since: 1.1.0
returns: {number} Returns the converted integer.
param: {string} string The string to convert.
param: {number} [radix=10] The radix to interpret `value` by.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

repeat(string, n, guard)   X-Ref
Repeats the given string `n` times.

since: 3.0.0
returns: {string} Returns the repeated string.
param: {string} [string=''] The string to repeat.
param: {number} [n=1] The number of times to repeat the string.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

replace()   X-Ref
Replaces matches for `pattern` in `string` with `replacement`.

**Note:** This method is based on
[`String#replace`](https://mdn.io/String/replace).

since: 4.0.0
returns: {string} Returns the modified string.
param: {string} [string=''] The string to modify.
param: {RegExp|string} pattern The pattern to replace.
param: {Function|string} replacement The match replacement.

split(string, separator, limit)   X-Ref
Splits `string` by `separator`.

**Note:** This method is based on
[`String#split`](https://mdn.io/String/split).

since: 4.0.0
returns: {Array} Returns the string segments.
param: {string} [string=''] The string to split.
param: {RegExp|string} separator The separator pattern to split by.
param: {number} [limit] The length to truncate results to.

startsWith(string, target, position)   X-Ref
Checks if `string` starts with the given target string.

since: 3.0.0
returns: {boolean} Returns `true` if `string` starts with `target`,
param: {string} [string=''] The string to inspect.
param: {string} [target] The string to search for.
param: {number} [position=0] The position to search from.

template(string, options, guard)   X-Ref
Creates a compiled template function that can interpolate data properties
in "interpolate" delimiters, HTML-escape interpolated data properties in
"escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
properties may be accessed as free variables in the template. If a setting
object is given, it takes precedence over `_.templateSettings` values.

**Note:** In the development build `_.template` utilizes
[sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
for easier debugging.

For more information on precompiling templates see
[lodash's custom builds documentation](https://lodash.com/custom-builds).

For more information on Chrome extension sandboxes see
[Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).

since: 0.1.0
returns: {Function} Returns the compiled template function.
param: {string} [string=''] The template string.
param: {Object} [options={}] The options object.
param: {RegExp} [options.escape=_.templateSettings.escape]
param: {RegExp} [options.evaluate=_.templateSettings.evaluate]
param: {Object} [options.imports=_.templateSettings.imports]
param: {RegExp} [options.interpolate=_.templateSettings.interpolate]
param: {string} [options.sourceURL='lodash.templateSources[n]']
param: {string} [options.variable='obj']
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

toLower(value)   X-Ref
Converts `string`, as a whole, to lower case just like
[String#toLowerCase](https://mdn.io/toLowerCase).

since: 4.0.0
returns: {string} Returns the lower cased string.
param: {string} [string=''] The string to convert.

toUpper(value)   X-Ref
Converts `string`, as a whole, to upper case just like
[String#toUpperCase](https://mdn.io/toUpperCase).

since: 4.0.0
returns: {string} Returns the upper cased string.
param: {string} [string=''] The string to convert.

trim(string, chars, guard)   X-Ref
Removes leading and trailing whitespace or specified characters from `string`.

since: 3.0.0
returns: {string} Returns the trimmed string.
param: {string} [string=''] The string to trim.
param: {string} [chars=whitespace] The characters to trim.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

trimEnd(string, chars, guard)   X-Ref
Removes trailing whitespace or specified characters from `string`.

since: 4.0.0
returns: {string} Returns the trimmed string.
param: {string} [string=''] The string to trim.
param: {string} [chars=whitespace] The characters to trim.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

trimStart(string, chars, guard)   X-Ref
Removes leading whitespace or specified characters from `string`.

since: 4.0.0
returns: {string} Returns the trimmed string.
param: {string} [string=''] The string to trim.
param: {string} [chars=whitespace] The characters to trim.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

truncate(string, options)   X-Ref
Truncates `string` if it's longer than the given maximum string length.
The last characters of the truncated string are replaced with the omission
string which defaults to "...".

since: 4.0.0
returns: {string} Returns the truncated string.
param: {string} [string=''] The string to truncate.
param: {Object} [options={}] The options object.
param: {number} [options.length=30] The maximum string length.
param: {string} [options.omission='...'] The string to indicate text is omitted.
param: {RegExp|string} [options.separator] The separator pattern to truncate to.

unescape(string)   X-Ref
The inverse of `_.escape`; this method converts the HTML entities
`&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to
their corresponding characters.

**Note:** No other HTML entities are unescaped. To unescape additional
HTML entities use a third-party library like [_he_](https://mths.be/he).

since: 0.6.0
returns: {string} Returns the unescaped string.
param: {string} [string=''] The string to unescape.

words(string, pattern, guard)   X-Ref
Splits `string` into an array of its words.

since: 3.0.0
returns: {Array} Returns the words of `string`.
param: {string} [string=''] The string to inspect.
param: {RegExp|string} [pattern] The pattern to match words.
param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`.

cond(pairs)   X-Ref
Creates a function that iterates over `pairs` and invokes the corresponding
function of the first predicate to return truthy. The predicate-function
pairs are invoked with the `this` binding and arguments of the created
function.

since: 4.0.0
returns: {Function} Returns the new composite function.
param: {Array} pairs The predicate-function pairs.

conforms(source)   X-Ref
Creates a function that invokes the predicate properties of `source` with
the corresponding property values of a given object, returning `true` if
all predicates return truthy, else `false`.

**Note:** The created function is equivalent to `_.conformsTo` with
`source` partially applied.

since: 4.0.0
returns: {Function} Returns the new spec function.
param: {Object} source The object of property predicates to conform to.

constant(value)   X-Ref
Creates a function that returns `value`.

since: 2.4.0
returns: {Function} Returns the new constant function.
param: {*} value The value to return from the new function.

defaultTo(value, defaultValue)   X-Ref
Checks `value` to determine whether a default value should be returned in
its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
or `undefined`.

since: 4.14.0
returns: {*} Returns the resolved value.
param: {*} value The value to check.
param: {*} defaultValue The default value.

identity(value)   X-Ref
This method returns the first argument it receives.

since: 0.1.0
returns: {*} Returns `value`.
param: {*} value Any value.

iteratee(func)   X-Ref
Creates a function that invokes `func` with the arguments of the created
function. If `func` is a property name, the created function returns the
property value for a given element. If `func` is an array or object, the
created function returns `true` for elements that contain the equivalent
source properties, otherwise it returns `false`.

since: 4.0.0
returns: {Function} Returns the callback.
param: {*} [func=_.identity] The value to convert to a callback.

matches(source)   X-Ref
Creates a function that performs a partial deep comparison between a given
object and `source`, returning `true` if the given object has equivalent
property values, else `false`.

**Note:** The created function is equivalent to `_.isMatch` with `source`
partially applied.

Partial comparisons will match empty array and empty object `source`
values against any array or object value, respectively. See `_.isEqual`
for a list of supported value comparisons.

**Note:** Multiple values can be checked by combining several matchers
using `_.overSome`

since: 3.0.0
returns: {Function} Returns the new spec function.
param: {Object} source The object of property values to match.

matchesProperty(path, srcValue)   X-Ref
Creates a function that performs a partial deep comparison between the
value at `path` of a given object to `srcValue`, returning `true` if the
object value is equivalent, else `false`.

**Note:** Partial comparisons will match empty array and empty object
`srcValue` values against any array or object value, respectively. See
`_.isEqual` for a list of supported value comparisons.

**Note:** Multiple values can be checked by combining several matchers
using `_.overSome`

since: 3.2.0
returns: {Function} Returns the new spec function.
param: {Array|string} path The path of the property to get.
param: {*} srcValue The value to match.

mixin(object, source, options)   X-Ref
Adds all own enumerable string keyed function properties of a source
object to the destination object. If `object` is a function, then methods
are added to its prototype as well.

**Note:** Use `_.runInContext` to create a pristine `lodash` function to
avoid conflicts caused by modifying the original.

since: 0.1.0
returns: {Function|Object} Returns `object`.
param: {Function|Object} [object=lodash] The destination object.
param: {Object} source The object of functions to add.
param: {Object} [options={}] The options object.
param: {boolean} [options.chain=true] Specify whether mixins are chainable.

noConflict()   X-Ref
Reverts the `_` variable to its previous value and returns a reference to
the `lodash` function.

since: 0.1.0
returns: {Function} Returns the `lodash` function.

noop()   X-Ref
This method returns `undefined`.

since: 2.3.0

nthArg(n)   X-Ref
Creates a function that gets the argument at index `n`. If `n` is negative,
the nth argument from the end is returned.

since: 4.0.0
returns: {Function} Returns the new pass-thru function.
param: {number} [n=0] The index of the argument to return.

property(path)   X-Ref
Creates a function that returns the value at `path` of a given object.

since: 2.4.0
returns: {Function} Returns the new accessor function.
param: {Array|string} path The path of the property to get.

propertyOf(object)   X-Ref
The opposite of `_.property`; this method creates a function that returns
the value at a given path of `object`.

since: 3.0.0
returns: {Function} Returns the new accessor function.
param: {Object} object The object to query.

stubArray()   X-Ref
This method returns a new empty array.

since: 4.13.0
returns: {Array} Returns the new empty array.

stubFalse()   X-Ref
This method returns `false`.

since: 4.13.0
returns: {boolean} Returns `false`.

stubObject()   X-Ref
This method returns a new empty object.

since: 4.13.0
returns: {Object} Returns the new empty object.

stubString()   X-Ref
This method returns an empty string.

since: 4.13.0
returns: {string} Returns the empty string.

stubTrue()   X-Ref
This method returns `true`.

since: 4.13.0
returns: {boolean} Returns `true`.

times(n, iteratee)   X-Ref
Invokes the iteratee `n` times, returning an array of the results of
each invocation. The iteratee is invoked with one argument; (index).

since: 0.1.0
returns: {Array} Returns the array of results.
param: {number} n The number of times to invoke `iteratee`.
param: {Function} [iteratee=_.identity] The function invoked per iteration.

toPath(value)   X-Ref
Converts `value` to a property path array.

since: 4.0.0
returns: {Array} Returns the new property path array.
param: {*} value The value to convert.

uniqueId(prefix)   X-Ref
Generates a unique ID. If `prefix` is given, the ID is appended to it.

since: 0.1.0
returns: {string} Returns the unique ID.
param: {string} [prefix=''] The value to prefix the ID with.

max(array)   X-Ref
Computes the maximum value of `array`. If `array` is empty or falsey,
`undefined` is returned.

since: 0.1.0
returns: {*} Returns the maximum value.
param: {Array} array The array to iterate over.

maxBy(array, iteratee)   X-Ref
This method is like `_.max` except that it accepts `iteratee` which is
invoked for each element in `array` to generate the criterion by which
the value is ranked. The iteratee is invoked with one argument: (value).

since: 4.0.0
returns: {*} Returns the maximum value.
param: {Array} array The array to iterate over.
param: {Function} [iteratee=_.identity] The iteratee invoked per element.

mean(array)   X-Ref
Computes the mean of the values in `array`.

since: 4.0.0
returns: {number} Returns the mean.
param: {Array} array The array to iterate over.

meanBy(array, iteratee)   X-Ref
This method is like `_.mean` except that it accepts `iteratee` which is
invoked for each element in `array` to generate the value to be averaged.
The iteratee is invoked with one argument: (value).

since: 4.7.0
returns: {number} Returns the mean.
param: {Array} array The array to iterate over.
param: {Function} [iteratee=_.identity] The iteratee invoked per element.

min(array)   X-Ref
Computes the minimum value of `array`. If `array` is empty or falsey,
`undefined` is returned.

since: 0.1.0
returns: {*} Returns the minimum value.
param: {Array} array The array to iterate over.

minBy(array, iteratee)   X-Ref
This method is like `_.min` except that it accepts `iteratee` which is
invoked for each element in `array` to generate the criterion by which
the value is ranked. The iteratee is invoked with one argument: (value).

since: 4.0.0
returns: {*} Returns the minimum value.
param: {Array} array The array to iterate over.
param: {Function} [iteratee=_.identity] The iteratee invoked per element.

sum(array)   X-Ref
Computes the sum of the values in `array`.

since: 3.4.0
returns: {number} Returns the sum.
param: {Array} array The array to iterate over.

sumBy(array, iteratee)   X-Ref
This method is like `_.sum` except that it accepts `iteratee` which is
invoked for each element in `array` to generate the value to be summed.
The iteratee is invoked with one argument: (value).

since: 4.0.0
returns: {number} Returns the sum.
param: {Array} array The array to iterate over.
param: {Function} [iteratee=_.identity] The iteratee invoked per element.



Generated: Sat Aug 8 01:00:03 2020 Cross-referenced by PHPXref 0.7.1