| /** |
| * @license |
| * lodash 4.11.2 (Custom Build) <https://lodash.com/> |
| * Build: `lodash core -o ./dist/lodash.core.js` |
| * Copyright jQuery Foundation and other contributors <https://jquery.org/> |
| * Released under MIT license <https://lodash.com/license> |
| * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE> |
| * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| */ |
| ;(function() { |
| |
| /** Used as a safe reference for `undefined` in pre-ES5 environments. */ |
| var undefined; |
| |
| /** Used as the semantic version number. */ |
| var VERSION = '4.11.2'; |
| |
| /** Used as the `TypeError` message for "Functions" methods. */ |
| var FUNC_ERROR_TEXT = 'Expected a function'; |
| |
| /** Used to compose bitmasks for wrapper metadata. */ |
| var BIND_FLAG = 1, |
| PARTIAL_FLAG = 32; |
| |
| /** Used to compose bitmasks for comparison styles. */ |
| var UNORDERED_COMPARE_FLAG = 1, |
| PARTIAL_COMPARE_FLAG = 2; |
| |
| /** Used as references for various `Number` constants. */ |
| var INFINITY = 1 / 0, |
| MAX_SAFE_INTEGER = 9007199254740991; |
| |
| /** `Object#toString` result references. */ |
| var argsTag = '[object Arguments]', |
| arrayTag = '[object Array]', |
| boolTag = '[object Boolean]', |
| dateTag = '[object Date]', |
| errorTag = '[object Error]', |
| funcTag = '[object Function]', |
| genTag = '[object GeneratorFunction]', |
| numberTag = '[object Number]', |
| objectTag = '[object Object]', |
| regexpTag = '[object RegExp]', |
| stringTag = '[object String]'; |
| |
| /** Used to match HTML entities and HTML characters. */ |
| var reUnescapedHtml = /[&<>"'`]/g, |
| reHasUnescapedHtml = RegExp(reUnescapedHtml.source); |
| |
| /** Used to detect unsigned integer values. */ |
| var reIsUint = /^(?:0|[1-9]\d*)$/; |
| |
| /** Used to map characters to HTML entities. */ |
| var htmlEscapes = { |
| '&': '&', |
| '<': '<', |
| '>': '>', |
| '"': '"', |
| "'": ''', |
| '`': '`' |
| }; |
| |
| /** Used to determine if values are of the language type `Object`. */ |
| var objectTypes = { |
| 'function': true, |
| 'object': true |
| }; |
| |
| /** Detect free variable `exports`. */ |
| var freeExports = (objectTypes[typeof exports] && exports && !exports.nodeType) |
| ? exports |
| : undefined; |
| |
| /** Detect free variable `module`. */ |
| var freeModule = (objectTypes[typeof module] && module && !module.nodeType) |
| ? module |
| : undefined; |
| |
| /** Detect the popular CommonJS extension `module.exports`. */ |
| var moduleExports = (freeModule && freeModule.exports === freeExports) |
| ? freeExports |
| : undefined; |
| |
| /** Detect free variable `global` from Node.js. */ |
| var freeGlobal = checkGlobal(freeExports && freeModule && typeof global == 'object' && global); |
| |
| /** Detect free variable `self`. */ |
| var freeSelf = checkGlobal(objectTypes[typeof self] && self); |
| |
| /** Detect free variable `window`. */ |
| var freeWindow = checkGlobal(objectTypes[typeof window] && window); |
| |
| /** Detect `this` as the global object. */ |
| var thisGlobal = checkGlobal(objectTypes[typeof this] && this); |
| |
| /** |
| * Used as a reference to the global object. |
| * |
| * The `this` value is used if it's the global object to avoid Greasemonkey's |
| * restricted `window` object, otherwise the `window` object is used. |
| */ |
| var root = freeGlobal || |
| ((freeWindow !== (thisGlobal && thisGlobal.window)) && freeWindow) || |
| freeSelf || thisGlobal || Function('return this')(); |
| |
| /*--------------------------------------------------------------------------*/ |
| |
| /** |
| * Creates a new array concatenating `array` with `other`. |
| * |
| * @private |
| * @param {Array} array The first array to concatenate. |
| * @param {Array} other The second array to concatenate. |
| * @returns {Array} Returns the new concatenated array. |
| */ |
| function arrayConcat(array, other) { |
| return arrayPush(copyArray(array), values); |
| } |
| |
| /** |
| * Appends the elements of `values` to `array`. |
| * |
| * @private |
| * @param {Array} array The array to modify. |
| * @param {Array} values The values to append. |
| * @returns {Array} Returns `array`. |
| */ |
| function arrayPush(array, values) { |
| array.push.apply(array, values); |
| return array; |
| } |
| |
| /** |
| * The base implementation of methods like `_.find` and `_.findKey`, without |
| * support for iteratee shorthands, which iterates over `collection` using |
| * `eachFunc`. |
| * |
| * @private |
| * @param {Array|Object} 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 |
| * instead of the element itself. |
| * @returns {*} Returns the found element or its key, else `undefined`. |
| */ |
| function baseFind(collection, predicate, eachFunc, retKey) { |
| var result; |
| eachFunc(collection, function(value, key, collection) { |
| if (predicate(value, key, collection)) { |
| result = retKey ? key : value; |
| return false; |
| } |
| }); |
| return result; |
| } |
| |
| /** |
| * The base implementation of `_.reduce` and `_.reduceRight`, without support |
| * for iteratee shorthands, which iterates over `collection` using `eachFunc`. |
| * |
| * @private |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @param {*} accumulator The initial value. |
| * @param {boolean} initAccum Specify using the first or last element of |
| * `collection` as the initial value. |
| * @param {Function} eachFunc The function to iterate over `collection`. |
| * @returns {*} Returns the accumulated value. |
| */ |
| function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) { |
| eachFunc(collection, function(value, index, collection) { |
| accumulator = initAccum |
| ? (initAccum = false, value) |
| : iteratee(accumulator, value, index, collection); |
| }); |
| return accumulator; |
| } |
| |
| /** |
| * The base implementation of `_.times` without support for iteratee shorthands |
| * or max array length checks. |
| * |
| * @private |
| * @param {number} n The number of times to invoke `iteratee`. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Array} Returns the array of results. |
| */ |
| function baseTimes(n, iteratee) { |
| var index = -1, |
| result = Array(n); |
| |
| while (++index < n) { |
| result[index] = iteratee(index); |
| } |
| return result; |
| } |
| |
| /** |
| * The base implementation of `_.values` and `_.valuesIn` which creates an |
| * array of `object` property values corresponding to the property names |
| * of `props`. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @param {Array} props The property names to get values for. |
| * @returns {Object} Returns the array of property values. |
| */ |
| function baseValues(object, props) { |
| return baseMap(props, function(key) { |
| return object[key]; |
| }); |
| } |
| |
| /** |
| * Checks if `value` is a global object. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {null|Object} Returns `value` if it's a global object, else `null`. |
| */ |
| function checkGlobal(value) { |
| return (value && value.Object === Object) ? value : null; |
| } |
| |
| /** |
| * Used by `_.escape` to convert characters to HTML entities. |
| * |
| * @private |
| * @param {string} chr The matched character to escape. |
| * @returns {string} Returns the escaped character. |
| */ |
| function escapeHtmlChar(chr) { |
| return htmlEscapes[chr]; |
| } |
| |
| /** |
| * Checks if `value` is a host object in IE < 9. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a host object, else `false`. |
| */ |
| function isHostObject(value) { |
| // Many host objects are `Object` objects that can coerce to strings |
| // despite having improperly defined `toString` methods. |
| var result = false; |
| if (value != null && typeof value.toString != 'function') { |
| try { |
| result = !!(value + ''); |
| } catch (e) {} |
| } |
| return result; |
| } |
| |
| /** |
| * Converts `iterator` to an array. |
| * |
| * @private |
| * @param {Object} iterator The iterator to convert. |
| * @returns {Array} Returns the converted array. |
| */ |
| function iteratorToArray(iterator) { |
| var data, |
| result = []; |
| |
| while (!(data = iterator.next()).done) { |
| result.push(data.value); |
| } |
| return result; |
| } |
| |
| /*--------------------------------------------------------------------------*/ |
| |
| /** Used for built-in method references. */ |
| var arrayProto = Array.prototype, |
| objectProto = Object.prototype; |
| |
| /** Used to check objects for own properties. */ |
| var hasOwnProperty = objectProto.hasOwnProperty; |
| |
| /** Used to generate unique IDs. */ |
| var idCounter = 0; |
| |
| /** |
| * Used to resolve the |
| * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) |
| * of values. |
| */ |
| var objectToString = objectProto.toString; |
| |
| /** Used to restore the original `_` reference in `_.noConflict`. */ |
| var oldDash = root._; |
| |
| /** Built-in value references. */ |
| var Reflect = root.Reflect, |
| Symbol = root.Symbol, |
| Uint8Array = root.Uint8Array, |
| enumerate = Reflect ? Reflect.enumerate : undefined, |
| objectCreate = Object.create, |
| propertyIsEnumerable = objectProto.propertyIsEnumerable; |
| |
| /* Built-in method references for those with the same name as other `lodash` methods. */ |
| var nativeIsFinite = root.isFinite, |
| nativeKeys = Object.keys, |
| nativeMax = Math.max; |
| |
| /*------------------------------------------------------------------------*/ |
| |
| /** |
| * Creates a `lodash` object which wraps `value` to enable implicit method |
| * chain sequences. Methods that operate on and return arrays, collections, |
| * and functions can be chained together. Methods that retrieve a single value |
| * or may return a primitive value will automatically end the chain sequence |
| * and return the unwrapped value. Otherwise, the value must be unwrapped |
| * with `_#value`. |
| * |
| * Explicit chain sequences, which must be unwrapped with `_#value`, may be |
| * enabled using `_.chain`. |
| * |
| * The execution of chained methods is lazy, that is, it's deferred until |
| * `_#value` is implicitly or explicitly called. |
| * |
| * Lazy evaluation allows several methods to support shortcut fusion. |
| * Shortcut fusion is an optimization to merge iteratee calls; this avoids |
| * the creation of intermediate arrays and can greatly reduce the number of |
| * iteratee executions. Sections of a chain sequence qualify for shortcut |
| * fusion if the section is applied to an array of at least `200` elements |
| * and any iteratees accept only one argument. The heuristic for whether a |
| * section qualifies for shortcut fusion is subject to change. |
| * |
| * Chaining is supported in custom builds as long as the `_#value` method is |
| * directly or indirectly included in the build. |
| * |
| * In addition to lodash methods, wrappers have `Array` and `String` methods. |
| * |
| * The wrapper `Array` methods are: |
| * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift` |
| * |
| * The wrapper `String` methods are: |
| * `replace` and `split` |
| * |
| * The wrapper methods that support shortcut fusion are: |
| * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`, |
| * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`, |
| * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray` |
| * |
| * The chainable wrapper methods are: |
| * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`, |
| * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`, |
| * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`, |
| * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`, |
| * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`, |
| * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`, |
| * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`, |
| * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`, |
| * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`, |
| * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`, |
| * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`, |
| * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`, |
| * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`, |
| * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`, |
| * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`, |
| * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`, |
| * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`, |
| * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`, |
| * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`, |
| * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`, |
| * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`, |
| * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`, |
| * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`, |
| * `zipObject`, `zipObjectDeep`, and `zipWith` |
| * |
| * The wrapper methods that are **not** chainable by default are: |
| * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`, |
| * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `deburr`, `divide`, `each`, |
| * `eachRight`, `endsWith`, `eq`, `escape`, `escapeRegExp`, `every`, `find`, |
| * `findIndex`, `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `first`, |
| * `floor`, `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, |
| * `forOwnRight`, `get`, `gt`, `gte`, `has`, `hasIn`, `head`, `identity`, |
| * `includes`, `indexOf`, `inRange`, `invoke`, `isArguments`, `isArray`, |
| * `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`, `isBoolean`, `isBuffer`, |
| * `isDate`, `isElement`, `isEmpty`, `isEqual`, `isEqualWith`, `isError`, |
| * `isFinite`, `isFunction`, `isInteger`, `isLength`, `isMap`, `isMatch`, |
| * `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`, `isNumber`, |
| * `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`, `isSafeInteger`, |
| * `isSet`, `isString`, `isUndefined`, `isTypedArray`, `isWeakMap`, `isWeakSet`, |
| * `join`, `kebabCase`, `last`, `lastIndexOf`, `lowerCase`, `lowerFirst`, |
| * `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`, `min`, `minBy`, `multiply`, |
| * `noConflict`, `noop`, `now`, `nth`, `pad`, `padEnd`, `padStart`, `parseInt`, |
| * `pop`, `random`, `reduce`, `reduceRight`, `repeat`, `result`, `round`, |
| * `runInContext`, `sample`, `shift`, `size`, `snakeCase`, `some`, `sortedIndex`, |
| * `sortedIndexBy`, `sortedLastIndex`, `sortedLastIndexBy`, `startCase`, |
| * `startsWith`, `subtract`, `sum`, `sumBy`, `template`, `times`, `toInteger`, |
| * `toJSON`, `toLength`, `toLower`, `toNumber`, `toSafeInteger`, `toString`, |
| * `toUpper`, `trim`, `trimEnd`, `trimStart`, `truncate`, `unescape`, |
| * `uniqueId`, `upperCase`, `upperFirst`, `value`, and `words` |
| * |
| * @name _ |
| * @constructor |
| * @category Seq |
| * @param {*} value The value to wrap in a `lodash` instance. |
| * @returns {Object} Returns the new `lodash` wrapper instance. |
| * @example |
| * |
| * function square(n) { |
| * return n * n; |
| * } |
| * |
| * var wrapped = _([1, 2, 3]); |
| * |
| * // Returns an unwrapped value. |
| * wrapped.reduce(_.add); |
| * // => 6 |
| * |
| * // Returns a wrapped value. |
| * var squares = wrapped.map(square); |
| * |
| * _.isArray(squares); |
| * // => false |
| * |
| * _.isArray(squares.value()); |
| * // => true |
| */ |
| function lodash(value) { |
| return value instanceof LodashWrapper |
| ? value |
| : new LodashWrapper(value); |
| } |
| |
| /** |
| * The base constructor for creating `lodash` wrapper objects. |
| * |
| * @private |
| * @param {*} value The value to wrap. |
| * @param {boolean} [chainAll] Enable explicit method chain sequences. |
| */ |
| function LodashWrapper(value, chainAll) { |
| this.__wrapped__ = value; |
| this.__actions__ = []; |
| this.__chain__ = !!chainAll; |
| } |
| |
| LodashWrapper.prototype = baseCreate(lodash.prototype); |
| LodashWrapper.prototype.constructor = LodashWrapper; |
| |
| /*------------------------------------------------------------------------*/ |
| |
| /** |
| * Used by `_.defaults` to customize its `_.assignIn` use. |
| * |
| * @private |
| * @param {*} objValue The destination value. |
| * @param {*} srcValue The source value. |
| * @param {string} key The key of the property to assign. |
| * @param {Object} object The parent object of `objValue`. |
| * @returns {*} Returns the value to assign. |
| */ |
| function assignInDefaults(objValue, srcValue, key, object) { |
| if (objValue === undefined || |
| (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) { |
| return srcValue; |
| } |
| return objValue; |
| } |
| |
| /** |
| * Assigns `value` to `key` of `object` if the existing value is not equivalent |
| * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
| * for equality comparisons. |
| * |
| * @private |
| * @param {Object} object The object to modify. |
| * @param {string} key The key of the property to assign. |
| * @param {*} value The value to assign. |
| */ |
| function assignValue(object, key, value) { |
| var objValue = object[key]; |
| if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || |
| (value === undefined && !(key in object))) { |
| object[key] = value; |
| } |
| } |
| |
| /** |
| * The base implementation of `_.create` without support for assigning |
| * properties to the created object. |
| * |
| * @private |
| * @param {Object} prototype The object to inherit from. |
| * @returns {Object} Returns the new object. |
| */ |
| function baseCreate(proto) { |
| return isObject(proto) ? objectCreate(proto) : {}; |
| } |
| |
| /** |
| * The base implementation of `_.delay` and `_.defer` which accepts an array |
| * of `func` arguments. |
| * |
| * @private |
| * @param {Function} func The function to delay. |
| * @param {number} wait The number of milliseconds to delay invocation. |
| * @param {Object} args The arguments to provide to `func`. |
| * @returns {number} Returns the timer id. |
| */ |
| function baseDelay(func, wait, args) { |
| if (typeof func != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| return setTimeout(function() { func.apply(undefined, args); }, wait); |
| } |
| |
| /** |
| * The base implementation of `_.forEach` without support for iteratee shorthands. |
| * |
| * @private |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Array|Object} Returns `collection`. |
| */ |
| var baseEach = createBaseEach(baseForOwn); |
| |
| /** |
| * The base implementation of `_.every` without support for iteratee shorthands. |
| * |
| * @private |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {Function} predicate The function invoked per iteration. |
| * @returns {boolean} Returns `true` if all elements pass the predicate check, |
| * else `false` |
| */ |
| function baseEvery(collection, predicate) { |
| var result = true; |
| baseEach(collection, function(value, index, collection) { |
| result = !!predicate(value, index, collection); |
| return result; |
| }); |
| return result; |
| } |
| |
| /** |
| * The base implementation of methods like `_.max` and `_.min` which accepts a |
| * `comparator` to determine the extremum value. |
| * |
| * @private |
| * @param {Array} array The array to iterate over. |
| * @param {Function} iteratee The iteratee invoked per iteration. |
| * @param {Function} comparator The comparator used to compare values. |
| * @returns {*} Returns the extremum value. |
| */ |
| function baseExtremum(array, iteratee, comparator) { |
| var index = -1, |
| length = array.length; |
| |
| while (++index < length) { |
| var value = array[index], |
| current = iteratee(value); |
| |
| if (current != null && (computed === undefined |
| ? (current === current && !false) |
| : comparator(current, computed) |
| )) { |
| var computed = current, |
| result = value; |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * The base implementation of `_.filter` without support for iteratee shorthands. |
| * |
| * @private |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {Function} predicate The function invoked per iteration. |
| * @returns {Array} Returns the new filtered array. |
| */ |
| function baseFilter(collection, predicate) { |
| var result = []; |
| baseEach(collection, function(value, index, collection) { |
| if (predicate(value, index, collection)) { |
| result.push(value); |
| } |
| }); |
| return result; |
| } |
| |
| /** |
| * The base implementation of `_.flatten` with support for restricting flattening. |
| * |
| * @private |
| * @param {Array} array The array to flatten. |
| * @param {number} depth The maximum recursion depth. |
| * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. |
| * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. |
| * @param {Array} [result=[]] The initial result value. |
| * @returns {Array} Returns the new flattened array. |
| */ |
| function baseFlatten(array, depth, predicate, isStrict, result) { |
| var index = -1, |
| length = array.length; |
| |
| predicate || (predicate = isFlattenable); |
| result || (result = []); |
| |
| while (++index < length) { |
| var value = array[index]; |
| if (depth > 0 && predicate(value)) { |
| if (depth > 1) { |
| // Recursively flatten arrays (susceptible to call stack limits). |
| baseFlatten(value, depth - 1, predicate, isStrict, result); |
| } else { |
| arrayPush(result, value); |
| } |
| } else if (!isStrict) { |
| result[result.length] = value; |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * The base implementation of `baseForOwn` which iterates over `object` |
| * properties returned by `keysFunc` and invokes `iteratee` for each property. |
| * Iteratee functions may exit iteration early by explicitly returning `false`. |
| * |
| * @private |
| * @param {Object} object The object to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @param {Function} keysFunc The function to get the keys of `object`. |
| * @returns {Object} Returns `object`. |
| */ |
| var baseFor = createBaseFor(); |
| |
| /** |
| * The base implementation of `_.forOwn` without support for iteratee shorthands. |
| * |
| * @private |
| * @param {Object} object The object to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Object} Returns `object`. |
| */ |
| function baseForOwn(object, iteratee) { |
| return object && baseFor(object, iteratee, keys); |
| } |
| |
| /** |
| * The base implementation of `_.functions` which creates an array of |
| * `object` function property names filtered from `props`. |
| * |
| * @private |
| * @param {Object} object The object to inspect. |
| * @param {Array} props The property names to filter. |
| * @returns {Array} Returns the new array of filtered property names. |
| */ |
| function baseFunctions(object, props) { |
| return baseFilter(props, function(key) { |
| return isFunction(object[key]); |
| }); |
| } |
| |
| /** |
| * The base implementation of `_.gt` which doesn't coerce arguments to numbers. |
| * |
| * @private |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @returns {boolean} Returns `true` if `value` is greater than `other`, |
| * else `false`. |
| */ |
| function baseGt(value, other) { |
| return value > other; |
| } |
| |
| /** |
| * The base implementation of `_.isEqual` which supports partial comparisons |
| * and tracks traversed objects. |
| * |
| * @private |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @param {Function} [customizer] The function to customize comparisons. |
| * @param {boolean} [bitmask] The bitmask of comparison flags. |
| * The bitmask may be composed of the following flags: |
| * 1 - Unordered comparison |
| * 2 - Partial comparison |
| * @param {Object} [stack] Tracks traversed `value` and `other` objects. |
| * @returns {boolean} Returns `true` if the values are equivalent, else `false`. |
| */ |
| function baseIsEqual(value, other, customizer, bitmask, stack) { |
| if (value === other) { |
| return true; |
| } |
| if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) { |
| return value !== value && other !== other; |
| } |
| return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack); |
| } |
| |
| /** |
| * 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. |
| * |
| * @private |
| * @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 comparisons. |
| * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual` |
| * for more details. |
| * @param {Object} [stack] Tracks traversed `object` and `other` objects. |
| * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. |
| */ |
| function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) { |
| var objIsArr = isArray(object), |
| othIsArr = isArray(other), |
| objTag = arrayTag, |
| othTag = arrayTag; |
| |
| if (!objIsArr) { |
| objTag = objectToString.call(object); |
| objTag = objTag == argsTag ? objectTag : objTag; |
| } |
| if (!othIsArr) { |
| othTag = objectToString.call(other); |
| othTag = othTag == argsTag ? objectTag : othTag; |
| } |
| var objIsObj = objTag == objectTag && !isHostObject(object), |
| othIsObj = othTag == objectTag && !isHostObject(other), |
| isSameTag = objTag == othTag; |
| |
| stack || (stack = []); |
| var stacked = find(stack, function(entry) { |
| return entry[0] === object; |
| }); |
| if (stacked && stacked[1]) { |
| return stacked[1] == other; |
| } |
| stack.push([object, other]); |
| if (isSameTag && !objIsObj) { |
| var result = (objIsArr || isTypedArray(object)) |
| ? equalArrays(object, other, equalFunc, customizer, bitmask, stack) |
| : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack); |
| stack.pop(); |
| return result; |
| } |
| if (!(bitmask & PARTIAL_COMPARE_FLAG)) { |
| var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), |
| othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); |
| |
| if (objIsWrapped || othIsWrapped) { |
| var objUnwrapped = objIsWrapped ? object.value() : object, |
| othUnwrapped = othIsWrapped ? other.value() : other; |
| |
| var result = equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack); |
| stack.pop(); |
| return result; |
| } |
| } |
| if (!isSameTag) { |
| return false; |
| } |
| var result = equalObjects(object, other, equalFunc, customizer, bitmask, stack); |
| stack.pop(); |
| return result; |
| } |
| |
| /** |
| * The base implementation of `_.iteratee`. |
| * |
| * @private |
| * @param {*} [value=_.identity] The value to convert to an iteratee. |
| * @returns {Function} Returns the iteratee. |
| */ |
| function baseIteratee(func) { |
| if (typeof func == 'function') { |
| return func; |
| } |
| if (func == null) { |
| return identity; |
| } |
| return (typeof func == 'object' ? baseMatches : baseProperty)(func); |
| } |
| |
| /** |
| * The base implementation of `_.keys` which doesn't skip the constructor |
| * property of prototypes or treat sparse arrays as dense. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @returns {Array} Returns the array of property names. |
| */ |
| function baseKeys(object) { |
| return nativeKeys(Object(object)); |
| } |
| |
| /** |
| * The base implementation of `_.keysIn` which doesn't skip the constructor |
| * property of prototypes or treat sparse arrays as dense. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @returns {Array} Returns the array of property names. |
| */ |
| function baseKeysIn(object) { |
| object = object == null ? object : Object(object); |
| |
| var result = []; |
| for (var key in object) { |
| result.push(key); |
| } |
| return result; |
| } |
| |
| // Fallback for IE < 9 with es6-shim. |
| if (enumerate && !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf')) { |
| baseKeysIn = function(object) { |
| return iteratorToArray(enumerate(object)); |
| }; |
| } |
| |
| /** |
| * The base implementation of `_.lt` which doesn't coerce arguments to numbers. |
| * |
| * @private |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @returns {boolean} Returns `true` if `value` is less than `other`, |
| * else `false`. |
| */ |
| function baseLt(value, other) { |
| return value < other; |
| } |
| |
| /** |
| * The base implementation of `_.map` without support for iteratee shorthands. |
| * |
| * @private |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Array} Returns the new mapped array. |
| */ |
| function baseMap(collection, iteratee) { |
| var index = -1, |
| result = isArrayLike(collection) ? Array(collection.length) : []; |
| |
| baseEach(collection, function(value, key, collection) { |
| result[++index] = iteratee(value, key, collection); |
| }); |
| return result; |
| } |
| |
| /** |
| * The base implementation of `_.matches` which doesn't clone `source`. |
| * |
| * @private |
| * @param {Object} source The object of property values to match. |
| * @returns {Function} Returns the new function. |
| */ |
| function baseMatches(source) { |
| var props = keys(source); |
| return function(object) { |
| var length = props.length; |
| if (object == null) { |
| return !length; |
| } |
| object = Object(object); |
| while (length--) { |
| var key = props[length]; |
| if (!(key in object && |
| baseIsEqual(source[key], object[key], undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG) |
| )) { |
| return false; |
| } |
| } |
| return true; |
| }; |
| } |
| |
| /** |
| * The base implementation of `_.pick` without support for individual |
| * property identifiers. |
| * |
| * @private |
| * @param {Object} object The source object. |
| * @param {string[]} props The property identifiers to pick. |
| * @returns {Object} Returns the new object. |
| */ |
| function basePick(object, props) { |
| object = Object(object); |
| return reduce(props, function(result, key) { |
| if (key in object) { |
| result[key] = object[key]; |
| } |
| return result; |
| }, {}); |
| } |
| |
| /** |
| * The base implementation of `_.property` without support for deep paths. |
| * |
| * @private |
| * @param {string} key The key of the property to get. |
| * @returns {Function} Returns the new function. |
| */ |
| function baseProperty(key) { |
| return function(object) { |
| return object == null ? undefined : object[key]; |
| }; |
| } |
| |
| /** |
| * The base implementation of `_.slice` without an iteratee call guard. |
| * |
| * @private |
| * @param {Array} array The array to slice. |
| * @param {number} [start=0] The start position. |
| * @param {number} [end=array.length] The end position. |
| * @returns {Array} Returns the slice of `array`. |
| */ |
| function baseSlice(array, start, end) { |
| var index = -1, |
| length = array.length; |
| |
| if (start < 0) { |
| start = -start > length ? 0 : (length + start); |
| } |
| end = end > length ? length : end; |
| if (end < 0) { |
| end += length; |
| } |
| length = start > end ? 0 : ((end - start) >>> 0); |
| start >>>= 0; |
| |
| var result = Array(length); |
| while (++index < length) { |
| result[index] = array[index + start]; |
| } |
| return result; |
| } |
| |
| /** |
| * Copies the values of `source` to `array`. |
| * |
| * @private |
| * @param {Array} source The array to copy values from. |
| * @param {Array} [array=[]] The array to copy values to. |
| * @returns {Array} Returns `array`. |
| */ |
| function copyArray(source) { |
| return baseSlice(source, 0, source.length); |
| } |
| |
| /** |
| * The base implementation of `_.some` without support for iteratee shorthands. |
| * |
| * @private |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {Function} predicate The function invoked per iteration. |
| * @returns {boolean} Returns `true` if any element passes the predicate check, |
| * else `false`. |
| */ |
| function baseSome(collection, predicate) { |
| var result; |
| |
| baseEach(collection, function(value, index, collection) { |
| result = predicate(value, index, collection); |
| return !result; |
| }); |
| return !!result; |
| } |
| |
| /** |
| * 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. |
| * |
| * @private |
| * @param {*} value The unwrapped value. |
| * @param {Array} actions Actions to perform to resolve the unwrapped value. |
| * @returns {*} Returns the resolved value. |
| */ |
| function baseWrapperValue(value, actions) { |
| var result = value; |
| return reduce(actions, function(result, action) { |
| return action.func.apply(action.thisArg, arrayPush([result], action.args)); |
| }, result); |
| } |
| |
| /** |
| * Compares values to sort them in ascending order. |
| * |
| * @private |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @returns {number} Returns the sort order indicator for `value`. |
| */ |
| function compareAscending(value, other) { |
| if (value !== other) { |
| var valIsDefined = value !== undefined, |
| valIsNull = value === null, |
| valIsReflexive = value === value, |
| valIsSymbol = false; |
| |
| var othIsDefined = other !== undefined, |
| othIsNull = other === null, |
| othIsReflexive = other === other, |
| othIsSymbol = false; |
| |
| if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) || |
| (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) || |
| (valIsNull && othIsDefined && othIsReflexive) || |
| (!valIsDefined && othIsReflexive) || |
| !valIsReflexive) { |
| return 1; |
| } |
| if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) || |
| (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) || |
| (othIsNull && valIsDefined && valIsReflexive) || |
| (!othIsDefined && valIsReflexive) || |
| !othIsReflexive) { |
| return -1; |
| } |
| } |
| return 0; |
| } |
| |
| /** |
| * Copies properties of `source` to `object`. |
| * |
| * @private |
| * @param {Object} source The object to copy properties from. |
| * @param {Array} props The property identifiers to copy. |
| * @param {Object} [object={}] The object to copy properties to. |
| * @param {Function} [customizer] The function to customize copied values. |
| * @returns {Object} Returns `object`. |
| */ |
| function copyObject(source, props, object, customizer) { |
| object || (object = {}); |
| |
| var index = -1, |
| length = props.length; |
| |
| while (++index < length) { |
| var key = props[index]; |
| |
| var newValue = customizer |
| ? customizer(object[key], source[key], key, object, source) |
| : source[key]; |
| |
| assignValue(object, key, newValue); |
| } |
| return object; |
| } |
| |
| /** |
| * Creates a function like `_.assign`. |
| * |
| * @private |
| * @param {Function} assigner The function to assign values. |
| * @returns {Function} Returns the new assigner function. |
| */ |
| function createAssigner(assigner) { |
| return rest(function(object, sources) { |
| var index = -1, |
| length = sources.length, |
| customizer = length > 1 ? sources[length - 1] : undefined; |
| |
| customizer = typeof customizer == 'function' |
| ? (length--, customizer) |
| : undefined; |
| |
| object = Object(object); |
| while (++index < length) { |
| var source = sources[index]; |
| if (source) { |
| assigner(object, source, index, customizer); |
| } |
| } |
| return object; |
| }); |
| } |
| |
| /** |
| * Creates a `baseEach` or `baseEachRight` function. |
| * |
| * @private |
| * @param {Function} eachFunc The function to iterate over a collection. |
| * @param {boolean} [fromRight] Specify iterating from right to left. |
| * @returns {Function} Returns the new base function. |
| */ |
| function createBaseEach(eachFunc, fromRight) { |
| return function(collection, iteratee) { |
| if (collection == null) { |
| return collection; |
| } |
| if (!isArrayLike(collection)) { |
| return eachFunc(collection, iteratee); |
| } |
| var length = collection.length, |
| index = fromRight ? length : -1, |
| iterable = Object(collection); |
| |
| while ((fromRight ? index-- : ++index < length)) { |
| if (iteratee(iterable[index], index, iterable) === false) { |
| break; |
| } |
| } |
| return collection; |
| }; |
| } |
| |
| /** |
| * Creates a base function for methods like `_.forIn` and `_.forOwn`. |
| * |
| * @private |
| * @param {boolean} [fromRight] Specify iterating from right to left. |
| * @returns {Function} Returns the new base function. |
| */ |
| function createBaseFor(fromRight) { |
| return function(object, iteratee, keysFunc) { |
| var index = -1, |
| iterable = Object(object), |
| props = keysFunc(object), |
| length = props.length; |
| |
| while (length--) { |
| var key = props[fromRight ? length : ++index]; |
| if (iteratee(iterable[key], key, iterable) === false) { |
| break; |
| } |
| } |
| return object; |
| }; |
| } |
| |
| /** |
| * 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`. |
| * |
| * @private |
| * @param {Function} Ctor The constructor to wrap. |
| * @returns {Function} Returns the new wrapped function. |
| */ |
| function createCtorWrapper(Ctor) { |
| return function() { |
| // Use a `switch` statement to work with class constructors. See |
| // http://ecma-international.org/ecma-262/6.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist |
| // for more details. |
| var args = arguments; |
| var thisBinding = baseCreate(Ctor.prototype), |
| result = Ctor.apply(thisBinding, args); |
| |
| // Mimic the constructor's `return` behavior. |
| // See https://es5.github.io/#x13.2.2 for more details. |
| return isObject(result) ? result : thisBinding; |
| }; |
| } |
| |
| /** |
| * Creates a function that wraps `func` to invoke it with the `this` binding |
| * of `thisArg` and `partials` prepended to the arguments it receives. |
| * |
| * @private |
| * @param {Function} func The function to wrap. |
| * @param {number} bitmask The bitmask of wrapper 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. |
| * @returns {Function} Returns the new wrapped function. |
| */ |
| function createPartialWrapper(func, bitmask, thisArg, partials) { |
| if (typeof func != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| var isBind = bitmask & BIND_FLAG, |
| Ctor = createCtorWrapper(func); |
| |
| function wrapper() { |
| var argsIndex = -1, |
| argsLength = arguments.length, |
| leftIndex = -1, |
| leftLength = partials.length, |
| args = Array(leftLength + argsLength), |
| fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; |
| |
| while (++leftIndex < leftLength) { |
| args[leftIndex] = partials[leftIndex]; |
| } |
| while (argsLength--) { |
| args[leftIndex++] = arguments[++argsIndex]; |
| } |
| return fn.apply(isBind ? thisArg : this, args); |
| } |
| return wrapper; |
| } |
| |
| /** |
| * A specialized version of `baseIsEqualDeep` for arrays with support for |
| * partial deep comparisons. |
| * |
| * @private |
| * @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 comparisons. |
| * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual` |
| * for more details. |
| * @param {Object} stack Tracks traversed `array` and `other` objects. |
| * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. |
| */ |
| function equalArrays(array, other, equalFunc, customizer, bitmask, stack) { |
| var index = -1, |
| isPartial = bitmask & PARTIAL_COMPARE_FLAG, |
| isUnordered = bitmask & UNORDERED_COMPARE_FLAG, |
| arrLength = array.length, |
| othLength = other.length; |
| |
| if (arrLength != othLength && !(isPartial && othLength > arrLength)) { |
| return false; |
| } |
| var result = true; |
| |
| // Ignore non-index properties. |
| while (++index < arrLength) { |
| var arrValue = array[index], |
| othValue = other[index]; |
| |
| var compared; |
| if (compared !== undefined) { |
| if (compared) { |
| continue; |
| } |
| result = false; |
| break; |
| } |
| // Recursively compare arrays (susceptible to call stack limits). |
| if (isUnordered) { |
| if (!baseSome(other, function(othValue) { |
| return arrValue === othValue || |
| equalFunc(arrValue, othValue, customizer, bitmask, stack); |
| })) { |
| result = false; |
| break; |
| } |
| } else if (!( |
| arrValue === othValue || |
| equalFunc(arrValue, othValue, customizer, bitmask, stack) |
| )) { |
| result = false; |
| break; |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * 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`. |
| * |
| * @private |
| * @param {Object} object The object to compare. |
| * @param {Object} other The other object to compare. |
| * @param {string} tag The `toStringTag` of the objects to compare. |
| * @param {Function} equalFunc The function to determine equivalents of values. |
| * @param {Function} customizer The function to customize comparisons. |
| * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual` |
| * for more details. |
| * @param {Object} stack Tracks traversed `object` and `other` objects. |
| * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. |
| */ |
| function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) { |
| switch (tag) { |
| |
| case boolTag: |
| case dateTag: |
| // Coerce dates and booleans to numbers, dates to milliseconds and |
| // booleans to `1` or `0` treating invalid dates coerced to `NaN` as |
| // not equal. |
| return +object == +other; |
| |
| case errorTag: |
| return object.name == other.name && object.message == other.message; |
| |
| case numberTag: |
| // Treat `NaN` vs. `NaN` as equal. |
| return (object != +object) ? other != +other : object == +other; |
| |
| case regexpTag: |
| case stringTag: |
| // Coerce regexes to strings and treat strings, primitives and objects, |
| // as equal. See http://www.ecma-international.org/ecma-262/6.0/#sec-regexp.prototype.tostring |
| // for more details. |
| return object == (other + ''); |
| |
| } |
| return false; |
| } |
| |
| /** |
| * A specialized version of `baseIsEqualDeep` for objects with support for |
| * partial deep comparisons. |
| * |
| * @private |
| * @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 comparisons. |
| * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual` |
| * for more details. |
| * @param {Object} stack Tracks traversed `object` and `other` objects. |
| * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. |
| */ |
| function equalObjects(object, other, equalFunc, customizer, bitmask, stack) { |
| var isPartial = bitmask & PARTIAL_COMPARE_FLAG, |
| objProps = keys(object), |
| objLength = objProps.length, |
| othProps = keys(other), |
| othLength = othProps.length; |
| |
| if (objLength != othLength && !isPartial) { |
| return false; |
| } |
| var index = objLength; |
| while (index--) { |
| var key = objProps[index]; |
| if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { |
| return false; |
| } |
| } |
| var result = true; |
| |
| var skipCtor = isPartial; |
| while (++index < objLength) { |
| key = objProps[index]; |
| var objValue = object[key], |
| othValue = other[key]; |
| |
| var compared; |
| // Recursively compare objects (susceptible to call stack limits). |
| if (!(compared === undefined |
| ? (objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack)) |
| : compared |
| )) { |
| result = false; |
| break; |
| } |
| skipCtor || (skipCtor = key == 'constructor'); |
| } |
| if (result && !skipCtor) { |
| var objCtor = object.constructor, |
| othCtor = other.constructor; |
| |
| // Non `Object` object instances with different constructors are not equal. |
| if (objCtor != othCtor && |
| ('constructor' in object && 'constructor' in other) && |
| !(typeof objCtor == 'function' && objCtor instanceof objCtor && |
| typeof othCtor == 'function' && othCtor instanceof othCtor)) { |
| result = false; |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Gets the "length" property value of `object`. |
| * |
| * **Note:** This function is used to avoid a |
| * [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792) that affects |
| * Safari on at least iOS 8.1-8.3 ARM64. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @returns {*} Returns the "length" value. |
| */ |
| var getLength = baseProperty('length'); |
| |
| /** |
| * Creates an array of index keys for `object` values of arrays, |
| * `arguments` objects, and strings, otherwise `null` is returned. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @returns {Array|null} Returns index keys, else `null`. |
| */ |
| function indexKeys(object) { |
| var length = object ? object.length : undefined; |
| if (isLength(length) && |
| (isArray(object) || isString(object) || isArguments(object))) { |
| return baseTimes(length, String); |
| } |
| return null; |
| } |
| |
| /** |
| * Checks if `value` is a flattenable `arguments` object or array. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. |
| */ |
| function isFlattenable(value) { |
| return isArrayLikeObject(value) && (isArray(value) || isArguments(value)); |
| } |
| |
| /** |
| * Checks if `value` is a valid array-like index. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. |
| * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. |
| */ |
| function isIndex(value, length) { |
| length = length == null ? MAX_SAFE_INTEGER : length; |
| return !!length && |
| (typeof value == 'number' || reIsUint.test(value)) && |
| (value > -1 && value % 1 == 0 && value < length); |
| } |
| |
| /** |
| * Checks if `value` is likely a prototype object. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. |
| */ |
| function isPrototype(value) { |
| var Ctor = value && value.constructor, |
| proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; |
| |
| return value === proto; |
| } |
| |
| /** |
| * Converts `value` to a string key if it's not a string or symbol. |
| * |
| * @private |
| * @param {*} value The value to inspect. |
| * @returns {string|symbol} Returns the key. |
| */ |
| var toKey = String; |
| |
| /*------------------------------------------------------------------------*/ |
| |
| /** |
| * Creates an array with all falsey values removed. The values `false`, `null`, |
| * `0`, `""`, `undefined`, and `NaN` are falsey. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Array |
| * @param {Array} array The array to compact. |
| * @returns {Array} Returns the new array of filtered values. |
| * @example |
| * |
| * _.compact([0, 1, false, 2, '', 3]); |
| * // => [1, 2, 3] |
| */ |
| function compact(array) { |
| return baseFilter(array, Boolean); |
| } |
| |
| /** |
| * Creates a new array concatenating `array` with any additional arrays |
| * and/or values. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Array |
| * @param {Array} array The array to concatenate. |
| * @param {...*} [values] The values to concatenate. |
| * @returns {Array} Returns the new concatenated array. |
| * @example |
| * |
| * var array = [1]; |
| * var other = _.concat(array, 2, [3], [[4]]); |
| * |
| * console.log(other); |
| * // => [1, 2, 3, [4]] |
| * |
| * console.log(array); |
| * // => [1] |
| */ |
| function concat() { |
| var length = arguments.length, |
| array = castArray(arguments[0]); |
| |
| if (length < 2) { |
| return length ? copyArray(array) : []; |
| } |
| var args = Array(length - 1); |
| while (length--) { |
| args[length - 1] = arguments[length]; |
| } |
| return arrayConcat(array, baseFlatten(args, 1)); |
| } |
| |
| /** |
| * Flattens `array` a single level deep. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Array |
| * @param {Array} array The array to flatten. |
| * @returns {Array} Returns the new flattened array. |
| * @example |
| * |
| * _.flatten([1, [2, [3, [4]], 5]]); |
| * // => [1, 2, [3, [4]], 5] |
| */ |
| function flatten(array) { |
| var length = array ? array.length : 0; |
| return length ? baseFlatten(array, 1) : []; |
| } |
| |
| /** |
| * Recursively flattens `array`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 3.0.0 |
| * @category Array |
| * @param {Array} array The array to flatten. |
| * @returns {Array} Returns the new flattened array. |
| * @example |
| * |
| * _.flattenDeep([1, [2, [3, [4]], 5]]); |
| * // => [1, 2, 3, 4, 5] |
| */ |
| function flattenDeep(array) { |
| var length = array ? array.length : 0; |
| return length ? baseFlatten(array, INFINITY) : []; |
| } |
| |
| /** |
| * Gets the first element of `array`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @alias first |
| * @category Array |
| * @param {Array} array The array to query. |
| * @returns {*} Returns the first element of `array`. |
| * @example |
| * |
| * _.head([1, 2, 3]); |
| * // => 1 |
| * |
| * _.head([]); |
| * // => undefined |
| */ |
| function head(array) { |
| return (array && array.length) ? array[0] : undefined; |
| } |
| |
| /** |
| * Gets the index at which the first occurrence of `value` is found in `array` |
| * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
| * for equality comparisons. If `fromIndex` is negative, it's used as the |
| * offset from the end of `array`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Array |
| * @param {Array} array The array to search. |
| * @param {*} value The value to search for. |
| * @param {number} [fromIndex=0] The index to search from. |
| * @returns {number} Returns the index of the matched value, else `-1`. |
| * @example |
| * |
| * _.indexOf([1, 2, 1, 2], 2); |
| * // => 1 |
| * |
| * // Search from the `fromIndex`. |
| * _.indexOf([1, 2, 1, 2], 2, 2); |
| * // => 3 |
| */ |
| function indexOf(array, value, fromIndex) { |
| var length = array ? array.length : 0; |
| if (typeof fromIndex == 'number') { |
| fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : fromIndex; |
| } else { |
| fromIndex = 0; |
| } |
| var index = (fromIndex || 0) - 1, |
| isReflexive = value === value; |
| |
| while (++index < length) { |
| var other = array[index]; |
| if ((isReflexive ? other === value : other !== other)) { |
| return index; |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * Gets the last element of `array`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Array |
| * @param {Array} array The array to query. |
| * @returns {*} Returns the last element of `array`. |
| * @example |
| * |
| * _.last([1, 2, 3]); |
| * // => 3 |
| */ |
| function last(array) { |
| var length = array ? array.length : 0; |
| return length ? array[length - 1] : undefined; |
| } |
| |
| /** |
| * Creates a slice of `array` from `start` up to, but not including, `end`. |
| * |
| * **Note:** This method is used instead of |
| * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are |
| * returned. |
| * |
| * @static |
| * @memberOf _ |
| * @since 3.0.0 |
| * @category Array |
| * @param {Array} array The array to slice. |
| * @param {number} [start=0] The start position. |
| * @param {number} [end=array.length] The end position. |
| * @returns {Array} Returns the slice of `array`. |
| */ |
| function slice(array, start, end) { |
| var length = array ? array.length : 0; |
| start = start == null ? 0 : +start; |
| end = end === undefined ? length : +end; |
| return length ? baseSlice(array, start, end) : []; |
| } |
| |
| /*------------------------------------------------------------------------*/ |
| |
| /** |
| * Creates a `lodash` wrapper instance that wraps `value` with explicit method |
| * chain sequences enabled. The result of such sequences must be unwrapped |
| * with `_#value`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 1.3.0 |
| * @category Seq |
| * @param {*} value The value to wrap. |
| * @returns {Object} Returns the new `lodash` wrapper instance. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36 }, |
| * { 'user': 'fred', 'age': 40 }, |
| * { 'user': 'pebbles', 'age': 1 } |
| * ]; |
| * |
| * var youngest = _ |
| * .chain(users) |
| * .sortBy('age') |
| * .map(function(o) { |
| * return o.user + ' is ' + o.age; |
| * }) |
| * .head() |
| * .value(); |
| * // => 'pebbles is 1' |
| */ |
| function chain(value) { |
| var result = lodash(value); |
| result.__chain__ = true; |
| return result; |
| } |
| |
| /** |
| * This method invokes `interceptor` and returns `value`. The interceptor |
| * is invoked with one argument; (value). The purpose of this method is to |
| * "tap into" a method chain sequence in order to modify intermediate results. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Seq |
| * @param {*} value The value to provide to `interceptor`. |
| * @param {Function} interceptor The function to invoke. |
| * @returns {*} Returns `value`. |
| * @example |
| * |
| * _([1, 2, 3]) |
| * .tap(function(array) { |
| * // Mutate input array. |
| * array.pop(); |
| * }) |
| * .reverse() |
| * .value(); |
| * // => [2, 1] |
| */ |
| function tap(value, interceptor) { |
| interceptor(value); |
| return value; |
| } |
| |
| /** |
| * This method is like `_.tap` except that it returns the result of `interceptor`. |
| * The purpose of this method is to "pass thru" values replacing intermediate |
| * results in a method chain sequence. |
| * |
| * @static |
| * @memberOf _ |
| * @since 3.0.0 |
| * @category Seq |
| * @param {*} value The value to provide to `interceptor`. |
| * @param {Function} interceptor The function to invoke. |
| * @returns {*} Returns the result of `interceptor`. |
| * @example |
| * |
| * _(' abc ') |
| * .chain() |
| * .trim() |
| * .thru(function(value) { |
| * return [value]; |
| * }) |
| * .value(); |
| * // => ['abc'] |
| */ |
| function thru(value, interceptor) { |
| return interceptor(value); |
| } |
| |
| /** |
| * Creates a `lodash` wrapper instance with explicit method chain sequences enabled. |
| * |
| * @name chain |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Seq |
| * @returns {Object} Returns the new `lodash` wrapper instance. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36 }, |
| * { 'user': 'fred', 'age': 40 } |
| * ]; |
| * |
| * // A sequence without explicit chaining. |
| * _(users).head(); |
| * // => { 'user': 'barney', 'age': 36 } |
| * |
| * // A sequence with explicit chaining. |
| * _(users) |
| * .chain() |
| * .head() |
| * .pick('user') |
| * .value(); |
| * // => { 'user': 'barney' } |
| */ |
| function wrapperChain() { |
| return chain(this); |
| } |
| |
| /** |
| * Executes the chain sequence to resolve the unwrapped value. |
| * |
| * @name value |
| * @memberOf _ |
| * @since 0.1.0 |
| * @alias toJSON, valueOf |
| * @category Seq |
| * @returns {*} Returns the resolved unwrapped value. |
| * @example |
| * |
| * _([1, 2, 3]).value(); |
| * // => [1, 2, 3] |
| */ |
| function wrapperValue() { |
| return baseWrapperValue(this.__wrapped__, this.__actions__); |
| } |
| |
| /*------------------------------------------------------------------------*/ |
| |
| /** |
| * Checks if `predicate` returns truthy for **all** elements of `collection`. |
| * Iteration is stopped once `predicate` returns falsey. The predicate is |
| * invoked with three arguments: (value, index|key, collection). |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Collection |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {Array|Function|Object|string} [predicate=_.identity] |
| * The function invoked per iteration. |
| * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. |
| * @returns {boolean} Returns `true` if all elements pass the predicate check, |
| * else `false`. |
| * @example |
| * |
| * _.every([true, 1, null, 'yes'], Boolean); |
| * // => false |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36, 'active': false }, |
| * { 'user': 'fred', 'age': 40, 'active': false } |
| * ]; |
| * |
| * // The `_.matches` iteratee shorthand. |
| * _.every(users, { 'user': 'barney', 'active': false }); |
| * // => false |
| * |
| * // The `_.matchesProperty` iteratee shorthand. |
| * _.every(users, ['active', false]); |
| * // => true |
| * |
| * // The `_.property` iteratee shorthand. |
| * _.every(users, 'active'); |
| * // => false |
| */ |
| function every(collection, predicate, guard) { |
| predicate = guard ? undefined : predicate; |
| return baseEvery(collection, baseIteratee(predicate)); |
| } |
| |
| /** |
| * Iterates over elements of `collection`, returning an array of all elements |
| * `predicate` returns truthy for. The predicate is invoked with three |
| * arguments: (value, index|key, collection). |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Collection |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {Array|Function|Object|string} [predicate=_.identity] |
| * The function invoked per iteration. |
| * @returns {Array} Returns the new filtered array. |
| * @see _.reject |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36, 'active': true }, |
| * { 'user': 'fred', 'age': 40, 'active': false } |
| * ]; |
| * |
| * _.filter(users, function(o) { return !o.active; }); |
| * // => objects for ['fred'] |
| * |
| * // The `_.matches` iteratee shorthand. |
| * _.filter(users, { 'age': 36, 'active': true }); |
| * // => objects for ['barney'] |
| * |
| * // The `_.matchesProperty` iteratee shorthand. |
| * _.filter(users, ['active', false]); |
| * // => objects for ['fred'] |
| * |
| * // The `_.property` iteratee shorthand. |
| * _.filter(users, 'active'); |
| * // => objects for ['barney'] |
| */ |
| function filter(collection, predicate) { |
| return baseFilter(collection, baseIteratee(predicate)); |
| } |
| |
| /** |
| * Iterates over elements of `collection`, returning the first element |
| * `predicate` returns truthy for. The predicate is invoked with three |
| * arguments: (value, index|key, collection). |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Collection |
| * @param {Array|Object} collection The collection to search. |
| * @param {Array|Function|Object|string} [predicate=_.identity] |
| * The function invoked per iteration. |
| * @returns {*} Returns the matched element, else `undefined`. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36, 'active': true }, |
| * { 'user': 'fred', 'age': 40, 'active': false }, |
| * { 'user': 'pebbles', 'age': 1, 'active': true } |
| * ]; |
| * |
| * _.find(users, function(o) { return o.age < 40; }); |
| * // => object for 'barney' |
| * |
| * // The `_.matches` iteratee shorthand. |
| * _.find(users, { 'age': 1, 'active': true }); |
| * // => object for 'pebbles' |
| * |
| * // The `_.matchesProperty` iteratee shorthand. |
| * _.find(users, ['active', false]); |
| * // => object for 'fred' |
| * |
| * // The `_.property` iteratee shorthand. |
| * _.find(users, 'active'); |
| * // => object for 'barney' |
| */ |
| function find(collection, predicate) { |
| return baseFind(collection, baseIteratee(predicate), baseEach); |
| } |
| |
| /** |
| * Iterates over elements of `collection` and invokes `iteratee` for each element. |
| * The iteratee is invoked with three arguments: (value, index|key, collection). |
| * Iteratee functions may exit iteration early by explicitly returning `false`. |
| * |
| * **Note:** As with other "Collections" methods, objects with a "length" |
| * property are iterated like arrays. To avoid this behavior use `_.forIn` |
| * or `_.forOwn` for object iteration. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @alias each |
| * @category Collection |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {Function} [iteratee=_.identity] The function invoked per iteration. |
| * @returns {Array|Object} Returns `collection`. |
| * @see _.forEachRight |
| * @example |
| * |
| * _([1, 2]).forEach(function(value) { |
| * console.log(value); |
| * }); |
| * // => Logs `1` then `2`. |
| * |
| * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { |
| * console.log(key); |
| * }); |
| * // => Logs 'a' then 'b' (iteration order is not guaranteed). |
| */ |
| function forEach(collection, iteratee) { |
| return baseEach(collection, baseIteratee(iteratee)); |
| } |
| |
| /** |
| * Creates an array of values by running each element in `collection` thru |
| * `iteratee`. The iteratee is invoked with three arguments: |
| * (value, index|key, collection). |
| * |
| * Many lodash methods are guarded to work as iteratees for methods like |
| * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. |
| * |
| * The guarded methods are: |
| * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, |
| * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`, |
| * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`, |
| * `template`, `trim`, `trimEnd`, `trimStart`, and `words` |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Collection |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {Array|Function|Object|string} [iteratee=_.identity] |
| * The function invoked per iteration. |
| * @returns {Array} Returns the new mapped array. |
| * @example |
| * |
| * function square(n) { |
| * return n * n; |
| * } |
| * |
| * _.map([4, 8], square); |
| * // => [16, 64] |
| * |
| * _.map({ 'a': 4, 'b': 8 }, square); |
| * // => [16, 64] (iteration order is not guaranteed) |
| * |
| * var users = [ |
| * { 'user': 'barney' }, |
| * { 'user': 'fred' } |
| * ]; |
| * |
| * // The `_.property` iteratee shorthand. |
| * _.map(users, 'user'); |
| * // => ['barney', 'fred'] |
| */ |
| function map(collection, iteratee) { |
| return baseMap(collection, baseIteratee(iteratee)); |
| } |
| |
| /** |
| * Reduces `collection` to a value which is the accumulated result of running |
| * each element in `collection` thru `iteratee`, where each successive |
| * invocation is supplied the return value of the previous. If `accumulator` |
| * is not given, the first element of `collection` is used as the initial |
| * value. The iteratee is invoked with four arguments: |
| * (accumulator, value, index|key, collection). |
| * |
| * Many lodash methods are guarded to work as iteratees for methods like |
| * `_.reduce`, `_.reduceRight`, and `_.transform`. |
| * |
| * The guarded methods are: |
| * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`, |
| * and `sortBy` |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Collection |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {Function} [iteratee=_.identity] The function invoked per iteration. |
| * @param {*} [accumulator] The initial value. |
| * @returns {*} Returns the accumulated value. |
| * @see _.reduceRight |
| * @example |
| * |
| * _.reduce([1, 2], function(sum, n) { |
| * return sum + n; |
| * }, 0); |
| * // => 3 |
| * |
| * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { |
| * (result[value] || (result[value] = [])).push(key); |
| * return result; |
| * }, {}); |
| * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed) |
| */ |
| function reduce(collection, iteratee, accumulator) { |
| return baseReduce(collection, baseIteratee(iteratee), accumulator, arguments.length < 3, baseEach); |
| } |
| |
| /** |
| * Gets the size of `collection` by returning its length for array-like |
| * values or the number of own enumerable string keyed properties for objects. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Collection |
| * @param {Array|Object} collection The collection to inspect. |
| * @returns {number} Returns the collection size. |
| * @example |
| * |
| * _.size([1, 2, 3]); |
| * // => 3 |
| * |
| * _.size({ 'a': 1, 'b': 2 }); |
| * // => 2 |
| * |
| * _.size('pebbles'); |
| * // => 7 |
| */ |
| function size(collection) { |
| if (collection == null) { |
| return 0; |
| } |
| collection = isArrayLike(collection) ? collection : keys(collection); |
| return collection.length; |
| } |
| |
| /** |
| * Checks if `predicate` returns truthy for **any** element of `collection`. |
| * Iteration is stopped once `predicate` returns truthy. The predicate is |
| * invoked with three arguments: (value, index|key, collection). |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Collection |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {Array|Function|Object|string} [predicate=_.identity] |
| * The function invoked per iteration. |
| * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. |
| * @returns {boolean} Returns `true` if any element passes the predicate check, |
| * else `false`. |
| * @example |
| * |
| * _.some([null, 0, 'yes', false], Boolean); |
| * // => true |
| * |
| * var users = [ |
| * { 'user': 'barney', 'active': true }, |
| * { 'user': 'fred', 'active': false } |
| * ]; |
| * |
| * // The `_.matches` iteratee shorthand. |
| * _.some(users, { 'user': 'barney', 'active': false }); |
| * // => false |
| * |
| * // The `_.matchesProperty` iteratee shorthand. |
| * _.some(users, ['active', false]); |
| * // => true |
| * |
| * // The `_.property` iteratee shorthand. |
| * _.some(users, 'active'); |
| * // => true |
| */ |
| function some(collection, predicate, guard) { |
| predicate = guard ? undefined : predicate; |
| return baseSome(collection, baseIteratee(predicate)); |
| } |
| |
| /** |
| * Creates an array of elements, sorted in ascending order by the results of |
| * running each element in a collection thru each iteratee. This method |
| * performs a stable sort, that is, it preserves the original sort order of |
| * equal elements. The iteratees are invoked with one argument: (value). |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Collection |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {...(Array|Array[]|Function|Function[]|Object|Object[]|string|string[])} |
| * [iteratees=[_.identity]] The iteratees to sort by. |
| * @returns {Array} Returns the new sorted array. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'fred', 'age': 48 }, |
| * { 'user': 'barney', 'age': 36 }, |
| * { 'user': 'fred', 'age': 40 }, |
| * { 'user': 'barney', 'age': 34 } |
| * ]; |
| * |
| * _.sortBy(users, function(o) { return o.user; }); |
| * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] |
| * |
| * _.sortBy(users, ['user', 'age']); |
| * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]] |
| * |
| * _.sortBy(users, 'user', function(o) { |
| * return Math.floor(o.age / 10); |
| * }); |
| * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] |
| */ |
| function sortBy(collection, iteratee) { |
| var index = 0; |
| iteratee = baseIteratee(iteratee); |
| |
| return baseMap(baseMap(collection, function(value, key, collection) { |
| return { 'value': value, 'index': index++, 'criteria': iteratee(value, key, collection) }; |
| }).sort(function(object, other) { |
| return compareAscending(object.criteria, other.criteria) || (object.index - other.index); |
| }), baseProperty('value')); |
| } |
| |
| /*------------------------------------------------------------------------*/ |
| |
| /** |
| * Creates a function that invokes `func`, with the `this` binding and arguments |
| * of the created function, while it's called less than `n` times. Subsequent |
| * calls to the created function return the result of the last `func` invocation. |
| * |
| * @static |
| * @memberOf _ |
| * @since 3.0.0 |
| * @category Function |
| * @param {number} n The number of calls at which `func` is no longer invoked. |
| * @param {Function} func The function to restrict. |
| * @returns {Function} Returns the new restricted function. |
| * @example |
| * |
| * jQuery(element).on('click', _.before(5, addContactToList)); |
| * // => allows adding up to 4 contacts to the list |
| */ |
| function before(n, func) { |
| var result; |
| if (typeof func != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| n = toInteger(n); |
| return function() { |
| if (--n > 0) { |
| result = func.apply(this, arguments); |
| } |
| if (n <= 1) { |
| func = undefined; |
| } |
| return result; |
| }; |
| } |
| |
| /** |
| * Creates a function that invokes `func` with the `this` binding of `thisArg` |
| * and `partials` prepended to the arguments it receives. |
| * |
| * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds, |
| * may be used as a placeholder for partially applied arguments. |
| * |
| * **Note:** Unlike native `Function#bind` this method doesn't set the "length" |
| * property of bound functions. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Function |
| * @param {Function} func The function to bind. |
| * @param {*} thisArg The `this` binding of `func`. |
| * @param {...*} [partials] The arguments to be partially applied. |
| * @returns {Function} Returns the new bound function. |
| * @example |
| * |
| * var greet = function(greeting, punctuation) { |
| * return greeting + ' ' + this.user + punctuation; |
| * }; |
| * |
| * var object = { 'user': 'fred' }; |
| * |
| * var bound = _.bind(greet, object, 'hi'); |
| * bound('!'); |
| * // => 'hi fred!' |
| * |
| * // Bound with placeholders. |
| * var bound = _.bind(greet, object, _, '!'); |
| * bound('hi'); |
| * // => 'hi fred!' |
| */ |
| var bind = rest(function(func, thisArg, partials) { |
| return createPartialWrapper(func, BIND_FLAG | PARTIAL_FLAG, thisArg, partials); |
| }); |
| |
| /** |
| * Defers invoking the `func` until the current call stack has cleared. Any |
| * additional arguments are provided to `func` when it's invoked. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Function |
| * @param {Function} func The function to defer. |
| * @param {...*} [args] The arguments to invoke `func` with. |
| * @returns {number} Returns the timer id. |
| * @example |
| * |
| * _.defer(function(text) { |
| * console.log(text); |
| * }, 'deferred'); |
| * // => Logs 'deferred' after one or more milliseconds. |
| */ |
| var defer = rest(function(func, args) { |
| return baseDelay(func, 1, args); |
| }); |
| |
| /** |
| * Invokes `func` after `wait` milliseconds. Any additional arguments are |
| * provided to `func` when it's invoked. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Function |
| * @param {Function} func The function to delay. |
| * @param {number} wait The number of milliseconds to delay invocation. |
| * @param {...*} [args] The arguments to invoke `func` with. |
| * @returns {number} Returns the timer id. |
| * @example |
| * |
| * _.delay(function(text) { |
| * console.log(text); |
| * }, 1000, 'later'); |
| * // => Logs 'later' after one second. |
| */ |
| var delay = rest(function(func, wait, args) { |
| return baseDelay(func, toNumber(wait) || 0, args); |
| }); |
| |
| /** |
| * 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. |
| * |
| * @static |
| * @memberOf _ |
| * @since 3.0.0 |
| * @category Function |
| * @param {Function} predicate The predicate to negate. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * function isEven(n) { |
| * return n % 2 == 0; |
| * } |
| * |
| * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven)); |
| * // => [1, 3, 5] |
| */ |
| function negate(predicate) { |
| if (typeof predicate != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| return function() { |
| return !predicate.apply(this, arguments); |
| }; |
| } |
| |
| /** |
| * Creates a function that is restricted to invoking `func` once. Repeat calls |
| * to the function return the value of the first invocation. The `func` is |
| * invoked with the `this` binding and arguments of the created function. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Function |
| * @param {Function} func The function to restrict. |
| * @returns {Function} Returns the new restricted function. |
| * @example |
| * |
| * var initialize = _.once(createApplication); |
| * initialize(); |
| * initialize(); |
| * // `initialize` invokes `createApplication` once |
| */ |
| function once(func) { |
| return before(2, func); |
| } |
| |
| /** |
| * Creates a function that invokes `func` with the `this` binding of the |
| * created function and arguments from `start` and beyond provided as |
| * an array. |
| * |
| * **Note:** This method is based on the |
| * [rest parameter](https://mdn.io/rest_parameters). |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category 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. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var say = _.rest(function(what, names) { |
| * return what + ' ' + _.initial(names).join(', ') + |
| * (_.size(names) > 1 ? ', & ' : '') + _.last(names); |
| * }); |
| * |
| * say('hello', 'fred', 'barney', 'pebbles'); |
| * // => 'hello fred, barney, & pebbles' |
| */ |
| function rest(func, start) { |
| if (typeof func != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| start = nativeMax(start === undefined ? (func.length - 1) : toInteger(start), 0); |
| return function() { |
| var args = arguments, |
| index = -1, |
| length = nativeMax(args.length - start, 0), |
| array = Array(length); |
| |
| while (++index < length) { |
| array[index] = args[start + index]; |
| } |
| var otherArgs = Array(start + 1); |
| index = -1; |
| while (++index < start) { |
| otherArgs[index] = args[index]; |
| } |
| otherArgs[start] = array; |
| return func.apply(this, otherArgs); |
| }; |
| } |
| |
| /*------------------------------------------------------------------------*/ |
| |
| /** |
| * Casts `value` as an array if it's not one. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.4.0 |
| * @category Lang |
| * @param {*} value The value to inspect. |
| * @returns {Array} Returns the cast array. |
| * @example |
| * |
| * _.castArray(1); |
| * // => [1] |
| * |
| * _.castArray({ 'a': 1 }); |
| * // => [{ 'a': 1 }] |
| * |
| * _.castArray('abc'); |
| * // => ['abc'] |
| * |
| * _.castArray(null); |
| * // => [null] |
| * |
| * _.castArray(undefined); |
| * // => [undefined] |
| * |
| * _.castArray(); |
| * // => [] |
| * |
| * var array = [1, 2, 3]; |
| * console.log(_.castArray(array) === array); |
| * // => true |
| */ |
| function castArray() { |
| if (!arguments.length) { |
| return []; |
| } |
| var value = arguments[0]; |
| return isArray(value) ? value : [value]; |
| } |
| |
| /** |
| * Creates a shallow clone of `value`. |
| * |
| * **Note:** This method is loosely based on the |
| * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm) |
| * and supports cloning arrays, array buffers, booleans, date objects, maps, |
| * numbers, `Object` objects, regexes, sets, strings, symbols, and typed |
| * arrays. The own enumerable properties of `arguments` objects are cloned |
| * as plain objects. An empty object is returned for uncloneable values such |
| * as error objects, functions, DOM nodes, and WeakMaps. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to clone. |
| * @returns {*} Returns the cloned value. |
| * @see _.cloneDeep |
| * @example |
| * |
| * var objects = [{ 'a': 1 }, { 'b': 2 }]; |
| * |
| * var shallow = _.clone(objects); |
| * console.log(shallow[0] === objects[0]); |
| * // => true |
| */ |
| function clone(value) { |
| if (!isObject(value)) { |
| return value; |
| } |
| return isArray(value) ? copyArray(value) : copyObject(value, keys(value)); |
| } |
| |
| /** |
| * Performs a |
| * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
| * comparison between two values to determine if they are equivalent. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @returns {boolean} Returns `true` if the values are equivalent, else `false`. |
| * @example |
| * |
| * var object = { 'user': 'fred' }; |
| * var other = { 'user': 'fred' }; |
| * |
| * _.eq(object, object); |
| * // => true |
| * |
| * _.eq(object, other); |
| * // => false |
| * |
| * _.eq('a', 'a'); |
| * // => true |
| * |
| * _.eq('a', Object('a')); |
| * // => false |
| * |
| * _.eq(NaN, NaN); |
| * // => true |
| */ |
| function eq(value, other) { |
| return value === other || (value !== value && other !== other); |
| } |
| |
| /** |
| * Checks if `value` is likely an `arguments` object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, |
| * else `false`. |
| * @example |
| * |
| * _.isArguments(function() { return arguments; }()); |
| * // => true |
| * |
| * _.isArguments([1, 2, 3]); |
| * // => false |
| */ |
| function isArguments(value) { |
| // Safari 8.1 incorrectly makes `arguments.callee` enumerable in strict mode. |
| return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') && |
| (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag); |
| } |
| |
| /** |
| * Checks if `value` is classified as an `Array` object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @type {Function} |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, |
| * else `false`. |
| * @example |
| * |
| * _.isArray([1, 2, 3]); |
| * // => true |
| * |
| * _.isArray(document.body.children); |
| * // => false |
| * |
| * _.isArray('abc'); |
| * // => false |
| * |
| * _.isArray(_.noop); |
| * // => false |
| */ |
| var isArray = Array.isArray; |
| |
| /** |
| * Checks if `value` is array-like. A value is considered array-like if it's |
| * not a function and has a `value.length` that's an integer greater than or |
| * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is array-like, else `false`. |
| * @example |
| * |
| * _.isArrayLike([1, 2, 3]); |
| * // => true |
| * |
| * _.isArrayLike(document.body.children); |
| * // => true |
| * |
| * _.isArrayLike('abc'); |
| * // => true |
| * |
| * _.isArrayLike(_.noop); |
| * // => false |
| */ |
| function isArrayLike(value) { |
| return value != null && isLength(getLength(value)) && !isFunction(value); |
| } |
| |
| /** |
| * This method is like `_.isArrayLike` except that it also checks if `value` |
| * is an object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is an array-like object, |
| * else `false`. |
| * @example |
| * |
| * _.isArrayLikeObject([1, 2, 3]); |
| * // => true |
| * |
| * _.isArrayLikeObject(document.body.children); |
| * // => true |
| * |
| * _.isArrayLikeObject('abc'); |
| * // => false |
| * |
| * _.isArrayLikeObject(_.noop); |
| * // => false |
| */ |
| function isArrayLikeObject(value) { |
| return isObjectLike(value) && isArrayLike(value); |
| } |
| |
| /** |
| * Checks if `value` is classified as a boolean primitive or object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, |
| * else `false`. |
| * @example |
| * |
| * _.isBoolean(false); |
| * // => true |
| * |
| * _.isBoolean(null); |
| * // => false |
| */ |
| function isBoolean(value) { |
| return value === true || value === false || |
| (isObjectLike(value) && objectToString.call(value) == boolTag); |
| } |
| |
| /** |
| * Checks if `value` is classified as a `Date` object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, |
| * else `false`. |
| * @example |
| * |
| * _.isDate(new Date); |
| * // => true |
| * |
| * _.isDate('Mon April 23 2012'); |
| * // => false |
| */ |
| function isDate(value) { |
| return isObjectLike(value) && objectToString.call(value) == dateTag; |
| } |
| |
| /** |
| * Checks if `value` is an empty object, collection, map, or set. |
| * |
| * Objects are considered empty if they have no own enumerable string keyed |
| * properties. |
| * |
| * Array-like values such as `arguments` objects, arrays, buffers, strings, or |
| * jQuery-like collections are considered empty if they have a `length` of `0`. |
| * Similarly, maps and sets are considered empty if they have a `size` of `0`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is empty, else `false`. |
| * @example |
| * |
| * _.isEmpty(null); |
| * // => true |
| * |
| * _.isEmpty(true); |
| * // => true |
| * |
| * _.isEmpty(1); |
| * // => true |
| * |
| * _.isEmpty([1, 2, 3]); |
| * // => false |
| * |
| * _.isEmpty({ 'a': 1 }); |
| * // => false |
| */ |
| function isEmpty(value) { |
| if (isArrayLike(value) && |
| (isArray(value) || isString(value) || |
| isFunction(value.splice) || isArguments(value))) { |
| return !value.length; |
| } |
| return !keys(value).length; |
| } |
| |
| /** |
| * Performs a deep comparison between two values to determine if they are |
| * equivalent. |
| * |
| * **Note:** This method supports comparing arrays, array buffers, booleans, |
| * date objects, error objects, maps, numbers, `Object` objects, regexes, |
| * sets, strings, symbols, and typed arrays. `Object` objects are compared |
| * by their own, not inherited, enumerable properties. Functions and DOM |
| * nodes are **not** supported. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @returns {boolean} Returns `true` if the values are equivalent, |
| * else `false`. |
| * @example |
| * |
| * var object = { 'user': 'fred' }; |
| * var other = { 'user': 'fred' }; |
| * |
| * _.isEqual(object, other); |
| * // => true |
| * |
| * object === other; |
| * // => false |
| */ |
| function isEqual(value, other) { |
| return baseIsEqual(value, other); |
| } |
| |
| /** |
| * Checks if `value` is a finite primitive number. |
| * |
| * **Note:** This method is based on |
| * [`Number.isFinite`](https://mdn.io/Number/isFinite). |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a finite number, |
| * else `false`. |
| * @example |
| * |
| * _.isFinite(3); |
| * // => true |
| * |
| * _.isFinite(Number.MAX_VALUE); |
| * // => true |
| * |
| * _.isFinite(3.14); |
| * // => true |
| * |
| * _.isFinite(Infinity); |
| * // => false |
| */ |
| function isFinite(value) { |
| return typeof value == 'number' && nativeIsFinite(value); |
| } |
| |
| /** |
| * Checks if `value` is classified as a `Function` object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, |
| * else `false`. |
| * @example |
| * |
| * _.isFunction(_); |
| * // => true |
| * |
| * _.isFunction(/abc/); |
| * // => false |
| */ |
| function isFunction(value) { |
| // The use of `Object#toString` avoids issues with the `typeof` operator |
| // in Safari 8 which returns 'object' for typed array and weak map constructors, |
| // and PhantomJS 1.9 which returns 'function' for `NodeList` instances. |
| var tag = isObject(value) ? objectToString.call(value) : ''; |
| return tag == funcTag || tag == genTag; |
| } |
| |
| /** |
| * Checks if `value` is a valid array-like length. |
| * |
| * **Note:** This function is loosely based on |
| * [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength). |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a valid length, |
| * else `false`. |
| * @example |
| * |
| * _.isLength(3); |
| * // => true |
| * |
| * _.isLength(Number.MIN_VALUE); |
| * // => false |
| * |
| * _.isLength(Infinity); |
| * // => false |
| * |
| * _.isLength('3'); |
| * // => false |
| */ |
| function isLength(value) { |
| return typeof value == 'number' && |
| value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; |
| } |
| |
| /** |
| * Checks if `value` is the |
| * [language type](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types) |
| * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is an object, else `false`. |
| * @example |
| * |
| * _.isObject({}); |
| * // => true |
| * |
| * _.isObject([1, 2, 3]); |
| * // => true |
| * |
| * _.isObject(_.noop); |
| * // => true |
| * |
| * _.isObject(null); |
| * // => false |
| */ |
| function isObject(value) { |
| var type = typeof value; |
| return !!value && (type == 'object' || type == 'function'); |
| } |
| |
| /** |
| * Checks if `value` is object-like. A value is object-like if it's not `null` |
| * and has a `typeof` result of "object". |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is object-like, else `false`. |
| * @example |
| * |
| * _.isObjectLike({}); |
| * // => true |
| * |
| * _.isObjectLike([1, 2, 3]); |
| * // => true |
| * |
| * _.isObjectLike(_.noop); |
| * // => false |
| * |
| * _.isObjectLike(null); |
| * // => false |
| */ |
| function isObjectLike(value) { |
| return !!value && typeof value == 'object'; |
| } |
| |
| /** |
| * Checks if `value` is `NaN`. |
| * |
| * **Note:** This method is based on |
| * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as |
| * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for |
| * `undefined` and other non-number values. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. |
| * @example |
| * |
| * _.isNaN(NaN); |
| * // => true |
| * |
| * _.isNaN(new Number(NaN)); |
| * // => true |
| * |
| * isNaN(undefined); |
| * // => true |
| * |
| * _.isNaN(undefined); |
| * // => false |
| */ |
| function isNaN(value) { |
| // An `NaN` primitive is the only value that is not equal to itself. |
| // Perform the `toStringTag` check first to avoid errors with some |
| // ActiveX objects in IE. |
| return isNumber(value) && value != +value; |
| } |
| |
| /** |
| * Checks if `value` is `null`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is `null`, else `false`. |
| * @example |
| * |
| * _.isNull(null); |
| * // => true |
| * |
| * _.isNull(void 0); |
| * // => false |
| */ |
| function isNull(value) { |
| return value === null; |
| } |
| |
| /** |
| * 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. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, |
| * else `false`. |
| * @example |
| * |
| * _.isNumber(3); |
| * // => true |
| * |
| * _.isNumber(Number.MIN_VALUE); |
| * // => true |
| * |
| * _.isNumber(Infinity); |
| * // => true |
| * |
| * _.isNumber('3'); |
| * // => false |
| */ |
| function isNumber(value) { |
| return typeof value == 'number' || |
| (isObjectLike(value) && objectToString.call(value) == numberTag); |
| } |
| |
| /** |
| * Checks if `value` is classified as a `RegExp` object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, |
| * else `false`. |
| * @example |
| * |
| * _.isRegExp(/abc/); |
| * // => true |
| * |
| * _.isRegExp('/abc/'); |
| * // => false |
| */ |
| function isRegExp(value) { |
| return isObject(value) && objectToString.call(value) == regexpTag; |
| } |
| |
| /** |
| * Checks if `value` is classified as a `String` primitive or object. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, |
| * else `false`. |
| * @example |
| * |
| * _.isString('abc'); |
| * // => true |
| * |
| * _.isString(1); |
| * // => false |
| */ |
| function isString(value) { |
| return typeof value == 'string' || |
| (!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag); |
| } |
| |
| /** |
| * Checks if `value` is `undefined`. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. |
| * @example |
| * |
| * _.isUndefined(void 0); |
| * // => true |
| * |
| * _.isUndefined(null); |
| * // => false |
| */ |
| function isUndefined(value) { |
| return value === undefined; |
| } |
| |
| /** |
| * Converts `value` to an array. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to convert. |
| * @returns {Array} Returns the converted array. |
| * @example |
| * |
| * _.toArray({ 'a': 1, 'b': 2 }); |
| * // => [1, 2] |
| * |
| * _.toArray('abc'); |
| * // => ['a', 'b', 'c'] |
| * |
| * _.toArray(1); |
| * // => [] |
| * |
| * _.toArray(null); |
| * // => [] |
| */ |
| function toArray(value) { |
| if (!isArrayLike(value)) { |
| return values(value); |
| } |
| return value.length ? copyArray(value) : []; |
| } |
| |
| /** |
| * Converts `value` to an integer. |
| * |
| * **Note:** This function is loosely based on |
| * [`ToInteger`](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger). |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to convert. |
| * @returns {number} Returns the converted integer. |
| * @example |
| * |
| * _.toInteger(3); |
| * // => 3 |
| * |
| * _.toInteger(Number.MIN_VALUE); |
| * // => 0 |
| * |
| * _.toInteger(Infinity); |
| * // => 1.7976931348623157e+308 |
| * |
| * _.toInteger('3'); |
| * // => 3 |
| */ |
| var toInteger = Number; |
| |
| /** |
| * Converts `value` to a number. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to process. |
| * @returns {number} Returns the number. |
| * @example |
| * |
| * _.toNumber(3); |
| * // => 3 |
| * |
| * _.toNumber(Number.MIN_VALUE); |
| * // => 5e-324 |
| * |
| * _.toNumber(Infinity); |
| * // => Infinity |
| * |
| * _.toNumber('3'); |
| * // => 3 |
| */ |
| var toNumber = Number; |
| |
| /** |
| * Converts `value` to a string. An empty string is returned for `null` |
| * and `undefined` values. The sign of `-0` is preserved. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to process. |
| * @returns {string} Returns the string. |
| * @example |
| * |
| * _.toString(null); |
| * // => '' |
| * |
| * _.toString(-0); |
| * // => '-0' |
| * |
| * _.toString([1, 2, 3]); |
| * // => '1,2,3' |
| */ |
| function toString(value) { |
| if (typeof value == 'string') { |
| return value; |
| } |
| return value == null ? '' : (value + ''); |
| } |
| |
| /*------------------------------------------------------------------------*/ |
| |
| /** |
| * Assigns own enumerable string keyed properties of source objects to the |
| * destination object. Source objects are applied from left to right. |
| * Subsequent sources overwrite property assignments of previous sources. |
| * |
| * **Note:** This method mutates `object` and is loosely based on |
| * [`Object.assign`](https://mdn.io/Object/assign). |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.10.0 |
| * @category Object |
| * @param {Object} object The destination object. |
| * @param {...Object} [sources] The source objects. |
| * @returns {Object} Returns `object`. |
| * @see _.assignIn |
| * @example |
| * |
| * function Foo() { |
| * this.c = 3; |
| * } |
| * |
| * function Bar() { |
| * this.e = 5; |
| * } |
| * |
| * Foo.prototype.d = 4; |
| * Bar.prototype.f = 6; |
| * |
| * _.assign({ 'a': 1 }, new Foo, new Bar); |
| * // => { 'a': 1, 'c': 3, 'e': 5 } |
| */ |
| var assign = createAssigner(function(object, source) { |
| copyObject(source, keys(source), object); |
| }); |
| |
| /** |
| * This method is like `_.assign` except that it iterates over own and |
| * inherited source properties. |
| * |
| * **Note:** This method mutates `object`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @alias extend |
| * @category Object |
| * @param {Object} object The destination object. |
| * @param {...Object} [sources] The source objects. |
| * @returns {Object} Returns `object`. |
| * @see _.assign |
| * @example |
| * |
| * function Foo() { |
| * this.b = 2; |
| * } |
| * |
| * function Bar() { |
| * this.d = 4; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * Bar.prototype.e = 5; |
| * |
| * _.assignIn({ 'a': 1 }, new Foo, new Bar); |
| * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5 } |
| */ |
| var assignIn = createAssigner(function(object, source) { |
| copyObject(source, keysIn(source), object); |
| }); |
| |
| /** |
| * This method is like `_.assignIn` except that it accepts `customizer` |
| * which is invoked to produce the assigned values. If `customizer` returns |
| * `undefined`, assignment is handled by the method instead. The `customizer` |
| * is invoked with five arguments: (objValue, srcValue, key, object, source). |
| * |
| * **Note:** This method mutates `object`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @alias extendWith |
| * @category Object |
| * @param {Object} object The destination object. |
| * @param {...Object} sources The source objects. |
| * @param {Function} [customizer] The function to customize assigned values. |
| * @returns {Object} Returns `object`. |
| * @see _.assignWith |
| * @example |
| * |
| * function customizer(objValue, srcValue) { |
| * return _.isUndefined(objValue) ? srcValue : objValue; |
| * } |
| * |
| * var defaults = _.partialRight(_.assignInWith, customizer); |
| * |
| * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); |
| * // => { 'a': 1, 'b': 2 } |
| */ |
| var assignInWith = createAssigner(function(object, source, srcIndex, customizer) { |
| copyObject(source, keysIn(source), object, customizer); |
| }); |
| |
| /** |
| * Creates an object that inherits from the `prototype` object. If a |
| * `properties` object is given, its own enumerable string keyed properties |
| * are assigned to the created object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 2.3.0 |
| * @category Object |
| * @param {Object} prototype The object to inherit from. |
| * @param {Object} [properties] The properties to assign to the object. |
| * @returns {Object} Returns the new object. |
| * @example |
| * |
| * function Shape() { |
| * this.x = 0; |
| * this.y = 0; |
| * } |
| * |
| * function Circle() { |
| * Shape.call(this); |
| * } |
| * |
| * Circle.prototype = _.create(Shape.prototype, { |
| * 'constructor': Circle |
| * }); |
| * |
| * var circle = new Circle; |
| * circle instanceof Circle; |
| * // => true |
| * |
| * circle instanceof Shape; |
| * // => true |
| */ |
| function create(prototype, properties) { |
| var result = baseCreate(prototype); |
| return properties ? assign(result, properties) : result; |
| } |
| |
| /** |
| * Assigns own and inherited enumerable string keyed properties of source |
| * objects to the destination object for all destination properties that |
| * resolve to `undefined`. Source objects are applied from left to right. |
| * Once a property is set, additional values of the same property are ignored. |
| * |
| * **Note:** This method mutates `object`. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The destination object. |
| * @param {...Object} [sources] The source objects. |
| * @returns {Object} Returns `object`. |
| * @see _.defaultsDeep |
| * @example |
| * |
| * _.defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' }); |
| * // => { 'user': 'barney', 'age': 36 } |
| */ |
| var defaults = rest(function(args) { |
| args.push(undefined, assignInDefaults); |
| return assignInWith.apply(undefined, args); |
| }); |
| |
| /** |
| * Checks if `path` is a direct property of `object`. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to query. |
| * @param {Array|string} path The path to check. |
| * @returns {boolean} Returns `true` if `path` exists, else `false`. |
| * @example |
| * |
| * var object = { 'a': { 'b': 2 } }; |
| * var other = _.create({ 'a': _.create({ 'b': 2 }) }); |
| * |
| * _.has(object, 'a'); |
| * // => true |
| * |
| * _.has(object, 'a.b'); |
| * // => true |
| * |
| * _.has(object, ['a', 'b']); |
| * // => true |
| * |
| * _.has(other, 'a'); |
| * // => false |
| */ |
| function has(object, path) { |
| return object != null && hasOwnProperty.call(object, path); |
| } |
| |
| /** |
| * Creates an array of the own enumerable property names of `object`. |
| * |
| * **Note:** Non-object values are coerced to objects. See the |
| * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys) |
| * for more details. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to query. |
| * @returns {Array} Returns the array of property names. |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * this.b = 2; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * |
| * _.keys(new Foo); |
| * // => ['a', 'b'] (iteration order is not guaranteed) |
| * |
| * _.keys('hi'); |
| * // => ['0', '1'] |
| */ |
| function keys(object) { |
| var isProto = isPrototype(object); |
| if (!(isProto || isArrayLike(object))) { |
| return baseKeys(object); |
| } |
| var indexes = indexKeys(object), |
| skipIndexes = !!indexes, |
| result = indexes || [], |
| length = result.length; |
| |
| for (var key in object) { |
| if (hasOwnProperty.call(object, key) && |
| !(skipIndexes && (key == 'length' || isIndex(key, length))) && |
| !(isProto && key == 'constructor')) { |
| result.push(key); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Creates an array of the own and inherited enumerable property names of `object`. |
| * |
| * **Note:** Non-object values are coerced to objects. |
| * |
| * @static |
| * @memberOf _ |
| * @since 3.0.0 |
| * @category Object |
| * @param {Object} object The object to query. |
| * @returns {Array} Returns the array of property names. |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * this.b = 2; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * |
| * _.keysIn(new Foo); |
| * // => ['a', 'b', 'c'] (iteration order is not guaranteed) |
| */ |
| function keysIn(object) { |
| var index = -1, |
| isProto = isPrototype(object), |
| props = baseKeysIn(object), |
| propsLength = props.length, |
| indexes = indexKeys(object), |
| skipIndexes = !!indexes, |
| result = indexes || [], |
| length = result.length; |
| |
| while (++index < propsLength) { |
| var key = props[index]; |
| if (!(skipIndexes && (key == 'length' || isIndex(key, length))) && |
| !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { |
| result.push(key); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Creates an object composed of the picked `object` properties. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The source object. |
| * @param {...(string|string[])} [props] The property identifiers to pick. |
| * @returns {Object} Returns the new object. |
| * @example |
| * |
| * var object = { 'a': 1, 'b': '2', 'c': 3 }; |
| * |
| * _.pick(object, ['a', 'c']); |
| * // => { 'a': 1, 'c': 3 } |
| */ |
| var pick = rest(function(object, props) { |
| return object == null ? {} : basePick(object, baseMap(baseFlatten(props, 1), toKey)); |
| }); |
| |
| /** |
| * This method is like `_.get` except that if the resolved value is a |
| * function it's invoked with the `this` binding of its parent object and |
| * its result is returned. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to query. |
| * @param {Array|string} path The path of the property to resolve. |
| * @param {*} [defaultValue] The value returned for `undefined` resolved values. |
| * @returns {*} Returns the resolved value. |
| * @example |
| * |
| * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] }; |
| * |
| * _.result(object, 'a[0].b.c1'); |
| * // => 3 |
| * |
| * _.result(object, 'a[0].b.c2'); |
| * // => 4 |
| * |
| * _.result(object, 'a[0].b.c3', 'default'); |
| * // => 'default' |
| * |
| * _.result(object, 'a[0].b.c3', _.constant('default')); |
| * // => 'default' |
| */ |
| function result(object, path, defaultValue) { |
| var value = object == null ? undefined : object[path]; |
| if (value === undefined) { |
| value = defaultValue; |
| } |
| return isFunction(value) ? value.call(object) : value; |
| } |
| |
| /** |
| * Creates an array of the own enumerable string keyed property values of `object`. |
| * |
| * **Note:** Non-object values are coerced to objects. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to query. |
| * @returns {Array} Returns the array of property values. |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * this.b = 2; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * |
| * _.values(new Foo); |
| * // => [1, 2] (iteration order is not guaranteed) |
| * |
| * _.values('hi'); |
| * // => ['h', 'i'] |
| */ |
| function values(object) { |
| return object ? baseValues(object, keys(object)) : []; |
| } |
| |
| /*------------------------------------------------------------------------*/ |
| |
| /** |
| * Converts the characters "&", "<", ">", '"', "'", and "\`" in `string` to |
| * their corresponding HTML entities. |
| * |
| * **Note:** No other characters are escaped. To escape additional |
| * characters use a third-party library like [_he_](https://mths.be/he). |
| * |
| * Though the ">" character is escaped for symmetry, characters like |
| * ">" and "/" don't need escaping in HTML and have no special meaning |
| * unless they're part of a tag or unquoted attribute value. See |
| * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands) |
| * (under "semi-related fun fact") for more details. |
| * |
| * Backticks are escaped because in IE < 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. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to escape. |
| * @returns {string} Returns the escaped string. |
| * @example |
| * |
| * _.escape('fred, barney, & pebbles'); |
| * // => 'fred, barney, & pebbles' |
| */ |
| function escape(string) { |
| string = toString(string); |
| return (string && reHasUnescapedHtml.test(string)) |
| ? string.replace(reUnescapedHtml, escapeHtmlChar) |
| : string; |
| } |
| |
| /*------------------------------------------------------------------------*/ |
| |
| /** |
| * This method returns the first argument given to it. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Util |
| * @param {*} value Any value. |
| * @returns {*} Returns `value`. |
| * @example |
| * |
| * var object = { 'user': 'fred' }; |
| * |
| * _.identity(object) === object; |
| * // => true |
| */ |
| function identity(value) { |
| return value; |
| } |
| |
| /** |
| * Creates a function that invokes `func` with the arguments of the created |
| * function. If `func` is a property name, the created function returns the |
| * property value for a given element. If `func` is an array or object, the |
| * created function returns `true` for elements that contain the equivalent |
| * source properties, otherwise it returns `false`. |
| * |
| * @static |
| * @since 4.0.0 |
| * @memberOf _ |
| * @category Util |
| * @param {*} [func=_.identity] The value to convert to a callback. |
| * @returns {Function} Returns the callback. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36, 'active': true }, |
| * { 'user': 'fred', 'age': 40, 'active': false } |
| * ]; |
| * |
| * // The `_.matches` iteratee shorthand. |
| * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true })); |
| * // => [{ 'user': 'barney', 'age': 36, 'active': true }] |
| * |
| * // The `_.matchesProperty` iteratee shorthand. |
| * _.filter(users, _.iteratee(['user', 'fred'])); |
| * // => [{ 'user': 'fred', 'age': 40 }] |
| * |
| * // The `_.property` iteratee shorthand. |
| * _.map(users, _.iteratee('user')); |
| * // => ['barney', 'fred'] |
| * |
| * // Create custom iteratee shorthands. |
| * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) { |
| * return !_.isRegExp(func) ? iteratee(func) : function(string) { |
| * return func.test(string); |
| * }; |
| * }); |
| * |
| * _.filter(['abc', 'def'], /ef/); |
| * // => ['def'] |
| */ |
| var iteratee = baseIteratee; |
| |
| /** |
| * Creates a function that performs a partial deep comparison between a given |
| * object and `source`, returning `true` if the given object has equivalent |
| * property values, else `false`. The created function is equivalent to |
| * `_.isMatch` with a `source` partially applied. |
| * |
| * **Note:** This method supports comparing the same values as `_.isEqual`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 3.0.0 |
| * @category Util |
| * @param {Object} source The object of property values to match. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36, 'active': true }, |
| * { 'user': 'fred', 'age': 40, 'active': false } |
| * ]; |
| * |
| * _.filter(users, _.matches({ 'age': 40, 'active': false })); |
| * // => [{ 'user': 'fred', 'age': 40, 'active': false }] |
| */ |
| function matches(source) { |
| return baseMatches(assign({}, source)); |
| } |
| |
| /** |
| * Adds all own enumerable string keyed function properties of a source |
| * object to the destination object. If `object` is a function, then methods |
| * are added to its prototype as well. |
| * |
| * **Note:** Use `_.runInContext` to create a pristine `lodash` function to |
| * avoid conflicts caused by modifying the original. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Util |
| * @param {Function|Object} [object=lodash] The destination object. |
| * @param {Object} source The object of functions to add. |
| * @param {Object} [options={}] The options object. |
| * @param {boolean} [options.chain=true] Specify whether mixins are chainable. |
| * @returns {Function|Object} Returns `object`. |
| * @example |
| * |
| * function vowels(string) { |
| * return _.filter(string, function(v) { |
| * return /[aeiou]/i.test(v); |
| * }); |
| * } |
| * |
| * _.mixin({ 'vowels': vowels }); |
| * _.vowels('fred'); |
| * // => ['e'] |
| * |
| * _('fred').vowels().value(); |
| * // => ['e'] |
| * |
| * _.mixin({ 'vowels': vowels }, { 'chain': false }); |
| * _('fred').vowels(); |
| * // => ['e'] |
| */ |
| function mixin(object, source, options) { |
| var props = keys(source), |
| methodNames = baseFunctions(source, props); |
| |
| if (options == null && |
| !(isObject(source) && (methodNames.length || !props.length))) { |
| options = source; |
| source = object; |
| object = this; |
| methodNames = baseFunctions(source, keys(source)); |
| } |
| var chain = !(isObject(options) && 'chain' in options) || !!options.chain, |
| isFunc = isFunction(object); |
| |
| baseEach(methodNames, function(methodName) { |
| var func = source[methodName]; |
| object[methodName] = func; |
| if (isFunc) { |
| object.prototype[methodName] = function() { |
| var chainAll = this.__chain__; |
| if (chain || chainAll) { |
| var result = object(this.__wrapped__), |
| actions = result.__actions__ = copyArray(this.__actions__); |
| |
| actions.push({ 'func': func, 'args': arguments, 'thisArg': object }); |
| result.__chain__ = chainAll; |
| return result; |
| } |
| return func.apply(object, arrayPush([this.value()], arguments)); |
| }; |
| } |
| }); |
| |
| return object; |
| } |
| |
| /** |
| * Reverts the `_` variable to its previous value and returns a reference to |
| * the `lodash` function. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Util |
| * @returns {Function} Returns the `lodash` function. |
| * @example |
| * |
| * var lodash = _.noConflict(); |
| */ |
| function noConflict() { |
| if (root._ === this) { |
| root._ = oldDash; |
| } |
| return this; |
| } |
| |
| /** |
| * A no-operation function that returns `undefined` regardless of the |
| * arguments it receives. |
| * |
| * @static |
| * @memberOf _ |
| * @since 2.3.0 |
| * @category Util |
| * @example |
| * |
| * var object = { 'user': 'fred' }; |
| * |
| * _.noop(object) === undefined; |
| * // => true |
| */ |
| function noop() { |
| // No operation performed. |
| } |
| |
| /** |
| * Generates a unique ID. If `prefix` is given, the ID is appended to it. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Util |
| * @param {string} [prefix=''] The value to prefix the ID with. |
| * @returns {string} Returns the unique ID. |
| * @example |
| * |
| * _.uniqueId('contact_'); |
| * // => 'contact_104' |
| * |
| * _.uniqueId(); |
| * // => '105' |
| */ |
| function uniqueId(prefix) { |
| var id = ++idCounter; |
| return toString(prefix) + id; |
| } |
| |
| /*------------------------------------------------------------------------*/ |
| |
| /** |
| * Computes the maximum value of `array`. If `array` is empty or falsey, |
| * `undefined` is returned. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Math |
| * @param {Array} array The array to iterate over. |
| * @returns {*} Returns the maximum value. |
| * @example |
| * |
| * _.max([4, 2, 8, 6]); |
| * // => 8 |
| * |
| * _.max([]); |
| * // => undefined |
| */ |
| function max(array) { |
| return (array && array.length) |
| ? baseExtremum(array, identity, baseGt) |
| : undefined; |
| } |
| |
| /** |
| * Computes the minimum value of `array`. If `array` is empty or falsey, |
| * `undefined` is returned. |
| * |
| * @static |
| * @since 0.1.0 |
| * @memberOf _ |
| * @category Math |
| * @param {Array} array The array to iterate over. |
| * @returns {*} Returns the minimum value. |
| * @example |
| * |
| * _.min([4, 2, 8, 6]); |
| * // => 2 |
| * |
| * _.min([]); |
| * // => undefined |
| */ |
| function min(array) { |
| return (array && array.length) |
| ? baseExtremum(array, identity, baseLt) |
| : undefined; |
| } |
| |
| /*------------------------------------------------------------------------*/ |
| |
| // Add methods that return wrapped values in chain sequences. |
| lodash.assignIn = assignIn; |
| lodash.before = before; |
| lodash.bind = bind; |
| lodash.chain = chain; |
| lodash.compact = compact; |
| lodash.concat = concat; |
| lodash.create = create; |
| lodash.defaults = defaults; |
| lodash.defer = defer; |
| lodash.delay = delay; |
| lodash.filter = filter; |
| lodash.flatten = flatten; |
| lodash.flattenDeep = flattenDeep; |
| lodash.iteratee = iteratee; |
| lodash.keys = keys; |
| lodash.map = map; |
| lodash.matches = matches; |
| lodash.mixin = mixin; |
| lodash.negate = negate; |
| lodash.once = once; |
| lodash.pick = pick; |
| lodash.slice = slice; |
| lodash.sortBy = sortBy; |
| lodash.tap = tap; |
| lodash.thru = thru; |
| lodash.toArray = toArray; |
| lodash.values = values; |
| |
| // Add aliases. |
| lodash.extend = assignIn; |
| |
| // Add methods to `lodash.prototype`. |
| mixin(lodash, lodash); |
| |
| /*------------------------------------------------------------------------*/ |
| |
| // Add methods that return unwrapped values in chain sequences. |
| lodash.clone = clone; |
| lodash.escape = escape; |
| lodash.every = every; |
| lodash.find = find; |
| lodash.forEach = forEach; |
| lodash.has = has; |
| lodash.head = head; |
| lodash.identity = identity; |
| lodash.indexOf = indexOf; |
| lodash.isArguments = isArguments; |
| lodash.isArray = isArray; |
| lodash.isBoolean = isBoolean; |
| lodash.isDate = isDate; |
| lodash.isEmpty = isEmpty; |
| lodash.isEqual = isEqual; |
| lodash.isFinite = isFinite; |
| lodash.isFunction = isFunction; |
| lodash.isNaN = isNaN; |
| lodash.isNull = isNull; |
| lodash.isNumber = isNumber; |
| lodash.isObject = isObject; |
| lodash.isRegExp = isRegExp; |
| lodash.isString = isString; |
| lodash.isUndefined = isUndefined; |
| lodash.last = last; |
| lodash.max = max; |
| lodash.min = min; |
| lodash.noConflict = noConflict; |
| lodash.noop = noop; |
| lodash.reduce = reduce; |
| lodash.result = result; |
| lodash.size = size; |
| lodash.some = some; |
| lodash.uniqueId = uniqueId; |
| |
| // Add aliases. |
| lodash.each = forEach; |
| lodash.first = head; |
| |
| mixin(lodash, (function() { |
| var source = {}; |
| baseForOwn(lodash, function(func, methodName) { |
| if (!hasOwnProperty.call(lodash.prototype, methodName)) { |
| source[methodName] = func; |
| } |
| }); |
| return source; |
| }()), { 'chain': false }); |
| |
| /*------------------------------------------------------------------------*/ |
| |
| /** |
| * The semantic version number. |
| * |
| * @static |
| * @memberOf _ |
| * @type {string} |
| */ |
| lodash.VERSION = VERSION; |
| |
| // Add `Array` methods to `lodash.prototype`. |
| baseEach(['pop', 'join', 'replace', 'reverse', 'split', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) { |
| var func = (/^(?:replace|split)$/.test(methodName) ? String.prototype : arrayProto)[methodName], |
| chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru', |
| retUnwrapped = /^(?:pop|join|replace|shift)$/.test(methodName); |
| |
| lodash.prototype[methodName] = function() { |
| var args = arguments; |
| if (retUnwrapped && !this.__chain__) { |
| var value = this.value(); |
| return func.apply(isArray(value) ? value : [], args); |
| } |
| return this[chainName](function(value) { |
| return func.apply(isArray(value) ? value : [], args); |
| }); |
| }; |
| }); |
| |
| // Add chain sequence methods to the `lodash` wrapper. |
| lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue; |
| |
| /*--------------------------------------------------------------------------*/ |
| |
| // Expose Lodash on the free variable `window` or `self` when available so it's |
| // globally accessible, even when bundled with Browserify, Webpack, etc. This |
| // also prevents errors in cases where Lodash is loaded by a script tag in the |
| // presence of an AMD loader. See http://requirejs.org/docs/errors.html#mismatch |
| // for more details. Use `_.noConflict` to remove Lodash from the global object. |
| (freeWindow || freeSelf || {})._ = lodash; |
| |
| // Some AMD build optimizers like r.js check for condition patterns like the following: |
| if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) { |
| // Define as an anonymous module so, through path mapping, it can be |
| // referenced as the "underscore" module. |
| define(function() { |
| return lodash; |
| }); |
| } |
| // Check for `exports` after `define` in case a build optimizer adds an `exports` object. |
| else if (freeExports && freeModule) { |
| // Export for Node.js. |
| if (moduleExports) { |
| (freeModule.exports = lodash)._ = lodash; |
| } |
| // Export for CommonJS support. |
| freeExports._ = lodash; |
| } |
| else { |
| // Export to the global object. |
| root._ = lodash; |
| } |
| }.call(this)); |