| 
								
							 | 
							
								var arrayReduce = require('./_arrayReduce'),
							 | 
						
						
						
							| 
								
							 | 
							
								    baseEach = require('./_baseEach'),
							 | 
						
						
						
							| 
								
							 | 
							
								    baseIteratee = require('./_baseIteratee'),
							 | 
						
						
						
							| 
								
							 | 
							
								    baseReduce = require('./_baseReduce'),
							 | 
						
						
						
							| 
								
							 | 
							
								    isArray = require('./isArray');
							 | 
						
						
						
							| 
								
							 | 
							
								
							 | 
						
						
						
							| 
								
							 | 
							
								/**
							 | 
						
						
						
							| 
								
							 | 
							
								 * 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) {
							 | 
						
						
						
							| 
								
							 | 
							
								  var func = isArray(collection) ? arrayReduce : baseReduce,
							 | 
						
						
						
							| 
								
							 | 
							
								      initAccum = arguments.length < 3;
							 | 
						
						
						
							| 
								
							 | 
							
								
							 | 
						
						
						
							| 
								
							 | 
							
								  return func(collection, baseIteratee(iteratee, 4), accumulator, initAccum, baseEach);
							 | 
						
						
						
							| 
								
							 | 
							
								}
							 | 
						
						
						
							| 
								
							 | 
							
								
							 | 
						
						
						
							| 
								
							 | 
							
								module.exports = reduce;
							 |