| [ Index ] |
PHP Cross Reference of WordPress |
[Source view] [Print] [Project Stats]
(no description)
| File Size: | 24546 lines (1054 kb) |
| Included or required: | 0 times |
| Referenced: | 0 times |
| Includes or requires: | 0 files |
| replacer(key, value) X-Ref |
| No description |
| truncate(s, n) X-Ref |
| No description |
| getMessage(self) X-Ref |
| No description |
| fail(actual, expected, message, operator, stackStartFunction) X-Ref |
| No description |
| ok(value, message) X-Ref |
| No description |
| _deepEqual(actual, expected) X-Ref |
| No description |
| isArguments(object) X-Ref |
| No description |
| objEquiv(a, b) X-Ref |
| No description |
| expectedException(actual, expected) X-Ref |
| No description |
| _throws(shouldThrow, block, expected, message) X-Ref |
| No description |
| EventEmitter() X-Ref |
| No description |
| g() X-Ref |
| No description |
| isFunction(arg) X-Ref |
| No description |
| isNumber(arg) X-Ref |
| No description |
| isObject(arg) X-Ref |
| No description |
| isUndefined(arg) X-Ref |
| No description |
| drainQueue() X-Ref |
| No description |
| noop() X-Ref |
| No description |
| deprecated() X-Ref |
| No description |
| inspect(obj, opts) X-Ref |
| Echos the value of a value. Trys to print the value out in the best way possible given the different types. param: {Object} obj The object to print out. param: {Object} opts Optional options object that alters the output. |
| stylizeWithColor(str, styleType) X-Ref |
| No description |
| stylizeNoColor(str, styleType) X-Ref |
| No description |
| arrayToHash(array) X-Ref |
| No description |
| formatValue(ctx, value, recurseTimes) X-Ref |
| No description |
| formatPrimitive(ctx, value) X-Ref |
| No description |
| formatError(value) X-Ref |
| No description |
| formatArray(ctx, value, recurseTimes, visibleKeys, keys) X-Ref |
| No description |
| formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) X-Ref |
| No description |
| reduceToSingleString(output, base, braces) X-Ref |
| No description |
| isArray(ar) X-Ref |
| No description |
| isBoolean(arg) X-Ref |
| No description |
| isNull(arg) X-Ref |
| No description |
| isNullOrUndefined(arg) X-Ref |
| No description |
| isNumber(arg) X-Ref |
| No description |
| isString(arg) X-Ref |
| No description |
| isSymbol(arg) X-Ref |
| No description |
| isUndefined(arg) X-Ref |
| No description |
| isRegExp(re) X-Ref |
| No description |
| isObject(arg) X-Ref |
| No description |
| isDate(d) X-Ref |
| No description |
| isError(e) X-Ref |
| No description |
| isFunction(arg) X-Ref |
| No description |
| isPrimitive(arg) X-Ref |
| No description |
| objectToString(o) X-Ref |
| No description |
| pad(n) X-Ref |
| No description |
| timestamp() X-Ref |
| No description |
| hasOwnProperty(obj, prop) X-Ref |
| No description |
| log() X-Ref |
| No description |
| info() X-Ref |
| No description |
| warn() X-Ref |
| No description |
| error() X-Ref |
| No description |
| time(label) X-Ref |
| No description |
| timeEnd(label) X-Ref |
| No description |
| trace() X-Ref |
| No description |
| dir(object) X-Ref |
| No description |
| consoleAssert(expression) X-Ref |
| No description |
| now() X-Ref |
| No description |
| baseCompareAscending(value, other) X-Ref |
| The base implementation of `compareAscending` which compares values and sorts them in ascending order without guaranteeing a stable sort. returns: {number} Returns the sort order indicator for `value`. param: {*} value The value to compare to `other`. param: {*} other The value to compare to `value`. |
| baseFindIndex(array, predicate, fromRight) X-Ref |
| The base implementation of `_.findIndex` and `_.findLastIndex` without support for callback shorthands and `this` binding. returns: {number} Returns the index of the matched value, else `-1`. param: {Array} array The array to search. param: {Function} predicate The function invoked per iteration. param: {boolean} [fromRight] Specify iterating from right to left. |
| baseIndexOf(array, value, fromIndex) X-Ref |
| The base implementation of `_.indexOf` without support for binary searches. returns: {number} Returns the index of the matched value, else `-1`. param: {Array} array The array to search. param: {*} value The value to search for. param: {number} fromIndex The index to search from. |
| baseIsFunction(value) X-Ref |
| The base implementation of `_.isFunction` without support for environments with incorrect `typeof` results. returns: {boolean} Returns `true` if `value` is correctly classified, else `false`. param: {*} value The value to check. |
| baseToString(value) X-Ref |
| Converts `value` to a string if it is not one. An empty string is returned for `null` or `undefined` values. returns: {string} Returns the string. param: {*} value The value to process. |
| charAtCallback(string) X-Ref |
| Used by `_.max` and `_.min` as the default callback for string values. returns: {number} Returns the code unit of the first character of the string. param: {string} string The string to inspect. |
| charsLeftIndex(string, chars) X-Ref |
| Used by `_.trim` and `_.trimLeft` to get the index of the first character of `string` that is not found in `chars`. returns: {number} Returns the index of the first character not found in `chars`. param: {string} string The string to inspect. param: {string} chars The characters to find. |
| charsRightIndex(string, chars) X-Ref |
| Used by `_.trim` and `_.trimRight` to get the index of the last character of `string` that is not found in `chars`. returns: {number} Returns the index of the last character not found in `chars`. param: {string} string The string to inspect. param: {string} chars The characters to find. |
| compareAscending(object, other) X-Ref |
| Used by `_.sortBy` to compare transformed elements of a collection and stable sort them in ascending order. returns: {number} Returns the sort order indicator for `object`. param: {Object} object The object to compare to `other`. param: {Object} other The object to compare to `object`. |
| compareMultiple(object, other, orders) X-Ref |
| Used by `_.sortByOrder` to compare multiple properties of each element in a collection and stable sort them in the following order: If `orders` is unspecified, sort in ascending order for all properties. Otherwise, for each property, sort in ascending order if its corresponding value in orders is true, and descending order if false. returns: {number} Returns the sort order indicator for `object`. param: {Object} object The object to compare to `other`. param: {Object} other The object to compare to `object`. param: {boolean[]} orders The order to sort by for each property. |
| deburrLetter(letter) X-Ref |
| Used by `_.deburr` to convert latin-1 supplementary letters to basic latin letters. returns: {string} Returns the deburred letter. param: {string} letter The matched letter to deburr. |
| escapeHtmlChar(chr) X-Ref |
| Used by `_.escape` to convert characters to HTML entities. returns: {string} Returns the escaped character. param: {string} chr The matched character to escape. |
| escapeStringChar(chr) X-Ref |
| Used by `_.template` to escape characters for inclusion in compiled string literals. returns: {string} Returns the escaped character. param: {string} chr The matched character to escape. |
| indexOfNaN(array, fromIndex, fromRight) X-Ref |
| Gets the index at which the first occurrence of `NaN` is found in `array`. returns: {number} Returns the index of the matched `NaN`, else `-1`. param: {Array} array The array to search. param: {number} fromIndex The index to search from. param: {boolean} [fromRight] Specify iterating from right to left. |
| isObjectLike(value) X-Ref |
| Checks if `value` is object-like. returns: {boolean} Returns `true` if `value` is object-like, else `false`. param: {*} value The value to check. |
| isSpace(charCode) X-Ref |
| Used by `trimmedLeftIndex` and `trimmedRightIndex` to determine if a character code is whitespace. returns: {boolean} Returns `true` if `charCode` is whitespace, else `false`. param: {number} charCode The character code to inspect. |
| replaceHolders(array, placeholder) X-Ref |
| Replaces all `placeholder` elements in `array` with an internal placeholder and returns an array of their indexes. returns: {Array} Returns the new array of placeholder indexes. param: {Array} array The array to modify. param: {*} placeholder The placeholder to replace. |
| sortedUniq(array, iteratee) X-Ref |
| An implementation of `_.uniq` optimized for sorted arrays without support for callback shorthands and `this` binding. returns: {Array} Returns the new duplicate-value-free array. param: {Array} array The array to inspect. param: {Function} [iteratee] The function invoked per iteration. |
| trimmedLeftIndex(string) X-Ref |
| Used by `_.trim` and `_.trimLeft` to get the index of the first non-whitespace character of `string`. returns: {number} Returns the index of the first non-whitespace character. param: {string} string The string to inspect. |
| trimmedRightIndex(string) X-Ref |
| Used by `_.trim` and `_.trimRight` to get the index of the last non-whitespace character of `string`. returns: {number} Returns the index of the last non-whitespace character. param: {string} string The string to inspect. |
| unescapeHtmlChar(chr) X-Ref |
| Used by `_.unescape` to convert HTML entities to characters. returns: {string} Returns the unescaped character. param: {string} chr The matched character to unescape. |
| runInContext(context) X-Ref |
| Create a new pristine `lodash` function using the given `context` object. returns: {Function} Returns a new `lodash` function. param: {Object} [context=root] The context object. |
| lodash(value) X-Ref |
| No description |
| baseLodash() X-Ref |
| The function whose prototype all chaining wrappers inherit from. |
| LodashWrapper(value, chainAll, actions) X-Ref |
| The base constructor for creating `lodash` wrapper objects. param: {*} value The value to wrap. param: {boolean} [chainAll] Enable chaining for all wrapper methods. param: {Array} [actions=[]] Actions to peform to resolve the unwrapped value. |
| 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. |
| MapCache() X-Ref |
| Creates a cache object to store key/value pairs. |
| mapDelete(key) X-Ref |
| Removes `key` and its value from the cache. returns: {boolean} Returns `true` if the entry was removed successfully, else `false`. param: {string} key The key of the value to remove. |
| mapGet(key) X-Ref |
| Gets the cached value for `key`. returns: {*} Returns the cached value. param: {string} key The key of the value to get. |
| mapHas(key) X-Ref |
| Checks if a cached value for `key` exists. returns: {boolean} Returns `true` if an entry for `key` exists, else `false`. param: {string} key The key of the entry to check. |
| mapSet(key, value) X-Ref |
| Sets `value` to `key` of the cache. returns: {Object} Returns the cache object. param: {string} key The key of the value to cache. param: {*} value The value to cache. |
| SetCache(values) X-Ref |
| Creates a cache object to store unique values. param: {Array} [values] The values to cache. |
| cacheIndexOf(cache, value) X-Ref |
| Checks if `value` is in `cache` mimicking the return signature of `_.indexOf` by returning `0` if the value is found, else `-1`. returns: {number} Returns `0` if `value` is found, else `-1`. param: {Object} cache The cache to search. param: {*} value The value to search for. |
| cachePush(value) X-Ref |
| Adds `value` to the cache. param: {*} value The value to cache. |
| arrayCopy(source, array) X-Ref |
| Copies the values of `source` to `array`. returns: {Array} Returns `array`. param: {Array} source The array to copy values from. param: {Array} [array=[]] The array to copy values to. |
| arrayEach(array, iteratee) X-Ref |
| A specialized version of `_.forEach` for arrays without support for callback shorthands and `this` binding. returns: {Array} Returns `array`. param: {Array} array The array to iterate over. param: {Function} iteratee The function invoked per iteration. |
| arrayEachRight(array, iteratee) X-Ref |
| A specialized version of `_.forEachRight` for arrays without support for callback shorthands and `this` binding. returns: {Array} Returns `array`. param: {Array} array The array to iterate over. param: {Function} iteratee The function invoked per iteration. |
| arrayEvery(array, predicate) X-Ref |
| A specialized version of `_.every` for arrays without support for callback shorthands and `this` binding. returns: {boolean} Returns `true` if all elements pass the predicate check, param: {Array} array The array to iterate over. param: {Function} predicate The function invoked per iteration. |
| arrayFilter(array, predicate) X-Ref |
| A specialized version of `_.filter` for arrays without support for callback shorthands and `this` binding. returns: {Array} Returns the new filtered array. param: {Array} array The array to iterate over. param: {Function} predicate The function invoked per iteration. |
| arrayMap(array, iteratee) X-Ref |
| A specialized version of `_.map` for arrays without support for callback shorthands and `this` binding. returns: {Array} Returns the new mapped array. param: {Array} array The array to iterate over. param: {Function} iteratee The function invoked per iteration. |
| arrayMax(array) X-Ref |
| A specialized version of `_.max` for arrays without support for iteratees. returns: {*} Returns the maximum value. param: {Array} array The array to iterate over. |
| arrayMin(array) X-Ref |
| A specialized version of `_.min` for arrays without support for iteratees. returns: {*} Returns the minimum value. param: {Array} array The array to iterate over. |
| arrayReduce(array, iteratee, accumulator, initFromArray) X-Ref |
| A specialized version of `_.reduce` for arrays without support for callback shorthands and `this` binding. returns: {*} Returns the accumulated value. param: {Array} array The array to iterate over. param: {Function} iteratee The function invoked per iteration. param: {*} [accumulator] The initial value. param: {boolean} [initFromArray] Specify using the first element of `array` |
| arrayReduceRight(array, iteratee, accumulator, initFromArray) X-Ref |
| A specialized version of `_.reduceRight` for arrays without support for callback shorthands and `this` binding. returns: {*} Returns the accumulated value. param: {Array} array The array to iterate over. param: {Function} iteratee The function invoked per iteration. param: {*} [accumulator] The initial value. param: {boolean} [initFromArray] Specify using the last element of `array` |
| arraySome(array, predicate) X-Ref |
| A specialized version of `_.some` for arrays without support for callback shorthands and `this` binding. returns: {boolean} Returns `true` if any element passes the predicate check, param: {Array} array The array to iterate over. param: {Function} predicate The function invoked per iteration. |
| arraySum(array) X-Ref |
| A specialized version of `_.sum` for arrays without support for iteratees. returns: {number} Returns the sum. param: {Array} array The array to iterate over. |
| assignDefaults(objectValue, sourceValue) X-Ref |
| Used by `_.defaults` to customize its `_.assign` use. returns: {*} Returns the value to assign to the destination object. param: {*} objectValue The destination object property value. param: {*} sourceValue The source object property value. |
| assignOwnDefaults(objectValue, sourceValue, key, object) X-Ref |
| Used by `_.template` to customize its `_.assign` use. **Note:** This function is like `assignDefaults` except that it ignores inherited property values when checking if a property is `undefined`. returns: {*} Returns the value to assign to the destination object. param: {*} objectValue The destination object property value. param: {*} sourceValue The source object property value. param: {string} key The key associated with the object and source values. param: {Object} object The destination object. |
| assignWith(object, source, customizer) X-Ref |
| A specialized version of `_.assign` for customizing assigned values without support for argument juggling, multiple sources, and `this` binding `customizer` functions. returns: {Object} Returns `object`. param: {Object} object The destination object. param: {Object} source The source object. param: {Function} customizer The function to customize assigned values. |
| baseAt(collection, props) X-Ref |
| The base implementation of `_.at` without support for string collections and individual key arguments. returns: {Array} Returns the new array of picked elements. param: {Array|Object} collection The collection to iterate over. param: {number[]|string[]} props The property names or indexes of elements to pick. |
| baseCopy(source, props, object) X-Ref |
| Copies properties of `source` to `object`. returns: {Object} Returns `object`. param: {Object} source The object to copy properties from. param: {Array} props The property names to copy. param: {Object} [object={}] The object to copy properties to. |
| baseCallback(func, thisArg, argCount) X-Ref |
| The base implementation of `_.callback` which supports specifying the number of arguments to provide to `func`. returns: {Function} Returns the callback. param: {*} [func=_.identity] The value to convert to a callback. param: {*} [thisArg] The `this` binding of `func`. param: {number} [argCount] The number of arguments to provide to `func`. |
| baseClone(value, isDeep, customizer, key, object, stackA, stackB) X-Ref |
| The base implementation of `_.clone` without support for argument juggling and `this` binding `customizer` functions. returns: {*} Returns the cloned value. param: {*} value The value to clone. param: {boolean} [isDeep] Specify a deep clone. param: {Function} [customizer] The function to customize cloning values. param: {string} [key] The key of `value`. param: {Object} [object] The object `value` belongs to. param: {Array} [stackA=[]] Tracks traversed source objects. param: {Array} [stackB=[]] Associates clones with source counterparts. |
| Object() X-Ref |
| The base implementation of `_.create` without support for assigning properties to the created object. returns: {Object} Returns the new object. param: {Object} prototype The object to inherit from. |
| baseDelay(func, wait, args) X-Ref |
| The base implementation of `_.delay` and `_.defer` which accepts an index of where to slice the arguments to provide to `func`. returns: {number} Returns the timer id. param: {Function} func The function to delay. param: {number} wait The number of milliseconds to delay invocation. param: {Object} args The arguments provide to `func`. |
| baseDifference(array, values) X-Ref |
| The base implementation of `_.difference` which accepts a single array of values to exclude. returns: {Array} Returns the new array of filtered values. param: {Array} array The array to inspect. param: {Array} values The values to exclude. |
| baseEvery(collection, predicate) X-Ref |
| The base implementation of `_.every` without support for callback shorthands and `this` binding. returns: {boolean} Returns `true` if all elements pass the predicate check, param: {Array|Object|string} collection The collection to iterate over. param: {Function} predicate The function invoked per iteration. |
| baseFill(array, value, start, end) X-Ref |
| The base implementation of `_.fill` without an iteratee call guard. returns: {Array} Returns `array`. param: {Array} array The array to fill. param: {*} value The value to fill `array` with. param: {number} [start=0] The start position. param: {number} [end=array.length] The end position. |
| baseFilter(collection, predicate) X-Ref |
| The base implementation of `_.filter` without support for callback shorthands and `this` binding. returns: {Array} Returns the new filtered array. param: {Array|Object|string} collection The collection to iterate over. param: {Function} predicate The function invoked per iteration. |
| baseFind(collection, predicate, eachFunc, retKey) X-Ref |
| The base implementation of `_.find`, `_.findLast`, `_.findKey`, and `_.findLastKey`, without support for callback shorthands and `this` binding, which iterates over `collection` using the provided `eachFunc`. returns: {*} Returns the found element or its key, else `undefined`. param: {Array|Object|string} collection The collection to search. param: {Function} predicate The function invoked per iteration. param: {Function} eachFunc The function to iterate over `collection`. param: {boolean} [retKey] Specify returning the key of the found element |
| baseFlatten(array, isDeep, isStrict) X-Ref |
| The base implementation of `_.flatten` with added support for restricting flattening and specifying the start index. returns: {Array} Returns the new flattened array. param: {Array} array The array to flatten. param: {boolean} isDeep Specify a deep flatten. param: {boolean} isStrict Restrict flattening to arrays and `arguments` objects. |
| baseForIn(object, iteratee) X-Ref |
| The base implementation of `_.forIn` without support for callback shorthands and `this` binding. returns: {Object} Returns `object`. param: {Object} object The object to iterate over. param: {Function} iteratee The function invoked per iteration. |
| baseForOwn(object, iteratee) X-Ref |
| The base implementation of `_.forOwn` without support for callback shorthands and `this` binding. returns: {Object} Returns `object`. param: {Object} object The object to iterate over. param: {Function} iteratee The function invoked per iteration. |
| baseForOwnRight(object, iteratee) X-Ref |
| The base implementation of `_.forOwnRight` without support for callback shorthands and `this` binding. returns: {Object} Returns `object`. param: {Object} object The object to iterate over. param: {Function} iteratee The function invoked per iteration. |
| baseFunctions(object, props) X-Ref |
| The base implementation of `_.functions` which creates an array of `object` function property names filtered from those provided. returns: {Array} Returns the new array of filtered property names. param: {Object} object The object to inspect. param: {Array} props The property names to filter. |
| baseGet(object, path, pathKey) X-Ref |
| The base implementation of `get` without support for string paths and default values. returns: {*} Returns the resolved value. param: {Object} object The object to query. param: {Array} path The path of the property to get. param: {string} [pathKey] The key representation of path. |
| baseIsEqual(value, other, customizer, isLoose, stackA, stackB) X-Ref |
| The base implementation of `_.isEqual` without support for `this` binding `customizer` functions. returns: {boolean} Returns `true` if the values are equivalent, else `false`. param: {*} value The value to compare. param: {*} other The other value to compare. param: {Function} [customizer] The function to customize comparing values. param: {boolean} [isLoose] Specify performing partial comparisons. param: {Array} [stackA] Tracks traversed `value` objects. param: {Array} [stackB] Tracks traversed `other` objects. |
| baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) X-Ref |
| A specialized version of `baseIsEqual` for arrays and objects which performs deep comparisons and tracks traversed objects enabling objects with circular references to be compared. returns: {boolean} Returns `true` if the objects are equivalent, else `false`. param: {Object} object The object to compare. param: {Object} other The other object to compare. param: {Function} equalFunc The function to determine equivalents of values. param: {Function} [customizer] The function to customize comparing objects. param: {boolean} [isLoose] Specify performing partial comparisons. param: {Array} [stackA=[]] Tracks traversed `value` objects. param: {Array} [stackB=[]] Tracks traversed `other` objects. |
| baseIsMatch(object, props, values, strictCompareFlags, customizer) X-Ref |
| The base implementation of `_.isMatch` without support for callback shorthands and `this` binding. returns: {boolean} Returns `true` if `object` is a match, else `false`. param: {Object} object The object to inspect. param: {Array} props The source property names to match. param: {Array} values The source values to match. param: {Array} strictCompareFlags Strict comparison flags for source values. param: {Function} [customizer] The function to customize comparing objects. |
| baseMap(collection, iteratee) X-Ref |
| The base implementation of `_.map` without support for callback shorthands and `this` binding. returns: {Array} Returns the new mapped array. param: {Array|Object|string} collection The collection to iterate over. param: {Function} iteratee The function invoked per iteration. |
| baseMatches(source) X-Ref |
| The base implementation of `_.matches` which does not clone `source`. returns: {Function} Returns the new function. param: {Object} source The object of property values to match. |
| baseMatchesProperty(path, value) X-Ref |
| The base implementation of `_.matchesProperty` which does not which does not clone `value`. returns: {Function} Returns the new function. param: {string} path The path of the property to get. param: {*} value The value to compare. |
| baseMerge(object, source, customizer, stackA, stackB) X-Ref |
| The base implementation of `_.merge` without support for argument juggling, multiple sources, and `this` binding `customizer` functions. returns: {Object} Returns `object`. param: {Object} object The destination object. param: {Object} source The source object. param: {Function} [customizer] The function to customize merging properties. param: {Array} [stackA=[]] Tracks traversed source objects. param: {Array} [stackB=[]] Associates values with source counterparts. |
| baseMergeDeep(object, source, key, mergeFunc, customizer, stackA, stackB) 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. returns: {boolean} Returns `true` if the objects are equivalent, else `false`. param: {Object} object The destination object. param: {Object} source The source object. param: {string} key The key of the value to merge. param: {Function} mergeFunc The function to merge values. param: {Function} [customizer] The function to customize merging properties. param: {Array} [stackA=[]] Tracks traversed source objects. param: {Array} [stackB=[]] Associates values with source counterparts. |
| baseProperty(key) X-Ref |
| The base implementation of `_.property` without support for deep paths. returns: {Function} Returns the new function. param: {string} key The key of the property to get. |
| basePropertyDeep(path) X-Ref |
| A specialized version of `baseProperty` which supports deep paths. returns: {Function} Returns the new function. param: {Array|string} path The path of the property to get. |
| basePullAt(array, indexes) X-Ref |
| The base implementation of `_.pullAt` without support for individual index arguments and capturing the removed elements. returns: {Array} Returns `array`. param: {Array} array The array to modify. param: {number[]} indexes The indexes of elements to remove. |
| baseRandom(min, max) X-Ref |
| The base implementation of `_.random` without support for argument juggling and returning floating-point numbers. returns: {number} Returns the random number. param: {number} min The minimum possible value. param: {number} max The maximum possible value. |
| baseReduce(collection, iteratee, accumulator, initFromCollection, eachFunc) X-Ref |
| The base implementation of `_.reduce` and `_.reduceRight` without support for callback shorthands and `this` binding, which iterates over `collection` using the provided `eachFunc`. returns: {*} Returns the accumulated value. param: {Array|Object|string} collection The collection to iterate over. param: {Function} iteratee The function invoked per iteration. param: {*} accumulator The initial value. param: {boolean} initFromCollection Specify using the first or last element param: {Function} eachFunc The function to iterate over `collection`. |
| baseSlice(array, start, end) X-Ref |
| The base implementation of `_.slice` without an iteratee call guard. returns: {Array} Returns the slice of `array`. param: {Array} array The array to slice. param: {number} [start=0] The start position. param: {number} [end=array.length] The end position. |
| baseSome(collection, predicate) X-Ref |
| The base implementation of `_.some` without support for callback shorthands and `this` binding. returns: {boolean} Returns `true` if any element passes the predicate check, param: {Array|Object|string} collection The collection to iterate over. param: {Function} predicate The function invoked per iteration. |
| baseSortBy(array, comparer) X-Ref |
| The base implementation of `_.sortBy` which uses `comparer` to define the sort order of `array` and replaces criteria objects with their corresponding values. returns: {Array} Returns `array`. param: {Array} array The array to sort. param: {Function} comparer The function to define sort order. |
| baseSortByOrder(collection, iteratees, orders) X-Ref |
| The base implementation of `_.sortByOrder` without param guards. returns: {Array} Returns the new sorted array. param: {Array|Object|string} collection The collection to iterate over. param: {Function[]|Object[]|string[]} iteratees The iteratees to sort by. param: {boolean[]} orders The sort orders of `iteratees`. |
| baseSum(collection, iteratee) X-Ref |
| The base implementation of `_.sum` without support for callback shorthands and `this` binding. returns: {number} Returns the sum. param: {Array|Object|string} collection The collection to iterate over. param: {Function} iteratee The function invoked per iteration. |
| baseUniq(array, iteratee) X-Ref |
| The base implementation of `_.uniq` without support for callback shorthands and `this` binding. returns: {Array} Returns the new duplicate-value-free array. param: {Array} array The array to inspect. param: {Function} [iteratee] The function invoked per iteration. |
| baseValues(object, props) X-Ref |
| The base implementation of `_.values` and `_.valuesIn` which creates an array of `object` property values corresponding to the property names of `props`. returns: {Object} Returns the array of property values. param: {Object} object The object to query. param: {Array} props The property names to get values for. |
| baseWhile(array, predicate, isDrop, fromRight) X-Ref |
| The base implementation of `_.dropRightWhile`, `_.dropWhile`, `_.takeRightWhile`, and `_.takeWhile` without support for callback shorthands and `this` binding. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {Function} predicate The function invoked per iteration. param: {boolean} [isDrop] Specify dropping elements instead of taking them. param: {boolean} [fromRight] Specify iterating from right to left. |
| baseWrapperValue(value, actions) X-Ref |
| The base implementation of `wrapperValue` which returns the result of performing a sequence of actions on the unwrapped `value`, where each successive action is supplied the return value of the previous. returns: {*} Returns the resolved value. param: {*} value The unwrapped value. param: {Array} actions Actions to peform to resolve the unwrapped value. |
| binaryIndex(array, value, retHighest) X-Ref |
| Performs a binary search of `array` to determine the index at which `value` should be inserted into `array` in order to maintain its sort order. returns: {number} Returns the index at which `value` should be inserted param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. param: {boolean} [retHighest] Specify returning the highest qualified index. |
| binaryIndexBy(array, value, iteratee, retHighest) X-Ref |
| This function is like `binaryIndex` except that it invokes `iteratee` for `value` and each element of `array` to compute their sort ranking. The iteratee is invoked with one argument; (value). returns: {number} Returns the index at which `value` should be inserted param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. param: {Function} iteratee The function invoked per iteration. param: {boolean} [retHighest] Specify returning the highest qualified index. |
| bindCallback(func, thisArg, argCount) X-Ref |
| A specialized version of `baseCallback` which only supports `this` binding and specifying the number of arguments to provide to `func`. returns: {Function} Returns the callback. param: {Function} func The function to bind. param: {*} thisArg The `this` binding of `func`. param: {number} [argCount] The number of arguments to provide to `func`. |
| bufferClone(buffer) X-Ref |
| Creates a clone of the given array buffer. returns: {ArrayBuffer} Returns the cloned array buffer. param: {ArrayBuffer} buffer The array buffer to clone. |
| composeArgs(args, partials, holders) X-Ref |
| Creates an array that is the composition of partially applied arguments, placeholders, and provided arguments into a single array of arguments. returns: {Array} Returns the new array of composed arguments. param: {Array|Object} args The provided arguments. param: {Array} partials The arguments to prepend to those provided. param: {Array} holders The `partials` placeholder indexes. |
| composeArgsRight(args, partials, holders) X-Ref |
| This function is like `composeArgs` except that the arguments composition is tailored for `_.partialRight`. returns: {Array} Returns the new array of composed arguments. param: {Array|Object} args The provided arguments. param: {Array} partials The arguments to append to those provided. param: {Array} holders The `partials` placeholder indexes. |
| createAggregator(setter, initializer) X-Ref |
| Creates a function that aggregates a collection, creating an accumulator object composed from the results of running each element in the collection through an iteratee. **Note:** This function is used to create `_.countBy`, `_.groupBy`, `_.indexBy`, and `_.partition`. returns: {Function} Returns the new aggregator function. param: {Function} setter The function to set keys and values of the accumulator object. param: {Function} [initializer] The function to initialize the accumulator object. |
| createAssigner(assigner) X-Ref |
| Creates a function that assigns properties of source object(s) to a given destination object. **Note:** This function is used to create `_.assign`, `_.defaults`, and `_.merge`. returns: {Function} Returns the new assigner function. param: {Function} assigner The function to assign values. |
| createBaseEach(eachFunc, fromRight) X-Ref |
| Creates a `baseEach` or `baseEachRight` function. returns: {Function} Returns the new base function. param: {Function} eachFunc The function to iterate over a collection. param: {boolean} [fromRight] Specify iterating from right to left. |
| createBaseFor(fromRight) X-Ref |
| Creates a base function for `_.forIn` or `_.forInRight`. returns: {Function} Returns the new base function. param: {boolean} [fromRight] Specify iterating from right to left. |
| createBindWrapper(func, thisArg) X-Ref |
| Creates a function that wraps `func` and invokes it with the `this` binding of `thisArg`. returns: {Function} Returns the new bound function. param: {Function} func The function to bind. param: {*} [thisArg] The `this` binding of `func`. |
| wrapper() X-Ref |
| No description |
| createCompounder(callback) X-Ref |
| Creates a function that produces compound words out of the words in a given string. returns: {Function} Returns the new compounder function. param: {Function} callback The function to combine each word. |
| createCtorWrapper(Ctor) X-Ref |
| Creates a function that produces an instance of `Ctor` regardless of whether it was invoked as part of a `new` expression or by `call` or `apply`. returns: {Function} Returns the new wrapped function. param: {Function} Ctor The constructor to wrap. |
| createCurry(flag) X-Ref |
| Creates a `_.curry` or `_.curryRight` function. returns: {Function} Returns the new curry function. param: {boolean} flag The curry bit flag. |
| curryFunc(func, arity, guard) X-Ref |
| No description |
| createExtremum(arrayFunc, isMin) X-Ref |
| Creates a `_.max` or `_.min` function. returns: {Function} Returns the new extremum function. param: {Function} arrayFunc The function to get the extremum value from an array. param: {boolean} [isMin] Specify returning the minimum, instead of the maximum, |
| createFind(eachFunc, fromRight) X-Ref |
| Creates a `_.find` or `_.findLast` function. returns: {Function} Returns the new find function. param: {Function} eachFunc The function to iterate over a collection. param: {boolean} [fromRight] Specify iterating from right to left. |
| createFindIndex(fromRight) X-Ref |
| Creates a `_.findIndex` or `_.findLastIndex` function. returns: {Function} Returns the new find function. param: {boolean} [fromRight] Specify iterating from right to left. |
| createFindKey(objectFunc) X-Ref |
| Creates a `_.findKey` or `_.findLastKey` function. returns: {Function} Returns the new find function. param: {Function} objectFunc The function to iterate over an object. |
| createFlow(fromRight) X-Ref |
| Creates a `_.flow` or `_.flowRight` function. returns: {Function} Returns the new flow function. param: {boolean} [fromRight] Specify iterating from right to left. |
| createForEach(arrayFunc, eachFunc) X-Ref |
| Creates a function for `_.forEach` or `_.forEachRight`. returns: {Function} Returns the new each function. param: {Function} arrayFunc The function to iterate over an array. param: {Function} eachFunc The function to iterate over a collection. |
| createForIn(objectFunc) X-Ref |
| Creates a function for `_.forIn` or `_.forInRight`. returns: {Function} Returns the new each function. param: {Function} objectFunc The function to iterate over an object. |
| createForOwn(objectFunc) X-Ref |
| Creates a function for `_.forOwn` or `_.forOwnRight`. returns: {Function} Returns the new each function. param: {Function} objectFunc The function to iterate over an object. |
| createPadDir(fromRight) X-Ref |
| Creates a function for `_.padLeft` or `_.padRight`. returns: {Function} Returns the new pad function. param: {boolean} [fromRight] Specify padding from the right. |
| createPartial(flag) X-Ref |
| Creates a `_.partial` or `_.partialRight` function. returns: {Function} Returns the new partial function. param: {boolean} flag The partial bit flag. |
| createReduce(arrayFunc, eachFunc) X-Ref |
| Creates a function for `_.reduce` or `_.reduceRight`. returns: {Function} Returns the new each function. param: {Function} arrayFunc The function to iterate over an array. param: {Function} eachFunc The function to iterate over a collection. |
| createHybridWrapper(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) X-Ref |
| Creates a function that wraps `func` and invokes it with optional `this` binding of, partial application, and currying. returns: {Function} Returns the new wrapped function. param: {Function|string} func The function or method name to reference. param: {number} bitmask The bitmask of flags. See `createWrapper` for more details. param: {*} [thisArg] The `this` binding of `func`. param: {Array} [partials] The arguments to prepend to those provided to the new function. param: {Array} [holders] The `partials` placeholder indexes. param: {Array} [partialsRight] The arguments to append to those provided to the new function. param: {Array} [holdersRight] The `partialsRight` placeholder indexes. param: {Array} [argPos] The argument positions of the new function. param: {number} [ary] The arity cap of `func`. param: {number} [arity] The arity of `func`. |
| wrapper() X-Ref |
| No description |
| createPadding(string, length, chars) X-Ref |
| Creates the padding required for `string` based on the given `length`. The `chars` string is truncated if the number of characters exceeds `length`. returns: {string} Returns the pad for `string`. param: {string} string The string to create padding for. param: {number} [length=0] The padding length. param: {string} [chars=' '] The string used as padding. |
| createPartialWrapper(func, bitmask, thisArg, partials) X-Ref |
| Creates a function that wraps `func` and invokes it with the optional `this` binding of `thisArg` and the `partials` prepended to those provided to the wrapper. returns: {Function} Returns the new bound function. param: {Function} func The function to partially apply arguments to. param: {number} bitmask The bitmask of flags. See `createWrapper` for more details. param: {*} thisArg The `this` binding of `func`. param: {Array} partials The arguments to prepend to those provided to the new function. |
| wrapper() X-Ref |
| No description |
| createSortedIndex(retHighest) X-Ref |
| Creates a `_.sortedIndex` or `_.sortedLastIndex` function. returns: {Function} Returns the new index function. param: {boolean} [retHighest] Specify returning the highest qualified index. |
| createWrapper(func, bitmask, thisArg, partials, holders, argPos, ary, arity) X-Ref |
| Creates a function that either curries or invokes `func` with optional `this` binding and partially applied arguments. returns: {Function} Returns the new wrapped function. param: {Function|string} func The function or method name to reference. param: {number} bitmask The bitmask of 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`. |
| equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) X-Ref |
| A specialized version of `baseIsEqualDeep` for arrays with support for partial deep comparisons. returns: {boolean} Returns `true` if the arrays are equivalent, else `false`. param: {Array} array The array to compare. param: {Array} other The other array to compare. param: {Function} equalFunc The function to determine equivalents of values. param: {Function} [customizer] The function to customize comparing arrays. param: {boolean} [isLoose] Specify performing partial comparisons. param: {Array} [stackA] Tracks traversed `value` objects. param: {Array} [stackB] Tracks traversed `other` objects. |
| equalByTag(object, other, tag) X-Ref |
| A specialized version of `baseIsEqualDeep` for comparing objects of the same `toStringTag`. **Note:** This function only supports comparing values with tags of `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. returns: {boolean} Returns `true` if the objects are equivalent, else `false`. param: {Object} value The object to compare. param: {Object} other The other object to compare. param: {string} tag The `toStringTag` of the objects to compare. |
| equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) X-Ref |
| A specialized version of `baseIsEqualDeep` for objects with support for partial deep comparisons. returns: {boolean} Returns `true` if the objects are equivalent, else `false`. param: {Object} object The object to compare. param: {Object} other The other object to compare. param: {Function} equalFunc The function to determine equivalents of values. param: {Function} [customizer] The function to customize comparing values. param: {boolean} [isLoose] Specify performing partial comparisons. param: {Array} [stackA] Tracks traversed `value` objects. param: {Array} [stackB] Tracks traversed `other` objects. |
| extremumBy(collection, iteratee, isMin) X-Ref |
| Gets the extremum value of `collection` invoking `iteratee` for each value in `collection` to generate the criterion by which the value is ranked. The `iteratee` is invoked with three arguments: (value, index, collection). returns: {*} Returns the extremum value. param: {Array|Object|string} collection The collection to iterate over. param: {Function} iteratee The function invoked per iteration. param: {boolean} [isMin] Specify returning the minimum, instead of the |
| getCallback(func, thisArg, argCount) X-Ref |
| Gets the appropriate "callback" function. If the `_.callback` method is customized this function returns the custom method, otherwise it returns the `baseCallback` function. If arguments are provided the chosen function is invoked with them and its result is returned. returns: {Function} Returns the chosen function or its result. |
| getIndexOf(collection, target, fromIndex) X-Ref |
| Gets the appropriate "indexOf" function. If the `_.indexOf` method is customized this function returns the custom method, otherwise it returns the `baseIndexOf` function. If arguments are provided the chosen function is invoked with them and its result is returned. returns: {Function|number} Returns the chosen function or its result. |
| getView(start, end, transforms) X-Ref |
| Gets the view, applying any `transforms` to the `start` and `end` positions. returns: {Object} Returns an object containing the `start` and `end` param: {number} start The start of the view. param: {number} end The end of the view. param: {Array} [transforms] The transformations to apply to the view. |
| initCloneArray(array) X-Ref |
| Initializes an array clone. returns: {Array} Returns the initialized clone. param: {Array} array The array to clone. |
| initCloneObject(object) X-Ref |
| Initializes an object clone. returns: {Object} Returns the initialized clone. param: {Object} object The object to clone. |
| initCloneByTag(object, tag, isDeep) X-Ref |
| Initializes an object clone based on its `toStringTag`. **Note:** This function only supports cloning values with tags of `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. returns: {Object} Returns the initialized clone. param: {Object} object The object to clone. param: {string} tag The `toStringTag` of the object to clone. param: {boolean} [isDeep] Specify a deep clone. |
| invokePath(object, path, args) X-Ref |
| Invokes the method at `path` on `object`. returns: {*} Returns the result of the invoked method. param: {Object} object The object to query. param: {Array|string} path The path of the method to invoke. param: {Array} args The arguments to invoke the method with. |
| isIndex(value, length) X-Ref |
| Checks if `value` is a valid array-like index. returns: {boolean} Returns `true` if `value` is a valid index, else `false`. param: {*} value The value to check. param: {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. |
| isIterateeCall(value, index, object) X-Ref |
| Checks if the provided arguments are from an iteratee call. returns: {boolean} Returns `true` if the arguments are from an iteratee call, else `false`. param: {*} value The potential iteratee value argument. param: {*} index The potential iteratee index or key argument. param: {*} object The potential iteratee object argument. |
| isKey(value, object) X-Ref |
| Checks if `value` is a property name and not a property path. returns: {boolean} Returns `true` if `value` is a property name, else `false`. param: {*} value The value to check. param: {Object} [object] The object to query keys on. |
| isLaziable(func) X-Ref |
| Checks if `func` has a lazy counterpart. returns: {boolean} Returns `true` if `func` has a lazy counterpart, else `false`. param: {Function} func The function to check. |
| isLength(value) X-Ref |
| Checks if `value` is a valid array-like length. **Note:** This function is based on [`ToLength`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength). returns: {boolean} Returns `true` if `value` is a valid length, else `false`. param: {*} value The value to check. |
| isStrictComparable(value) X-Ref |
| Checks if `value` is suitable for strict equality comparisons, i.e. `===`. returns: {boolean} Returns `true` if `value` if suitable for strict param: {*} value The value to check. |
| mergeData(data, source) X-Ref |
| Merges the function metadata of `source` into `data`. Merging metadata reduces the number of wrappers required 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` augment function arguments, making the order in which they are executed important, preventing the merging of metadata. However, we make an exception for a safe common case where curried functions have `_.ary` and or `_.rearg` applied. returns: {Array} Returns `data`. param: {Array} data The destination metadata. param: {Array} source The source metadata. |
| pickByArray(object, props) X-Ref |
| A specialized version of `_.pick` that picks `object` properties specified by `props`. returns: {Object} Returns the new object. param: {Object} object The source object. param: {string[]} props The property names to pick. |
| pickByCallback(object, predicate) X-Ref |
| A specialized version of `_.pick` that picks `object` properties `predicate` returns truthy for. returns: {Object} Returns the new object. param: {Object} object The source object. param: {Function} predicate The function invoked per iteration. |
| reorder(array, indexes) X-Ref |
| Reorder `array` according to the specified indexes where the element at the first index is assigned as the first element, the element at the second index is assigned as the second element, and so on. returns: {Array} Returns `array`. param: {Array} array The array to reorder. param: {Array} indexes The arranged array indexes. |
| shimIsPlainObject(value) X-Ref |
| A fallback implementation of `_.isPlainObject` which checks if `value` is an object created by the `Object` constructor or has a `[[Prototype]]` of `null`. returns: {boolean} Returns `true` if `value` is a plain object, else `false`. param: {*} value The value to check. |
| shimKeys(object) X-Ref |
| A fallback implementation of `Object.keys` which creates an array of the own enumerable property names of `object`. returns: {Array} Returns the array of property names. param: {Object} object The object to query. |
| toIterable(value) X-Ref |
| Converts `value` to an array-like object if it is not one. returns: {Array|Object} Returns the array-like object. param: {*} value The value to process. |
| toObject(value) X-Ref |
| Converts `value` to an object if it is not one. returns: {Object} Returns the object. param: {*} value The value to process. |
| toPath(value) X-Ref |
| Converts `value` to property path array if it is not one. returns: {Array} Returns the property path array. param: {*} value The value to process. |
| wrapperClone(wrapper) X-Ref |
| Creates a clone of `wrapper`. returns: {Object} Returns the cloned wrapper. param: {Object} wrapper The wrapper to clone. |
| chunk(array, size, guard) X-Ref |
| Creates an array of elements split into groups the length of `size`. If `collection` can't be split evenly, the final chunk will be the remaining elements. returns: {Array} Returns the new array containing chunks. param: {Array} array The array to process. param: {number} [size=1] The length of each chunk. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| compact(array) X-Ref |
| Creates an array with all falsey values removed. The values `false`, `null`, `0`, `""`, `undefined`, and `NaN` are falsey. returns: {Array} Returns the new array of filtered values. param: {Array} array The array to compact. |
| drop(array, n, guard) X-Ref |
| Creates a slice of `array` with `n` elements dropped from the beginning. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {number} [n=1] The number of elements to drop. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| dropRight(array, n, guard) X-Ref |
| Creates a slice of `array` with `n` elements dropped from the end. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {number} [n=1] The number of elements to drop. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| dropRightWhile(array, predicate, thisArg) X-Ref |
| Creates a slice of `array` excluding elements dropped from the end. Elements are dropped until `predicate` returns falsey. The predicate is bound to `thisArg` and invoked with three arguments: (value, index, array). If a property name is provided for `predicate` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `predicate` the created `_.matches` style callback returns `true` for elements that match the properties of the given object, else `false`. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {Function|Object|string} [predicate=_.identity] The function invoked param: {*} [thisArg] The `this` binding of `predicate`. |
| dropWhile(array, predicate, thisArg) X-Ref |
| Creates a slice of `array` excluding elements dropped from the beginning. Elements are dropped until `predicate` returns falsey. The predicate is bound to `thisArg` and invoked with three arguments: (value, index, array). If a property name is provided for `predicate` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `predicate` the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {Function|Object|string} [predicate=_.identity] The function invoked param: {*} [thisArg] The `this` binding of `predicate`. |
| 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`. returns: {Array} Returns `array`. param: {Array} array The array to fill. param: {*} value The value to fill `array` with. param: {number} [start=0] The start position. param: {number} [end=array.length] The end position. |
| first(array) X-Ref |
| Gets the first element of `array`. returns: {*} Returns the first element of `array`. param: {Array} array The array to query. |
| flatten(array, isDeep, guard) X-Ref |
| Flattens a nested array. If `isDeep` is `true` the array is recursively flattened, otherwise it is only flattened a single level. returns: {Array} Returns the new flattened array. param: {Array} array The array to flatten. param: {boolean} [isDeep] Specify a deep flatten. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| flattenDeep(array) X-Ref |
| Recursively flattens a nested array. returns: {Array} Returns the new flattened array. param: {Array} array The array to recursively flatten. |
| indexOf(array, value, fromIndex) X-Ref |
| Gets the index at which the first occurrence of `value` is found in `array` using `SameValueZero` for equality comparisons. If `fromIndex` is negative, it is used as the offset from the end of `array`. If `array` is sorted providing `true` for `fromIndex` performs a faster binary search. **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero) comparisons are like strict equality comparisons, e.g. `===`, except that `NaN` matches `NaN`. returns: {number} Returns the index of the matched value, else `-1`. param: {Array} array The array to search. param: {*} value The value to search for. param: {boolean|number} [fromIndex=0] The index to search from or `true` |
| initial(array) X-Ref |
| Gets all but the last element of `array`. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. |
| intersection() X-Ref |
| Creates an array of unique values in all provided arrays using `SameValueZero` for equality comparisons. **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero) comparisons are like strict equality comparisons, e.g. `===`, except that `NaN` matches `NaN`. returns: {Array} Returns the new array of shared values. param: {...Array} [arrays] The arrays to inspect. |
| last(array) X-Ref |
| Gets the last element of `array`. returns: {*} Returns the last element of `array`. param: {Array} array The array to query. |
| lastIndexOf(array, value, fromIndex) X-Ref |
| This method is like `_.indexOf` except that it iterates over elements of `array` from right to left. returns: {number} Returns the index of the matched value, else `-1`. param: {Array} array The array to search. param: {*} value The value to search for. param: {boolean|number} [fromIndex=array.length-1] The index to search from |
| pull() X-Ref |
| Removes all provided values from `array` using `SameValueZero` for equality comparisons. **Notes:** - Unlike `_.without`, this method mutates `array` - [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero) comparisons are like strict equality comparisons, e.g. `===`, except that `NaN` matches `NaN` returns: {Array} Returns `array`. param: {Array} array The array to modify. param: {...*} [values] The values to remove. |
| remove(array, predicate, thisArg) X-Ref |
| Removes all elements from `array` that `predicate` returns truthy for and returns an array of the removed elements. The predicate is bound to `thisArg` and invoked with three arguments: (value, index, array). If a property name is provided for `predicate` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `predicate` the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. **Note:** Unlike `_.filter`, this method mutates `array`. returns: {Array} Returns the new array of removed elements. param: {Array} array The array to modify. param: {Function|Object|string} [predicate=_.identity] The function invoked param: {*} [thisArg] The `this` binding of `predicate`. |
| rest(array) X-Ref |
| Gets all but the first element of `array`. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. |
| 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` to support node lists in IE < 9 and to ensure dense arrays are returned. returns: {Array} Returns the slice of `array`. param: {Array} array The array to slice. param: {number} [start=0] The start position. param: {number} [end=array.length] The end position. |
| take(array, n, guard) X-Ref |
| Creates a slice of `array` with `n` elements taken from the beginning. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {number} [n=1] The number of elements to take. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| takeRight(array, n, guard) X-Ref |
| Creates a slice of `array` with `n` elements taken from the end. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {number} [n=1] The number of elements to take. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| takeRightWhile(array, predicate, thisArg) X-Ref |
| Creates a slice of `array` with elements taken from the end. Elements are taken until `predicate` returns falsey. The predicate is bound to `thisArg` and invoked with three arguments: (value, index, array). If a property name is provided for `predicate` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `predicate` the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {Function|Object|string} [predicate=_.identity] The function invoked param: {*} [thisArg] The `this` binding of `predicate`. |
| takeWhile(array, predicate, thisArg) X-Ref |
| Creates a slice of `array` with elements taken from the beginning. Elements are taken until `predicate` returns falsey. The predicate is bound to `thisArg` and invoked with three arguments: (value, index, array). If a property name is provided for `predicate` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `predicate` the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {Function|Object|string} [predicate=_.identity] The function invoked param: {*} [thisArg] The `this` binding of `predicate`. |
| uniq(array, isSorted, iteratee, thisArg) X-Ref |
| Creates a duplicate-free version of an array, using `SameValueZero` for equality comparisons, in which only the first occurence of each element is kept. Providing `true` for `isSorted` performs a faster search algorithm for sorted arrays. If an iteratee function is provided it is invoked for each element in the array to generate the criterion by which uniqueness is computed. The `iteratee` is bound to `thisArg` and invoked with three arguments: (value, index, array). If a property name is provided for `iteratee` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `iteratee` the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero) comparisons are like strict equality comparisons, e.g. `===`, except that `NaN` matches `NaN`. returns: {Array} Returns the new duplicate-value-free array. param: {Array} array The array to inspect. param: {boolean} [isSorted] Specify the array is sorted. param: {Function|Object|string} [iteratee] The function invoked per iteration. param: {*} [thisArg] The `this` binding of `iteratee`. |
| 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. returns: {Array} Returns the new array of regrouped elements. param: {Array} array The array of grouped elements to process. |
| xor() X-Ref |
| Creates an array that is the [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference) of the provided arrays. returns: {Array} Returns the new array of values. param: {...Array} [arrays] The arrays to inspect. |
| zipObject(props, values) X-Ref |
| The inverse of `_.pairs`; this method returns an object composed from arrays of property names and values. Provide either a single two dimensional array, e.g. `[[key1, value1], [key2, value2]]` or two arrays, one of property names and one of corresponding values. returns: {Object} Returns the new object. param: {Array} props The property names. param: {Array} [values=[]] The property values. |
| chain(value) X-Ref |
| Creates a `lodash` object that wraps `value` with explicit method chaining enabled. returns: {Object} Returns the new `lodash` wrapper instance. param: {*} value The value to wrap. |
| tap(value, interceptor, thisArg) X-Ref |
| This method invokes `interceptor` and returns `value`. The interceptor is bound to `thisArg` and invoked with one argument; (value). The purpose of this method is to "tap into" a method chain in order to perform operations on intermediate results within the chain. returns: {*} Returns `value`. param: {*} value The value to provide to `interceptor`. param: {Function} interceptor The function to invoke. param: {*} [thisArg] The `this` binding of `interceptor`. |
| thru(value, interceptor, thisArg) X-Ref |
| This method is like `_.tap` except that it returns the result of `interceptor`. returns: {*} Returns the result of `interceptor`. param: {*} value The value to provide to `interceptor`. param: {Function} interceptor The function to invoke. param: {*} [thisArg] The `this` binding of `interceptor`. |
| wrapperChain() X-Ref |
| Enables explicit method chaining on the wrapper object. returns: {Object} Returns the new `lodash` wrapper instance. |
| wrapperCommit() X-Ref |
| Executes the chained sequence and returns the wrapped result. returns: {Object} Returns the new `lodash` wrapper instance. |
| wrapperPlant(value) X-Ref |
| Creates a clone of the chained sequence planting `value` as the wrapped value. returns: {Object} Returns the new `lodash` wrapper instance. |
| wrapperReverse() X-Ref |
| Reverses the wrapped array so the first element becomes the last, the second element becomes the second to last, and so on. **Note:** This method mutates the wrapped array. returns: {Object} Returns the new reversed `lodash` wrapper instance. |
| wrapperToString() X-Ref |
| Produces the result of coercing the unwrapped value to a string. returns: {string} Returns the coerced string value. |
| wrapperValue() X-Ref |
| Executes the chained sequence to extract the unwrapped value. returns: {*} Returns the resolved unwrapped value. |
| every(collection, predicate, thisArg) X-Ref |
| Checks if `predicate` returns truthy for **all** elements of `collection`. The predicate is bound to `thisArg` and invoked with three arguments: (value, index|key, collection). If a property name is provided for `predicate` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `predicate` the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. returns: {boolean} Returns `true` if all elements pass the predicate check, param: {Array|Object|string} collection The collection to iterate over. param: {Function|Object|string} [predicate=_.identity] The function invoked param: {*} [thisArg] The `this` binding of `predicate`. |
| filter(collection, predicate, thisArg) X-Ref |
| Iterates over elements of `collection`, returning an array of all elements `predicate` returns truthy for. The predicate is bound to `thisArg` and invoked with three arguments: (value, index|key, collection). If a property name is provided for `predicate` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `predicate` the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. returns: {Array} Returns the new filtered array. param: {Array|Object|string} collection The collection to iterate over. param: {Function|Object|string} [predicate=_.identity] The function invoked param: {*} [thisArg] The `this` binding of `predicate`. |
| findWhere(collection, source) X-Ref |
| Performs a deep comparison between each element in `collection` and the source object, returning the first element that has equivalent property values. **Note:** This method supports comparing arrays, booleans, `Date` objects, numbers, `Object` objects, regexes, and strings. Objects are compared by their own, not inherited, enumerable properties. For comparing a single own or inherited property value see `_.matchesProperty`. returns: {*} Returns the matched element, else `undefined`. param: {Array|Object|string} collection The collection to search. param: {Object} source The object of property values to match. |
| includes(collection, target, fromIndex, guard) X-Ref |
| Checks if `value` is in `collection` using `SameValueZero` for equality comparisons. If `fromIndex` is negative, it is used as the offset from the end of `collection`. **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero) comparisons are like strict equality comparisons, e.g. `===`, except that `NaN` matches `NaN`. returns: {boolean} Returns `true` if a matching element is found, else `false`. param: {Array|Object|string} collection The collection to search. param: {*} target The value to search for. param: {number} [fromIndex=0] The index to search from. param: - {Object} [guard] Enables use as a callback for functions like `_.reduce`. |
| map(collection, iteratee, thisArg) X-Ref |
| Creates an array of values by running each element in `collection` through `iteratee`. The `iteratee` is bound to `thisArg` and invoked with three arguments: (value, index|key, collection). If a property name is provided for `iteratee` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `iteratee` the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. Many lodash methods are guarded to work as interatees for methods like `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. The guarded methods are: `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`, `parseInt`, `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`, `trimLeft`, `trimRight`, `trunc`, `random`, `range`, `sample`, `some`, `uniq`, and `words` returns: {Array} Returns the new mapped array. param: {Array|Object|string} collection The collection to iterate over. param: {Function|Object|string} [iteratee=_.identity] The function invoked param: {*} [thisArg] The `this` binding of `iteratee`. |
| pluck(collection, path) X-Ref |
| Gets the property value of `path` from all elements in `collection`. returns: {Array} Returns the property values. param: {Array|Object|string} collection The collection to iterate over. param: {Array|string} path The path of the property to pluck. |
| reject(collection, predicate, thisArg) X-Ref |
| The opposite of `_.filter`; this method returns the elements of `collection` that `predicate` does **not** return truthy for. If a property name is provided for `predicate` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `predicate` the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. returns: {Array} Returns the new filtered array. param: {Array|Object|string} collection The collection to iterate over. param: {Function|Object|string} [predicate=_.identity] The function invoked param: {*} [thisArg] The `this` binding of `predicate`. |
| sample(collection, n, guard) X-Ref |
| Gets a random element or `n` random elements from a collection. returns: {*} Returns the random sample(s). param: {Array|Object|string} collection The collection to sample. param: {number} [n] The number of elements to sample. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| shuffle(collection) X-Ref |
| Creates an array of shuffled values, using a version of the [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle). returns: {Array} Returns the new shuffled array. param: {Array|Object|string} collection The collection to shuffle. |
| size(collection) X-Ref |
| Gets the size of `collection` by returning its length for array-like values or the number of own enumerable properties for objects. returns: {number} Returns the size of `collection`. param: {Array|Object|string} collection The collection to inspect. |
| some(collection, predicate, thisArg) X-Ref |
| Checks if `predicate` returns truthy for **any** element of `collection`. The function returns as soon as it finds a passing value and does not iterate over the entire collection. The predicate is bound to `thisArg` and invoked with three arguments: (value, index|key, collection). If a property name is provided for `predicate` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `predicate` the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. returns: {boolean} Returns `true` if any element passes the predicate check, param: {Array|Object|string} collection The collection to iterate over. param: {Function|Object|string} [predicate=_.identity] The function invoked param: {*} [thisArg] The `this` binding of `predicate`. |
| sortBy(collection, iteratee, thisArg) X-Ref |
| Creates an array of elements, sorted in ascending order by the results of running each element in a collection through `iteratee`. This method performs a stable sort, that is, it preserves the original sort order of equal elements. The `iteratee` is bound to `thisArg` and invoked with three arguments: (value, index|key, collection). If a property name is provided for `iteratee` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `iteratee` the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. returns: {Array} Returns the new sorted array. param: {Array|Object|string} collection The collection to iterate over. param: {Function|Object|string} [iteratee=_.identity] The function invoked param: {*} [thisArg] The `this` binding of `iteratee`. |
| sortByOrder(collection, iteratees, orders, guard) X-Ref |
| This method is like `_.sortByAll` except that it allows specifying the sort orders of the iteratees to sort by. A truthy value in `orders` will sort the corresponding property name in ascending order while a falsey value will sort it in descending order. If a property name is provided for an iteratee the created `_.property` style callback returns the property value of the given element. If an object is provided for an iteratee the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. returns: {Array} Returns the new sorted array. param: {Array|Object|string} collection The collection to iterate over. param: {Function[]|Object[]|string[]} iteratees The iteratees to sort by. param: {boolean[]} orders The sort orders of `iteratees`. param: - {Object} [guard] Enables use as a callback for functions like `_.reduce`. |
| where(collection, source) X-Ref |
| Performs a deep comparison between each element in `collection` and the source object, returning an array of all elements that have equivalent property values. **Note:** This method supports comparing arrays, booleans, `Date` objects, numbers, `Object` objects, regexes, and strings. Objects are compared by their own, not inherited, enumerable properties. For comparing a single own or inherited property value see `_.matchesProperty`. returns: {Array} Returns the new filtered array. param: {Array|Object|string} collection The collection to search. param: {Object} source The object of property values to match. |
| after(n, func) X-Ref |
| The opposite of `_.before`; this method creates a function that invokes `func` once it is called `n` or more times. returns: {Function} Returns the new restricted function. param: {number} n The number of calls before `func` is invoked. param: {Function} func The function to restrict. |
| ary(func, n, guard) X-Ref |
| Creates a function that accepts up to `n` arguments ignoring any additional arguments. returns: {Function} Returns the new function. param: {Function} func The function to cap arguments for. param: {number} [n=func.length] The arity cap. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| before(n, func) X-Ref |
| Creates a function that invokes `func`, with the `this` binding and arguments of the created function, while it is called less than `n` times. Subsequent calls to the created function return the result of the last `func` invocation. returns: {Function} Returns the new restricted function. param: {number} n The number of calls at which `func` is no longer invoked. param: {Function} func The function to restrict. |
| debounce(func, wait, options) X-Ref |
| Creates a function that delays invoking `func` until after `wait` milliseconds have elapsed since the last time it was invoked. The created function comes with a `cancel` method to cancel delayed invocations. Provide an options object to indicate that `func` should be invoked on the leading and/or trailing edge of the `wait` timeout. 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 the debounced function is invoked more than once during the `wait` timeout. See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation) for details over the differences between `_.debounce` and `_.throttle`. returns: {Function} Returns the new debounced function. param: {Function} func The function to debounce. param: {number} [wait=0] The number of milliseconds to delay. param: {Object} [options] The options object. param: {boolean} [options.leading=false] Specify invoking on the leading param: {number} [options.maxWait] The maximum time `func` is allowed to be param: {boolean} [options.trailing=true] Specify invoking on the trailing |
| cancel() X-Ref |
| No description |
| delayed() X-Ref |
| No description |
| maxDelayed() X-Ref |
| No description |
| debounced() X-Ref |
| No description |
| 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 coerced to a string and used as the 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`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-properties-of-the-map-prototype-object) method interface of `get`, `has`, and `set`. returns: {Function} Returns the new memoizing function. param: {Function} func The function to have its output memoized. param: {Function} [resolver] The function to resolve the cache key. |
| negate(predicate) X-Ref |
| Creates a function that negates the result of the predicate `func`. The `func` predicate is invoked with the `this` binding and arguments of the created function. returns: {Function} Returns the new function. param: {Function} predicate The predicate to negate. |
| once(func) X-Ref |
| Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first call. The `func` is invoked with the `this` binding and arguments of the created function. returns: {Function} Returns the new restricted function. param: {Function} func The function to restrict. |
| restParam(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://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters). returns: {Function} Returns the new function. param: {Function} func The function to apply a rest parameter to. param: {number} [start=func.length-1] The start position of the rest parameter. |
| spread(func) X-Ref |
| Creates a function that invokes `func` with the `this` binding of the created function and an array of arguments much like [`Function#apply`](https://es5.github.io/#x15.3.4.3). **Note:** This method is based on the [spread operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator). returns: {Function} Returns the new function. param: {Function} func The function to spread arguments over. |
| throttle(func, wait, options) X-Ref |
| Creates a function that only invokes `func` at most once per every `wait` milliseconds. The created function comes with a `cancel` method to cancel delayed invocations. Provide an options object to indicate that `func` should be invoked on the leading and/or trailing edge of the `wait` timeout. Subsequent calls to the throttled function return the result of the last `func` call. **Note:** If `leading` and `trailing` options are `true`, `func` is invoked on the trailing edge of the timeout only if the the throttled function is invoked more than once during the `wait` timeout. See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation) for details over the differences between `_.throttle` and `_.debounce`. returns: {Function} Returns the new throttled function. param: {Function} func The function to throttle. param: {number} [wait=0] The number of milliseconds to throttle invocations to. param: {Object} [options] The options object. param: {boolean} [options.leading=true] Specify invoking on the leading param: {boolean} [options.trailing=true] Specify invoking on the trailing |
| wrap(value, wrapper) X-Ref |
| Creates a function that provides `value` to the wrapper function as its first argument. Any additional arguments provided to the function are appended to those provided to the wrapper function. The wrapper is invoked with the `this` binding of the created function. returns: {Function} Returns the new function. param: {*} value The value to wrap. param: {Function} wrapper The wrapper function. |
| clone(value, isDeep, customizer, thisArg) X-Ref |
| Creates a clone of `value`. If `isDeep` is `true` nested objects are cloned, otherwise they are assigned by reference. If `customizer` is provided it is invoked to produce the cloned values. If `customizer` returns `undefined` cloning is handled by the method instead. The `customizer` is bound to `thisArg` and invoked with two argument; (value [, index|key, object]). **Note:** This method is loosely based on the [structured clone algorithm](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm). The enumerable properties of `arguments` objects and objects created by constructors other than `Object` are cloned to plain `Object` objects. An empty object is returned for uncloneable values such as functions, DOM nodes, Maps, Sets, and WeakMaps. returns: {*} Returns the cloned value. param: {*} value The value to clone. param: {boolean} [isDeep] Specify a deep clone. param: {Function} [customizer] The function to customize cloning values. param: {*} [thisArg] The `this` binding of `customizer`. |
| cloneDeep(value, customizer, thisArg) X-Ref |
| Creates a deep clone of `value`. If `customizer` is provided it is invoked to produce the cloned values. If `customizer` returns `undefined` cloning is handled by the method instead. The `customizer` is bound to `thisArg` and invoked with two argument; (value [, index|key, object]). **Note:** This method is loosely based on the [structured clone algorithm](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm). The enumerable properties of `arguments` objects and objects created by constructors other than `Object` are cloned to plain `Object` objects. An empty object is returned for uncloneable values such as functions, DOM nodes, Maps, Sets, and WeakMaps. returns: {*} Returns the deep cloned value. param: {*} value The value to deep clone. param: {Function} [customizer] The function to customize cloning values. param: {*} [thisArg] The `this` binding of `customizer`. |
| isArguments(value) X-Ref |
| Checks if `value` is classified as an `arguments` object. returns: {boolean} Returns `true` if `value` is correctly classified, else `false`. param: {*} value The value to check. |
| isBoolean(value) X-Ref |
| Checks if `value` is classified as a boolean primitive or object. returns: {boolean} Returns `true` if `value` is correctly classified, else `false`. param: {*} value The value to check. |
| isDate(value) X-Ref |
| Checks if `value` is classified as a `Date` object. returns: {boolean} Returns `true` if `value` is correctly classified, else `false`. param: {*} value The value to check. |
| isElement(value) X-Ref |
| Checks if `value` is a DOM element. returns: {boolean} Returns `true` if `value` is a DOM element, else `false`. param: {*} value The value to check. |
| isEmpty(value) X-Ref |
| Checks if `value` is empty. A value is considered empty unless it is an `arguments` object, array, string, or jQuery-like collection with a length greater than `0` or an object with own enumerable properties. returns: {boolean} Returns `true` if `value` is empty, else `false`. param: {Array|Object|string} value The value to inspect. |
| isEqual(value, other, customizer, thisArg) X-Ref |
| Performs a deep comparison between two values to determine if they are equivalent. If `customizer` is provided it is invoked to compare values. If `customizer` returns `undefined` comparisons are handled by the method instead. The `customizer` is bound to `thisArg` and invoked with three arguments: (value, other [, index|key]). **Note:** This method supports comparing arrays, booleans, `Date` objects, numbers, `Object` objects, regexes, and strings. Objects are compared by their own, not inherited, enumerable properties. Functions and DOM nodes are **not** supported. Provide a customizer function to extend support for comparing other values. returns: {boolean} Returns `true` if the values are equivalent, else `false`. param: {*} value The value to compare. param: {*} other The other value to compare. param: {Function} [customizer] The function to customize value comparisons. param: {*} [thisArg] The `this` binding of `customizer`. |
| isError(value) X-Ref |
| Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, `SyntaxError`, `TypeError`, or `URIError` object. returns: {boolean} Returns `true` if `value` is an error object, else `false`. param: {*} value The value to check. |
| isObject(value) X-Ref |
| Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) returns: {boolean} Returns `true` if `value` is an object, else `false`. param: {*} value The value to check. |
| isMatch(object, source, customizer, thisArg) X-Ref |
| Performs a deep comparison between `object` and `source` to determine if `object` contains equivalent property values. If `customizer` is provided it is invoked to compare values. If `customizer` returns `undefined` comparisons are handled by the method instead. The `customizer` is bound to `thisArg` and invoked with three arguments: (value, other, index|key). **Note:** This method supports comparing properties of arrays, booleans, `Date` objects, numbers, `Object` objects, regexes, and strings. Functions and DOM nodes are **not** supported. Provide a customizer function to extend support for comparing other values. returns: {boolean} Returns `true` if `object` is a match, else `false`. param: {Object} object The object to inspect. param: {Object} source The object of property values to match. param: {Function} [customizer] The function to customize value comparisons. param: {*} [thisArg] The `this` binding of `customizer`. |
| isNaN(value) X-Ref |
| Checks if `value` is `NaN`. **Note:** This method is not the same as [`isNaN`](https://es5.github.io/#x15.1.2.4) which returns `true` for `undefined` and other non-numeric values. returns: {boolean} Returns `true` if `value` is `NaN`, else `false`. param: {*} value The value to check. |
| isNative(value) X-Ref |
| Checks if `value` is a native function. returns: {boolean} Returns `true` if `value` is a native function, else `false`. param: {*} value The value to check. |
| isNull(value) X-Ref |
| Checks if `value` is `null`. returns: {boolean} Returns `true` if `value` is `null`, else `false`. param: {*} value The value to check. |
| isNumber(value) X-Ref |
| Checks if `value` is classified as a `Number` primitive or object. **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are classified as numbers, use the `_.isFinite` method. returns: {boolean} Returns `true` if `value` is correctly classified, else `false`. param: {*} value The value to check. |
| isRegExp(value) X-Ref |
| Checks if `value` is classified as a `RegExp` object. returns: {boolean} Returns `true` if `value` is correctly classified, else `false`. param: {*} value The value to check. |
| isString(value) X-Ref |
| Checks if `value` is classified as a `String` primitive or object. returns: {boolean} Returns `true` if `value` is correctly classified, else `false`. param: {*} value The value to check. |
| isTypedArray(value) X-Ref |
| Checks if `value` is classified as a typed array. returns: {boolean} Returns `true` if `value` is correctly classified, else `false`. param: {*} value The value to check. |
| isUndefined(value) X-Ref |
| Checks if `value` is `undefined`. returns: {boolean} Returns `true` if `value` is `undefined`, else `false`. param: {*} value The value to check. |
| toArray(value) X-Ref |
| Converts `value` to an array. returns: {Array} Returns the converted array. param: {*} value The value to convert. |
| toPlainObject(value) X-Ref |
| Converts `value` to a plain object flattening inherited enumerable properties of `value` to own properties of the plain object. returns: {Object} Returns the converted plain object. param: {*} value The value to convert. |
| create(prototype, properties, guard) X-Ref |
| Creates an object that inherits from the given `prototype` object. If a `properties` object is provided its own enumerable properties are assigned to the created object. returns: {Object} Returns the new object. param: {Object} prototype The object to inherit from. param: {Object} [properties] The properties to assign to the object. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| functions(object) X-Ref |
| Creates an array of function property names from all enumerable properties, own and inherited, of `object`. returns: {Array} Returns the new array of property names. param: {Object} object The object to inspect. |
| get(object, path, defaultValue) X-Ref |
| Gets the property value of `path` on `object`. If the resolved value is `undefined` the `defaultValue` is used in its place. returns: {*} Returns the resolved value. param: {Object} object The object to query. param: {Array|string} path The path of the property to get. param: {*} [defaultValue] The value returned if the resolved value is `undefined`. |
| has(object, path) X-Ref |
| Checks if `path` is a direct property. returns: {boolean} Returns `true` if `path` is a direct property, else `false`. param: {Object} object The object to query. param: {Array|string} path The path to check. |
| invert(object, multiValue, guard) X-Ref |
| Creates an object composed of the inverted keys and values of `object`. If `object` contains duplicate values, subsequent values overwrite property assignments of previous values unless `multiValue` is `true`. returns: {Object} Returns the new inverted object. param: {Object} object The object to invert. param: {boolean} [multiValue] Allow multiple values per key. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| 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. returns: {Array} Returns the array of property names. param: {Object} object The object to query. |
| mapValues(object, iteratee, thisArg) X-Ref |
| Creates an object with the same keys as `object` and values generated by running each own enumerable property of `object` through `iteratee`. The iteratee function is bound to `thisArg` and invoked with three arguments: (value, key, object). If a property name is provided for `iteratee` the created `_.property` style callback returns the property value of the given element. If a value is also provided for `thisArg` the created `_.matchesProperty` style callback returns `true` for elements that have a matching property value, else `false`. If an object is provided for `iteratee` the created `_.matches` style callback returns `true` for elements that have the properties of the given object, else `false`. returns: {Object} Returns the new mapped object. param: {Object} object The object to iterate over. param: {Function|Object|string} [iteratee=_.identity] The function invoked param: {*} [thisArg] The `this` binding of `iteratee`. |
| pairs(object) X-Ref |
| Creates a two dimensional array of the key-value pairs for `object`, e.g. `[[key1, value1], [key2, value2]]`. returns: {Array} Returns the new array of key-value pairs. param: {Object} object The object to query. |
| result(object, path, defaultValue) X-Ref |
| This method is like `_.get` except that if the resolved value is a function it is invoked with the `this` binding of its parent object and its result is returned. returns: {*} Returns the resolved value. param: {Object} object The object to query. param: {Array|string} path The path of the property to resolve. param: {*} [defaultValue] The value returned if the resolved value is `undefined`. |
| set(object, path, value) X-Ref |
| Sets the property value of `path` on `object`. If a portion of `path` does not exist it is created. returns: {Object} Returns `object`. param: {Object} object The object to augment. param: {Array|string} path The path of the property to set. param: {*} value The value to set. |
| transform(object, iteratee, accumulator, thisArg) 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 properties through `iteratee`, with each invocation potentially mutating the `accumulator` object. The `iteratee` is bound to `thisArg` and invoked with four arguments: (accumulator, value, key, object). Iteratee functions may exit iteration early by explicitly returning `false`. returns: {*} Returns the accumulated value. param: {Array|Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. param: {*} [accumulator] The custom accumulator value. param: {*} [thisArg] The `this` binding of `iteratee`. |
| values(object) X-Ref |
| Creates an array of the own enumerable property values of `object`. **Note:** Non-object values are coerced to objects. returns: {Array} Returns the array of property values. param: {Object} object The object to query. |
| valuesIn(object) X-Ref |
| Creates an array of the own and inherited enumerable property values of `object`. **Note:** Non-object values are coerced to objects. returns: {Array} Returns the array of property values. param: {Object} object The object to query. |
| inRange(value, start, end) X-Ref |
| Checks if `n` is between `start` and up to but not including, `end`. If `end` is not specified it is set to `start` with `start` then set to `0`. returns: {boolean} Returns `true` if `n` is in the range, else `false`. param: {number} n The number to check. param: {number} [start=0] The start of the range. param: {number} end The end of the range. |
| random(min, max, floating) X-Ref |
| Produces a random number between `min` and `max` (inclusive). If only one argument is provided a number between `0` and the given number is returned. If `floating` is `true`, or either `min` or `max` are floats, a floating-point number is returned instead of an integer. returns: {number} Returns the random number. param: {number} [min=0] The minimum possible value. param: {number} [max=1] The maximum possible value. param: {boolean} [floating] Specify returning a floating-point number. |
| capitalize(string) X-Ref |
| Capitalizes the first character of `string`. returns: {string} Returns the capitalized string. param: {string} [string=''] The string to capitalize. |
| deburr(string) X-Ref |
| Deburrs `string` by converting [latin-1 supplementary letters](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table) to basic latin letters and removing [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). returns: {string} Returns the deburred string. param: {string} [string=''] The string to deburr. |
| endsWith(string, target, position) X-Ref |
| Checks if `string` ends with the given target string. returns: {boolean} Returns `true` if `string` ends with `target`, else `false`. param: {string} [string=''] The string to search. param: {string} [target] The string to search for. param: {number} [position=string.length] The position to search from. |
| 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 require 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. Backticks are escaped because in Internet Explorer < 9, they can break out of attribute values or HTML comments. See [#59](https://html5sec.org/#59), [#102](https://html5sec.org/#102), [#108](https://html5sec.org/#108), and [#133](https://html5sec.org/#133) of the [HTML5 Security Cheatsheet](https://html5sec.org/) for more details. When working with HTML you should always [quote attribute values](http://wonko.com/post/html-escaping) to reduce XSS vectors. returns: {string} Returns the escaped string. param: {string} [string=''] The string to escape. |
| escapeRegExp(string) X-Ref |
| Escapes the `RegExp` special characters "\", "/", "^", "$", ".", "|", "?", "*", "+", "(", ")", "[", "]", "{" and "}" in `string`. returns: {string} Returns the escaped string. param: {string} [string=''] The string to escape. |
| pad(string, length, chars) X-Ref |
| Pads `string` on the left and right sides if it is shorter than `length`. Padding characters are truncated if they can't be evenly divided by `length`. returns: {string} Returns the padded string. param: {string} [string=''] The string to pad. param: {number} [length=0] The padding length. param: {string} [chars=' '] The string used as padding. |
| parseInt(string, radix, guard) X-Ref |
| Converts `string` to an integer of the specified radix. If `radix` is `undefined` or `0`, a `radix` of `10` is used unless `value` is a hexadecimal, in which case a `radix` of `16` is used. **Note:** This method aligns with the [ES5 implementation](https://es5.github.io/#E) of `parseInt`. returns: {number} Returns the converted integer. param: {string} string The string to convert. param: {number} [radix] The radix to interpret `value` by. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| repeat(string, n) X-Ref |
| Repeats the given string `n` times. returns: {string} Returns the repeated string. param: {string} [string=''] The string to repeat. param: {number} [n=0] The number of times to repeat the string. |
| startsWith(string, target, position) X-Ref |
| Checks if `string` starts with the given target string. returns: {boolean} Returns `true` if `string` starts with `target`, else `false`. param: {string} [string=''] The string to search. param: {string} [target] The string to search for. param: {number} [position=0] The position to search from. |
| template(string, options, otherOptions) 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 provided 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). returns: {Function} Returns the compiled template function. param: {string} [string=''] The template string. param: {Object} [options] The options object. param: {RegExp} [options.escape] The HTML "escape" delimiter. param: {RegExp} [options.evaluate] The "evaluate" delimiter. param: {Object} [options.imports] An object to import into the template as free variables. param: {RegExp} [options.interpolate] The "interpolate" delimiter. param: {string} [options.sourceURL] The sourceURL of the template's compiled source. param: {string} [options.variable] The data object variable name. param: - {Object} [otherOptions] Enables the legacy `options` param signature. |
| trim(string, chars, guard) X-Ref |
| Removes leading and trailing whitespace or specified characters from `string`. returns: {string} Returns the trimmed string. param: {string} [string=''] The string to trim. param: {string} [chars=whitespace] The characters to trim. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| trimLeft(string, chars, guard) X-Ref |
| Removes leading whitespace or specified characters from `string`. returns: {string} Returns the trimmed string. param: {string} [string=''] The string to trim. param: {string} [chars=whitespace] The characters to trim. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| trimRight(string, chars, guard) X-Ref |
| Removes trailing whitespace or specified characters from `string`. returns: {string} Returns the trimmed string. param: {string} [string=''] The string to trim. param: {string} [chars=whitespace] The characters to trim. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| trunc(string, options, guard) X-Ref |
| Truncates `string` if it is longer than the given maximum string length. The last characters of the truncated string are replaced with the omission string which defaults to "...". returns: {string} Returns the truncated string. param: {string} [string=''] The string to truncate. param: {Object|number} [options] The options object or maximum string length. 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. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| unescape(string) X-Ref |
| The inverse of `_.escape`; this method converts the HTML entities `&`, `<`, `>`, `"`, `'`, and ``` 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). returns: {string} Returns the unescaped string. param: {string} [string=''] The string to unescape. |
| words(string, pattern, guard) X-Ref |
| Splits `string` into an array of its words. returns: {Array} Returns the words of `string`. param: {string} [string=''] The string to inspect. param: {RegExp|string} [pattern] The pattern to match words. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| callback(func, thisArg, guard) X-Ref |
| Creates a function that invokes `func` with the `this` binding of `thisArg` and arguments of the created function. If `func` is a property name the created callback returns the property value for a given element. If `func` is an object the created callback returns `true` for elements that contain the equivalent object properties, otherwise it returns `false`. returns: {Function} Returns the callback. param: {*} [func=_.identity] The value to convert to a callback. param: {*} [thisArg] The `this` binding of `func`. param: - {Object} [guard] Enables use as a callback for functions like `_.map`. |
| constant(value) X-Ref |
| Creates a function that returns `value`. returns: {Function} Returns the new function. param: {*} value The value to return from the new function. |
| identity(value) X-Ref |
| This method returns the first argument provided to it. returns: {*} Returns `value`. param: {*} value Any value. |
| matches(source) X-Ref |
| Creates a function which performs a deep comparison between a given object and `source`, returning `true` if the given object has equivalent property values, else `false`. **Note:** This method supports comparing arrays, booleans, `Date` objects, numbers, `Object` objects, regexes, and strings. Objects are compared by their own, not inherited, enumerable properties. For comparing a single own or inherited property value see `_.matchesProperty`. returns: {Function} Returns the new function. param: {Object} source The object of property values to match. |
| matchesProperty(path, value) X-Ref |
| Creates a function which compares the property value of `path` on a given object to `value`. **Note:** This method supports comparing arrays, booleans, `Date` objects, numbers, `Object` objects, regexes, and strings. Objects are compared by their own, not inherited, enumerable properties. returns: {Function} Returns the new function. param: {Array|string} path The path of the property to get. param: {*} value The value to compare. |
| mixin(object, source, options) X-Ref |
| Adds all own enumerable 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. returns: {Function|Object} Returns `object`. param: {Function|Object} [object=lodash] The destination object. param: {Object} source The object of functions to add. param: {Object} [options] The options object. param: {boolean} [options.chain=true] Specify whether the functions added |
| 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 |
| A no-operation function which returns `undefined` regardless of the arguments it receives. |
| property(path) X-Ref |
| Creates a function which returns the property value at `path` on a given object. returns: {Function} Returns the new function. param: {Array|string} path The path of the property to get. |
| propertyOf(object) X-Ref |
| The opposite of `_.property`; this method creates a function which returns the property value at a given path on `object`. returns: {Function} Returns the new function. param: {Object} object The object to query. |
| range(start, end, step) X-Ref |
| Creates an array of numbers (positive and/or negative) progressing from `start` up to, but not including, `end`. If `end` is not specified it is set to `start` with `start` then set to `0`. If `end` is less than `start` a zero-length range is created unless a negative `step` is specified. returns: {Array} Returns the new array of numbers. param: {number} [start=0] The start of the range. param: {number} end The end of the range. param: {number} [step=1] The value to increment or decrement by. |
| times(n, iteratee, thisArg) X-Ref |
| Invokes the iteratee function `n` times, returning an array of the results of each invocation. The `iteratee` is bound to `thisArg` and invoked with one argument; (index). returns: {Array} Returns the array of results. param: {number} n The number of times to invoke `iteratee`. param: {Function} [iteratee=_.identity] The function invoked per iteration. param: {*} [thisArg] The `this` binding of `iteratee`. |
| uniqueId(prefix) X-Ref |
| Generates a unique ID. If `prefix` is provided the ID is appended to it. returns: {string} Returns the unique ID. param: {string} [prefix] The value to prefix the ID with. |
| add(augend, addend) X-Ref |
| Adds two numbers. returns: {number} Returns the sum. param: {number} augend The first number to add. param: {number} addend The second number to add. |
| sum(collection, iteratee, thisArg) X-Ref |
| Gets the sum of the values in `collection`. returns: {number} Returns the sum. param: {Array|Object|string} collection The collection to iterate over. param: {Function|Object|string} [iteratee] The function invoked per iteration. param: {*} [thisArg] The `this` binding of `iteratee`. |
| isHex(str) X-Ref |
| No description |
| isHexDigit(str) X-Ref |
| No description |
| asyncTrigger() X-Ref |
| No description |
| Lexer(source) X-Ref |
| No description |
| commentToken(label, body, opt) X-Ref |
| No description |
| isNonAsciiIdentifierStart(code) X-Ref |
| No description |
| isNonAsciiIdentifierPart(code) X-Ref |
| No description |
| removeEscapeSequences(id) X-Ref |
| No description |
| isDecimalDigit(str) X-Ref |
| No description |
| isOctalDigit(str) X-Ref |
| No description |
| isBinaryDigit(str) X-Ref |
| No description |
| isIdentifierStart(ch) X-Ref |
| No description |
| isReserved(token, isProperty) X-Ref |
| No description |
| NameStack() X-Ref |
| No description |
| _newScope(type) X-Ref |
| No description |
| warning(code, token) X-Ref |
| No description |
| error(code, token) X-Ref |
| No description |
| _setupUsages(labelName) X-Ref |
| No description |
| _checkForUnused() X-Ref |
| Checks the current scope for unused identifiers |
| _checkParams() X-Ref |
| Checks the current scope for unused parameters Must be called in a function parameter scope |
| _getLabel(labelName) X-Ref |
| Finds the relevant label's scope, searching from nearest outwards returns: {Object} the scope the label was found in |
| usedSoFarInCurrentFunction(labelName) X-Ref |
| No description |
| _checkOuterShadow(labelName, token) X-Ref |
| No description |
| _latedefWarning(type, labelName, token) X-Ref |
| No description |
| checkOption(name, t) X-Ref |
| No description |
| isString(obj) X-Ref |
| No description |
| isIdentifier(tkn, value) X-Ref |
| No description |
| isReserved(token) X-Ref |
| No description |
| supplant(str, data) X-Ref |
| No description |
| combine(dest, src) X-Ref |
| No description |
| processenforceall() X-Ref |
| No description |
| applyOptions() X-Ref |
| Apply all linting options according to the status of the `state` object. |
| quit(code, token, a, b) X-Ref |
| No description |
| removeIgnoredMessages() X-Ref |
| No description |
| warning(code, t, a, b, c, d) X-Ref |
| No description |
| warningAt(m, l, ch, a, b, c, d) X-Ref |
| No description |
| error(m, t, a, b, c, d) X-Ref |
| No description |
| errorAt(m, l, ch, a, b, c, d) X-Ref |
| No description |
| addEvalCode(elem, token) X-Ref |
| No description |
| lintingDirective(directiveToken, previous) X-Ref |
| Process an inline linting directive param: {Token} directiveToken - the directive-bearing comment token param: {Token} previous - the token that preceeds the directive |
| peek(p) X-Ref |
| Return a token beyond the token available in `state.tokens.next`. If no such token exists, return the "(end)" token. This function is used to determine parsing strategies in cases where the value of the next token does not provide sufficient information, as is the case with `for` loops, e.g.: for ( var i in ... versus: for ( var i = ... returns: {token} param: {number} [p] - offset of desired token; defaults to 0 |
| peekIgnoreEOL() X-Ref |
| No description |
| advance(id, t) X-Ref |
| No description |
| isOperator(token) X-Ref |
| Determine whether a given token is an operator. returns: {boolean} param: {token} token |
| isEndOfExpr(curr, next) X-Ref |
| No description |
| expression(rbp, initial) X-Ref |
| No description |
| startLine(token) X-Ref |
| No description |
| nobreaknonadjacent(left, right) X-Ref |
| No description |
| nolinebreak(t) X-Ref |
| No description |
| nobreakcomma(left, right) X-Ref |
| No description |
| parseComma(opts) X-Ref |
| No description |
| symbol(s, p) X-Ref |
| No description |
| delim(s) X-Ref |
| No description |
| stmt(s, f) X-Ref |
| No description |
| blockstmt(s, f) X-Ref |
| No description |
| reserveName(x) X-Ref |
| No description |
| prefix(s, f) X-Ref |
| No description |
| type(s, f) X-Ref |
| No description |
| reserve(name, func) X-Ref |
| No description |
| FutureReservedWord(name, meta) X-Ref |
| No description |
| reservevar(s, v) X-Ref |
| No description |
| infix(s, f, p, w) X-Ref |
| No description |
| application(s) X-Ref |
| No description |
| relation(s, f) X-Ref |
| No description |
| isTypoTypeof(left, right, state) X-Ref |
| No description |
| isGlobalEval(left, state) X-Ref |
| No description |
| findNativePrototype(left) X-Ref |
| No description |
| walkPrototype(obj) X-Ref |
| No description |
| walkNative(obj) X-Ref |
| No description |
| checkLeftSideAssign(left, assignToken, options) X-Ref |
| Checks the left hand side of an assignment for issues, returns if ok returns: {boolean} Whether the left hand side is OK param: {token} left - the left hand side of the assignment param: {token=} assignToken - the token for the assignment, used for reporting param: {object=} options - optional object param: {boolean} options.allowDestructuring - whether to allow destructuting binding |
| assignop(s, f, p) X-Ref |
| No description |
| bitwise(s, f, p) X-Ref |
| No description |
| bitwiseassignop(s) X-Ref |
| No description |
| suffix(s) X-Ref |
| No description |
| optionalidentifier(fnparam, prop, preserve) X-Ref |
| No description |
| identifier(fnparam, prop) X-Ref |
| No description |
| reachable(controlToken) X-Ref |
| No description |
| parseFinalSemicolon(stmt) X-Ref |
| Consume the semicolon that delimits the statement currently being parsed, emitting relevant warnings/errors as appropriate. param: {token} stmt - token describing the statement under consideration |
| statement() X-Ref |
| No description |
| statements() X-Ref |
| No description |
| directives() X-Ref |
| No description |
| block(ordinary, stmt, isfunc, isfatarrow, iscase) X-Ref |
| No description |
| countMember(m) X-Ref |
| No description |
| comprehensiveArrayExpression() X-Ref |
| No description |
| isMethod() X-Ref |
| No description |
| isPropertyName(token) X-Ref |
| No description |
| propertyName(preserveOrToken) X-Ref |
| No description |
| functionparams(options) X-Ref |
returns: {{ arity: number, params: Array.<string>}} param: {Object} [options] param: {token} [options.loneArg] The argument to the function in cases param: {bool} [options.parsedOpening] Whether the opening parenthesis has |
| addParam(addParamArgs) X-Ref |
| No description |
| functor(name, token, overwrites) X-Ref |
| No description |
| isFunctor(token) X-Ref |
| No description |
| hasParsedCode(funct) X-Ref |
| Determine if the parser has begun parsing executable code. returns: {boolean} param: {Token} funct - The current "functor" token |
| doTemplateLiteral(leftOrRbp) X-Ref |
| This function is used as both a null-denotation method *and* a left-denotation method, meaning the first parameter is overloaded. |
| end() X-Ref |
| No description |
| doFunction(options) X-Ref |
param: {Object} [options] param: {token} [options.name] The identifier belonging to the function (if param: {boolean} [options.statement] The statement that triggered creation param: {string} [options.type] If specified, either "generator" or "arrow" param: {token} [options.loneArg] The argument to the function in cases param: {bool} [options.parsedOpening] Whether the opening parenthesis has param: {token} [options.classExprBinding] Define a function with this |
| createMetrics(functionStartToken) X-Ref |
| No description |
| increaseComplexityCount() X-Ref |
| No description |
| checkCondAssignment(expr) X-Ref |
| No description |
| checkProperties(props) X-Ref |
param: {object} props Collection of property descriptors for a given |
| metaProperty(name, c) X-Ref |
| No description |
| destructuringPattern(options) X-Ref |
| No description |
| destructuringPatternRecursive(options) X-Ref |
| No description |
| destructuringPatternMatch(tokens, value) X-Ref |
| No description |
| blockVariableStatement(type, statement, context) X-Ref |
| No description |
| classdef(rbp, isStatement) X-Ref |
| No description |
| classtail(c) X-Ref |
| No description |
| classbody(c) X-Ref |
| No description |
| doCatch() X-Ref |
| No description |
| saveProperty(props, name, tkn, isClass, isStatic) X-Ref |
| No description |
| saveAccessor(accessorType, props, name, tkn, isClass, isStatic) X-Ref |
param: {string} accessorType - Either "get" or "set" param: {object} props - a collection of all properties of the object to param: {object} tkn - the identifier token representing the accessor name param: {boolean} isClass - whether the accessor is part of an ES6 Class param: {boolean} isStatic - whether the accessor is a static method |
| computedPropertyName() X-Ref |
| No description |
| checkPunctuators(token, values) X-Ref |
| Test whether a given token is a punctuator matching one of the specified values returns: {boolean} param: {Token} token param: {Array.<string>} values |
| checkPunctuator(token, value) X-Ref |
| Test whether a given token is a punctuator matching the specified value returns: {boolean} param: {Token} token param: {string} value |
| destructuringAssignOrJsonValue() X-Ref |
| No description |
| declare(v) X-Ref |
| No description |
| use(v) X-Ref |
| No description |
| jsonValue() X-Ref |
| No description |
| jsonObject() X-Ref |
| No description |
| jsonArray() X-Ref |
| No description |
| lintEvalCode(internals, options, globals) X-Ref |
| Lint dynamically-evaluated code, appending any resulting errors/warnings into the global `errors` array. param: {array} internals - collection of "internals" objects describing param: {object} options - linting options to apply param: {object} globals - globally-defined bindings for the evaluated code |
| each(obj, cb) X-Ref |
| No description |
| Generated: Tue Jan 23 01:00:03 2018 | Cross-referenced by PHPXref 0.7.1 |