[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

title

Body

[close]

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

(no description)

License:
File Size: 17112 lines (541 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`.

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

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

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.
returns: {Function} Returns `accumulator`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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
returns: {*} Returns the accumulated value.

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

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
returns: {*} Returns the accumulated value.

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

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

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

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

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

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

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`.

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`.
returns: {*} Returns the found element or its key, else `undefined`.

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

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.
returns: {number} Returns the index of the matched value, else `-1`.

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

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

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

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.
returns: {number} Returns the index of the matched value, else `-1`.

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

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

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

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

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

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

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

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

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`.

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`.
returns: {*} Returns the accumulated value.

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.

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

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

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

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

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

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`.

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

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

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

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`.

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

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

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

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.

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

lodash(value)   X-Ref
No description

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

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

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.

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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.

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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.
returns: {Function} Returns `accumulator`.

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

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

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

param: {Object} object The destination object.
param: {Object} source The source object.
returns: {Object} Returns `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.

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

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

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

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

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.
returns: {*} Returns the cloned value.

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

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

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

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

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

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`.
returns: {number|Object} Returns the timer id or timeout object.

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

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.
returns: {Array} Returns the new array of filtered values.

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

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

baseExtremum(array, iteratee, comparator)   X-Ref
The base implementation of methods like `_.max` and `_.min` which accepts a
`comparator` to determine 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.
returns: {*} Returns the extremum value.

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

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.
returns: {Array} Returns `array`.

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

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

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

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.
returns: {Array} Returns the new flattened array.

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

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

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

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

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

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

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

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

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`.

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`.
returns: {Array} Returns the array of property names and symbols.

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

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

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

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

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

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

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

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

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

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

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.

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

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`.

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.
returns: {Function} Returns `accumulator`.

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

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.
returns: {*} Returns the result of the invoked method.

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

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

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

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

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

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

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

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.
returns: {boolean} Returns `true` if the values are equivalent, else `false`.

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.

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.
returns: {boolean} Returns `true` if the objects are equivalent, else `false`.

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

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

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

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.
returns: {boolean} Returns `true` if `object` is a match, else `false`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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`.
returns: {Array} Returns the new sorted array.

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

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

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

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

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

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

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

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.
returns: {Array} Returns `array`.

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

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

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

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

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

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.
returns: {Array} Returns the range of numbers.

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

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

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

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

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

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

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

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

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

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.
returns: {Object} Returns `object`.

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

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

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

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

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

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

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.

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

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).

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.
returns: {number} Returns the index at which `value` should be inserted

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

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

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

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

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

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

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

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

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

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

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

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.
returns: {Object} Returns `object`.

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

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.
returns: {Array} Returns the slice of `array`.

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.

param: {*} value The unwrapped value.
param: {Array} actions Actions to perform to resolve the unwrapped value.
returns: {*} Returns the resolved 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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.
returns: {number} Returns the sort order indicator for `object`.

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.

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

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

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

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

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

copyObject(source, props, object, customizer)   X-Ref
Copies properties of `source` to `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.
returns: {Object} Returns `object`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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`.
returns: {Function} Returns the new wrapped function.

wrapper()   X-Ref
No description

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

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

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

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

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`.

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

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

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`.
returns: {Function} Returns the new wrapped function.

wrapper()   X-Ref
No description

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

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

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

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

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.

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`.
returns: {Function} Returns the new wrapped function.

wrapper()   X-Ref
No description

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

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

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

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

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

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

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`.

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

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.

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
returns: {Function} Returns the new wrapped function.

wrapper()   X-Ref
No description

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

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

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

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

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

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`.
returns: {Function} Returns the new wrapped function.

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

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

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

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

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.

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`.
returns: {Function} Returns the new wrapped function.

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`.

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`.
returns: {*} Returns the value to assign.

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.

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
returns: {*} Returns the value to assign.

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

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

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

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.
returns: {boolean} Returns `true` if the arrays are equivalent, else `false`.

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`.

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.
returns: {boolean} Returns `true` if the objects are equivalent, else `false`.

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

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.
returns: {boolean} Returns `true` if the objects are equivalent, else `false`.

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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.
returns: {Object} Returns an object containing the `start` and `end`

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

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

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

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

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

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

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

param: {Object} object The object to clone.
returns: {Object} Returns the initialized 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`.

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

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

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

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

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

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

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

isIterateeCall(value, index, object)   X-Ref
Checks if the given 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.
returns: {boolean} Returns `true` if the arguments are from an iteratee call,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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.

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

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

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

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

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.
returns: {Function} Returns the new function.

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

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

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.

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

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

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

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.

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

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.

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

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

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

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

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

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

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

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

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

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

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

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.

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`.
returns: {Array} Returns the new array of chunks.

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

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

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

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

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

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`.
returns: {Array} Returns the slice of `array`.

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

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`.
returns: {Array} Returns the slice of `array`.

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).

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

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).

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

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`.

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.
returns: {Array} Returns `array`.

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.

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.
returns: {number} Returns the index of the found element, else `-1`.

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

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.
returns: {number} Returns the index of the found element, else `-1`.

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

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

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

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

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

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

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

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

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

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

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`.

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

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

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

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

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

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

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

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

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.
returns: {number} Returns the index of the matched value, else `-1`.

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.

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

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`.

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

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`.

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

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`.

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

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.

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

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).

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

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.

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

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.

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

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).

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

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

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

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.

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

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).

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

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

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

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

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

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

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

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

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

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

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`.
returns: {Array} Returns the slice of `array`.

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

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`.
returns: {Array} Returns the slice of `array`.

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).

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

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).

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

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.

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

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).

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

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).

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

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.

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

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).

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

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.

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

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

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

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`.

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

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.

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

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.

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

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

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

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

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).

returns: {Object} Returns the next iterator value.

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

returns: {Object} Returns the wrapper object.

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

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

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

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

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

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

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.

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`.
returns: {boolean} Returns `true` if all elements pass the predicate check,

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.

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

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).

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

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

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

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

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.
returns: {Array} Returns the new flattened array.

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.

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

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

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

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`.

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`.
returns: {boolean} Returns `true` if `value` is found, else `false`.

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`

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

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.

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`.
returns: {Array} Returns the new sorted array.

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`

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

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

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

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

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

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

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

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

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`.
returns: {Array} Returns the random elements.

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).

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

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.

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

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).

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`.
returns: {boolean} Returns `true` if any element passes the predicate check,

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.

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

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

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`.
returns: {Function} Returns the new capped function.

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.

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

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.

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`.
returns: {Function} Returns the new curried function.

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.

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`.
returns: {Function} Returns the new curried function.

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`.

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]
returns: {Function} Returns the new debounced function.

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.

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

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`.

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

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.

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

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.

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

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).

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

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).

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

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`.

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]
returns: {Function} Returns the new throttled function.

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

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

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.

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

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

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

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.

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

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]).

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

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

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

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

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

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.

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

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.

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

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`.

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

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

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

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

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

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

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

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`.

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

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. `===`.

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

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]).

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

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

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

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).

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

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

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

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

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

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

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).

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

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('')`)

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

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".

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

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.

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

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).

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.
returns: {boolean} Returns `true` if `object` is a match, else `false`.

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.

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

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.

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

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

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

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

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

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.

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

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`.

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

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).

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

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

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

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

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

isUndefined(value)   X-Ref
Checks if `value` is `undefined`.

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

isWeakMap(value)   X-Ref
Checks if `value` is classified as a `WeakMap` object.

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

isWeakSet(value)   X-Ref
Checks if `value` is classified as a `WeakSet` object.

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

toArray(value)   X-Ref
Converts `value` to an array.

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

toFinite(value)   X-Ref
Converts `value` to a finite number.

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

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).

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

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).

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

toNumber(value)   X-Ref
Converts `value` to a number.

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

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.

param: {*} value The value to convert.
returns: {Object} Returns the converted plain object.

toSafeInteger(value)   X-Ref
Converts `value` to a safe integer. A safe integer can be compared and
represented correctly.

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

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.

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

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.

param: {Object} prototype The object to inherit from.
param: {Object} [properties] The properties to assign to the object.
returns: {Object} Returns the new 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.

param: {Object} object The object to inspect.
param: {Function} [predicate=_.identity] The function invoked per iteration.
returns: {string|undefined} Returns the key of the matched element,

findLastKey(object, predicate)   X-Ref
This method is like `_.findKey` except that it iterates over elements of
a collection in the opposite order.

param: {Object} object The object to inspect.
param: {Function} [predicate=_.identity] The function invoked per iteration.
returns: {string|undefined} Returns the key of the matched element,

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`.

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

forInRight(object, iteratee)   X-Ref
This method is like `_.forIn` except that it iterates over properties of
`object` in the opposite order.

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

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`.

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

forOwnRight(object, iteratee)   X-Ref
This method is like `_.forOwn` except that it iterates over properties of
`object` in the opposite order.

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

functions(object)   X-Ref
Creates an array of function property names from own enumerable properties
of `object`.

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

functionsIn(object)   X-Ref
Creates an array of function property names from own and inherited
enumerable properties of `object`.

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

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.

param: {Object} object The object to query.
param: {Array|string} path The path of the property to get.
param: {*} [defaultValue] The value returned for `undefined` resolved values.
returns: {*} Returns the resolved value.

has(object, path)   X-Ref
Checks if `path` is a direct property of `object`.

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

hasIn(object, path)   X-Ref
Checks if `path` is a direct or inherited property of `object`.

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

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.

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

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.

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

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).

param: {Object} object The object to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.
returns: {Object} Returns the new mapped object.

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).

param: {Object} object The object to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.
returns: {Object} Returns the new mapped object.

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).

param: {Object} object The source object.
param: {Function} [predicate=_.identity] The function invoked per property.
returns: {Object} Returns the new object.

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).

param: {Object} object The source object.
param: {Function} [predicate=_.identity] The function invoked per property.
returns: {Object} Returns the new object.

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.

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.
returns: {*} Returns the resolved value.

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`.

param: {Object} object The object to modify.
param: {Array|string} path The path of the property to set.
param: {*} value The value to set.
returns: {Object} Returns `object`.

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`.

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.
returns: {Object} Returns `object`.

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`.

param: {Object} object The object to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.
param: {*} [accumulator] The custom accumulator value.
returns: {*} Returns the accumulated value.

unset(object, path)   X-Ref
Removes the property at `path` of `object`.

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

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

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`.

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.
returns: {Object} Returns `object`.

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`.

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.
returns: {Object} Returns `object`.

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.

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

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.

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

clamp(number, lower, upper)   X-Ref
Clamps `number` within the inclusive `lower` and `upper` bounds.

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

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.

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

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.

param: {number} [lower=0] The lower bound.
param: {number} [upper=1] The upper bound.
param: {boolean} [floating] Specify returning a floating-point number.
returns: {number} Returns the random number.

capitalize(string)   X-Ref
Converts the first character of `string` to upper case and the remaining
to lower case.

param: {string} [string=''] The string to capitalize.
returns: {string} Returns the capitalized string.

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).

param: {string} [string=''] The string to deburr.
returns: {string} Returns the deburred string.

endsWith(string, target, position)   X-Ref
Checks if `string` ends with the given target string.

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.
returns: {boolean} Returns `true` if `string` ends with `target`,

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.

param: {string} [string=''] The string to escape.
returns: {string} Returns the escaped string.

escapeRegExp(string)   X-Ref
Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
"?", "(", ")", "[", "]", "{", "}", and "|" in `string`.

param: {string} [string=''] The string to escape.
returns: {string} Returns the escaped string.

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`.

param: {string} [string=''] The string to pad.
param: {number} [length=0] The padding length.
param: {string} [chars=' '] The string used as padding.
returns: {string} Returns the padded string.

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`.

param: {string} [string=''] The string to pad.
param: {number} [length=0] The padding length.
param: {string} [chars=' '] The string used as padding.
returns: {string} Returns the padded string.

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`.

param: {string} [string=''] The string to pad.
param: {number} [length=0] The padding length.
param: {string} [chars=' '] The string used as padding.
returns: {string} Returns the padded string.

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`.

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`.
returns: {number} Returns the converted integer.

repeat(string, n, guard)   X-Ref
Repeats the given string `n` times.

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`.
returns: {string} Returns the repeated string.

replace()   X-Ref
Replaces matches for `pattern` in `string` with `replacement`.

**Note:** This method is based on
[`String#replace`](https://mdn.io/String/replace).

param: {string} [string=''] The string to modify.
param: {RegExp|string} pattern The pattern to replace.
param: {Function|string} replacement The match replacement.
returns: {string} Returns the modified string.

split(string, separator, limit)   X-Ref
Splits `string` by `separator`.

**Note:** This method is based on
[`String#split`](https://mdn.io/String/split).

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.
returns: {Array} Returns the string segments.

startsWith(string, target, position)   X-Ref
Checks if `string` starts with the given target string.

param: {string} [string=''] The string to inspect.
param: {string} [target] The string to search for.
param: {number} [position=0] The position to search from.
returns: {boolean} Returns `true` if `string` starts with `target`,

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).

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`.
returns: {Function} Returns the compiled template function.

toLower(value)   X-Ref
Converts `string`, as a whole, to lower case just like
[String#toLowerCase](https://mdn.io/toLowerCase).

param: {string} [string=''] The string to convert.
returns: {string} Returns the lower cased string.

toUpper(value)   X-Ref
Converts `string`, as a whole, to upper case just like
[String#toUpperCase](https://mdn.io/toUpperCase).

param: {string} [string=''] The string to convert.
returns: {string} Returns the upper cased string.

trim(string, chars, guard)   X-Ref
Removes leading and trailing whitespace or specified characters from `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`.
returns: {string} Returns the trimmed string.

trimEnd(string, chars, guard)   X-Ref
Removes trailing whitespace or specified characters from `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`.
returns: {string} Returns the trimmed string.

trimStart(string, chars, guard)   X-Ref
Removes leading whitespace or specified characters from `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`.
returns: {string} Returns the trimmed string.

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 "...".

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.
returns: {string} Returns the truncated string.

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).

param: {string} [string=''] The string to unescape.
returns: {string} Returns the unescaped string.

words(string, pattern, guard)   X-Ref
Splits `string` into an array of its words.

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`.
returns: {Array} Returns the words of `string`.

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.

param: {Array} pairs The predicate-function pairs.
returns: {Function} Returns the new composite function.

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.

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

constant(value)   X-Ref
Creates a function that returns `value`.

param: {*} value The value to return from the new function.
returns: {Function} Returns the new constant 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`.

param: {*} value The value to check.
param: {*} defaultValue The default value.
returns: {*} Returns the resolved value.

identity(value)   X-Ref
This method returns the first argument it receives.

param: {*} value Any value.
returns: {*} Returns `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`.

param: {*} [func=_.identity] The value to convert to a callback.
returns: {Function} Returns the 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.

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

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.

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

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.

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.
returns: {Function|Object} Returns `object`.

noConflict()   X-Ref
Reverts the `_` variable to its previous value and returns a reference to
the `lodash` function.

returns: {Function} Returns the `lodash` function.

noop()   X-Ref
This method returns `undefined`.


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.

param: {number} [n=0] The index of the argument to return.
returns: {Function} Returns the new pass-thru function.

property(path)   X-Ref
Creates a function that returns the value at `path` of a given object.

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

propertyOf(object)   X-Ref
The opposite of `_.property`; this method creates a function that returns
the value at a given path of `object`.

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

stubArray()   X-Ref
This method returns a new empty array.

returns: {Array} Returns the new empty array.

stubFalse()   X-Ref
This method returns `false`.

returns: {boolean} Returns `false`.

stubObject()   X-Ref
This method returns a new empty object.

returns: {Object} Returns the new empty object.

stubString()   X-Ref
This method returns an empty string.

returns: {string} Returns the empty string.

stubTrue()   X-Ref
This method returns `true`.

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).

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

toPath(value)   X-Ref
Converts `value` to a property path array.

param: {*} value The value to convert.
returns: {Array} Returns the new property path array.

uniqueId(prefix)   X-Ref
Generates a unique ID. If `prefix` is given, the ID is appended to it.

param: {string} [prefix=''] The value to prefix the ID with.
returns: {string} Returns the unique ID.

max(array)   X-Ref
Computes the maximum value of `array`. If `array` is empty or falsey,
`undefined` is returned.

param: {Array} array The array to iterate over.
returns: {*} Returns the maximum value.

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).

param: {Array} array The array to iterate over.
param: {Function} [iteratee=_.identity] The iteratee invoked per element.
returns: {*} Returns the maximum value.

mean(array)   X-Ref
Computes the mean of the values in `array`.

param: {Array} array The array to iterate over.
returns: {number} Returns the mean.

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).

param: {Array} array The array to iterate over.
param: {Function} [iteratee=_.identity] The iteratee invoked per element.
returns: {number} Returns the mean.

min(array)   X-Ref
Computes the minimum value of `array`. If `array` is empty or falsey,
`undefined` is returned.

param: {Array} array The array to iterate over.
returns: {*} Returns the minimum value.

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).

param: {Array} array The array to iterate over.
param: {Function} [iteratee=_.identity] The iteratee invoked per element.
returns: {*} Returns the minimum value.

sum(array)   X-Ref
Computes the sum of the values in `array`.

param: {Array} array The array to iterate over.
returns: {number} Returns the sum.

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).

param: {Array} array The array to iterate over.
param: {Function} [iteratee=_.identity] The iteratee invoked per element.
returns: {number} Returns the sum.



Generated: Fri Oct 25 08:20:01 2019 Cross-referenced by PHPXref 0.7