Bump to v3.0.0.

collection/all.js

@@ -0,0 +1,3 @@
+define(["./every"], function(every) {
+  return every;
+});

collection/any.js

@@ -0,0 +1,3 @@
+define(["./some"], function(some) {
+  return some;
+});

collection/at.js

@@ -0,0 +1,32 @@
+define(['../internal/baseAt', '../internal/baseFlatten', '../internal/isLength', '../internal/toIterable'], function(baseAt, baseFlatten, isLength, toIterable) {
+
+  /**
+   * Creates an array of elements corresponding to the given keys, or indexes,
+   * of `collection`. Keys may be specified as individual arguments or as arrays
+   * of keys.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {...(number|number[]|string|string[])} [props] The property names
+   *  or indexes of elements to pick, specified individually or in arrays.
+   * @returns {Array} Returns the new array of picked elements.
+   * @example
+   *
+   * _.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]);
+   * // => ['a', 'c', 'e']
+   *
+   * _.at(['fred', 'barney', 'pebbles'], 0, 2);
+   * // => ['fred', 'pebbles']
+   */
+  function at(collection) {
+    var length = collection ? collection.length : 0;
+    if (isLength(length)) {
+      collection = toIterable(collection);
+    }
+    return baseAt(collection, baseFlatten(arguments, false, false, 1));
+  }
+
+  return at;
+});

collection/collect.js

@@ -0,0 +1,3 @@
+define(["./map"], function(map) {
+  return map;
+});

collection/contains.js

@@ -0,0 +1,3 @@
+define(["./includes"], function(includes) {
+  return includes;
+});

collection/countBy.js

@@ -0,0 +1,48 @@
+define(['../internal/createAggregator'], function(createAggregator) {
+
+  /** Used for native method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /**
+   * Creates an object composed of keys generated from the results of running
+   * each element of `collection` through `iteratee`. The corresponding value
+   * of each key is the number of times the key was returned by `iteratee`.
+   * The `iteratee` is bound to `thisArg` and invoked with three arguments;
+   * (value, index|key, collection).
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function|Object|string} [iteratee=_.identity] The function invoked
+   *  per iteration. If a property name or object is provided it is used to
+   *  create a "_.property" or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `iteratee`.
+   * @returns {Object} Returns the composed aggregate object.
+   * @example
+   *
+   * _.countBy([4.3, 6.1, 6.4], function(n) { return Math.floor(n); });
+   * // => { '4': 1, '6': 2 }
+   *
+   * _.countBy([4.3, 6.1, 6.4], function(n) { return this.floor(n); }, Math);
+   * // => { '4': 1, '6': 2 }
+   *
+   * _.countBy(['one', 'two', 'three'], 'length');
+   * // => { '3': 2, '5': 1 }
+   */
+  var countBy = createAggregator(function(result, value, key) {
+    hasOwnProperty.call(result, key) ? ++result[key] : (result[key] = 1);
+  });
+
+  return countBy;
+});

collection/detect.js

@@ -0,0 +1,3 @@
+define(["./find"], function(find) {
+  return find;
+});

collection/each.js

@@ -0,0 +1,3 @@
+define(["./forEach"], function(forEach) {
+  return forEach;
+});

collection/eachRight.js

@@ -0,0 +1,3 @@
+define(["./forEachRight"], function(forEachRight) {
+  return forEachRight;
+});

collection/every.js

@@ -0,0 +1,53 @@
+define(['../internal/arrayEvery', '../internal/baseCallback', '../internal/baseEvery', '../lang/isArray'], function(arrayEvery, baseCallback, baseEvery, isArray) {
+
+  /**
+   * Checks if `predicate` returns truthy for **all** elements of `collection`.
+   * The predicate is bound to `thisArg` and invoked with three arguments;
+   * (value, index|key, collection).
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @alias all
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function|Object|string} [predicate=_.identity] The function invoked
+   *  per iteration. If a property name or object is provided it is used to
+   *  create a "_.property" or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `predicate`.
+   * @returns {boolean} Returns `true` if all elements pass the predicate check,
+   *  else `false`.
+   * @example
+   *
+   * _.every([true, 1, null, 'yes']);
+   * // => false
+   *
+   * var users = [
+   *   { 'user': 'barney', 'age': 36 },
+   *   { 'user': 'fred',   'age': 40 }
+   * ];
+   *
+   * // using the "_.property" callback shorthand
+   * _.every(users, 'age');
+   * // => true
+   *
+   * // using the "_.matches" callback shorthand
+   * _.every(users, { 'age': 36 });
+   * // => false
+   */
+  function every(collection, predicate, thisArg) {
+    var func = isArray(collection) ? arrayEvery : baseEvery;
+    if (typeof predicate != 'function' || typeof thisArg != 'undefined') {
+      predicate = baseCallback(predicate, thisArg, 3);
+    }
+    return func(collection, predicate);
+  }
+
+  return every;
+});

collection/filter.js

@@ -0,0 +1,50 @@
+define(['../internal/arrayFilter', '../internal/baseCallback', '../internal/baseFilter', '../lang/isArray'], function(arrayFilter, baseCallback, baseFilter, isArray) {
+
+  /**
+   * Iterates over elements of `collection`, returning an array of all elements
+   * `predicate` returns truthy for. The predicate is bound to `thisArg` and
+   * invoked with three arguments; (value, index|key, collection).
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @alias select
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function|Object|string} [predicate=_.identity] The function invoked
+   *  per iteration. If a property name or object is provided it is used to
+   *  create a "_.property" or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `predicate`.
+   * @returns {Array} Returns the new filtered array.
+   * @example
+   *
+   * var evens = _.filter([1, 2, 3, 4], function(n) { return n % 2 == 0; });
+   * // => [2, 4]
+   *
+   * var users = [
+   *   { 'user': 'barney', 'age': 36, 'active': false },
+   *   { 'user': 'fred',   'age': 40, 'active': true }
+   * ];
+   *
+   * // using the "_.property" callback shorthand
+   * _.pluck(_.filter(users, 'active'), 'user');
+   * // => ['fred']
+   *
+   * // using the "_.matches" callback shorthand
+   * _.pluck(_.filter(users, { 'age': 36 }), 'user');
+   * // => ['barney']
+   */
+  function filter(collection, predicate, thisArg) {
+    var func = isArray(collection) ? arrayFilter : baseFilter;
+    predicate = baseCallback(predicate, thisArg, 3);
+    return func(collection, predicate);
+  }
+
+  return filter;
+});

collection/find.js

@@ -0,0 +1,57 @@
+define(['../internal/baseCallback', '../internal/baseEach', '../internal/baseFind', '../array/findIndex', '../lang/isArray'], function(baseCallback, baseEach, baseFind, findIndex, isArray) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * Iterates over elements of `collection`, returning the first element
+   * `predicate` returns truthy for. The predicate is bound to `thisArg` and
+   * invoked with three arguments; (value, index|key, collection).
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @alias detect
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to search.
+   * @param {Function|Object|string} [predicate=_.identity] The function invoked
+   *  per iteration. If a property name or object is provided it is used to
+   *  create a "_.property" or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `predicate`.
+   * @returns {*} Returns the matched element, else `undefined`.
+   * @example
+   *
+   * var users = [
+   *   { 'user': 'barney',  'age': 36, 'active': false },
+   *   { 'user': 'fred',    'age': 40, 'active': true },
+   *   { 'user': 'pebbles', 'age': 1,  'active': false }
+   * ];
+   *
+   * _.result(_.find(users, function(chr) { return chr.age < 40; }), 'user');
+   * // => 'barney'
+   *
+   * // using the "_.matches" callback shorthand
+   * _.result(_.find(users, { 'age': 1 }), 'user');
+   * // => 'pebbles'
+   *
+   * // using the "_.property" callback shorthand
+   * _.result(_.find(users, 'active'), 'user');
+   * // => 'fred'
+   */
+  function find(collection, predicate, thisArg) {
+    if (isArray(collection)) {
+      var index = findIndex(collection, predicate, thisArg);
+      return index > -1 ? collection[index] : undefined;
+    }
+    predicate = baseCallback(predicate, thisArg, 3);
+    return baseFind(collection, predicate, baseEach);
+  }
+
+  return find;
+});

collection/findLast.js

@@ -0,0 +1,27 @@
+define(['../internal/baseCallback', '../internal/baseEachRight', '../internal/baseFind'], function(baseCallback, baseEachRight, baseFind) {
+
+  /**
+   * This method is like `_.find` except that it iterates over elements of
+   * `collection` from right to left.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to search.
+   * @param {Function|Object|string} [predicate=_.identity] The function invoked
+   *  per iteration. If a property name or object is provided it is used to
+   *  create a "_.property" or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `predicate`.
+   * @returns {*} Returns the matched element, else `undefined`.
+   * @example
+   *
+   * _.findLast([1, 2, 3, 4], function(n) { return n % 2 == 1; });
+   * // => 3
+   */
+  function findLast(collection, predicate, thisArg) {
+    predicate = baseCallback(predicate, thisArg, 3);
+    return baseFind(collection, predicate, baseEachRight);
+  }
+
+  return findLast;
+});

collection/findWhere.js

@@ -0,0 +1,32 @@
+define(['./find', '../utility/matches'], function(find, matches) {
+
+  /**
+   * Performs a deep comparison between each element in `collection` and the
+   * source object, returning the first element that has equivalent property
+   * values.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to search.
+   * @param {Object} source The object of property values to match.
+   * @returns {*} Returns the matched element, else `undefined`.
+   * @example
+   *
+   * var users = [
+   *   { 'user': 'barney', 'age': 36, 'status': 'busy' },
+   *   { 'user': 'fred',   'age': 40, 'status': 'busy' }
+   * ];
+   *
+   * _.result(_.findWhere(users, { 'status': 'busy' }), 'user');
+   * // => 'barney'
+   *
+   * _.result(_.findWhere(users, { 'age': 40 }), 'user');
+   * // => 'fred'
+   */
+  function findWhere(collection, source) {
+    return find(collection, matches(source));
+  }
+
+  return findWhere;
+});

collection/foldl.js

@@ -0,0 +1,3 @@
+define(["./reduce"], function(reduce) {
+  return reduce;
+});

collection/foldr.js

@@ -0,0 +1,3 @@
+define(["./reduceRight"], function(reduceRight) {
+  return reduceRight;
+});

collection/forEach.js

@@ -0,0 +1,36 @@
+define(['../internal/arrayEach', '../internal/baseEach', '../internal/bindCallback', '../lang/isArray'], function(arrayEach, baseEach, bindCallback, isArray) {
+
+  /**
+   * Iterates over elements of `collection` invoking `iteratee` for each element.
+   * The `iteratee` is bound to `thisArg` and invoked with three arguments;
+   * (value, index|key, collection). Iterator 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 `_.forIn` or `_.forOwn`
+   * may be used for object iteration.
+   *
+   * @static
+   * @memberOf _
+   * @alias each
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+   * @param {*} [thisArg] The `this` binding of `iteratee`.
+   * @returns {Array|Object|string} Returns `collection`.
+   * @example
+   *
+   * _([1, 2, 3]).forEach(function(n) { console.log(n); });
+   * // => logs each value from left to right and returns the array
+   *
+   * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, function(n, key) { console.log(n, key); });
+   * // => logs each value-key pair and returns the object (iteration order is not guaranteed)
+   */
+  function forEach(collection, iteratee, thisArg) {
+    return (typeof iteratee == 'function' && typeof thisArg == 'undefined' && isArray(collection))
+      ? arrayEach(collection, iteratee)
+      : baseEach(collection, bindCallback(iteratee, thisArg, 3));
+  }
+
+  return forEach;
+});

collection/forEachRight.js

@@ -0,0 +1,27 @@
+define(['../internal/arrayEachRight', '../internal/baseEachRight', '../internal/bindCallback', '../lang/isArray'], function(arrayEachRight, baseEachRight, bindCallback, isArray) {
+
+  /**
+   * This method is like `_.forEach` except that it iterates over elements of
+   * `collection` from right to left.
+   *
+   * @static
+   * @memberOf _
+   * @alias eachRight
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+   * @param {*} [thisArg] The `this` binding of `iteratee`.
+   * @returns {Array|Object|string} Returns `collection`.
+   * @example
+   *
+   * _([1, 2, 3]).forEachRight(function(n) { console.log(n); }).join(',');
+   * // => logs each value from right to left and returns the array
+   */
+  function forEachRight(collection, iteratee, thisArg) {
+    return (typeof iteratee == 'function' && typeof thisArg == 'undefined' && isArray(collection))
+      ? arrayEachRight(collection, iteratee)
+      : baseEachRight(collection, bindCallback(iteratee, thisArg, 3));
+  }
+
+  return forEachRight;
+});

collection/groupBy.js

@@ -0,0 +1,53 @@
+define(['../internal/createAggregator'], function(createAggregator) {
+
+  /** Used for native method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /**
+   * Creates an object composed of keys generated from the results of running
+   * each element of `collection` through `iteratee`. The corresponding value
+   * of each key is an array of the elements responsible for generating the key.
+   * The `iteratee` is bound to `thisArg` and invoked with three arguments;
+   * (value, index|key, collection).
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function|Object|string} [iteratee=_.identity] The function invoked
+   *  per iteration. If a property name or object is provided it is used to
+   *  create a "_.property" or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `iteratee`.
+   * @returns {Object} Returns the composed aggregate object.
+   * @example
+   *
+   * _.groupBy([4.2, 6.1, 6.4], function(n) { return Math.floor(n); });
+   * // => { '4': [4.2], '6': [6.1, 6.4] }
+   *
+   * _.groupBy([4.2, 6.1, 6.4], function(n) { return this.floor(n); }, Math);
+   * // => { '4': [4.2], '6': [6.1, 6.4] }
+   *
+   * // using the "_.property" callback shorthand
+   * _.groupBy(['one', 'two', 'three'], 'length');
+   * // => { '3': ['one', 'two'], '5': ['three'] }
+   */
+  var groupBy = createAggregator(function(result, value, key) {
+    if (hasOwnProperty.call(result, key)) {
+      result[key].push(value);
+    } else {
+      result[key] = [value];
+    }
+  });
+
+  return groupBy;
+});

collection/include.js

@@ -0,0 +1,3 @@
+define(["./includes"], function(includes) {
+  return includes;
+});

collection/includes.js

@@ -0,0 +1,58 @@
+define(['../internal/baseIndexOf', '../lang/isArray', '../internal/isLength', '../lang/isString', '../object/values'], function(baseIndexOf, isArray, isLength, isString, values) {
+
+  /* Native method references for those with the same name as other `lodash` methods. */
+  var nativeMax = Math.max;
+
+  /**
+   * Checks if `value` is in `collection` using `SameValueZero` for equality
+   * comparisons. If `fromIndex` is negative, it is used as the offset from
+   * the end of `collection`.
+   *
+   * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
+   * e.g. `===`, except that `NaN` matches `NaN`. See the
+   * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+   * for more details.
+   *
+   * @static
+   * @memberOf _
+   * @alias contains, include
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to search.
+   * @param {*} target The value to search for.
+   * @param {number} [fromIndex=0] The index to search from.
+   * @returns {boolean} Returns `true` if a matching element is found, else `false`.
+   * @example
+   *
+   * _.includes([1, 2, 3], 1);
+   * // => true
+   *
+   * _.includes([1, 2, 3], 1, 2);
+   * // => false
+   *
+   * _.includes({ 'user': 'fred', 'age': 40 }, 'fred');
+   * // => true
+   *
+   * _.includes('pebbles', 'eb');
+   * // => true
+   */
+  function includes(collection, target, fromIndex) {
+    var length = collection ? collection.length : 0;
+    if (!isLength(length)) {
+      collection = values(collection);
+      length = collection.length;
+    }
+    if (!length) {
+      return false;
+    }
+    if (typeof fromIndex == 'number') {
+      fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : (fromIndex || 0);
+    } else {
+      fromIndex = 0;
+    }
+    return (typeof collection == 'string' || !isArray(collection) && isString(collection))
+      ? (fromIndex < length && collection.indexOf(target, fromIndex) > -1)
+      : (baseIndexOf(collection, target, fromIndex) > -1);
+  }
+
+  return includes;
+});

collection/indexBy.js

@@ -0,0 +1,47 @@
+define(['../internal/createAggregator'], function(createAggregator) {
+
+  /**
+   * Creates an object composed of keys generated from the results of running
+   * each element of `collection` through `iteratee`. The corresponding value
+   * of each key is the last element responsible for generating the key. The
+   * iteratee function is bound to `thisArg` and invoked with three arguments;
+   * (value, index|key, collection).
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function|Object|string} [iteratee=_.identity] The function invoked
+   *  per iteration. If a property name or object is provided it is used to
+   *  create a "_.property" or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `iteratee`.
+   * @returns {Object} Returns the composed aggregate object.
+   * @example
+   *
+   * var keyData = [
+   *   { 'dir': 'left', 'code': 97 },
+   *   { 'dir': 'right', 'code': 100 }
+   * ];
+   *
+   * _.indexBy(keyData, 'dir');
+   * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
+   *
+   * _.indexBy(keyData, function(object) { return String.fromCharCode(object.code); });
+   * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+   *
+   * _.indexBy(keyData, function(object) { return this.fromCharCode(object.code); }, String);
+   * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+   */
+  var indexBy = createAggregator(function(result, value, key) {
+    result[key] = value;
+  });
+
+  return indexBy;
+});

collection/inject.js

@@ -0,0 +1,3 @@
+define(["./reduce"], function(reduce) {
+  return reduce;
+});

collection/invoke.js

@@ -0,0 +1,30 @@
+define(['../internal/baseInvoke', '../internal/baseSlice'], function(baseInvoke, baseSlice) {
+
+  /**
+   * Invokes the method named by `methodName` on each element in `collection`,
+   * returning an array of the results of each invoked method. Any additional
+   * arguments are provided to each invoked method. If `methodName` is a function
+   * it is invoked for, and `this` bound to, each element in `collection`.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function|string} methodName The name of the method to invoke or
+   *  the function invoked per iteration.
+   * @param {...*} [args] The arguments to invoke the method with.
+   * @returns {Array} Returns the array of results.
+   * @example
+   *
+   * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+   * // => [[1, 5, 7], [1, 2, 3]]
+   *
+   * _.invoke([123, 456], String.prototype.split, '');
+   * // => [['1', '2', '3'], ['4', '5', '6']]
+   */
+  function invoke(collection, methodName) {
+    return baseInvoke(collection, methodName, baseSlice(arguments, 2));
+  }
+
+  return invoke;
+});

collection/map.js

@@ -0,0 +1,49 @@
+define(['../internal/arrayMap', '../internal/baseCallback', '../internal/baseMap', '../lang/isArray'], function(arrayMap, baseCallback, baseMap, isArray) {
+
+  /**
+   * Creates an array of values by running each element in `collection` through
+   * `iteratee`. The `iteratee` is bound to `thisArg` and invoked with three
+   * arguments; (value, index|key, collection).
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @alias collect
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function|Object|string} [iteratee=_.identity] The function invoked
+   *  per iteration. If a property name or object is provided it is used to
+   *  create a "_.property" or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `iteratee`.
+   * @returns {Array} Returns the new mapped array.
+   * @example
+   *
+   * _.map([1, 2, 3], function(n) { return n * 3; });
+   * // => [3, 6, 9]
+   *
+   * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(n) { return n * 3; });
+   * // => [3, 6, 9] (iteration order is not guaranteed)
+   *
+   * var users = [
+   *   { 'user': 'barney' },
+   *   { 'user': 'fred' }
+   * ];
+   *
+   * // using the "_.property" callback shorthand
+   * _.map(users, 'user');
+   * // => ['barney', 'fred']
+   */
+  function map(collection, iteratee, thisArg) {
+    var func = isArray(collection) ? arrayMap : baseMap;
+    iteratee = baseCallback(iteratee, thisArg, 3);
+    return func(collection, iteratee);
+  }
+
+  return map;
+});

collection/max.js

@@ -0,0 +1,49 @@
+define(['../internal/arrayMax', '../internal/createExtremum'], function(arrayMax, createExtremum) {
+
+  /**
+   * Gets the maximum value of `collection`. If `collection` is empty or falsey
+   * `-Infinity` is returned. If an iteratee function is provided it is invoked
+   * for each value in `collection` to generate the criterion by which the value
+   * is ranked. The `iteratee` is bound to `thisArg` and invoked with three
+   * arguments; (value, index, collection).
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function|Object|string} [iteratee] The function invoked per iteration.
+   *  If a property name or object is provided it is used to create a "_.property"
+   *  or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `iteratee`.
+   * @returns {*} Returns the maximum value.
+   * @example
+   *
+   * _.max([4, 2, 8, 6]);
+   * // => 8
+   *
+   * _.max([]);
+   * // => -Infinity
+   *
+   * var users = [
+   *   { 'user': 'barney', 'age': 36 },
+   *   { 'user': 'fred',   'age': 40 }
+   * ];
+   *
+   * _.max(users, function(chr) { return chr.age; });
+   * // => { 'user': 'fred', 'age': 40 };
+   *
+   * // using the "_.property" callback shorthand
+   * _.max(users, 'age');
+   * // => { 'user': 'fred', 'age': 40 };
+   */
+  var max = createExtremum(arrayMax);
+
+  return max;
+});

collection/min.js

@@ -0,0 +1,49 @@
+define(['../internal/arrayMin', '../internal/createExtremum'], function(arrayMin, createExtremum) {
+
+  /**
+   * Gets the minimum value of `collection`. If `collection` is empty or falsey
+   * `Infinity` is returned. If an iteratee function is provided it is invoked
+   * for each value in `collection` to generate the criterion by which the value
+   * is ranked. The `iteratee` is bound to `thisArg` and invoked with three
+   * arguments; (value, index, collection).
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function|Object|string} [iteratee] The function invoked per iteration.
+   *  If a property name or object is provided it is used to create a "_.property"
+   *  or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `iteratee`.
+   * @returns {*} Returns the minimum value.
+   * @example
+   *
+   * _.min([4, 2, 8, 6]);
+   * // => 2
+   *
+   * _.min([]);
+   * // => Infinity
+   *
+   * var users = [
+   *   { 'user': 'barney', 'age': 36 },
+   *   { 'user': 'fred',   'age': 40 }
+   * ];
+   *
+   * _.min(users, function(chr) { return chr.age; });
+   * // => { 'user': 'barney', 'age': 36 };
+   *
+   * // using the "_.property" callback shorthand
+   * _.min(users, 'age');
+   * // => { 'user': 'barney', 'age': 36 };
+   */
+  var min = createExtremum(arrayMin, true);
+
+  return min;
+});

collection/partition.js

@@ -0,0 +1,52 @@
+define(['../internal/createAggregator'], function(createAggregator) {
+
+  /**
+   * Creates an array of elements split into two groups, the first of which
+   * contains elements `predicate` returns truthy for, while the second of which
+   * contains elements `predicate` returns falsey for. The predicate is bound
+   * to `thisArg` and invoked with three arguments; (value, index|key, collection).
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function|Object|string} [predicate=_.identity] The function invoked
+   *  per iteration. If a property name or object is provided it is used to
+   *  create a "_.property" or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `predicate`.
+   * @returns {Array} Returns the array of grouped elements.
+   * @example
+   *
+   * _.partition([1, 2, 3], function(n) { return n % 2; });
+   * // => [[1, 3], [2]]
+   *
+   * _.partition([1.2, 2.3, 3.4], function(n) { return this.floor(n) % 2; }, Math);
+   * // => [[1, 3], [2]]
+   *
+   * var users = [
+   *   { 'user': 'barney',  'age': 36, 'active': false },
+   *   { 'user': 'fred',    'age': 40, 'active': true },
+   *   { 'user': 'pebbles', 'age': 1,  'active': false }
+   * ];
+   *
+   * // using the "_.matches" callback shorthand
+   * _.map(_.partition(users, { 'age': 1 }), function(array) { return _.pluck(array, 'user'); });
+   * // => [['pebbles'], ['barney', 'fred']]
+   *
+   * // using the "_.property" callback shorthand
+   * _.map(_.partition(users, 'active'), function(array) { return _.pluck(array, 'user'); });
+   * // => [['fred'], ['barney', 'pebbles']]
+   */
+  var partition = createAggregator(function(result, value, key) {
+    result[key ? 0 : 1].push(value);
+  }, function() { return [[], []]; });
+
+  return partition;
+});

collection/pluck.js

@@ -0,0 +1,31 @@
+define(['./map', '../utility/property'], function(map, property) {
+
+  /**
+   * Gets the value of `key` from all elements in `collection`.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {string} key The key of the property to pluck.
+   * @returns {Array} Returns the property values.
+   * @example
+   *
+   * var users = [
+   *   { 'user': 'barney', 'age': 36 },
+   *   { 'user': 'fred',   'age': 40 }
+   * ];
+   *
+   * _.pluck(users, 'user');
+   * // => ['barney', 'fred']
+   *
+   * var userIndex = _.indexBy(users, 'user');
+   * _.pluck(userIndex, 'age');
+   * // => [36, 40] (iteration order is not guaranteed)
+   */
+  function pluck(collection, key) {
+    return map(collection, property(key));
+  }
+
+  return pluck;
+});

collection/reduce.js

@@ -0,0 +1,37 @@
+define(['../internal/arrayReduce', '../internal/baseCallback', '../internal/baseEach', '../internal/baseReduce', '../lang/isArray'], function(arrayReduce, baseCallback, baseEach, baseReduce, isArray) {
+
+  /**
+   * Reduces `collection` to a value which is the accumulated result of running
+   * each element in `collection` through `iteratee`, where each successive
+   * invocation is supplied the return value of the previous. If `accumulator`
+   * is not provided the first element of `collection` is used as the initial
+   * value. The `iteratee` is bound to `thisArg`and invoked with four arguments;
+   * (accumulator, value, index|key, collection).
+   *
+   * @static
+   * @memberOf _
+   * @alias foldl, inject
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+   * @param {*} [accumulator] The initial value.
+   * @param {*} [thisArg] The `this` binding of `iteratee`.
+   * @returns {*} Returns the accumulated value.
+   * @example
+   *
+   * var sum = _.reduce([1, 2, 3], function(sum, n) { return sum + n; });
+   * // => 6
+   *
+   * var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, n, key) {
+   *   result[key] = n * 3;
+   *   return result;
+   * }, {});
+   * // => { 'a': 3, 'b': 6, 'c': 9 } (iteration order is not guaranteed)
+   */
+  function reduce(collection, iteratee, accumulator, thisArg) {
+    var func = isArray(collection) ? arrayReduce : baseReduce;
+    return func(collection, baseCallback(iteratee, thisArg, 4), accumulator, arguments.length < 3, baseEach);
+  }
+
+  return reduce;
+});

collection/reduceRight.js

@@ -0,0 +1,28 @@
+define(['../internal/arrayReduceRight', '../internal/baseCallback', '../internal/baseEachRight', '../internal/baseReduce', '../lang/isArray'], function(arrayReduceRight, baseCallback, baseEachRight, baseReduce, isArray) {
+
+  /**
+   * This method is like `_.reduce` except that it iterates over elements of
+   * `collection` from right to left.
+   *
+   * @static
+   * @memberOf _
+   * @alias foldr
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+   * @param {*} [accumulator] The initial value.
+   * @param {*} [thisArg] The `this` binding of `iteratee`.
+   * @returns {*} Returns the accumulated value.
+   * @example
+   *
+   * var array = [[0, 1], [2, 3], [4, 5]];
+   * _.reduceRight(array, function(flattened, other) { return flattened.concat(other); }, []);
+   * // => [4, 5, 2, 3, 0, 1]
+   */
+  function reduceRight(collection, iteratee, accumulator, thisArg) {
+    var func = isArray(collection) ? arrayReduceRight : baseReduce;
+    return func(collection, baseCallback(iteratee, thisArg, 4), accumulator, arguments.length < 3, baseEachRight);
+  }
+
+  return reduceRight;
+});

collection/reject.js

@@ -0,0 +1,50 @@
+define(['../internal/arrayFilter', '../internal/baseCallback', '../internal/baseFilter', '../lang/isArray'], function(arrayFilter, baseCallback, baseFilter, isArray) {
+
+  /**
+   * The opposite of `_.filter`; this method returns the elements of `collection`
+   * that `predicate` does **not** return truthy for.
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function|Object|string} [predicate=_.identity] The function invoked
+   *  per iteration. If a property name or object is provided it is used to
+   *  create a "_.property" or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `predicate`.
+   * @returns {Array} Returns the new filtered array.
+   * @example
+   *
+   * var odds = _.reject([1, 2, 3, 4], function(n) { return n % 2 == 0; });
+   * // => [1, 3]
+   *
+   * var users = [
+   *   { 'user': 'barney', 'age': 36, 'active': false },
+   *   { 'user': 'fred',   'age': 40, 'active': true }
+   * ];
+   *
+   * // using the "_.property" callback shorthand
+   * _.pluck(_.reject(users, 'active'), 'user');
+   * // => ['barney']
+   *
+   * // using the "_.matches" callback shorthand
+   * _.pluck(_.reject(users, { 'age': 36 }), 'user');
+   * // => ['fred']
+   */
+  function reject(collection, predicate, thisArg) {
+    var func = isArray(collection) ? arrayFilter : baseFilter;
+    predicate = baseCallback(predicate, thisArg, 3);
+    return func(collection, function(value, index, collection) {
+      return !predicate(value, index, collection);
+    });
+  }
+
+  return reject;
+});

collection/sample.js

@@ -0,0 +1,39 @@
+define(['../internal/baseRandom', '../internal/isIterateeCall', './shuffle', '../internal/toIterable'], function(baseRandom, isIterateeCall, shuffle, toIterable) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /* Native method references for those with the same name as other `lodash` methods. */
+  var nativeMin = Math.min;
+
+  /**
+   * Gets a random element or `n` random elements from a collection.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to sample.
+   * @param {number} [n] The number of elements to sample.
+   * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
+   * @returns {*} Returns the random sample(s).
+   * @example
+   *
+   * _.sample([1, 2, 3, 4]);
+   * // => 2
+   *
+   * _.sample([1, 2, 3, 4], 2);
+   * // => [3, 1]
+   */
+  function sample(collection, n, guard) {
+    if (guard ? isIterateeCall(collection, n, guard) : n == null) {
+      collection = toIterable(collection);
+      var length = collection.length;
+      return length > 0 ? collection[baseRandom(0, length - 1)] : undefined;
+    }
+    var result = shuffle(collection);
+    result.length = nativeMin(n < 0 ? 0 : (+n || 0), result.length);
+    return result;
+  }
+
+  return sample;
+});

collection/select.js

@@ -0,0 +1,3 @@
+define(["./filter"], function(filter) {
+  return filter;
+});

collection/shuffle.js

@@ -0,0 +1,36 @@
+define(['../internal/baseRandom', '../internal/toIterable'], function(baseRandom, toIterable) {
+
+  /**
+   * Creates an array of shuffled values, using a version of the Fisher-Yates
+   * shuffle. See [Wikipedia](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle)
+   * for more details.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to shuffle.
+   * @returns {Array} Returns the new shuffled array.
+   * @example
+   *
+   * _.shuffle([1, 2, 3, 4]);
+   * // => [4, 1, 3, 2]
+   */
+  function shuffle(collection) {
+    collection = toIterable(collection);
+
+    var index = -1,
+        length = collection.length,
+        result = Array(length);
+
+    while (++index < length) {
+      var rand = baseRandom(0, index);
+      if (index != rand) {
+        result[index] = result[rand];
+      }
+      result[rand] = collection[index];
+    }
+    return result;
+  }
+
+  return shuffle;
+});

collection/size.js

@@ -0,0 +1,29 @@
+define(['../internal/isLength', '../object/keys'], function(isLength, keys) {
+
+  /**
+   * Gets the size of `collection` by returning `collection.length` for
+   * array-like values or the number of own enumerable properties for objects.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to inspect.
+   * @returns {number} Returns the size of `collection`.
+   * @example
+   *
+   * _.size([1, 2]);
+   * // => 2
+   *
+   * _.size({ 'one': 1, 'two': 2, 'three': 3 });
+   * // => 3
+   *
+   * _.size('pebbles');
+   * // => 7
+   */
+  function size(collection) {
+    var length = collection ? collection.length : 0;
+    return isLength(length) ? length : keys(collection).length;
+  }
+
+  return size;
+});

collection/some.js

@@ -0,0 +1,54 @@
+define(['../internal/arraySome', '../internal/baseCallback', '../internal/baseSome', '../lang/isArray'], function(arraySome, baseCallback, baseSome, isArray) {
+
+  /**
+   * Checks if `predicate` returns truthy for **any** element of `collection`.
+   * The function returns as soon as it finds a passing value and does not iterate
+   * over the entire collection. The predicate is bound to `thisArg` and invoked
+   * with three arguments; (value, index|key, collection).
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @alias any
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Function|Object|string} [predicate=_.identity] The function invoked
+   *  per iteration. If a property name or object is provided it is used to
+   *  create a "_.property" or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `predicate`.
+   * @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', 'age': 36, 'active': false },
+   *   { 'user': 'fred',   'age': 40, 'active': true }
+   * ];
+   *
+   * // using the "_.property" callback shorthand
+   * _.some(users, 'active');
+   * // => true
+   *
+   * // using the "_.matches" callback shorthand
+   * _.some(users, { 'age': 1 });
+   * // => false
+   */
+  function some(collection, predicate, thisArg) {
+    var func = isArray(collection) ? arraySome : baseSome;
+    if (typeof predicate != 'function' || typeof thisArg != 'undefined') {
+      predicate = baseCallback(predicate, thisArg, 3);
+    }
+    return func(collection, predicate);
+  }
+
+  return some;
+});

collection/sortBy.js

@@ -0,0 +1,60 @@
+define(['../internal/baseCallback', '../internal/baseEach', '../internal/baseSortBy', '../internal/compareAscending', '../internal/isIterateeCall', '../internal/isLength'], function(baseCallback, baseEach, baseSortBy, compareAscending, isIterateeCall, isLength) {
+
+  /**
+   * Creates an array of elements, sorted in ascending order by the results of
+   * running each element in a collection through `iteratee`. This method performs
+   * a stable sort, that is, it preserves the original sort order of equal elements.
+   * The `iteratee` is bound to `thisArg` and invoked with three arguments;
+   * (value, index|key, collection).
+   *
+   * If a property name is provided for `predicate` the created "_.property"
+   * style callback returns the property value of the given element.
+   *
+   * If an object is provided for `predicate` the created "_.matches" style
+   * callback returns `true` for elements that have the properties of the given
+   * object, else `false`.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Array|Function|Object|string} [iteratee=_.identity] The function
+   *  invoked per iteration. If a property name or an object is provided it is
+   *  used to create a "_.property" or "_.matches" style callback respectively.
+   * @param {*} [thisArg] The `this` binding of `iteratee`.
+   * @returns {Array} Returns the new sorted array.
+   * @example
+   *
+   * _.sortBy([1, 2, 3], function(n) { return Math.sin(n); });
+   * // => [3, 1, 2]
+   *
+   * _.sortBy([1, 2, 3], function(n) { return this.sin(n); }, Math);
+   * // => [3, 1, 2]
+   *
+   * var users = [
+   *   { 'user': 'fred' },
+   *   { 'user': 'pebbles' },
+   *   { 'user': 'barney' }
+   * ];
+   *
+   * // using the "_.property" callback shorthand
+   * _.pluck(_.sortBy(users, 'user'), 'user');
+   * // => ['barney', 'fred', 'pebbles']
+   */
+  function sortBy(collection, iteratee, thisArg) {
+    var index = -1,
+        length = collection ? collection.length : 0,
+        result = isLength(length) ? Array(length) : [];
+
+    if (thisArg && isIterateeCall(collection, iteratee, thisArg)) {
+      iteratee = null;
+    }
+    iteratee = baseCallback(iteratee, thisArg, 3);
+    baseEach(collection, function(value, key, collection) {
+      result[++index] = { 'criteria': iteratee(value, key, collection), 'index': index, 'value': value };
+    });
+    return baseSortBy(result, compareAscending);
+  }
+
+  return sortBy;
+});

collection/sortByAll.js

@@ -0,0 +1,52 @@
+define(['../internal/baseEach', '../internal/baseFlatten', '../internal/baseSortBy', '../internal/compareMultipleAscending', '../internal/isIterateeCall', '../internal/isLength'], function(baseEach, baseFlatten, baseSortBy, compareMultipleAscending, isIterateeCall, isLength) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * This method is like `_.sortBy` except that it sorts by property names
+   * instead of an iteratee function.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {...(string|string[])} props The property names to sort by,
+   *  specified as individual property names or arrays of property names.
+   * @returns {Array} Returns the new sorted array.
+   * @example
+   *
+   * var users = [
+   *   { 'user': 'barney', 'age': 36 },
+   *   { 'user': 'fred',   'age': 40 },
+   *   { 'user': 'barney', 'age': 26 },
+   *   { 'user': 'fred',   'age': 30 }
+   * ];
+   *
+   * _.map(_.sortByAll(users, ['user', 'age']), _.values);
+   * // => [['barney', 26], ['barney', 36], ['fred', 30], ['fred', 40]]
+   */
+  function sortByAll(collection) {
+    var args = arguments;
+    if (args.length > 3 && isIterateeCall(args[1], args[2], args[3])) {
+      args = [collection, args[1]];
+    }
+    var index = -1,
+        length = collection ? collection.length : 0,
+        props = baseFlatten(args, false, false, 1),
+        result = isLength(length) ? Array(length) : [];
+
+    baseEach(collection, function(value, key, collection) {
+      var length = props.length,
+          criteria = Array(length);
+
+      while (length--) {
+        criteria[length] = value == null ? undefined : value[props[length]];
+      }
+      result[++index] = { 'criteria': criteria, 'index': index, 'value': value };
+    });
+    return baseSortBy(result, compareMultipleAscending);
+  }
+
+  return sortByAll;
+});

collection/where.js

@@ -0,0 +1,35 @@
+define(['./filter', '../utility/matches'], function(filter, matches) {
+
+  /**
+   * Performs a deep comparison between each element in `collection` and the
+   * source object, returning an array of all elements that have equivalent
+   * property values.
+   *
+   * @static
+   * @memberOf _
+   * @category Collection
+   * @param {Array|Object|string} collection The collection to search.
+   * @param {Object} source The object of property values to match.
+   * @returns {Array} Returns the new filtered array.
+   * @example
+   *
+   * var users = [
+   *   { 'user': 'barney', 'age': 36, 'status': 'busy', 'pets': ['hoppy'] },
+   *   { 'user': 'fred',   'age': 40, 'status': 'busy', 'pets': ['baby puss', 'dino'] }
+   * ];
+   *
+   * _.pluck(_.where(users, { 'age': 36 }), 'user');
+   * // => ['barney']
+   *
+   * _.pluck(_.where(users, { 'pets': ['dino'] }), 'user');
+   * // => ['fred']
+   *
+   * _.pluck(_.where(users, { 'status': 'busy' }), 'user');
+   * // => ['barney', 'fred']
+   */
+  function where(collection, source) {
+    return filter(collection, matches(source));
+  }
+
+  return where;
+});