Bump to v4.3.0.

.npmignore

@@ -0,0 +1 @@
+.*

LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>
+Based on Underscore.js, copyright 2009-2016 Jeremy Ashkenas,
+DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
-Based on Underscore.js 1.7.0, copyright 2009-2015 Jeremy Ashkenas,
-DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,23 +1,30 @@
-# lodash v3.2.0
+# lodash-amd v4.3.0
 
-The [modern build](https://github.com/lodash/lodash/wiki/Build-Differences) of [lodash](https://lodash.com/) exported as [AMD](https://github.com/amdjs/amdjs-api/wiki/AMD) modules.
+The [lodash](https://lodash.com/) library exported as [AMD](https://github.com/amdjs/amdjs-api/wiki/AMD) modules.
 
 Generated using [lodash-cli](https://www.npmjs.com/package/lodash-cli):
 ```bash
-$ lodash modularize modern exports=amd -o ./
+$ lodash exports=amd -o ./
-$ lodash modern exports=amd -d -o ./main.js
+$ lodash exports=amd -d -o ./main.js
 ```
 
 ## Installation
 
-Defining a build as `'lodash'`.
+Using npm:
+```bash
+$ {sudo -H} npm i -g npm
+$ npm i --save lodash-amd
+```
 
+Using an AMD loader:
 ```js
 require({
   'packages': [
     { 'name': 'lodash', 'location': 'path/to/lodash' }
   ]
-}, ['lodash/array/chunk'], function(chunk) {
+}, ['lodash/chunk'], function(chunk) {
   // use `chunk`
 });
 ```
+
+See the [package source](https://github.com/lodash/lodash/tree/4.3.0-amd) for more details.

_Hash.js

@@ -0,0 +1,18 @@
+define(['./_nativeCreate'], function(nativeCreate) {
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Creates an hash object.
+   *
+   * @private
+   * @returns {Object} Returns the new hash object.
+   */
+  function Hash() {}
+
+  // Avoid inheriting from `Object.prototype` when possible.
+  Hash.prototype = nativeCreate ? nativeCreate(null) : objectProto;
+
+  return Hash;
+});

_LazyWrapper.js

@@ -0,0 +1,26 @@
+define(['./_baseCreate', './_baseLodash'], function(baseCreate, baseLodash) {
+
+  /** Used as references for the maximum length and index of an array. */
+  var MAX_ARRAY_LENGTH = 4294967295;
+
+  /**
+   * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
+   *
+   * @private
+   * @param {*} value The value to wrap.
+   */
+  function LazyWrapper(value) {
+    this.__wrapped__ = value;
+    this.__actions__ = [];
+    this.__dir__ = 1;
+    this.__filtered__ = false;
+    this.__iteratees__ = [];
+    this.__takeCount__ = MAX_ARRAY_LENGTH;
+    this.__views__ = [];
+  }
+
+  LazyWrapper.prototype = baseCreate(baseLodash.prototype);
+  LazyWrapper.prototype.constructor = LazyWrapper;
+
+  return LazyWrapper;
+});

_LodashWrapper.js

@@ -0,0 +1,25 @@
+define(['./_baseCreate', './_baseLodash'], function(baseCreate, baseLodash) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base constructor for creating `lodash` wrapper objects.
+   *
+   * @private
+   * @param {*} value The value to wrap.
+   * @param {boolean} [chainAll] Enable chaining for all wrapper methods.
+   */
+  function LodashWrapper(value, chainAll) {
+    this.__wrapped__ = value;
+    this.__actions__ = [];
+    this.__chain__ = !!chainAll;
+    this.__index__ = 0;
+    this.__values__ = undefined;
+  }
+
+  LodashWrapper.prototype = baseCreate(baseLodash.prototype);
+  LodashWrapper.prototype.constructor = LodashWrapper;
+
+  return LodashWrapper;
+});

_Map.js

@@ -0,0 +1,7 @@
+define(['./_getNative', './_root'], function(getNative, root) {
+
+  /* Built-in method references that are verified to be native. */
+  var Map = getNative(root, 'Map');
+
+  return Map;
+});

_MapCache.js

@@ -0,0 +1,28 @@
+define(['./_mapClear', './_mapDelete', './_mapGet', './_mapHas', './_mapSet'], function(mapClear, mapDelete, mapGet, mapHas, mapSet) {
+
+  /**
+   * Creates a map cache object to store key-value pairs.
+   *
+   * @private
+   * @param {Array} [values] The values to cache.
+   */
+  function MapCache(values) {
+    var index = -1,
+        length = values ? values.length : 0;
+
+    this.clear();
+    while (++index < length) {
+      var entry = values[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  // Add functions to the `MapCache`.
+  MapCache.prototype.clear = mapClear;
+  MapCache.prototype['delete'] = mapDelete;
+  MapCache.prototype.get = mapGet;
+  MapCache.prototype.has = mapHas;
+  MapCache.prototype.set = mapSet;
+
+  return MapCache;
+});

_Reflect.js

@@ -0,0 +1,7 @@
+define(['./_root'], function(root) {
+
+  /** Built-in value references. */
+  var Reflect = root.Reflect;
+
+  return Reflect;
+});

_Set.js

@@ -0,0 +1,7 @@
+define(['./_getNative', './_root'], function(getNative, root) {
+
+  /* Built-in method references that are verified to be native. */
+  var Set = getNative(root, 'Set');
+
+  return Set;
+});

_SetCache.js

@@ -0,0 +1,24 @@
+define(['./_MapCache', './_cachePush'], function(MapCache, cachePush) {
+
+  /**
+   *
+   * Creates a set cache object to store unique values.
+   *
+   * @private
+   * @param {Array} [values] The values to cache.
+   */
+  function SetCache(values) {
+    var index = -1,
+        length = values ? values.length : 0;
+
+    this.__data__ = new MapCache;
+    while (++index < length) {
+      this.push(values[index]);
+    }
+  }
+
+  // Add functions to the `SetCache`.
+  SetCache.prototype.push = cachePush;
+
+  return SetCache;
+});

_Stack.js

@@ -0,0 +1,28 @@
+define(['./_stackClear', './_stackDelete', './_stackGet', './_stackHas', './_stackSet'], function(stackClear, stackDelete, stackGet, stackHas, stackSet) {
+
+  /**
+   * Creates a stack cache object to store key-value pairs.
+   *
+   * @private
+   * @param {Array} [values] The values to cache.
+   */
+  function Stack(values) {
+    var index = -1,
+        length = values ? values.length : 0;
+
+    this.clear();
+    while (++index < length) {
+      var entry = values[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  // Add functions to the `Stack` cache.
+  Stack.prototype.clear = stackClear;
+  Stack.prototype['delete'] = stackDelete;
+  Stack.prototype.get = stackGet;
+  Stack.prototype.has = stackHas;
+  Stack.prototype.set = stackSet;
+
+  return Stack;
+});

_Symbol.js

@@ -0,0 +1,7 @@
+define(['./_root'], function(root) {
+
+  /** Built-in value references. */
+  var Symbol = root.Symbol;
+
+  return Symbol;
+});

_Uint8Array.js

@@ -0,0 +1,7 @@
+define(['./_root'], function(root) {
+
+  /** Built-in value references. */
+  var Uint8Array = root.Uint8Array;
+
+  return Uint8Array;
+});

_WeakMap.js

@@ -0,0 +1,7 @@
+define(['./_getNative', './_root'], function(getNative, root) {
+
+  /* Built-in method references that are verified to be native. */
+  var WeakMap = getNative(root, 'WeakMap');
+
+  return WeakMap;
+});

_addMapEntry.js

@@ -0,0 +1,17 @@
+define([], function() {
+
+  /**
+   * Adds the key-value `pair` to `map`.
+   *
+   * @private
+   * @param {Object} map The map to modify.
+   * @param {Array} pair The key-value pair to add.
+   * @returns {Object} Returns `map`.
+   */
+  function addMapEntry(map, pair) {
+    map.set(pair[0], pair[1]);
+    return map;
+  }
+
+  return addMapEntry;
+});

_addSetEntry.js

@@ -0,0 +1,17 @@
+define([], function() {
+
+  /**
+   * Adds `value` to `set`.
+   *
+   * @private
+   * @param {Object} set The set to modify.
+   * @param {*} value The value to add.
+   * @returns {Object} Returns `set`.
+   */
+  function addSetEntry(set, value) {
+    set.add(value);
+    return set;
+  }
+
+  return addSetEntry;
+});

_apply.js

@@ -0,0 +1,25 @@
+define([], function() {
+
+  /**
+   * A faster alternative to `Function#apply`, this function invokes `func`
+   * with the `this` binding of `thisArg` and the arguments of `args`.
+   *
+   * @private
+   * @param {Function} func The function to invoke.
+   * @param {*} thisArg The `this` binding of `func`.
+   * @param {...*} args The arguments to invoke `func` with.
+   * @returns {*} Returns the result of `func`.
+   */
+  function apply(func, thisArg, args) {
+    var length = args.length;
+    switch (length) {
+      case 0: return func.call(thisArg);
+      case 1: return func.call(thisArg, args[0]);
+      case 2: return func.call(thisArg, args[0], args[1]);
+      case 3: return func.call(thisArg, args[0], args[1], args[2]);
+    }
+    return func.apply(thisArg, args);
+  }
+
+  return apply;
+});

_arrayAggregator.js

@@ -0,0 +1,25 @@
+define([], function() {
+
+  /**
+   * A specialized version of `baseAggregator` for arrays.
+   *
+   * @private
+   * @param {Array} array The array to iterate over.
+   * @param {Function} setter The function to set `accumulator` values.
+   * @param {Function} iteratee The iteratee to transform keys.
+   * @param {Object} accumulator The initial aggregated object.
+   * @returns {Function} Returns `accumulator`.
+   */
+  function arrayAggregator(array, setter, iteratee, accumulator) {
+    var index = -1,
+        length = array.length;
+
+    while (++index < length) {
+      var value = array[index];
+      setter(accumulator, value, iteratee(value), array);
+    }
+    return accumulator;
+  }
+
+  return arrayAggregator;
+});

_arrayConcat.js

@@ -0,0 +1,28 @@
+define([], function() {
+
+  /**
+   * 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) {
+    var index = -1,
+        length = array.length,
+        othIndex = -1,
+        othLength = other.length,
+        result = Array(length + othLength);
+
+    while (++index < length) {
+      result[index] = array[index];
+    }
+    while (++othIndex < othLength) {
+      result[index++] = other[othIndex];
+    }
+    return result;
+  }
+
+  return arrayConcat;
+});

_arrayEach.js

@@ -1,8 +1,8 @@
 define([], function() {
 
   /**
-   * A specialized version of `_.forEach` for arrays without support for callback
+   * A specialized version of `_.forEach` for arrays without support for
-   * shorthands or `this` binding.
+   * iteratee shorthands.
    *
    * @private
    * @param {Array} array The array to iterate over.

_arrayEachRight.js

@@ -2,7 +2,7 @@ define([], function() {
 
   /**
    * A specialized version of `_.forEachRight` for arrays without support for
-   * callback shorthands or `this` binding.
+   * iteratee shorthands.
    *
    * @private
    * @param {Array} array The array to iterate over.

_arrayEvery.js

@@ -1,14 +1,13 @@
 define([], function() {
 
   /**
-   * A specialized version of `_.every` for arrays without support for callback
+   * A specialized version of `_.every` for arrays without support for
-   * shorthands or `this` binding.
+   * iteratee shorthands.
    *
    * @private
    * @param {Array} array The array to iterate over.
    * @param {Function} predicate The function invoked per iteration.
-   * @returns {boolean} Returns `true` if all elements pass the predicate check,
+   * @returns {boolean} Returns `true` if all elements pass the predicate check, else `false`.
-   *  else `false`.
    */
   function arrayEvery(array, predicate) {
     var index = -1,

_arrayFilter.js

@@ -1,8 +1,8 @@
 define([], function() {
 
   /**
-   * A specialized version of `_.filter` for arrays without support for callback
+   * A specialized version of `_.filter` for arrays without support for
-   * shorthands or `this` binding.
+   * iteratee shorthands.
    *
    * @private
    * @param {Array} array The array to iterate over.

_arrayIncludes.js

@@ -0,0 +1,17 @@
+define(['./_baseIndexOf'], function(baseIndexOf) {
+
+  /**
+   * A specialized version of `_.includes` for arrays without support for
+   * specifying an index to search from.
+   *
+   * @private
+   * @param {Array} array The array to search.
+   * @param {*} target The value to search for.
+   * @returns {boolean} Returns `true` if `target` is found, else `false`.
+   */
+  function arrayIncludes(array, value) {
+    return !!array.length && baseIndexOf(array, value, 0) > -1;
+  }
+
+  return arrayIncludes;
+});

_arrayIncludesWith.js

@@ -0,0 +1,26 @@
+define([], function() {
+
+  /**
+   * A specialized version of `_.includesWith` for arrays without support for
+   * specifying an index to search from.
+   *
+   * @private
+   * @param {Array} array The array to search.
+   * @param {*} target The value to search for.
+   * @param {Function} comparator The comparator invoked per element.
+   * @returns {boolean} Returns `true` if `target` is found, else `false`.
+   */
+  function arrayIncludesWith(array, value, comparator) {
+    var index = -1,
+        length = array.length;
+
+    while (++index < length) {
+      if (comparator(value, array[index])) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  return arrayIncludesWith;
+});

_arrayMap.js

@@ -1,8 +1,8 @@
 define([], function() {
 
   /**
-   * A specialized version of `_.map` for arrays without support for callback
+   * A specialized version of `_.map` for arrays without support for iteratee
-   * shorthands or `this` binding.
+   * shorthands.
    *
    * @private
    * @param {Array} array The array to iterate over.

_arrayPush.js

@@ -0,0 +1,23 @@
+define([], function() {
+
+  /**
+   * 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) {
+    var index = -1,
+        length = values.length,
+        offset = array.length;
+
+    while (++index < length) {
+      array[offset + index] = values[index];
+    }
+    return array;
+  }
+
+  return arrayPush;
+});

_arrayReduce.js

@@ -1,22 +1,21 @@
 define([], function() {
 
   /**
-   * A specialized version of `_.reduce` for arrays without support for callback
+   * A specialized version of `_.reduce` for arrays without support for
-   * shorthands or `this` binding.
+   * iteratee shorthands.
    *
    * @private
    * @param {Array} array The array to iterate over.
    * @param {Function} iteratee The function invoked per iteration.
    * @param {*} [accumulator] The initial value.
-   * @param {boolean} [initFromArray] Specify using the first element of `array`
+   * @param {boolean} [initAccum] Specify using the first element of `array` as the initial value.
-   *  as the initial value.
    * @returns {*} Returns the accumulated value.
    */
-  function arrayReduce(array, iteratee, accumulator, initFromArray) {
+  function arrayReduce(array, iteratee, accumulator, initAccum) {
     var index = -1,
         length = array.length;
 
-    if (initFromArray && length) {
+    if (initAccum && length) {
       accumulator = array[++index];
     }
     while (++index < length) {

_arrayReduceRight.js

@@ -2,19 +2,18 @@ define([], function() {
 
   /**
    * A specialized version of `_.reduceRight` for arrays without support for
-   * callback shorthands or `this` binding.
+   * iteratee shorthands.
    *
    * @private
    * @param {Array} array The array to iterate over.
    * @param {Function} iteratee The function invoked per iteration.
    * @param {*} [accumulator] The initial value.
-   * @param {boolean} [initFromArray] Specify using the last element of `array`
+   * @param {boolean} [initAccum] Specify using the last element of `array` as the initial value.
-   *  as the initial value.
    * @returns {*} Returns the accumulated value.
    */
-  function arrayReduceRight(array, iteratee, accumulator, initFromArray) {
+  function arrayReduceRight(array, iteratee, accumulator, initAccum) {
     var length = array.length;
-    if (initFromArray && length) {
+    if (initAccum && length) {
       accumulator = array[--length];
     }
     while (length--) {

_arraySome.js

@@ -1,14 +1,13 @@
 define([], function() {
 
   /**
-   * A specialized version of `_.some` for arrays without support for callback
+   * A specialized version of `_.some` for arrays without support for iteratee
-   * shorthands or `this` binding.
+   * shorthands.
    *
    * @private
    * @param {Array} array The array to iterate over.
    * @param {Function} predicate The function invoked per iteration.
-   * @returns {boolean} Returns `true` if any element passes the predicate check,
+   * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
-   *  else `false`.
    */
   function arraySome(array, predicate) {
     var index = -1,

_assignInDefaults.js

@@ -0,0 +1,31 @@
+define(['./eq'], function(eq) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /**
+   * 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;
+  }
+
+  return assignInDefaults;
+});

_assignMergeValue.js

@@ -0,0 +1,22 @@
+define(['./eq'], function(eq) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * This function is like `assignValue` except that it doesn't assign `undefined` values.
+   *
+   * @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 assignMergeValue(object, key, value) {
+    if ((value !== undefined && !eq(object[key], value)) ||
+        (typeof key == 'number' && value === undefined && !(key in object))) {
+      object[key] = value;
+    }
+  }
+
+  return assignMergeValue;
+});

_assignValue.js

@@ -0,0 +1,32 @@
+define(['./eq'], function(eq) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /**
+   * 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 ((!eq(objValue, value) ||
+          (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) ||
+        (value === undefined && !(key in object))) {
+      object[key] = value;
+    }
+  }
+
+  return assignValue;
+});

_assocDelete.js

@@ -0,0 +1,32 @@
+define(['./_assocIndexOf'], function(assocIndexOf) {
+
+  /** Used for built-in method references. */
+  var arrayProto = Array.prototype;
+
+  /** Built-in value references. */
+  var splice = arrayProto.splice;
+
+  /**
+   * Removes `key` and its value from the associative array.
+   *
+   * @private
+   * @param {Array} array The array to query.
+   * @param {string} key The key of the value to remove.
+   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+   */
+  function assocDelete(array, key) {
+    var index = assocIndexOf(array, key);
+    if (index < 0) {
+      return false;
+    }
+    var lastIndex = array.length - 1;
+    if (index == lastIndex) {
+      array.pop();
+    } else {
+      splice.call(array, index, 1);
+    }
+    return true;
+  }
+
+  return assocDelete;
+});

_assocGet.js

@@ -0,0 +1,20 @@
+define(['./_assocIndexOf'], function(assocIndexOf) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * Gets the associative array value for `key`.
+   *
+   * @private
+   * @param {Array} array The array to query.
+   * @param {string} key The key of the value to get.
+   * @returns {*} Returns the entry value.
+   */
+  function assocGet(array, key) {
+    var index = assocIndexOf(array, key);
+    return index < 0 ? undefined : array[index][1];
+  }
+
+  return assocGet;
+});

_assocHas.js

@@ -0,0 +1,16 @@
+define(['./_assocIndexOf'], function(assocIndexOf) {
+
+  /**
+   * Checks if an associative array value for `key` exists.
+   *
+   * @private
+   * @param {Array} array The array to query.
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+   */
+  function assocHas(array, key) {
+    return assocIndexOf(array, key) > -1;
+  }
+
+  return assocHas;
+});

_assocIndexOf.js

@@ -0,0 +1,23 @@
+define(['./eq'], function(eq) {
+
+  /**
+   * Gets the index at which the first occurrence of `key` is found in `array`
+   * of key-value pairs.
+   *
+   * @private
+   * @param {Array} array The array to search.
+   * @param {*} key The key to search for.
+   * @returns {number} Returns the index of the matched value, else `-1`.
+   */
+  function assocIndexOf(array, key) {
+    var length = array.length;
+    while (length--) {
+      if (eq(array[length][0], key)) {
+        return length;
+      }
+    }
+    return -1;
+  }
+
+  return assocIndexOf;
+});

_assocSet.js

@@ -0,0 +1,21 @@
+define(['./_assocIndexOf'], function(assocIndexOf) {
+
+  /**
+   * Sets the associative array `key` to `value`.
+   *
+   * @private
+   * @param {Array} array The array to modify.
+   * @param {string} key The key of the value to set.
+   * @param {*} value The value to set.
+   */
+  function assocSet(array, key, value) {
+    var index = assocIndexOf(array, key);
+    if (index < 0) {
+      array.push([key, value]);
+    } else {
+      array[index][1] = value;
+    }
+  }
+
+  return assocSet;
+});

_baseAggregator.js

@@ -0,0 +1,22 @@
+define(['./_baseEach'], function(baseEach) {
+
+  /**
+   * Aggregates elements of `collection` on `accumulator` with keys transformed
+   * by `iteratee` and values set by `setter`.
+   *
+   * @private
+   * @param {Array|Object} collection The collection to iterate over.
+   * @param {Function} setter The function to set `accumulator` values.
+   * @param {Function} iteratee The iteratee to transform keys.
+   * @param {Object} accumulator The initial aggregated object.
+   * @returns {Function} Returns `accumulator`.
+   */
+  function baseAggregator(collection, setter, iteratee, accumulator) {
+    baseEach(collection, function(value, key, collection) {
+      setter(accumulator, value, iteratee(value), collection);
+    });
+    return accumulator;
+  }
+
+  return baseAggregator;
+});

_baseAssign.js

@@ -0,0 +1,17 @@
+define(['./_copyObject', './keys'], function(copyObject, keys) {
+
+  /**
+   * The base implementation of `_.assign` without support for multiple sources
+   * or `customizer` functions.
+   *
+   * @private
+   * @param {Object} object The destination object.
+   * @param {Object} source The source object.
+   * @returns {Object} Returns `object`.
+   */
+  function baseAssign(object, source) {
+    return object && copyObject(source, keys(source), object);
+  }
+
+  return baseAssign;
+});

_baseAt.js

@@ -0,0 +1,27 @@
+define(['./get'], function(get) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.at` without support for individual paths.
+   *
+   * @private
+   * @param {Object} object The object to iterate over.
+   * @param {string[]} paths The property paths of elements to pick.
+   * @returns {Array} Returns the new array of picked elements.
+   */
+  function baseAt(object, paths) {
+    var index = -1,
+        isNil = object == null,
+        length = paths.length,
+        result = Array(length);
+
+    while (++index < length) {
+      result[index] = isNil ? undefined : get(object, paths[index]);
+    }
+    return result;
+  }
+
+  return baseAt;
+});

_baseClamp.js

@@ -0,0 +1,28 @@
+define([], function() {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.clamp` which doesn't coerce arguments to numbers.
+   *
+   * @private
+   * @param {number} number The number to clamp.
+   * @param {number} [lower] The lower bound.
+   * @param {number} upper The upper bound.
+   * @returns {number} Returns the clamped number.
+   */
+  function baseClamp(number, lower, upper) {
+    if (number === number) {
+      if (upper !== undefined) {
+        number = number <= upper ? number : upper;
+      }
+      if (lower !== undefined) {
+        number = number >= lower ? number : lower;
+      }
+    }
+    return number;
+  }
+
+  return baseClamp;
+});

_baseClone.js

@@ -1,4 +1,7 @@
-define(['./arrayCopy', './arrayEach', './baseCopy', './baseForOwn', './initCloneArray', './initCloneByTag', './initCloneObject', '../lang/isArray', '../lang/isObject', '../object/keys'], function(arrayCopy, arrayEach, baseCopy, baseForOwn, initCloneArray, initCloneByTag, initCloneObject, isArray, isObject, keys) {
+define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseForOwn', './_cloneBuffer', './_copyArray', './_copySymbols', './_getTag', './_initCloneArray', './_initCloneByTag', './_initCloneObject', './isArray', './isBuffer', './_isHostObject', './isObject'], function(Stack, arrayEach, assignValue, baseAssign, baseForOwn, cloneBuffer, copyArray, copySymbols, getTag, initCloneArray, initCloneByTag, initCloneObject, isArray, isBuffer, isHostObject, isObject) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
 
   /** `Object#toString` result references. */
   var argsTag = '[object Arguments]',
@@ -7,12 +10,14 @@ define(['./arrayCopy', './arrayEach', './baseCopy', './baseForOwn', './initClone
       dateTag = '[object Date]',
       errorTag = '[object Error]',
       funcTag = '[object Function]',
+      genTag = '[object GeneratorFunction]',
       mapTag = '[object Map]',
       numberTag = '[object Number]',
       objectTag = '[object Object]',
       regexpTag = '[object RegExp]',
       setTag = '[object Set]',
       stringTag = '[object String]',
+      symbolTag = '[object Symbol]',
       weakMapTag = '[object WeakMap]';
 
   var arrayBufferTag = '[object ArrayBuffer]',
@@ -33,44 +38,34 @@ define(['./arrayCopy', './arrayEach', './baseCopy', './baseForOwn', './initClone
   cloneableTags[dateTag] = cloneableTags[float32Tag] =
   cloneableTags[float64Tag] = cloneableTags[int8Tag] =
   cloneableTags[int16Tag] = cloneableTags[int32Tag] =
-  cloneableTags[numberTag] = cloneableTags[objectTag] =
+  cloneableTags[mapTag] = cloneableTags[numberTag] =
-  cloneableTags[regexpTag] = cloneableTags[stringTag] =
+  cloneableTags[objectTag] = cloneableTags[regexpTag] =
-  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+  cloneableTags[setTag] = cloneableTags[stringTag] =
-  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+  cloneableTags[symbolTag] = cloneableTags[uint8Tag] =
+  cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] =
+  cloneableTags[uint32Tag] = true;
   cloneableTags[errorTag] = cloneableTags[funcTag] =
-  cloneableTags[mapTag] = cloneableTags[setTag] =
   cloneableTags[weakMapTag] = false;
 
-  /** Used for native method references. */
-  var objectProto = Object.prototype;
-
   /**
-   * Used to resolve the `toStringTag` of values.
+   * The base implementation of `_.clone` and `_.cloneDeep` which tracks
-   * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
+   * traversed objects.
-   * for more details.
-   */
-  var objToString = objectProto.toString;
-
-  /**
-   * The base implementation of `_.clone` without support for argument juggling
-   * and `this` binding `customizer` functions.
    *
    * @private
    * @param {*} value The value to clone.
    * @param {boolean} [isDeep] Specify a deep clone.
-   * @param {Function} [customizer] The function to customize cloning values.
+   * @param {Function} [customizer] The function to customize cloning.
    * @param {string} [key] The key of `value`.
-   * @param {Object} [object] The object `value` belongs to.
+   * @param {Object} [object] The parent object of `value`.
-   * @param {Array} [stackA=[]] Tracks traversed source objects.
+   * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
-   * @param {Array} [stackB=[]] Associates clones with source counterparts.
    * @returns {*} Returns the cloned value.
    */
-  function baseClone(value, isDeep, customizer, key, object, stackA, stackB) {
+  function baseClone(value, isDeep, customizer, key, object, stack) {
     var result;
     if (customizer) {
-      result = object ? customizer(value, key, object) : customizer(value);
+      result = object ? customizer(value, key, object, stack) : customizer(value);
     }
-    if (typeof result != 'undefined') {
+    if (result !== undefined) {
       return result;
     }
     if (!isObject(value)) {
@@ -80,16 +75,22 @@ define(['./arrayCopy', './arrayEach', './baseCopy', './baseForOwn', './initClone
     if (isArr) {
       result = initCloneArray(value);
       if (!isDeep) {
-        return arrayCopy(value, result);
+        return copyArray(value, result);
       }
     } else {
-      var tag = objToString.call(value),
+      var tag = getTag(value),
-          isFunc = tag == funcTag;
+          isFunc = tag == funcTag || tag == genTag;
 
+      if (isBuffer(value)) {
+        return cloneBuffer(value, isDeep);
+      }
       if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+        if (isHostObject(value)) {
+          return object ? value : {};
+        }
         result = initCloneObject(isFunc ? {} : value);
         if (!isDeep) {
-          return baseCopy(value, result, keys(value));
+          return copySymbols(value, baseAssign(result, value));
         }
       } else {
         return cloneableTags[tag]
@@ -97,25 +98,19 @@ define(['./arrayCopy', './arrayEach', './baseCopy', './baseForOwn', './initClone
           : (object ? value : {});
       }
     }
-    // Check for circular references and return corresponding clone.
+    // Check for circular references and return its corresponding clone.
-    stackA || (stackA = []);
+    stack || (stack = new Stack);
-    stackB || (stackB = []);
+    var stacked = stack.get(value);
-
+    if (stacked) {
-    var length = stackA.length;
+      return stacked;
-    while (length--) {
-      if (stackA[length] == value) {
-        return stackB[length];
-      }
     }
-    // Add the source value to the stack of traversed objects and associate it with its clone.
+    stack.set(value, result);
-    stackA.push(value);
-    stackB.push(result);
 
     // Recursively populate clone (susceptible to call stack limits).
     (isArr ? arrayEach : baseForOwn)(value, function(subValue, key) {
-      result[key] = baseClone(subValue, isDeep, customizer, key, value, stackA, stackB);
+      assignValue(result, key, baseClone(subValue, isDeep, customizer, key, value, stack));
     });
-    return result;
+    return isArr ? result : copySymbols(value, result);
   }
 
   return baseClone;

_baseConforms.js

@@ -0,0 +1,36 @@
+define(['./keys'], function(keys) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.conforms` which doesn't clone `source`.
+   *
+   * @private
+   * @param {Object} source The object of property predicates to conform to.
+   * @returns {Function} Returns the new function.
+   */
+  function baseConforms(source) {
+    var props = keys(source),
+        length = props.length;
+
+    return function(object) {
+      if (object == null) {
+        return !length;
+      }
+      var index = length;
+      while (index--) {
+        var key = props[index],
+            predicate = source[key],
+            value = object[key];
+
+        if ((value === undefined && !(key in Object(object))) || !predicate(value)) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+
+  return baseConforms;
+});

_baseCreate.js

@@ -1,4 +1,7 @@
-define(['../lang/isObject', './root'], function(isObject, root) {
+define(['./isObject'], function(isObject) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
 
   /**
    * The base implementation of `_.create` without support for assigning
@@ -9,14 +12,14 @@ define(['../lang/isObject', './root'], function(isObject, root) {
    * @returns {Object} Returns the new object.
    */
   var baseCreate = (function() {
-    function Object() {}
+    function object() {}
     return function(prototype) {
       if (isObject(prototype)) {
-        Object.prototype = prototype;
+        object.prototype = prototype;
-        var result = new Object;
+        var result = new object;
-        Object.prototype = null;
+        object.prototype = undefined;
       }
-      return result || root.Object();
+      return result || {};
     };
   }());
 

_baseDelay.js

@@ -1,4 +1,4 @@
-define(['./baseSlice'], function(baseSlice) {
+define([], function() {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -7,20 +7,20 @@ define(['./baseSlice'], function(baseSlice) {
   var FUNC_ERROR_TEXT = 'Expected a function';
 
   /**
-   * The base implementation of `_.delay` and `_.defer` which accepts an index
+   * The base implementation of `_.delay` and `_.defer` which accepts an array
-   * of where to slice the arguments to provide to `func`.
+   * 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` object to slice and provide to `func`.
+   * @param {Object} args The arguments to provide to `func`.
    * @returns {number} Returns the timer id.
    */
-  function baseDelay(func, wait, args, fromIndex) {
+  function baseDelay(func, wait, args) {
     if (typeof func != 'function') {
       throw new TypeError(FUNC_ERROR_TEXT);
     }
-    return setTimeout(function() { func.apply(undefined, baseSlice(args, fromIndex)); }, wait);
+    return setTimeout(function() { func.apply(undefined, args); }, wait);
   }
 
   return baseDelay;

_baseDifference.js

@@ -0,0 +1,62 @@
+define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap', './_baseUnary', './_cacheHas'], function(SetCache, arrayIncludes, arrayIncludesWith, arrayMap, baseUnary, cacheHas) {
+
+  /** Used as the size to enable large array optimizations. */
+  var LARGE_ARRAY_SIZE = 200;
+
+  /**
+   * The base implementation of methods like `_.difference` without support for
+   * excluding multiple arrays or iteratee shorthands.
+   *
+   * @private
+   * @param {Array} array The array to inspect.
+   * @param {Array} values The values to exclude.
+   * @param {Function} [iteratee] The iteratee invoked per element.
+   * @param {Function} [comparator] The comparator invoked per element.
+   * @returns {Array} Returns the new array of filtered values.
+   */
+  function baseDifference(array, values, iteratee, comparator) {
+    var index = -1,
+        includes = arrayIncludes,
+        isCommon = true,
+        length = array.length,
+        result = [],
+        valuesLength = values.length;
+
+    if (!length) {
+      return result;
+    }
+    if (iteratee) {
+      values = arrayMap(values, baseUnary(iteratee));
+    }
+    if (comparator) {
+      includes = arrayIncludesWith;
+      isCommon = false;
+    }
+    else if (values.length >= LARGE_ARRAY_SIZE) {
+      includes = cacheHas;
+      isCommon = false;
+      values = new SetCache(values);
+    }
+    outer:
+    while (++index < length) {
+      var value = array[index],
+          computed = iteratee ? iteratee(value) : value;
+
+      if (isCommon && computed === computed) {
+        var valuesIndex = valuesLength;
+        while (valuesIndex--) {
+          if (values[valuesIndex] === computed) {
+            continue outer;
+          }
+        }
+        result.push(value);
+      }
+      else if (!includes(values, computed, comparator)) {
+        result.push(value);
+      }
+    }
+    return result;
+  }
+
+  return baseDifference;
+});

_baseEach.js

@@ -0,0 +1,14 @@
+define(['./_baseForOwn', './_createBaseEach'], function(baseForOwn, createBaseEach) {
+
+  /**
+   * 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);
+
+  return baseEach;
+});

_baseEachRight.js

@@ -0,0 +1,14 @@
+define(['./_baseForOwnRight', './_createBaseEach'], function(baseForOwnRight, createBaseEach) {
+
+  /**
+   * The base implementation of `_.forEachRight` 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 baseEachRight = createBaseEach(baseForOwnRight, true);
+
+  return baseEachRight;
+});

_baseEvery.js

@@ -1,14 +1,12 @@
-define(['./baseEach'], function(baseEach) {
+define(['./_baseEach'], function(baseEach) {
 
   /**
-   * The base implementation of `_.every` without support for callback
+   * The base implementation of `_.every` without support for iteratee shorthands.
-   * shorthands or `this` binding.
    *
    * @private
-   * @param {Array|Object|string} collection The collection to iterate over.
+   * @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,
+   * @returns {boolean} Returns `true` if all elements pass the predicate check, else `false`
-   *  else `false`
    */
   function baseEvery(collection, predicate) {
     var result = true;

_baseExtremum.js

@@ -0,0 +1,36 @@
+define([], function() {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * 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
+            : comparator(current, computed)
+          )) {
+        var computed = current,
+            result = value;
+      }
+    }
+    return result;
+  }
+
+  return baseExtremum;
+});

_baseFill.js

@@ -1,4 +1,7 @@
-define([], function() {
+define(['./toInteger', './toLength'], function(toInteger, toLength) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
 
   /**
    * The base implementation of `_.fill` without an iteratee call guard.
@@ -13,18 +16,16 @@ define([], function() {
   function baseFill(array, value, start, end) {
     var length = array.length;
 
-    start = start == null ? 0 : (+start || 0);
+    start = toInteger(start);
     if (start < 0) {
       start = -start > length ? 0 : (length + start);
     }
-    end = (typeof end == 'undefined' || end > length) ? length : (+end || 0);
+    end = (end === undefined || end > length) ? length : toInteger(end);
     if (end < 0) {
       end += length;
     }
-    length = start > end ? 0 : end >>> 0;
+    end = start > end ? 0 : toLength(end);
-    start >>>= 0;
+    while (start < end) {
-
-    while (start < length) {
       array[start++] = value;
     }
     return array;

_baseFilter.js

@@ -1,11 +1,10 @@
-define(['./baseEach'], function(baseEach) {
+define(['./_baseEach'], function(baseEach) {
 
   /**
-   * The base implementation of `_.filter` without support for callback
+   * The base implementation of `_.filter` without support for iteratee shorthands.
-   * shorthands or `this` binding.
    *
    * @private
-   * @param {Array|Object|string} collection The collection to iterate over.
+   * @param {Array|Object} collection The collection to iterate over.
    * @param {Function} predicate The function invoked per iteration.
    * @returns {Array} Returns the new filtered array.
    */

_baseFind.js

@@ -1,16 +1,15 @@
 define([], function() {
 
   /**
-   * The base implementation of `_.find`, `_.findLast`, `_.findKey`, and `_.findLastKey`,
+   * The base implementation of methods like `_.find` and `_.findKey`, without
-   * without support for callback shorthands and `this` binding, which iterates
+   * support for iteratee shorthands, which iterates over `collection` using
-   * over `collection` using the provided `eachFunc`.
+   * `eachFunc`.
    *
    * @private
-   * @param {Array|Object|string} collection The collection to search.
+   * @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
+   * @param {boolean} [retKey] Specify returning the key of the found element instead of the element itself.
-   *  instead of the element itself.
    * @returns {*} Returns the found element or its key, else `undefined`.
    */
   function baseFind(collection, predicate, eachFunc, retKey) {

_baseFindIndex.js

@@ -0,0 +1,26 @@
+define([], function() {
+
+  /**
+   * The base implementation of `_.findIndex` and `_.findLastIndex` without
+   * support for iteratee shorthands.
+   *
+   * @private
+   * @param {Array} array The array to search.
+   * @param {Function} predicate The function invoked per iteration.
+   * @param {boolean} [fromRight] Specify iterating from right to left.
+   * @returns {number} Returns the index of the matched value, else `-1`.
+   */
+  function baseFindIndex(array, predicate, fromRight) {
+    var length = array.length,
+        index = fromRight ? length : -1;
+
+    while ((fromRight ? index-- : ++index < length)) {
+      if (predicate(array[index], index, array)) {
+        return index;
+      }
+    }
+    return -1;
+  }
+
+  return baseFindIndex;
+});

_baseFlatten.js

@@ -0,0 +1,37 @@
+define(['./_arrayPush', './isArguments', './isArray', './isArrayLikeObject'], function(arrayPush, isArguments, isArray, isArrayLikeObject) {
+
+  /**
+   * The base implementation of `_.flatten` with support for restricting flattening.
+   *
+   * @private
+   * @param {Array} array The array to flatten.
+   * @param {boolean} [isDeep] Specify a deep flatten.
+   * @param {boolean} [isStrict] Restrict flattening to arrays-like objects.
+   * @param {Array} [result=[]] The initial result value.
+   * @returns {Array} Returns the new flattened array.
+   */
+  function baseFlatten(array, isDeep, isStrict, result) {
+    result || (result = []);
+
+    var index = -1,
+        length = array.length;
+
+    while (++index < length) {
+      var value = array[index];
+      if (isArrayLikeObject(value) &&
+          (isStrict || isArray(value) || isArguments(value))) {
+        if (isDeep) {
+          // Recursively flatten arrays (susceptible to call stack limits).
+          baseFlatten(value, isDeep, isStrict, result);
+        } else {
+          arrayPush(result, value);
+        }
+      } else if (!isStrict) {
+        result[result.length] = value;
+      }
+    }
+    return result;
+  }
+
+  return baseFlatten;
+});

_baseFor.js

@@ -1,9 +1,9 @@
-define(['./toObject'], function(toObject) {
+define(['./_createBaseFor'], function(createBaseFor) {
 
   /**
    * The base implementation of `baseForIn` and `baseForOwn` which iterates
    * over `object` properties returned by `keysFunc` invoking `iteratee` for
-   * each property. Iterator functions may exit iteration early by explicitly
+   * each property. Iteratee functions may exit iteration early by explicitly
    * returning `false`.
    *
    * @private
@@ -12,20 +12,7 @@ define(['./toObject'], function(toObject) {
    * @param {Function} keysFunc The function to get the keys of `object`.
    * @returns {Object} Returns `object`.
    */
-  function baseFor(object, iteratee, keysFunc) {
+  var baseFor = createBaseFor();
-    var index = -1,
-        iterable = toObject(object),
-        props = keysFunc(object),
-        length = props.length;
-
-    while (++index < length) {
-      var key = props[index];
-      if (iteratee(iterable[key], key, iterable) === false) {
-        break;
-      }
-    }
-    return object;
-  }
 
   return baseFor;
 });

_baseForIn.js

@@ -1,8 +1,7 @@
-define(['./baseFor', '../object/keysIn'], function(baseFor, keysIn) {
+define(['./_baseFor', './keysIn'], function(baseFor, keysIn) {
 
   /**
-   * The base implementation of `_.forIn` without support for callback
+   * The base implementation of `_.forIn` without support for iteratee shorthands.
-   * shorthands and `this` binding.
    *
    * @private
    * @param {Object} object The object to iterate over.
@@ -10,7 +9,7 @@ define(['./baseFor', '../object/keysIn'], function(baseFor, keysIn) {
    * @returns {Object} Returns `object`.
    */
   function baseForIn(object, iteratee) {
-    return baseFor(object, iteratee, keysIn);
+    return object == null ? object : baseFor(object, iteratee, keysIn);
   }
 
   return baseForIn;

_baseForOwn.js

@@ -1,8 +1,7 @@
-define(['./baseFor', '../object/keys'], function(baseFor, keys) {
+define(['./_baseFor', './keys'], function(baseFor, keys) {
 
   /**
-   * The base implementation of `_.forOwn` without support for callback
+   * The base implementation of `_.forOwn` without support for iteratee shorthands.
-   * shorthands and `this` binding.
    *
    * @private
    * @param {Object} object The object to iterate over.
@@ -10,7 +9,7 @@ define(['./baseFor', '../object/keys'], function(baseFor, keys) {
    * @returns {Object} Returns `object`.
    */
   function baseForOwn(object, iteratee) {
-    return baseFor(object, iteratee, keys);
+    return object && baseFor(object, iteratee, keys);
   }
 
   return baseForOwn;

_baseForOwnRight.js

@@ -1,8 +1,7 @@
-define(['./baseForRight', '../object/keys'], function(baseForRight, keys) {
+define(['./_baseForRight', './keys'], function(baseForRight, keys) {
 
   /**
-   * The base implementation of `_.forOwnRight` without support for callback
+   * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
-   * shorthands and `this` binding.
    *
    * @private
    * @param {Object} object The object to iterate over.
@@ -10,7 +9,7 @@ define(['./baseForRight', '../object/keys'], function(baseForRight, keys) {
    * @returns {Object} Returns `object`.
    */
   function baseForOwnRight(object, iteratee) {
-    return baseForRight(object, iteratee, keys);
+    return object && baseForRight(object, iteratee, keys);
   }
 
   return baseForOwnRight;

_baseForRight.js

@@ -1,4 +1,4 @@
-define(['./toObject'], function(toObject) {
+define(['./_createBaseFor'], function(createBaseFor) {
 
   /**
    * This function is like `baseFor` except that it iterates over properties
@@ -10,19 +10,7 @@ define(['./toObject'], function(toObject) {
    * @param {Function} keysFunc The function to get the keys of `object`.
    * @returns {Object} Returns `object`.
    */
-  function baseForRight(object, iteratee, keysFunc) {
+  var baseForRight = createBaseFor(true);
-    var iterable = toObject(object),
-        props = keysFunc(object),
-        length = props.length;
-
-    while (length--) {
-      var key = props[length];
-      if (iteratee(iterable[key], key, iterable) === false) {
-        break;
-      }
-    }
-    return object;
-  }
 
   return baseForRight;
 });

_baseFunctions.js

@@ -0,0 +1,19 @@
+define(['./_arrayFilter', './isFunction'], function(arrayFilter, isFunction) {
+
+  /**
+   * 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 arrayFilter(props, function(key) {
+      return isFunction(object[key]);
+    });
+  }
+
+  return baseFunctions;
+});

_baseGet.js

@@ -0,0 +1,27 @@
+define(['./_baseToPath', './_isKey'], function(baseToPath, isKey) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.get` without support for default values.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {Array|string} path The path of the property to get.
+   * @returns {*} Returns the resolved value.
+   */
+  function baseGet(object, path) {
+    path = isKey(path, object) ? [path + ''] : baseToPath(path);
+
+    var index = 0,
+        length = path.length;
+
+    while (object != null && index < length) {
+      object = object[path[index++]];
+    }
+    return (index && index == length) ? object : undefined;
+  }
+
+  return baseGet;
+});

_baseHas.js

@@ -0,0 +1,29 @@
+define([], function() {
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /** Built-in value references. */
+  var getPrototypeOf = Object.getPrototypeOf;
+
+  /**
+   * The base implementation of `_.has` without support for deep paths.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {Array|string} key The key to check.
+   * @returns {boolean} Returns `true` if `key` exists, else `false`.
+   */
+  function baseHas(object, key) {
+    // Avoid a bug in IE 10-11 where objects with a [[Prototype]] of `null`,
+    // that are composed entirely of index properties, return `false` for
+    // `hasOwnProperty` checks of them.
+    return hasOwnProperty.call(object, key) ||
+      (typeof object == 'object' && key in object && getPrototypeOf(object) === null);
+  }
+
+  return baseHas;
+});

_baseHasIn.js

@@ -0,0 +1,16 @@
+define([], function() {
+
+  /**
+   * The base implementation of `_.hasIn` without support for deep paths.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {Array|string} key The key to check.
+   * @returns {boolean} Returns `true` if `key` exists, else `false`.
+   */
+  function baseHasIn(object, key) {
+    return key in Object(object);
+  }
+
+  return baseHasIn;
+});

_baseInRange.js

@@ -0,0 +1,21 @@
+define([], function() {
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeMax = Math.max,
+      nativeMin = Math.min;
+
+  /**
+   * The base implementation of `_.inRange` which doesn't coerce arguments to numbers.
+   *
+   * @private
+   * @param {number} number The number to check.
+   * @param {number} start The start of the range.
+   * @param {number} end The end of the range.
+   * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
+   */
+  function baseInRange(number, start, end) {
+    return number >= nativeMin(start, end) && number < nativeMax(start, end);
+  }
+
+  return baseInRange;
+});

_baseIndexOf.js

@@ -1,19 +1,19 @@
-define(['./indexOfNaN'], function(indexOfNaN) {
+define(['./_indexOfNaN'], function(indexOfNaN) {
 
   /**
-   * The base implementation of `_.indexOf` without support for binary searches.
+   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
    *
    * @private
    * @param {Array} array The array to search.
    * @param {*} value The value to search for.
-   * @param {number} [fromIndex=0] The index to search from.
+   * @param {number} fromIndex The index to search from.
    * @returns {number} Returns the index of the matched value, else `-1`.
    */
   function baseIndexOf(array, value, fromIndex) {
     if (value !== value) {
       return indexOfNaN(array, fromIndex);
     }
-    var index = (fromIndex || 0) - 1,
+    var index = fromIndex - 1,
         length = array.length;
 
     while (++index < length) {

_baseIntersection.js

@@ -0,0 +1,61 @@
+define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap', './_baseUnary', './_cacheHas'], function(SetCache, arrayIncludes, arrayIncludesWith, arrayMap, baseUnary, cacheHas) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of methods like `_.intersection`, without support
+   * for iteratee shorthands, that accepts an array of arrays to inspect.
+   *
+   * @private
+   * @param {Array} arrays The arrays to inspect.
+   * @param {Function} [iteratee] The iteratee invoked per element.
+   * @param {Function} [comparator] The comparator invoked per element.
+   * @returns {Array} Returns the new array of shared values.
+   */
+  function baseIntersection(arrays, iteratee, comparator) {
+    var includes = comparator ? arrayIncludesWith : arrayIncludes,
+        othLength = arrays.length,
+        othIndex = othLength,
+        caches = Array(othLength),
+        result = [];
+
+    while (othIndex--) {
+      var array = arrays[othIndex];
+      if (othIndex && iteratee) {
+        array = arrayMap(array, baseUnary(iteratee));
+      }
+      caches[othIndex] = !comparator && (iteratee || array.length >= 120)
+        ? new SetCache(othIndex && array)
+        : undefined;
+    }
+    array = arrays[0];
+
+    var index = -1,
+        length = array.length,
+        seen = caches[0];
+
+    outer:
+    while (++index < length) {
+      var value = array[index],
+          computed = iteratee ? iteratee(value) : value;
+
+      if (!(seen ? cacheHas(seen, computed) : includes(result, computed, comparator))) {
+        var othIndex = othLength;
+        while (--othIndex) {
+          var cache = caches[othIndex];
+          if (!(cache ? cacheHas(cache, computed) : includes(arrays[othIndex], computed, comparator))) {
+            continue outer;
+          }
+        }
+        if (seen) {
+          seen.push(computed);
+        }
+        result.push(value);
+      }
+    }
+    return result;
+  }
+
+  return baseIntersection;
+});

_baseInverter.js

@@ -0,0 +1,22 @@
+define(['./_baseForOwn'], function(baseForOwn) {
+
+  /**
+   * The base implementation of `_.invert` and `_.invertBy` which inverts
+   * `object` with values transformed by `iteratee` and set by `setter`.
+   *
+   * @private
+   * @param {Object} object The object to iterate over.
+   * @param {Function} setter The function to set `accumulator` values.
+   * @param {Function} iteratee The iteratee to transform values.
+   * @param {Object} accumulator The initial inverted object.
+   * @returns {Function} Returns `accumulator`.
+   */
+  function baseInverter(object, setter, iteratee, accumulator) {
+    baseForOwn(object, function(value, key, object) {
+      setter(accumulator, iteratee(value), key, object);
+    });
+    return accumulator;
+  }
+
+  return baseInverter;
+});

_baseInvoke.js

@@ -0,0 +1,27 @@
+define(['./_apply', './_baseToPath', './_isKey', './last', './_parent'], function(apply, baseToPath, isKey, last, parent) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.invoke` without support for individual
+   * method arguments.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {Array|string} path The path of the method to invoke.
+   * @param {Array} args The arguments to invoke the method with.
+   * @returns {*} Returns the result of the invoked method.
+   */
+  function baseInvoke(object, path, args) {
+    if (!isKey(path, object)) {
+      path = baseToPath(path);
+      object = parent(object, path);
+      path = last(path);
+    }
+    var func = object == null ? object : object[path];
+    return func == null ? undefined : apply(func, object, args);
+  }
+
+  return baseInvoke;
+});

_baseIsEqual.js

@@ -0,0 +1,29 @@
+define(['./_baseIsEqualDeep', './isObject', './isObjectLike'], function(baseIsEqualDeep, isObject, isObjectLike) {
+
+  /**
+   * 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);
+  }
+
+  return baseIsEqual;
+});

_baseIsEqualDeep.js

@@ -0,0 +1,77 @@
+define(['./_Stack', './_equalArrays', './_equalByTag', './_equalObjects', './_getTag', './isArray', './_isHostObject', './isTypedArray'], function(Stack, equalArrays, equalByTag, equalObjects, getTag, isArray, isHostObject, isTypedArray) {
+
+  /** Used to compose bitmasks for comparison styles. */
+  var PARTIAL_COMPARE_FLAG = 2;
+
+  /** `Object#toString` result references. */
+  var argsTag = '[object Arguments]',
+      arrayTag = '[object Array]',
+      objectTag = '[object Object]';
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /**
+   * 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 = getTag(object);
+      if (objTag == argsTag) {
+        objTag = objectTag;
+      } else if (objTag != objectTag) {
+        objIsArr = isTypedArray(object);
+      }
+    }
+    if (!othIsArr) {
+      othTag = getTag(other);
+      if (othTag == argsTag) {
+        othTag = objectTag;
+      } else if (othTag != objectTag) {
+        othIsArr = isTypedArray(other);
+      }
+    }
+    var objIsObj = objTag == objectTag && !isHostObject(object),
+        othIsObj = othTag == objectTag && !isHostObject(other),
+        isSameTag = objTag == othTag;
+
+    if (isSameTag && !(objIsArr || objIsObj)) {
+      return equalByTag(object, other, objTag, equalFunc, customizer, bitmask);
+    }
+    var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
+    if (!isPartial) {
+      var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+          othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+      if (objIsWrapped || othIsWrapped) {
+        return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, bitmask, stack);
+      }
+    }
+    if (!isSameTag) {
+      return false;
+    }
+    stack || (stack = new Stack);
+    return (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, bitmask, stack);
+  }
+
+  return baseIsEqualDeep;
+});

_baseIsMatch.js

@@ -0,0 +1,64 @@
+define(['./_Stack', './_baseIsEqual'], function(Stack, baseIsEqual) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /** Used to compose bitmasks for comparison styles. */
+  var UNORDERED_COMPARE_FLAG = 1,
+      PARTIAL_COMPARE_FLAG = 2;
+
+  /**
+   * The base implementation of `_.isMatch` without support for iteratee shorthands.
+   *
+   * @private
+   * @param {Object} object The object to inspect.
+   * @param {Object} source The object of property values to match.
+   * @param {Array} matchData The property names, values, and compare flags to match.
+   * @param {Function} [customizer] The function to customize comparisons.
+   * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+   */
+  function baseIsMatch(object, source, matchData, customizer) {
+    var index = matchData.length,
+        length = index,
+        noCustomizer = !customizer;
+
+    if (object == null) {
+      return !length;
+    }
+    object = Object(object);
+    while (index--) {
+      var data = matchData[index];
+      if ((noCustomizer && data[2])
+            ? data[1] !== object[data[0]]
+            : !(data[0] in object)
+          ) {
+        return false;
+      }
+    }
+    while (++index < length) {
+      data = matchData[index];
+      var key = data[0],
+          objValue = object[key],
+          srcValue = data[1];
+
+      if (noCustomizer && data[2]) {
+        if (objValue === undefined && !(key in object)) {
+          return false;
+        }
+      } else {
+        var stack = new Stack,
+            result = customizer ? customizer(objValue, srcValue, key, object, source, stack) : undefined;
+
+        if (!(result === undefined
+              ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack)
+              : result
+            )) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  return baseIsMatch;
+});

_baseIteratee.js

@@ -0,0 +1,27 @@
+define(['./_baseMatches', './_baseMatchesProperty', './identity', './isArray', './property'], function(baseMatches, baseMatchesProperty, identity, isArray, property) {
+
+  /**
+   * The base implementation of `_.iteratee`.
+   *
+   * @private
+   * @param {*} [value=_.identity] The value to convert to an iteratee.
+   * @returns {Function} Returns the iteratee.
+   */
+  function baseIteratee(value) {
+    var type = typeof value;
+    if (type == 'function') {
+      return value;
+    }
+    if (value == null) {
+      return identity;
+    }
+    if (type == 'object') {
+      return isArray(value)
+        ? baseMatchesProperty(value[0], value[1])
+        : baseMatches(value);
+    }
+    return property(value);
+  }
+
+  return baseIteratee;
+});

_baseKeys.js

@@ -0,0 +1,20 @@
+define([], function() {
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeKeys = Object.keys;
+
+  /**
+   * The base implementation of `_.keys` which doesn't skip the constructor
+   * property of prototypes or treat sparse arrays as dense.
+   *
+   * @private
+   * @type Function
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of property names.
+   */
+  function baseKeys(object) {
+    return nativeKeys(Object(object));
+  }
+
+  return baseKeys;
+});

_baseKeysIn.js

@@ -0,0 +1,39 @@
+define(['./_Reflect', './_iteratorToArray'], function(Reflect, iteratorToArray) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Built-in value references. */
+  var enumerate = Reflect ? Reflect.enumerate : undefined,
+      propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+  /**
+   * 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));
+    };
+  }
+
+  return baseKeysIn;
+});

_baseLodash.js

@@ -0,0 +1,13 @@
+define([], function() {
+
+  /**
+   * The function whose prototype all chaining wrappers inherit from.
+   *
+   * @private
+   */
+  function baseLodash() {
+    // No operation performed.
+  }
+
+  return baseLodash;
+});

_baseMap.js

@@ -0,0 +1,22 @@
+define(['./_baseEach', './isArrayLike'], function(baseEach, isArrayLike) {
+
+  /**
+   * 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;
+  }
+
+  return baseMap;
+});

_baseMatches.js

@@ -0,0 +1,33 @@
+define(['./_baseIsMatch', './_getMatchData'], function(baseIsMatch, getMatchData) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * 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 matchData = getMatchData(source);
+    if (matchData.length == 1 && matchData[0][2]) {
+      var key = matchData[0][0],
+          value = matchData[0][1];
+
+      return function(object) {
+        if (object == null) {
+          return false;
+        }
+        return object[key] === value &&
+          (value !== undefined || (key in Object(object)));
+      };
+    }
+    return function(object) {
+      return object === source || baseIsMatch(object, source, matchData);
+    };
+  }
+
+  return baseMatches;
+});

_baseMatchesProperty.js

@@ -0,0 +1,28 @@
+define(['./_baseIsEqual', './get', './hasIn'], function(baseIsEqual, get, hasIn) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /** Used to compose bitmasks for comparison styles. */
+  var UNORDERED_COMPARE_FLAG = 1,
+      PARTIAL_COMPARE_FLAG = 2;
+
+  /**
+   * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
+   *
+   * @private
+   * @param {string} path The path of the property to get.
+   * @param {*} srcValue The value to match.
+   * @returns {Function} Returns the new function.
+   */
+  function baseMatchesProperty(path, srcValue) {
+    return function(object) {
+      var objValue = get(object, path);
+      return (objValue === undefined && objValue === srcValue)
+        ? hasIn(object, path)
+        : baseIsEqual(srcValue, objValue, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
+    };
+  }
+
+  return baseMatchesProperty;
+});

_baseMerge.js

@@ -0,0 +1,41 @@
+define(['./_Stack', './_arrayEach', './_assignMergeValue', './_baseMergeDeep', './isArray', './isObject', './isTypedArray', './keysIn'], function(Stack, arrayEach, assignMergeValue, baseMergeDeep, isArray, isObject, isTypedArray, keysIn) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.merge` without support for multiple sources.
+   *
+   * @private
+   * @param {Object} object The destination object.
+   * @param {Object} source The source object.
+   * @param {number} srcIndex The index of `source`.
+   * @param {Function} [customizer] The function to customize merged values.
+   * @param {Object} [stack] Tracks traversed source values and their merged counterparts.
+   */
+  function baseMerge(object, source, srcIndex, customizer, stack) {
+    if (object === source) {
+      return;
+    }
+    var props = (isArray(source) || isTypedArray(source)) ? undefined : keysIn(source);
+    arrayEach(props || source, function(srcValue, key) {
+      if (props) {
+        key = srcValue;
+        srcValue = source[key];
+      }
+      if (isObject(srcValue)) {
+        stack || (stack = new Stack);
+        baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+      }
+      else {
+        var newValue = customizer ? customizer(object[key], srcValue, (key + ''), object, source, stack) : undefined;
+        if (newValue === undefined) {
+          newValue = srcValue;
+        }
+        assignMergeValue(object, key, newValue);
+      }
+    });
+  }
+
+  return baseMerge;
+});

_baseMergeDeep.js

@@ -0,0 +1,72 @@
+define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments', './isArray', './isArrayLikeObject', './isFunction', './isObject', './isPlainObject', './isTypedArray', './toPlainObject'], function(assignMergeValue, baseClone, copyArray, isArguments, isArray, isArrayLikeObject, isFunction, isObject, isPlainObject, isTypedArray, toPlainObject) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * A specialized version of `baseMerge` for arrays and objects which performs
+   * deep merges and tracks traversed objects enabling objects with circular
+   * references to be merged.
+   *
+   * @private
+   * @param {Object} object The destination object.
+   * @param {Object} source The source object.
+   * @param {string} key The key of the value to merge.
+   * @param {number} srcIndex The index of `source`.
+   * @param {Function} mergeFunc The function to merge values.
+   * @param {Function} [customizer] The function to customize assigned values.
+   * @param {Object} [stack] Tracks traversed source values and their merged counterparts.
+   */
+  function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+    var objValue = object[key],
+        srcValue = source[key],
+        stacked = stack.get(srcValue);
+
+    if (stacked) {
+      assignMergeValue(object, key, stacked);
+      return;
+    }
+    var newValue = customizer ? customizer(objValue, srcValue, (key + ''), object, source, stack) : undefined,
+        isCommon = newValue === undefined;
+
+    if (isCommon) {
+      newValue = srcValue;
+      if (isArray(srcValue) || isTypedArray(srcValue)) {
+        if (isArray(objValue)) {
+          newValue = srcIndex ? copyArray(objValue) : objValue;
+        }
+        else if (isArrayLikeObject(objValue)) {
+          newValue = copyArray(objValue);
+        }
+        else {
+          isCommon = false;
+          newValue = baseClone(srcValue);
+        }
+      }
+      else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+        if (isArguments(objValue)) {
+          newValue = toPlainObject(objValue);
+        }
+        else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
+          isCommon = false;
+          newValue = baseClone(srcValue);
+        }
+        else {
+          newValue = srcIndex ? baseClone(objValue) : objValue;
+        }
+      }
+      else {
+        isCommon = false;
+      }
+    }
+    stack.set(srcValue, newValue);
+
+    if (isCommon) {
+      // Recursively merge objects and arrays (susceptible to call stack limits).
+      mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+    }
+    assignMergeValue(object, key, newValue);
+  }
+
+  return baseMergeDeep;
+});

_baseOrderBy.js

@@ -0,0 +1,33 @@
+define(['./_arrayMap', './_baseIteratee', './_baseMap', './_baseSortBy', './_compareMultiple'], function(arrayMap, baseIteratee, baseMap, baseSortBy, compareMultiple) {
+
+  /**
+   * The base implementation of `_.orderBy` without param guards.
+   *
+   * @private
+   * @param {Array|Object} collection The collection to iterate over.
+   * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
+   * @param {string[]} orders The sort orders of `iteratees`.
+   * @returns {Array} Returns the new sorted array.
+   */
+  function baseOrderBy(collection, iteratees, orders) {
+    var index = -1,
+        toIteratee = baseIteratee;
+
+    iteratees = arrayMap(iteratees.length ? iteratees : Array(1), function(iteratee) {
+      return toIteratee(iteratee);
+    });
+
+    var result = baseMap(collection, function(value, key, collection) {
+      var criteria = arrayMap(iteratees, function(iteratee) {
+        return iteratee(value);
+      });
+      return { 'criteria': criteria, 'index': ++index, 'value': value };
+    });
+
+    return baseSortBy(result, function(object, other) {
+      return compareMultiple(object, other, orders);
+    });
+  }
+
+  return baseOrderBy;
+});

_basePick.js

@@ -0,0 +1,23 @@
+define(['./_arrayReduce'], function(arrayReduce) {
+
+  /**
+   * The base implementation of `_.pick` without support for individual
+   * property names.
+   *
+   * @private
+   * @param {Object} object The source object.
+   * @param {string[]} props The property names to pick.
+   * @returns {Object} Returns the new object.
+   */
+  function basePick(object, props) {
+    object = Object(object);
+    return arrayReduce(props, function(result, key) {
+      if (key in object) {
+        result[key] = object[key];
+      }
+      return result;
+    }, {});
+  }
+
+  return basePick;
+});

_basePickBy.js

@@ -0,0 +1,22 @@
+define(['./_baseForIn'], function(baseForIn) {
+
+  /**
+   * The base implementation of  `_.pickBy` without support for iteratee shorthands.
+   *
+   * @private
+   * @param {Object} object The source object.
+   * @param {Function} predicate The function invoked per property.
+   * @returns {Object} Returns the new object.
+   */
+  function basePickBy(object, predicate) {
+    var result = {};
+    baseForIn(object, function(value, key) {
+      if (predicate(value, key)) {
+        result[key] = value;
+      }
+    });
+    return result;
+  }
+
+  return basePickBy;
+});

_baseProperty.js

@@ -4,7 +4,7 @@ define([], function() {
   var undefined;
 
   /**
-   * The base implementation of `_.property` which does not coerce `key` to a string.
+   * The base implementation of `_.property` without support for deep paths.
    *
    * @private
    * @param {string} key The key of the property to get.

_basePropertyDeep.js

@@ -0,0 +1,17 @@
+define(['./_baseGet'], function(baseGet) {
+
+  /**
+   * A specialized version of `baseProperty` which supports deep paths.
+   *
+   * @private
+   * @param {Array|string} path The path of the property to get.
+   * @returns {Function} Returns the new function.
+   */
+  function basePropertyDeep(path) {
+    return function(object) {
+      return baseGet(object, path);
+    };
+  }
+
+  return basePropertyDeep;
+});

_basePullAll.js

@@ -0,0 +1,16 @@
+define(['./_basePullAllBy'], function(basePullAllBy) {
+
+  /**
+   * The base implementation of `_.pullAll`.
+   *
+   * @private
+   * @param {Array} array The array to modify.
+   * @param {Array} values The values to remove.
+   * @returns {Array} Returns `array`.
+   */
+  function basePullAll(array, values) {
+    return basePullAllBy(array, values);
+  }
+
+  return basePullAll;
+});

_basePullAllBy.js

@@ -0,0 +1,43 @@
+define(['./_arrayMap', './_baseIndexOf'], function(arrayMap, baseIndexOf) {
+
+  /** Used for built-in method references. */
+  var arrayProto = Array.prototype;
+
+  /** Built-in value references. */
+  var splice = arrayProto.splice;
+
+  /**
+   * The base implementation of `_.pullAllBy` without support for iteratee
+   * shorthands.
+   *
+   * @private
+   * @param {Array} array The array to modify.
+   * @param {Array} values The values to remove.
+   * @param {Function} [iteratee] The iteratee invoked per element.
+   * @returns {Array} Returns `array`.
+   */
+  function basePullAllBy(array, values, iteratee) {
+    var index = -1,
+        length = values.length,
+        seen = array;
+
+    if (iteratee) {
+      seen = arrayMap(array, function(value) { return iteratee(value); });
+    }
+    while (++index < length) {
+      var fromIndex = 0,
+          value = values[index],
+          computed = iteratee ? iteratee(value) : value;
+
+      while ((fromIndex = baseIndexOf(seen, computed, fromIndex)) > -1) {
+        if (seen !== array) {
+          splice.call(seen, fromIndex, 1);
+        }
+        splice.call(array, fromIndex, 1);
+      }
+    }
+    return array;
+  }
+
+  return basePullAllBy;
+});

_basePullAt.js

@@ -0,0 +1,46 @@
+define(['./_baseToPath', './_isIndex', './_isKey', './last', './_parent'], function(baseToPath, isIndex, isKey, last, parent) {
+
+  /** Used for built-in method references. */
+  var arrayProto = Array.prototype;
+
+  /** Built-in value references. */
+  var splice = arrayProto.splice;
+
+  /**
+   * The base implementation of `_.pullAt` without support for individual
+   * indexes or capturing the removed elements.
+   *
+   * @private
+   * @param {Array} array The array to modify.
+   * @param {number[]} indexes The indexes of elements to remove.
+   * @returns {Array} Returns `array`.
+   */
+  function basePullAt(array, indexes) {
+    var length = array ? indexes.length : 0,
+        lastIndex = length - 1;
+
+    while (length--) {
+      var index = indexes[length];
+      if (lastIndex == length || index != previous) {
+        var previous = index;
+        if (isIndex(index)) {
+          splice.call(array, index, 1);
+        }
+        else if (!isKey(index, array)) {
+          var path = baseToPath(index),
+              object = parent(array, path);
+
+          if (object != null) {
+            delete object[last(path)];
+          }
+        }
+        else {
+          delete array[index];
+        }
+      }
+    }
+    return array;
+  }
+
+  return basePullAt;
+});

_baseRandom.js

@@ -0,0 +1,21 @@
+define([], function() {
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeFloor = Math.floor,
+      nativeRandom = Math.random;
+
+  /**
+   * The base implementation of `_.random` without support for returning
+   * floating-point numbers.
+   *
+   * @private
+   * @param {number} lower The lower bound.
+   * @param {number} upper The upper bound.
+   * @returns {number} Returns the random number.
+   */
+  function baseRandom(lower, upper) {
+    return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
+  }
+
+  return baseRandom;
+});

_baseRange.js

@@ -0,0 +1,31 @@
+define([], function() {
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeCeil = Math.ceil,
+      nativeMax = Math.max;
+
+  /**
+   * The base implementation of `_.range` and `_.rangeRight` which doesn't
+   * coerce arguments to numbers.
+   *
+   * @private
+   * @param {number} start The start of the range.
+   * @param {number} end The end of the range.
+   * @param {number} step The value to increment or decrement by.
+   * @param {boolean} [fromRight] Specify iterating from right to left.
+   * @returns {Array} Returns the new array of numbers.
+   */
+  function baseRange(start, end, step, fromRight) {
+    var index = -1,
+        length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
+        result = Array(length);
+
+    while (length--) {
+      result[fromRight ? length : ++index] = start;
+      start += step;
+    }
+    return result;
+  }
+
+  return baseRange;
+});

_baseReduce.js

@@ -0,0 +1,25 @@
+define([], function() {
+
+  /**
+   * 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;
+  }
+
+  return baseReduce;
+});

_baseSet.js

@@ -0,0 +1,43 @@
+define(['./_assignValue', './_baseToPath', './_isIndex', './_isKey', './isObject'], function(assignValue, baseToPath, isIndex, isKey, isObject) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.set`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {Array|string} path The path of the property to set.
+   * @param {*} value The value to set.
+   * @param {Function} [customizer] The function to customize path creation.
+   * @returns {Object} Returns `object`.
+   */
+  function baseSet(object, path, value, customizer) {
+    path = isKey(path, object) ? [path + ''] : baseToPath(path);
+
+    var index = -1,
+        length = path.length,
+        lastIndex = length - 1,
+        nested = object;
+
+    while (nested != null && ++index < length) {
+      var key = path[index];
+      if (isObject(nested)) {
+        var newValue = value;
+        if (index != lastIndex) {
+          var objValue = nested[key];
+          newValue = customizer ? customizer(objValue, key, nested) : undefined;
+          if (newValue === undefined) {
+            newValue = objValue == null ? (isIndex(path[index + 1]) ? [] : {}) : objValue;
+          }
+        }
+        assignValue(nested, key, newValue);
+      }
+      nested = nested[key];
+    }
+    return object;
+  }
+
+  return baseSet;
+});

_baseSetData.js

@@ -1,4 +1,4 @@
-define(['../utility/identity', './metaMap'], function(identity, metaMap) {
+define(['./identity', './_metaMap'], function(identity, metaMap) {
 
   /**
    * The base implementation of `setData` without support for hot loop detection.

_baseSlice.js

@@ -13,15 +13,14 @@ define([], function() {
     var index = -1,
         length = array.length;
 
-    start = start == null ? 0 : (+start || 0);
     if (start < 0) {
       start = -start > length ? 0 : (length + start);
     }
-    end = (typeof end == 'undefined' || end > length) ? length : (+end || 0);
+    end = end > length ? length : end;
     if (end < 0) {
       end += length;
     }
-    length = start > end ? 0 : (end - start) >>> 0;
+    length = start > end ? 0 : ((end - start) >>> 0);
     start >>>= 0;
 
     var result = Array(length);

_baseSome.js

@@ -1,14 +1,12 @@
-define(['./baseEach'], function(baseEach) {
+define(['./_baseEach'], function(baseEach) {
 
   /**
-   * The base implementation of `_.some` without support for callback shorthands
+   * The base implementation of `_.some` without support for iteratee shorthands.
-   * or `this` binding.
    *
    * @private
-   * @param {Array|Object|string} collection The collection to iterate over.
+   * @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,
+   * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
-   *  else `false`.
    */
   function baseSome(collection, predicate) {
     var result;

_baseSortBy.js

@@ -1,8 +1,8 @@
 define([], function() {
 
   /**
-   * The base implementation of `_.sortBy` and `_.sortByAll` which uses `comparer`
+   * The base implementation of `_.sortBy` which uses `comparer` to define
-   * to define the sort order of `array` and replaces criteria objects with their
+   * the sort order of `array` and replaces criteria objects with their
    * corresponding values.
    *
    * @private