Bump to v4.11.1.

LICENSE

@@ -1,7 +1,17 @@
-Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>
-Based on Underscore.js, copyright 2009-2016 Jeremy Ashkenas,
+Copyright jQuery Foundation and other contributors <https://jquery.org/>
+
+Based on Underscore.js, copyright Jeremy Ashkenas,
 DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
 
+This software consists of voluntary contributions made by many
+individuals. For exact contribution history, see the revision history
+available at https://github.com/lodash/lodash
+
+The following license applies to all parts of this software except as
+documented below:
+
+====
+
 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
@@ -20,3 +30,18 @@ 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.
+
+====
+
+Copyright and related rights for sample code are waived via CC0. Sample
+code is defined as all source code displayed within the prose of the
+documentation.
+
+CC0: http://creativecommons.org/publicdomain/zero/1.0/
+
+====
+
+Files located in the node_modules and vendor directories are externally
+maintained libraries used by this software which have their own
+licenses; we recommend you read them, as their terms may differ from the
+terms above.

README.md

@@ -1,6 +1,6 @@
-# lodash-amd v4.2.0
+# lodash-amd v4.11.1
 
-The [lodash](https://lodash.com/) library 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
@@ -27,4 +27,4 @@ require({
 });
 ```
 
-See the [package source](https://github.com/lodash/lodash/tree/4.2.0-amd) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.11.1-amd) for more details.

_DataView.js

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

_Hash.js

@@ -4,9 +4,10 @@ define(['./_nativeCreate'], function(nativeCreate) {
   var objectProto = Object.prototype;
 
   /**
-   * Creates an hash object.
+   * Creates a hash object.
    *
    * @private
+   * @constructor
    * @returns {Object} Returns the new hash object.
    */
   function Hash() {}

_LazyWrapper.js

@@ -7,6 +7,7 @@ define(['./_baseCreate', './_baseLodash'], function(baseCreate, baseLodash) {
    * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
    *
    * @private
+   * @constructor
    * @param {*} value The value to wrap.
    */
   function LazyWrapper(value) {
@@ -19,6 +20,7 @@ define(['./_baseCreate', './_baseLodash'], function(baseCreate, baseLodash) {
     this.__views__ = [];
   }
 
+  // Ensure `LazyWrapper` is an instance of `baseLodash`.
   LazyWrapper.prototype = baseCreate(baseLodash.prototype);
   LazyWrapper.prototype.constructor = LazyWrapper;
 

_LodashWrapper.js

@@ -8,7 +8,7 @@ define(['./_baseCreate', './_baseLodash'], function(baseCreate, baseLodash) {
    *
    * @private
    * @param {*} value The value to wrap.
-   * @param {boolean} [chainAll] Enable chaining for all wrapper methods.
+   * @param {boolean} [chainAll] Enable explicit method chain sequences.
    */
   function LodashWrapper(value, chainAll) {
     this.__wrapped__ = value;

_MapCache.js

@@ -4,6 +4,7 @@ define(['./_mapClear', './_mapDelete', './_mapGet', './_mapHas', './_mapSet'], f
    * Creates a map cache object to store key-value pairs.
    *
    * @private
+   * @constructor
    * @param {Array} [values] The values to cache.
    */
   function MapCache(values) {
@@ -17,7 +18,7 @@ define(['./_mapClear', './_mapDelete', './_mapGet', './_mapHas', './_mapSet'], f
     }
   }
 
-  // Add functions to the `MapCache`.
+  // Add methods to `MapCache`.
   MapCache.prototype.clear = mapClear;
   MapCache.prototype['delete'] = mapDelete;
   MapCache.prototype.get = mapGet;

_Promise.js

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

_SetCache.js

@@ -5,6 +5,7 @@ define(['./_MapCache', './_cachePush'], function(MapCache, cachePush) {
    * Creates a set cache object to store unique values.
    *
    * @private
+   * @constructor
    * @param {Array} [values] The values to cache.
    */
   function SetCache(values) {
@@ -17,7 +18,7 @@ define(['./_MapCache', './_cachePush'], function(MapCache, cachePush) {
     }
   }
 
-  // Add functions to the `SetCache`.
+  // Add methods to `SetCache`.
   SetCache.prototype.push = cachePush;
 
   return SetCache;

_Stack.js

@@ -4,6 +4,7 @@ define(['./_stackClear', './_stackDelete', './_stackGet', './_stackHas', './_sta
    * Creates a stack cache object to store key-value pairs.
    *
    * @private
+   * @constructor
    * @param {Array} [values] The values to cache.
    */
   function Stack(values) {
@@ -17,7 +18,7 @@ define(['./_stackClear', './_stackDelete', './_stackGet', './_stackHas', './_sta
     }
   }
 
-  // Add functions to the `Stack` cache.
+  // Add methods to `Stack`.
   Stack.prototype.clear = stackClear;
   Stack.prototype['delete'] = stackDelete;
   Stack.prototype.get = stackGet;

_addMapEntry.js

@@ -9,6 +9,7 @@ define([], function() {
    * @returns {Object} Returns `map`.
    */
   function addMapEntry(map, pair) {
+    // Don't return `Map#set` because it doesn't return the map instance in IE 11.
     map.set(pair[0], pair[1]);
     return map;
   }

_apply.js

@@ -7,7 +7,7 @@ define([], function() {
    * @private
    * @param {Function} func The function to invoke.
    * @param {*} thisArg The `this` binding of `func`.
-   * @param {...*} args The arguments to invoke `func` with.
+   * @param {Array} args The arguments to invoke `func` with.
    * @returns {*} Returns the result of `func`.
    */
   function apply(func, thisArg, args) {

_arrayEvery.js

@@ -7,7 +7,8 @@ define([], function() {
    * @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, else `false`.
+   * @returns {boolean} Returns `true` if all elements pass the predicate check,
+   *  else `false`.
    */
   function arrayEvery(array, predicate) {
     var index = -1,

_arrayFilter.js

@@ -12,13 +12,13 @@ define([], function() {
   function arrayFilter(array, predicate) {
     var index = -1,
         length = array.length,
-        resIndex = -1,
+        resIndex = 0,
         result = [];
 
     while (++index < length) {
       var value = array[index];
       if (predicate(value, index, array)) {
-        result[++resIndex] = value;
+        result[resIndex++] = value;
       }
     }
     return result;

_arrayIncludesWith.js

@@ -1,8 +1,7 @@
 define([], function() {
 
   /**
-   * A specialized version of `_.includesWith` for arrays without support for
-   * specifying an index to search from.
+   * This function is like `arrayIncludes` except that it accepts a comparator.
    *
    * @private
    * @param {Array} array The array to search.

_arrayReduce.js

@@ -8,7 +8,8 @@ define([], function() {
    * @param {Array} array The array to iterate over.
    * @param {Function} iteratee The function invoked per iteration.
    * @param {*} [accumulator] The initial value.
-   * @param {boolean} [initAccum] Specify using the first element of `array` as the initial value.
+   * @param {boolean} [initAccum] Specify using the first element of `array` as
+   *  the initial value.
    * @returns {*} Returns the accumulated value.
    */
   function arrayReduce(array, iteratee, accumulator, initAccum) {

_arrayReduceRight.js

@@ -8,7 +8,8 @@ define([], function() {
    * @param {Array} array The array to iterate over.
    * @param {Function} iteratee The function invoked per iteration.
    * @param {*} [accumulator] The initial value.
-   * @param {boolean} [initAccum] Specify using the last element of `array` as the initial value.
+   * @param {boolean} [initAccum] Specify using the last element of `array` as
+   *  the initial value.
    * @returns {*} Returns the accumulated value.
    */
   function arrayReduceRight(array, iteratee, accumulator, initAccum) {

_arraySome.js

@@ -7,7 +7,8 @@ define([], function() {
    * @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, else `false`.
+   * @returns {boolean} Returns `true` if any element passes the predicate check,
+   *  else `false`.
    */
   function arraySome(array, predicate) {
     var index = -1,

_assignMergeValue.js

@@ -4,7 +4,8 @@ define(['./eq'], function(eq) {
   var undefined;
 
   /**
-   * This function is like `assignValue` except that it doesn't assign `undefined` values.
+   * This function is like `assignValue` except that it doesn't assign
+   * `undefined` values.
    *
    * @private
    * @param {Object} object The object to modify.

_assignValue.js

@@ -21,8 +21,7 @@ define(['./eq'], function(eq) {
    */
   function assignValue(object, key, value) {
     var objValue = object[key];
-    if ((!eq(objValue, value) ||
-          (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) ||
+    if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
         (value === undefined && !(key in object))) {
       object[key] = value;
     }

_assocDelete.js

@@ -10,7 +10,7 @@ define(['./_assocIndexOf'], function(assocIndexOf) {
    * Removes `key` and its value from the associative array.
    *
    * @private
-   * @param {Array} array The array to query.
+   * @param {Array} array The array to modify.
    * @param {string} key The key of the value to remove.
    * @returns {boolean} Returns `true` if the entry was removed, else `false`.
    */

_assocIndexOf.js

@@ -1,8 +1,7 @@
 define(['./eq'], function(eq) {
 
   /**
-   * Gets the index at which the first occurrence of `key` is found in `array`
-   * of key-value pairs.
+   * Gets the index at which the `key` is found in `array` of key-value pairs.
    *
    * @private
    * @param {Array} array The array to search.

_baseClone.js

@@ -1,4 +1,4 @@
-define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseForOwn', './_copyArray', './_copySymbols', './_getTag', './_initCloneArray', './_initCloneByTag', './_initCloneObject', './isArray', './_isHostObject', './isObject'], function(Stack, arrayEach, assignValue, baseAssign, baseForOwn, copyArray, copySymbols, getTag, initCloneArray, initCloneByTag, initCloneObject, isArray, isHostObject, isObject) {
+define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_cloneBuffer', './_copyArray', './_copySymbols', './_getAllKeys', './_getTag', './_initCloneArray', './_initCloneByTag', './_initCloneObject', './isArray', './isBuffer', './_isHostObject', './isObject', './keys'], function(Stack, arrayEach, assignValue, baseAssign, cloneBuffer, copyArray, copySymbols, getAllKeys, getTag, initCloneArray, initCloneByTag, initCloneObject, isArray, isBuffer, isHostObject, isObject, keys) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -21,6 +21,7 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseF
       weakMapTag = '[object WeakMap]';
 
   var arrayBufferTag = '[object ArrayBuffer]',
+      dataViewTag = '[object DataView]',
       float32Tag = '[object Float32Array]',
       float64Tag = '[object Float64Array]',
       int8Tag = '[object Int8Array]',
@@ -34,16 +35,16 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseF
   /** Used to identify `toStringTag` values supported by `_.clone`. */
   var cloneableTags = {};
   cloneableTags[argsTag] = cloneableTags[arrayTag] =
-  cloneableTags[arrayBufferTag] = cloneableTags[boolTag] =
-  cloneableTags[dateTag] = cloneableTags[float32Tag] =
-  cloneableTags[float64Tag] = cloneableTags[int8Tag] =
-  cloneableTags[int16Tag] = cloneableTags[int32Tag] =
-  cloneableTags[mapTag] = cloneableTags[numberTag] =
-  cloneableTags[objectTag] = cloneableTags[regexpTag] =
-  cloneableTags[setTag] = cloneableTags[stringTag] =
-  cloneableTags[symbolTag] = cloneableTags[uint8Tag] =
-  cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] =
-  cloneableTags[uint32Tag] = true;
+  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+  cloneableTags[boolTag] = cloneableTags[dateTag] =
+  cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+  cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+  cloneableTags[int32Tag] = cloneableTags[mapTag] =
+  cloneableTags[numberTag] = cloneableTags[objectTag] =
+  cloneableTags[regexpTag] = cloneableTags[setTag] =
+  cloneableTags[stringTag] = cloneableTags[symbolTag] =
+  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
   cloneableTags[errorTag] = cloneableTags[funcTag] =
   cloneableTags[weakMapTag] = false;
 
@@ -54,13 +55,14 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseF
    * @private
    * @param {*} value The value to clone.
    * @param {boolean} [isDeep] Specify a deep clone.
+   * @param {boolean} [isFull] Specify a clone including symbols.
    * @param {Function} [customizer] The function to customize cloning.
    * @param {string} [key] The key of `value`.
    * @param {Object} [object] The parent object of `value`.
    * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
    * @returns {*} Returns the cloned value.
    */
-  function baseClone(value, isDeep, customizer, key, object, stack) {
+  function baseClone(value, isDeep, isFull, customizer, key, object, stack) {
     var result;
     if (customizer) {
       result = object ? customizer(value, key, object, stack) : customizer(value);
@@ -81,6 +83,9 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseF
       var tag = getTag(value),
           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 : {};
@@ -90,9 +95,10 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseF
           return copySymbols(value, baseAssign(result, value));
         }
       } else {
-        return cloneableTags[tag]
-          ? initCloneByTag(value, tag, isDeep)
-          : (object ? value : {});
+        if (!cloneableTags[tag]) {
+          return object ? value : {};
+        }
+        result = initCloneByTag(value, tag, baseClone, isDeep);
       }
     }
     // Check for circular references and return its corresponding clone.
@@ -103,11 +109,18 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_baseF
     }
     stack.set(value, result);
 
+    if (!isArr) {
+      var props = isFull ? getAllKeys(value) : keys(value);
+    }
     // Recursively populate clone (susceptible to call stack limits).
-    (isArr ? arrayEach : baseForOwn)(value, function(subValue, key) {
-      assignValue(result, key, baseClone(subValue, isDeep, customizer, key, value, stack));
+    arrayEach(props || value, function(subValue, key) {
+      if (props) {
+        key = subValue;
+        subValue = value[key];
+      }
+      assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
     });
-    return isArr ? result : copySymbols(value, result);
+    return result;
   }
 
   return baseClone;

_baseConforms.js

@@ -24,7 +24,8 @@ define(['./keys'], function(keys) {
             predicate = source[key],
             value = object[key];
 
-        if ((value === undefined && !(key in Object(object))) || !predicate(value)) {
+        if ((value === undefined &&
+            !(key in Object(object))) || !predicate(value)) {
           return false;
         }
       }

_baseCreate.js

@@ -1,7 +1,7 @@
 define(['./isObject'], function(isObject) {
 
-  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
-  var undefined;
+  /** Built-in value references. */
+  var objectCreate = Object.create;
 
   /**
    * The base implementation of `_.create` without support for assigning
@@ -11,17 +11,9 @@ define(['./isObject'], function(isObject) {
    * @param {Object} prototype The object to inherit from.
    * @returns {Object} Returns the new object.
    */
-  var baseCreate = (function() {
-    function object() {}
-    return function(prototype) {
-      if (isObject(prototype)) {
-        object.prototype = prototype;
-        var result = new object;
-        object.prototype = undefined;
-      }
-      return result || {};
-    };
-  }());
+  function baseCreate(proto) {
+    return isObject(proto) ? objectCreate(proto) : {};
+  }
 
   return baseCreate;
 });

_baseDelay.js

@@ -13,7 +13,7 @@ define([], function() {
    * @private
    * @param {Function} func The function to delay.
    * @param {number} wait The number of milliseconds to delay invocation.
-   * @param {Object} args The arguments provide to `func`.
+   * @param {Object} args The arguments to provide to `func`.
    * @returns {number} Returns the timer id.
    */
   function baseDelay(func, wait, args) {

_baseDifference.js

@@ -4,8 +4,8 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
   var LARGE_ARRAY_SIZE = 200;
 
   /**
-   * The base implementation of methods like `_.difference` without support for
-   * excluding multiple arrays or iteratee shorthands.
+   * The base implementation of methods like `_.difference` without support
+   * for excluding multiple arrays or iteratee shorthands.
    *
    * @private
    * @param {Array} array The array to inspect.

_baseEvery.js

@@ -6,7 +6,8 @@ define(['./_baseEach'], function(baseEach) {
    * @private
    * @param {Array|Object} collection The collection to iterate over.
    * @param {Function} predicate The function invoked per iteration.
-   * @returns {boolean} Returns `true` if all elements pass the predicate check, else `false`
+   * @returns {boolean} Returns `true` if all elements pass the predicate check,
+   *  else `false`
    */
   function baseEvery(collection, predicate) {
     var result = true;

_baseFind.js

@@ -9,7 +9,8 @@ define([], function() {
    * @param {Array|Object} collection The collection to search.
    * @param {Function} predicate The function invoked per iteration.
    * @param {Function} eachFunc The function to iterate over `collection`.
-   * @param {boolean} [retKey] Specify returning the key of the found element instead of the element itself.
+   * @param {boolean} [retKey] Specify returning the key of the found element
+   *  instead of the element itself.
    * @returns {*} Returns the found element or its key, else `undefined`.
    */
   function baseFind(collection, predicate, eachFunc, retKey) {

_baseFlatten.js

@@ -1,28 +1,29 @@
-define(['./_arrayPush', './isArguments', './isArray', './isArrayLikeObject'], function(arrayPush, isArguments, isArray, isArrayLikeObject) {
+define(['./_arrayPush', './_isFlattenable'], function(arrayPush, isFlattenable) {
 
   /**
    * 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 {number} depth The maximum recursion depth.
+   * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
+   * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
    * @param {Array} [result=[]] The initial result value.
    * @returns {Array} Returns the new flattened array.
    */
-  function baseFlatten(array, isDeep, isStrict, result) {
-    result || (result = []);
-
+  function baseFlatten(array, depth, predicate, isStrict, result) {
     var index = -1,
         length = array.length;
 
+    predicate || (predicate = isFlattenable);
+    result || (result = []);
+
     while (++index < length) {
       var value = array[index];
-      if (isArrayLikeObject(value) &&
-          (isStrict || isArray(value) || isArguments(value))) {
-        if (isDeep) {
+      if (depth > 0 && predicate(value)) {
+        if (depth > 1) {
           // Recursively flatten arrays (susceptible to call stack limits).
-          baseFlatten(value, isDeep, isStrict, result);
+          baseFlatten(value, depth - 1, predicate, isStrict, result);
         } else {
           arrayPush(result, value);
         }

_baseFor.js

@@ -1,10 +1,9 @@
 define(['./_createBaseFor'], function(createBaseFor) {
 
   /**
-   * The base implementation of `baseForIn` and `baseForOwn` which iterates
-   * over `object` properties returned by `keysFunc` invoking `iteratee` for
-   * each property. Iteratee functions may exit iteration early by explicitly
-   * returning `false`.
+   * The base implementation of `baseForOwn` which iterates over `object`
+   * properties returned by `keysFunc` and invokes `iteratee` for each property.
+   * Iteratee functions may exit iteration early by explicitly returning `false`.
    *
    * @private
    * @param {Object} object The object to iterate over.

_baseForIn.js

@@ -1,16 +0,0 @@
-define(['./_baseFor', './keysIn'], function(baseFor, keysIn) {
-
-  /**
-   * The base implementation of `_.forIn` without support for iteratee shorthands.
-   *
-   * @private
-   * @param {Object} object The object to iterate over.
-   * @param {Function} iteratee The function invoked per iteration.
-   * @returns {Object} Returns `object`.
-   */
-  function baseForIn(object, iteratee) {
-    return object == null ? object : baseFor(object, iteratee, keysIn);
-  }
-
-  return baseForIn;
-});

_baseFunctions.js

@@ -2,7 +2,7 @@ define(['./_arrayFilter', './isFunction'], function(arrayFilter, isFunction) {
 
   /**
    * The base implementation of `_.functions` which creates an array of
-   * `object` function property names filtered from those provided.
+   * `object` function property names filtered from `props`.
    *
    * @private
    * @param {Object} object The object to inspect.

_baseGet.js

@@ -1,4 +1,4 @@
-define(['./_baseToPath', './_isKey'], function(baseToPath, isKey) {
+define(['./_castPath', './_isKey'], function(castPath, isKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -12,7 +12,7 @@ define(['./_baseToPath', './_isKey'], function(baseToPath, isKey) {
    * @returns {*} Returns the resolved value.
    */
   function baseGet(object, path) {
-    path = isKey(path, object) ? [path + ''] : baseToPath(path);
+    path = isKey(path, object) ? [path] : castPath(path);
 
     var index = 0,
         length = path.length;

_baseGetAllKeys.js

@@ -0,0 +1,22 @@
+define(['./_arrayPush', './isArray'], function(arrayPush, isArray) {
+
+  /**
+   * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+   * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+   * symbols of `object`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {Function} keysFunc The function to get the keys of `object`.
+   * @param {Function} symbolsFunc The function to get the symbols of `object`.
+   * @returns {Array} Returns the array of property names and symbols.
+   */
+  function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+    var result = keysFunc(object);
+    return isArray(object)
+      ? result
+      : arrayPush(result, symbolsFunc(object));
+  }
+
+  return baseGetAllKeys;
+});

_baseHas.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_getPrototype'], function(getPrototype) {
 
   /** Used for built-in method references. */
   var objectProto = Object.prototype;
@@ -6,9 +6,6 @@ define([], function() {
   /** 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.
    *
@@ -22,7 +19,7 @@ define([], function() {
     // 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);
+      (typeof object == 'object' && key in object && getPrototype(object) === null);
   }
 
   return baseHas;

_baseIndexOfWith.js

@@ -0,0 +1,26 @@
+define([], function() {
+
+  /**
+   * This function is like `baseIndexOf` except that it accepts a comparator.
+   *
+   * @private
+   * @param {Array} array The array to search.
+   * @param {*} value The value to search for.
+   * @param {number} fromIndex The index to search from.
+   * @param {Function} comparator The comparator invoked per element.
+   * @returns {number} Returns the index of the matched value, else `-1`.
+   */
+  function baseIndexOfWith(array, value, fromIndex, comparator) {
+    var index = fromIndex - 1,
+        length = array.length;
+
+    while (++index < length) {
+      if (comparator(array[index], value)) {
+        return index;
+      }
+    }
+    return -1;
+  }
+
+  return baseIndexOfWith;
+});

_baseIntersection.js

@@ -3,6 +3,9 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeMin = Math.min;
+
   /**
    * The base implementation of methods like `_.intersection`, without support
    * for iteratee shorthands, that accepts an array of arrays to inspect.
@@ -15,9 +18,11 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
    */
   function baseIntersection(arrays, iteratee, comparator) {
     var includes = comparator ? arrayIncludesWith : arrayIncludes,
+        length = arrays[0].length,
         othLength = arrays.length,
         othIndex = othLength,
         caches = Array(othLength),
+        maxLength = Infinity,
         result = [];
 
     while (othIndex--) {
@@ -25,26 +30,32 @@ define(['./_SetCache', './_arrayIncludes', './_arrayIncludesWith', './_arrayMap'
       if (othIndex && iteratee) {
         array = arrayMap(array, baseUnary(iteratee));
       }
-      caches[othIndex] = !comparator && (iteratee || array.length >= 120)
+      maxLength = nativeMin(array.length, maxLength);
+      caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
         ? new SetCache(othIndex && array)
         : undefined;
     }
     array = arrays[0];
 
     var index = -1,
-        length = array.length,
         seen = caches[0];
 
     outer:
-    while (++index < length) {
+    while (++index < length && result.length < maxLength) {
       var value = array[index],
           computed = iteratee ? iteratee(value) : value;
 
-      if (!(seen ? cacheHas(seen, computed) : includes(result, computed, comparator))) {
-        var othIndex = othLength;
+      if (!(seen
+            ? cacheHas(seen, computed)
+            : includes(result, computed, comparator)
+          )) {
+        othIndex = othLength;
         while (--othIndex) {
           var cache = caches[othIndex];
-          if (!(cache ? cacheHas(cache, computed) : includes(arrays[othIndex], computed, comparator))) {
+          if (!(cache
+                ? cacheHas(cache, computed)
+                : includes(arrays[othIndex], computed, comparator))
+              ) {
             continue outer;
           }
         }

_baseInvoke.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_baseToPath', './_isKey', './last', './_parent'], function(apply, baseToPath, isKey, last, parent) {
+define(['./_apply', './_castPath', './_isKey', './last', './_parent'], function(apply, castPath, isKey, last, parent) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -15,7 +15,7 @@ define(['./_apply', './_baseToPath', './_isKey', './last', './_parent'], functio
    */
   function baseInvoke(object, path, args) {
     if (!isKey(path, object)) {
-      path = baseToPath(path);
+      path = castPath(path);
       object = parent(object, path);
       path = last(path);
     }

_baseIsEqualDeep.js

@@ -24,7 +24,8 @@ define(['./_Stack', './_equalArrays', './_equalByTag', './_equalObjects', './_ge
    * @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 {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`.
    */
@@ -36,41 +37,39 @@ define(['./_Stack', './_equalArrays', './_equalByTag', './_equalObjects', './_ge
 
     if (!objIsArr) {
       objTag = getTag(object);
-      if (objTag == argsTag) {
-        objTag = objectTag;
-      } else if (objTag != objectTag) {
-        objIsArr = isTypedArray(object);
-      }
+      objTag = objTag == argsTag ? objectTag : objTag;
     }
     if (!othIsArr) {
       othTag = getTag(other);
-      if (othTag == argsTag) {
-        othTag = objectTag;
-      } else if (othTag != objectTag) {
-        othIsArr = isTypedArray(other);
-      }
+      othTag = othTag == argsTag ? objectTag : othTag;
     }
     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);
+    if (isSameTag && !objIsObj) {
+      stack || (stack = new Stack);
+      return (objIsArr || isTypedArray(object))
+        ? equalArrays(object, other, equalFunc, customizer, bitmask, stack)
+        : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);
     }
-    var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
-    if (!isPartial) {
+    if (!(bitmask & PARTIAL_COMPARE_FLAG)) {
       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);
+        var objUnwrapped = objIsWrapped ? object.value() : object,
+            othUnwrapped = othIsWrapped ? other.value() : other;
+
+        stack || (stack = new Stack);
+        return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack);
       }
     }
     if (!isSameTag) {
       return false;
     }
     stack || (stack = new Stack);
-    return (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, bitmask, stack);
+    return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
   }
 
   return baseIsEqualDeep;

_baseIsMatch.js

@@ -46,9 +46,10 @@ define(['./_Stack', './_baseIsEqual'], function(Stack, baseIsEqual) {
           return false;
         }
       } else {
-        var stack = new Stack,
-            result = customizer ? customizer(objValue, srcValue, key, object, source, stack) : undefined;
-
+        var stack = new Stack;
+        if (customizer) {
+          var result = customizer(objValue, srcValue, key, object, source, stack);
+        }
         if (!(result === undefined
               ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack)
               : result

_baseIteratee.js

@@ -8,14 +8,15 @@ define(['./_baseMatches', './_baseMatchesProperty', './identity', './isArray', '
    * @returns {Function} Returns the iteratee.
    */
   function baseIteratee(value) {
-    var type = typeof value;
-    if (type == 'function') {
+    // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
+    // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
+    if (typeof value == 'function') {
       return value;
     }
     if (value == null) {
       return identity;
     }
-    if (type == 'object') {
+    if (typeof value == 'object') {
       return isArray(value)
         ? baseMatchesProperty(value[0], value[1])
         : baseMatches(value);

_baseKeys.js

@@ -8,7 +8,6 @@ define([], function() {
    * 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.
    */

_baseLodash.js

@@ -1,7 +1,7 @@
 define([], function() {
 
   /**
-   * The function whose prototype all chaining wrappers inherit from.
+   * The function whose prototype chain sequence wrappers inherit from.
    *
    * @private
    */

_baseMatches.js

@@ -1,7 +1,4 @@
-define(['./_baseIsMatch', './_getMatchData'], function(baseIsMatch, getMatchData) {
-
-  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
-  var undefined;
+define(['./_baseIsMatch', './_getMatchData', './_matchesStrictComparable'], function(baseIsMatch, getMatchData, matchesStrictComparable) {
 
   /**
    * The base implementation of `_.matches` which doesn't clone `source`.
@@ -13,16 +10,7 @@ define(['./_baseIsMatch', './_getMatchData'], function(baseIsMatch, getMatchData
   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 matchesStrictComparable(matchData[0][0], matchData[0][1]);
     }
     return function(object) {
       return object === source || baseIsMatch(object, source, matchData);

_baseMatchesProperty.js

@@ -1,4 +1,4 @@
-define(['./_baseIsEqual', './get', './hasIn'], function(baseIsEqual, get, hasIn) {
+define(['./_baseIsEqual', './get', './hasIn', './_isKey', './_isStrictComparable', './_matchesStrictComparable'], function(baseIsEqual, get, hasIn, isKey, isStrictComparable, matchesStrictComparable) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -16,6 +16,9 @@ define(['./_baseIsEqual', './get', './hasIn'], function(baseIsEqual, get, hasIn)
    * @returns {Function} Returns the new function.
    */
   function baseMatchesProperty(path, srcValue) {
+    if (isKey(path) && isStrictComparable(srcValue)) {
+      return matchesStrictComparable(path, srcValue);
+    }
     return function(object) {
       var objValue = get(object, path);
       return (objValue === undefined && objValue === srcValue)

_baseMean.js

@@ -0,0 +1,21 @@
+define(['./_baseSum'], function(baseSum) {
+
+  /** Used as references for various `Number` constants. */
+  var NAN = 0 / 0;
+
+  /**
+   * The base implementation of `_.mean` and `_.meanBy` without support for
+   * iteratee shorthands.
+   *
+   * @private
+   * @param {Array} array The array to iterate over.
+   * @param {Function} iteratee The function invoked per iteration.
+   * @returns {number} Returns the mean.
+   */
+  function baseMean(array, iteratee) {
+    var length = array ? array.length : 0;
+    return length ? (baseSum(array, iteratee) / length) : NAN;
+  }
+
+  return baseMean;
+});

_baseMerge.js

@@ -11,13 +11,16 @@ define(['./_Stack', './_arrayEach', './_assignMergeValue', './_baseMergeDeep', '
    * @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.
+   * @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);
+    if (!(isArray(source) || isTypedArray(source))) {
+      var props = keysIn(source);
+    }
     arrayEach(props || source, function(srcValue, key) {
       if (props) {
         key = srcValue;
@@ -28,7 +31,10 @@ define(['./_Stack', './_arrayEach', './_assignMergeValue', './_baseMergeDeep', '
         baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
       }
       else {
-        var newValue = customizer ? customizer(object[key], srcValue, (key + ''), object, source, stack) : undefined;
+        var newValue = customizer
+          ? customizer(object[key], srcValue, (key + ''), object, source, stack)
+          : undefined;
+
         if (newValue === undefined) {
           newValue = srcValue;
         }

_baseMergeDeep.js

@@ -15,7 +15,8 @@ define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments',
    * @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.
+   * @param {Object} [stack] Tracks traversed source values and their merged
+   *  counterparts.
    */
   function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
     var objValue = object[key],
@@ -26,21 +27,24 @@ define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments',
       assignMergeValue(object, key, stacked);
       return;
     }
-    var newValue = customizer ? customizer(objValue, srcValue, (key + ''), object, source, stack) : undefined,
-        isCommon = newValue === undefined;
+    var newValue = customizer
+      ? customizer(objValue, srcValue, (key + ''), object, source, stack)
+      : undefined;
+
+    var isCommon = newValue === undefined;
 
     if (isCommon) {
       newValue = srcValue;
       if (isArray(srcValue) || isTypedArray(srcValue)) {
         if (isArray(objValue)) {
-          newValue = srcIndex ? copyArray(objValue) : objValue;
+          newValue = objValue;
         }
         else if (isArrayLikeObject(objValue)) {
           newValue = copyArray(objValue);
         }
         else {
           isCommon = false;
-          newValue = baseClone(srcValue);
+          newValue = baseClone(srcValue, true);
         }
       }
       else if (isPlainObject(srcValue) || isArguments(srcValue)) {
@@ -49,10 +53,10 @@ define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments',
         }
         else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
           isCommon = false;
-          newValue = baseClone(srcValue);
+          newValue = baseClone(srcValue, true);
         }
         else {
-          newValue = srcIndex ? baseClone(objValue) : objValue;
+          newValue = objValue;
         }
       }
       else {
@@ -65,6 +69,7 @@ define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments',
       // Recursively merge objects and arrays (susceptible to call stack limits).
       mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
     }
+    stack['delete'](srcValue);
     assignMergeValue(object, key, newValue);
   }
 

_baseNth.js

@@ -0,0 +1,24 @@
+define(['./_isIndex'], function(isIndex) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.nth` which doesn't coerce `n` to an integer.
+   *
+   * @private
+   * @param {Array} array The array to query.
+   * @param {number} n The index of the element to return.
+   * @returns {*} Returns the nth element of `array`.
+   */
+  function baseNth(array, n) {
+    var length = array.length;
+    if (!length) {
+      return;
+    }
+    n += n < 0 ? length : 0;
+    return isIndex(n, length) ? array[n] : undefined;
+  }
+
+  return baseNth;
+});

_baseOrderBy.js

@@ -1,4 +1,4 @@
-define(['./_arrayMap', './_baseIteratee', './_baseMap', './_baseSortBy', './_compareMultiple'], function(arrayMap, baseIteratee, baseMap, baseSortBy, compareMultiple) {
+define(['./_arrayMap', './_baseIteratee', './_baseMap', './_baseSortBy', './_baseUnary', './_compareMultiple', './identity'], function(arrayMap, baseIteratee, baseMap, baseSortBy, baseUnary, compareMultiple, identity) {
 
   /**
    * The base implementation of `_.orderBy` without param guards.
@@ -10,12 +10,8 @@ define(['./_arrayMap', './_baseIteratee', './_baseMap', './_baseSortBy', './_com
    * @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 index = -1;
+    iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee));
 
     var result = baseMap(collection, function(value, key, collection) {
       var criteria = arrayMap(iteratees, function(iteratee) {

_basePick.js

@@ -2,11 +2,11 @@ define(['./_arrayReduce'], function(arrayReduce) {
 
   /**
    * The base implementation of `_.pick` without support for individual
-   * property names.
+   * property identifiers.
    *
    * @private
    * @param {Object} object The source object.
-   * @param {string[]} props The property names to pick.
+   * @param {string[]} props The property identifiers to pick.
    * @returns {Object} Returns the new object.
    */
   function basePick(object, props) {

_basePickBy.js

@@ -1,4 +1,4 @@
-define(['./_baseForIn'], function(baseForIn) {
+define(['./_getAllKeysIn'], function(getAllKeysIn) {
 
   /**
    * The base implementation of  `_.pickBy` without support for iteratee shorthands.
@@ -9,12 +9,19 @@ define(['./_baseForIn'], function(baseForIn) {
    * @returns {Object} Returns the new object.
    */
   function basePickBy(object, predicate) {
-    var result = {};
-    baseForIn(object, function(value, key) {
+    var index = -1,
+        props = getAllKeysIn(object),
+        length = props.length,
+        result = {};
+
+    while (++index < length) {
+      var key = props[index],
+          value = object[key];
+
       if (predicate(value, key)) {
         result[key] = value;
       }
-    });
+    }
     return result;
   }
 

_basePullAll.js

@@ -1,15 +1,44 @@
-define(['./_basePullAllBy'], function(basePullAllBy) {
+define(['./_arrayMap', './_baseIndexOf', './_baseIndexOfWith', './_baseUnary'], function(arrayMap, baseIndexOf, baseIndexOfWith, baseUnary) {
+
+  /** Used for built-in method references. */
+  var arrayProto = Array.prototype;
+
+  /** Built-in value references. */
+  var splice = arrayProto.splice;
 
   /**
-   * The base implementation of `_.pullAll`.
+   * 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.
+   * @param {Function} [comparator] The comparator invoked per element.
    * @returns {Array} Returns `array`.
    */
-  function basePullAll(array, values) {
-    return basePullAllBy(array, values);
+  function basePullAll(array, values, iteratee, comparator) {
+    var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
+        index = -1,
+        length = values.length,
+        seen = array;
+
+    if (iteratee) {
+      seen = arrayMap(array, baseUnary(iteratee));
+    }
+    while (++index < length) {
+      var fromIndex = 0,
+          value = values[index],
+          computed = iteratee ? iteratee(value) : value;
+
+      while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
+        if (seen !== array) {
+          splice.call(seen, fromIndex, 1);
+        }
+        splice.call(array, fromIndex, 1);
+      }
+    }
+    return array;
   }
 
   return basePullAll;

_basePullAllBy.js

@@ -1,43 +0,0 @@
-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

@@ -1,4 +1,4 @@
-define(['./_baseToPath', './_isIndex', './_isKey', './last', './_parent'], function(baseToPath, isIndex, isKey, last, parent) {
+define(['./_castPath', './_isIndex', './_isKey', './last', './_parent'], function(castPath, isIndex, isKey, last, parent) {
 
   /** Used for built-in method references. */
   var arrayProto = Array.prototype;
@@ -27,7 +27,7 @@ define(['./_baseToPath', './_isIndex', './_isKey', './last', './_parent'], funct
           splice.call(array, index, 1);
         }
         else if (!isKey(index, array)) {
-          var path = baseToPath(index),
+          var path = castPath(index),
               object = parent(array, path);
 
           if (object != null) {

_baseReduce.js

@@ -8,7 +8,8 @@ define([], function() {
    * @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 {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.
    */

_baseRepeat.js

@@ -0,0 +1,38 @@
+define([], function() {
+
+  /** Used as references for various `Number` constants. */
+  var MAX_SAFE_INTEGER = 9007199254740991;
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeFloor = Math.floor;
+
+  /**
+   * The base implementation of `_.repeat` which doesn't coerce arguments.
+   *
+   * @private
+   * @param {string} string The string to repeat.
+   * @param {number} n The number of times to repeat the string.
+   * @returns {string} Returns the repeated string.
+   */
+  function baseRepeat(string, n) {
+    var result = '';
+    if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
+      return result;
+    }
+    // Leverage the exponentiation by squaring algorithm for a faster repeat.
+    // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
+    do {
+      if (n % 2) {
+        result += string;
+      }
+      n = nativeFloor(n / 2);
+      if (n) {
+        string += string;
+      }
+    } while (n);
+
+    return result;
+  }
+
+  return baseRepeat;
+});

_baseSet.js

@@ -1,4 +1,4 @@
-define(['./_assignValue', './_baseToPath', './_isIndex', './_isKey', './isObject'], function(assignValue, baseToPath, isIndex, isKey, isObject) {
+define(['./_assignValue', './_castPath', './_isIndex', './_isKey', './isObject'], function(assignValue, castPath, isIndex, isKey, isObject) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -14,7 +14,7 @@ define(['./_assignValue', './_baseToPath', './_isIndex', './_isKey', './isObject
    * @returns {Object} Returns `object`.
    */
   function baseSet(object, path, value, customizer) {
-    path = isKey(path, object) ? [path + ''] : baseToPath(path);
+    path = isKey(path, object) ? [path] : castPath(path);
 
     var index = -1,
         length = path.length,
@@ -29,7 +29,9 @@ define(['./_assignValue', './_baseToPath', './_isIndex', './_isKey', './isObject
           var objValue = nested[key];
           newValue = customizer ? customizer(objValue, key, nested) : undefined;
           if (newValue === undefined) {
-            newValue = objValue == null ? (isIndex(path[index + 1]) ? [] : {}) : objValue;
+            newValue = objValue == null
+              ? (isIndex(path[index + 1]) ? [] : {})
+              : objValue;
           }
         }
         assignValue(nested, key, newValue);

_baseSome.js

@@ -6,7 +6,8 @@ define(['./_baseEach'], function(baseEach) {
    * @private
    * @param {Array|Object} collection The collection to iterate over.
    * @param {Function} predicate The function invoked per iteration.
-   * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
+   * @returns {boolean} Returns `true` if any element passes the predicate check,
+   *  else `false`.
    */
   function baseSome(collection, predicate) {
     var result;

_baseSortBy.js

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

_baseSortedIndexBy.js

@@ -21,7 +21,8 @@ define([], function() {
    * @param {*} value The value to evaluate.
    * @param {Function} iteratee The iteratee invoked per element.
    * @param {boolean} [retHighest] Specify returning the highest qualified index.
-   * @returns {number} Returns the index at which `value` should be inserted into `array`.
+   * @returns {number} Returns the index at which `value` should be inserted
+   *  into `array`.
    */
   function baseSortedIndexBy(array, value, iteratee, retHighest) {
     value = iteratee(value);

_baseSortedUniqBy.js

@@ -15,7 +15,7 @@ define(['./eq'], function(eq) {
         value = array[0],
         computed = iteratee ? iteratee(value) : value,
         seen = computed,
-        resIndex = 0,
+        resIndex = 1,
         result = [value];
 
     while (++index < length) {
@@ -24,7 +24,7 @@ define(['./eq'], function(eq) {
 
       if (!eq(computed, seen)) {
         seen = computed;
-        result[++resIndex] = value;
+        result[resIndex++] = value;
       }
     }
     return result;

_baseSum.js

@@ -4,7 +4,8 @@ define([], function() {
   var undefined;
 
   /**
-   * The base implementation of `_.sum` without support for iteratee shorthands.
+   * The base implementation of `_.sum` and `_.sumBy` without support for
+   * iteratee shorthands.
    *
    * @private
    * @param {Array} array The array to iterate over.

_baseToPath.js

@@ -1,16 +0,0 @@
-define(['./isArray', './_stringToPath'], function(isArray, stringToPath) {
-
-  /**
-   * The base implementation of `_.toPath` which only converts `value` to a
-   * path if it's not one.
-   *
-   * @private
-   * @param {*} value The value to process.
-   * @returns {Array} Returns the property path array.
-   */
-  function baseToPath(value) {
-    return isArray(value) ? value : stringToPath(value);
-  }
-
-  return baseToPath;
-});

_baseUnset.js

@@ -1,4 +1,4 @@
-define(['./_baseToPath', './has', './_isKey', './last', './_parent'], function(baseToPath, has, isKey, last, parent) {
+define(['./_castPath', './has', './_isKey', './last', './_parent'], function(castPath, has, isKey, last, parent) {
 
   /**
    * The base implementation of `_.unset`.
@@ -9,7 +9,7 @@ define(['./_baseToPath', './has', './_isKey', './last', './_parent'], function(b
    * @returns {boolean} Returns `true` if the property is deleted, else `false`.
    */
   function baseUnset(object, path) {
-    path = isKey(path, object) ? [path + ''] : baseToPath(path);
+    path = isKey(path, object) ? [path] : castPath(path);
     object = parent(object, path);
     var key = last(path);
     return (object != null && has(object, key)) ? delete object[key] : true;

_baseUpdate.js

@@ -0,0 +1,18 @@
+define(['./_baseGet', './_baseSet'], function(baseGet, baseSet) {
+
+  /**
+   * The base implementation of `_.update`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {Array|string} path The path of the property to update.
+   * @param {Function} updater The function to produce the updated value.
+   * @param {Function} [customizer] The function to customize path creation.
+   * @returns {Object} Returns `object`.
+   */
+  function baseUpdate(object, path, updater, customizer) {
+    return baseSet(object, path, updater(baseGet(object, path)), customizer);
+  }
+
+  return baseUpdate;
+});

_baseZipObject.js

@@ -7,7 +7,7 @@ define([], function() {
    * This base implementation of `_.zipObject` which assigns values using `assignFunc`.
    *
    * @private
-   * @param {Array} props The property names.
+   * @param {Array} props The property identifiers.
    * @param {Array} values The property values.
    * @param {Function} assignFunc The function to assign values.
    * @returns {Object} Returns the new object.
@@ -19,7 +19,8 @@ define([], function() {
         result = {};
 
     while (++index < length) {
-      assignFunc(result, props[index], index < valsLength ? values[index] : undefined);
+      var value = index < valsLength ? values[index] : undefined;
+      assignFunc(result, props[index], value);
     }
     return result;
   }

_castArrayLikeObject.js

@@ -0,0 +1,15 @@
+define(['./isArrayLikeObject'], function(isArrayLikeObject) {
+
+  /**
+   * Casts `value` to an empty array if it's not an array like object.
+   *
+   * @private
+   * @param {*} value The value to inspect.
+   * @returns {Array|Object} Returns the cast array-like object.
+   */
+  function castArrayLikeObject(value) {
+    return isArrayLikeObject(value) ? value : [];
+  }
+
+  return castArrayLikeObject;
+});

_castFunction.js

@@ -0,0 +1,15 @@
+define(['./identity'], function(identity) {
+
+  /**
+   * Casts `value` to `identity` if it's not a function.
+   *
+   * @private
+   * @param {*} value The value to inspect.
+   * @returns {Function} Returns cast function.
+   */
+  function castFunction(value) {
+    return typeof value == 'function' ? value : identity;
+  }
+
+  return castFunction;
+});

_castPath.js

@@ -0,0 +1,15 @@
+define(['./isArray', './_stringToPath'], function(isArray, stringToPath) {
+
+  /**
+   * Casts `value` to a path array if it's not one.
+   *
+   * @private
+   * @param {*} value The value to inspect.
+   * @returns {Array} Returns the cast property path array.
+   */
+  function castPath(value) {
+    return isArray(value) ? value : stringToPath(value);
+  }
+
+  return castPath;
+});

_castSlice.js

@@ -0,0 +1,22 @@
+define(['./_baseSlice'], function(baseSlice) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * Casts `array` to a slice if it's needed.
+   *
+   * @private
+   * @param {Array} array The array to inspect.
+   * @param {number} start The start position.
+   * @param {number} [end=array.length] The end position.
+   * @returns {Array} Returns the cast slice.
+   */
+  function castSlice(array, start, end) {
+    var length = array.length;
+    end = end === undefined ? length : end;
+    return (!start && end >= length) ? array : baseSlice(array, start, end);
+  }
+
+  return castSlice;
+});

_cloneArrayBuffer.js

@@ -0,0 +1,17 @@
+define(['./_Uint8Array'], function(Uint8Array) {
+
+  /**
+   * Creates a clone of `arrayBuffer`.
+   *
+   * @private
+   * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+   * @returns {ArrayBuffer} Returns the cloned array buffer.
+   */
+  function cloneArrayBuffer(arrayBuffer) {
+    var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+    new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+    return result;
+  }
+
+  return cloneArrayBuffer;
+});

_cloneBuffer.js

@@ -1,18 +1,19 @@
-define(['./_Uint8Array'], function(Uint8Array) {
+define([], function() {
 
   /**
-   * Creates a clone of `buffer`.
+   * Creates a clone of  `buffer`.
    *
    * @private
-   * @param {ArrayBuffer} buffer The array buffer to clone.
-   * @returns {ArrayBuffer} Returns the cloned array buffer.
+   * @param {Buffer} buffer The buffer to clone.
+   * @param {boolean} [isDeep] Specify a deep clone.
+   * @returns {Buffer} Returns the cloned buffer.
    */
-  function cloneBuffer(buffer) {
-    var Ctor = buffer.constructor,
-        result = new Ctor(buffer.byteLength),
-        view = new Uint8Array(result);
-
-    view.set(new Uint8Array(buffer));
+  function cloneBuffer(buffer, isDeep) {
+    if (isDeep) {
+      return buffer.slice();
+    }
+    var result = new buffer.constructor(buffer.length);
+    buffer.copy(result);
     return result;
   }
 

_cloneDataView.js

@@ -0,0 +1,17 @@
+define(['./_cloneArrayBuffer'], function(cloneArrayBuffer) {
+
+  /**
+   * Creates a clone of `dataView`.
+   *
+   * @private
+   * @param {Object} dataView The data view to clone.
+   * @param {boolean} [isDeep] Specify a deep clone.
+   * @returns {Object} Returns the cloned data view.
+   */
+  function cloneDataView(dataView, isDeep) {
+    var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+    return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+  }
+
+  return cloneDataView;
+});

_cloneMap.js

@@ -5,11 +5,13 @@ define(['./_addMapEntry', './_arrayReduce', './_mapToArray'], function(addMapEnt
    *
    * @private
    * @param {Object} map The map to clone.
+   * @param {Function} cloneFunc The function to clone values.
+   * @param {boolean} [isDeep] Specify a deep clone.
    * @returns {Object} Returns the cloned map.
    */
-  function cloneMap(map) {
-    var Ctor = map.constructor;
-    return arrayReduce(mapToArray(map), addMapEntry, new Ctor);
+  function cloneMap(map, isDeep, cloneFunc) {
+    var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);
+    return arrayReduce(array, addMapEntry, new map.constructor);
   }
 
   return cloneMap;

_cloneRegExp.js

@@ -11,9 +11,7 @@ define([], function() {
    * @returns {Object} Returns the cloned regexp.
    */
   function cloneRegExp(regexp) {
-    var Ctor = regexp.constructor,
-        result = new Ctor(regexp.source, reFlags.exec(regexp));
-
+    var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
     result.lastIndex = regexp.lastIndex;
     return result;
   }

_cloneSet.js

@@ -5,11 +5,13 @@ define(['./_addSetEntry', './_arrayReduce', './_setToArray'], function(addSetEnt
    *
    * @private
    * @param {Object} set The set to clone.
+   * @param {Function} cloneFunc The function to clone values.
+   * @param {boolean} [isDeep] Specify a deep clone.
    * @returns {Object} Returns the cloned set.
    */
-  function cloneSet(set) {
-    var Ctor = set.constructor;
-    return arrayReduce(setToArray(set), addSetEntry, new Ctor);
+  function cloneSet(set, isDeep, cloneFunc) {
+    var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);
+    return arrayReduce(array, addSetEntry, new set.constructor);
   }
 
   return cloneSet;

_cloneSymbol.js

@@ -5,7 +5,7 @@ define(['./_Symbol'], function(Symbol) {
 
   /** Used to convert symbols to primitives and strings. */
   var symbolProto = Symbol ? Symbol.prototype : undefined,
-      symbolValueOf = Symbol ? symbolProto.valueOf : undefined;
+      symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
 
   /**
    * Creates a clone of the `symbol` object.
@@ -15,7 +15,7 @@ define(['./_Symbol'], function(Symbol) {
    * @returns {Object} Returns the cloned symbol object.
    */
   function cloneSymbol(symbol) {
-    return Symbol ? Object(symbolValueOf.call(symbol)) : {};
+    return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
   }
 
   return cloneSymbol;

_cloneTypedArray.js

@@ -1,4 +1,4 @@
-define(['./_cloneBuffer'], function(cloneBuffer) {
+define(['./_cloneArrayBuffer'], function(cloneArrayBuffer) {
 
   /**
    * Creates a clone of `typedArray`.
@@ -9,10 +9,8 @@ define(['./_cloneBuffer'], function(cloneBuffer) {
    * @returns {Object} Returns the cloned typed array.
    */
   function cloneTypedArray(typedArray, isDeep) {
-    var buffer = typedArray.buffer,
-        Ctor = typedArray.constructor;
-
-    return new Ctor(isDeep ? cloneBuffer(buffer) : buffer, typedArray.byteOffset, typedArray.length);
+    var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+    return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
   }
 
   return cloneTypedArray;

_compareMultiple.js

@@ -37,7 +37,7 @@ define(['./_compareAscending'], function(compareAscending) {
     // for more details.
     //
     // This also ensures a stable sort in V8 and other engines.
-    // See https://code.google.com/p/v8/issues/detail?id=90 for more details.
+    // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
     return object.index - other.index;
   }
 

_composeArgs.js

@@ -11,23 +11,28 @@ define([], function() {
    * @param {Array|Object} args The provided arguments.
    * @param {Array} partials The arguments to prepend to those provided.
    * @param {Array} holders The `partials` placeholder indexes.
+   * @params {boolean} [isCurried] Specify composing for a curried function.
    * @returns {Array} Returns the new array of composed arguments.
    */
-  function composeArgs(args, partials, holders) {
-    var holdersLength = holders.length,
-        argsIndex = -1,
-        argsLength = nativeMax(args.length - holdersLength, 0),
+  function composeArgs(args, partials, holders, isCurried) {
+    var argsIndex = -1,
+        argsLength = args.length,
+        holdersLength = holders.length,
         leftIndex = -1,
         leftLength = partials.length,
-        result = Array(leftLength + argsLength);
+        rangeLength = nativeMax(argsLength - holdersLength, 0),
+        result = Array(leftLength + rangeLength),
+        isUncurried = !isCurried;
 
     while (++leftIndex < leftLength) {
       result[leftIndex] = partials[leftIndex];
     }
     while (++argsIndex < holdersLength) {
-      result[holders[argsIndex]] = args[argsIndex];
+      if (isUncurried || argsIndex < argsLength) {
+        result[holders[argsIndex]] = args[argsIndex];
+      }
     }
-    while (argsLength--) {
+    while (rangeLength--) {
       result[leftIndex++] = args[argsIndex++];
     }
     return result;

_composeArgsRight.js

@@ -11,18 +11,21 @@ define([], function() {
    * @param {Array|Object} args The provided arguments.
    * @param {Array} partials The arguments to append to those provided.
    * @param {Array} holders The `partials` placeholder indexes.
+   * @params {boolean} [isCurried] Specify composing for a curried function.
    * @returns {Array} Returns the new array of composed arguments.
    */
-  function composeArgsRight(args, partials, holders) {
-    var holdersIndex = -1,
+  function composeArgsRight(args, partials, holders, isCurried) {
+    var argsIndex = -1,
+        argsLength = args.length,
+        holdersIndex = -1,
         holdersLength = holders.length,
-        argsIndex = -1,
-        argsLength = nativeMax(args.length - holdersLength, 0),
         rightIndex = -1,
         rightLength = partials.length,
-        result = Array(argsLength + rightLength);
+        rangeLength = nativeMax(argsLength - holdersLength, 0),
+        result = Array(rangeLength + rightLength),
+        isUncurried = !isCurried;
 
-    while (++argsIndex < argsLength) {
+    while (++argsIndex < rangeLength) {
       result[argsIndex] = args[argsIndex];
     }
     var offset = argsIndex;
@@ -30,7 +33,9 @@ define([], function() {
       result[offset + rightIndex] = partials[rightIndex];
     }
     while (++holdersIndex < holdersLength) {
-      result[offset + holders[holdersIndex]] = args[argsIndex++];
+      if (isUncurried || argsIndex < argsLength) {
+        result[offset + holders[holdersIndex]] = args[argsIndex++];
+      }
     }
     return result;
   }

_copyObject.js

@@ -1,16 +1,31 @@
-define(['./_copyObjectWith'], function(copyObjectWith) {
+define(['./_assignValue'], function(assignValue) {
 
   /**
    * Copies properties of `source` to `object`.
    *
    * @private
    * @param {Object} source The object to copy properties from.
-   * @param {Array} props The property names to copy.
+   * @param {Array} props The property identifiers to copy.
    * @param {Object} [object={}] The object to copy properties to.
+   * @param {Function} [customizer] The function to customize copied values.
    * @returns {Object} Returns `object`.
    */
-  function copyObject(source, props, object) {
-    return copyObjectWith(source, props, object);
+  function copyObject(source, props, object, customizer) {
+    object || (object = {});
+
+    var index = -1,
+        length = props.length;
+
+    while (++index < length) {
+      var key = props[index];
+
+      var newValue = customizer
+        ? customizer(object[key], source[key], key, object, source)
+        : source[key];
+
+      assignValue(object, key, newValue);
+    }
+    return object;
   }
 
   return copyObject;

_copyObjectWith.js

@@ -1,30 +0,0 @@
-define(['./_assignValue'], function(assignValue) {
-
-  /**
-   * This function is like `copyObject` except that it accepts a function to
-   * customize copied values.
-   *
-   * @private
-   * @param {Object} source The object to copy properties from.
-   * @param {Array} props The property names to copy.
-   * @param {Object} [object={}] The object to copy properties to.
-   * @param {Function} [customizer] The function to customize copied values.
-   * @returns {Object} Returns `object`.
-   */
-  function copyObjectWith(source, props, object, customizer) {
-    object || (object = {});
-
-    var index = -1,
-        length = props.length;
-
-    while (++index < length) {
-      var key = props[index],
-          newValue = customizer ? customizer(object[key], source[key], key, object, source) : source[key];
-
-      assignValue(object, key, newValue);
-    }
-    return object;
-  }
-
-  return copyObjectWith;
-});

_countHolders.js

@@ -0,0 +1,24 @@
+define([], function() {
+
+  /**
+   * Gets the number of `placeholder` occurrences in `array`.
+   *
+   * @private
+   * @param {Array} array The array to inspect.
+   * @param {*} placeholder The placeholder to search for.
+   * @returns {number} Returns the placeholder count.
+   */
+  function countHolders(array, placeholder) {
+    var length = array.length,
+        result = 0;
+
+    while (length--) {
+      if (array[length] === placeholder) {
+        result++;
+      }
+    }
+    return result;
+  }
+
+  return countHolders;
+});

_createAssigner.js

@@ -17,7 +17,10 @@ define(['./_isIterateeCall', './rest'], function(isIterateeCall, rest) {
           customizer = length > 1 ? sources[length - 1] : undefined,
           guard = length > 2 ? sources[2] : undefined;
 
-      customizer = typeof customizer == 'function' ? (length--, customizer) : undefined;
+      customizer = typeof customizer == 'function'
+        ? (length--, customizer)
+        : undefined;
+
       if (guard && isIterateeCall(sources[0], sources[1], guard)) {
         customizer = length < 3 ? undefined : customizer;
         length = 1;

_createBaseFor.js

@@ -1,7 +1,7 @@
 define([], function() {
 
   /**
-   * Creates a base function for methods like `_.forIn`.
+   * Creates a base function for methods like `_.forIn` and `_.forOwn`.
    *
    * @private
    * @param {boolean} [fromRight] Specify iterating from right to left.

_createBaseWrapper.js

@@ -9,7 +9,8 @@ define(['./_createCtorWrapper', './_root'], function(createCtorWrapper, root) {
    *
    * @private
    * @param {Function} func The function to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper` for more details.
+   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
+   *  for more details.
    * @param {*} [thisArg] The `this` binding of `func`.
    * @returns {Function} Returns the new wrapped function.
    */

_createCaseFirst.js

@@ -1,20 +1,8 @@
-define(['./_stringToArray', './toString'], function(stringToArray, toString) {
+define(['./_castSlice', './_reHasComplexSymbol', './_stringToArray', './toString'], function(castSlice, reHasComplexSymbol, stringToArray, toString) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose unicode character classes. */
-  var rsAstralRange = '\\ud800-\\udfff',
-      rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
-      rsComboSymbolsRange = '\\u20d0-\\u20f0',
-      rsVarRange = '\\ufe0e\\ufe0f';
-
-  /** Used to compose unicode capture groups. */
-  var rsZWJ = '\\u200d';
-
-  /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
-  var reHasComplexSymbol = RegExp('[' + rsZWJ + rsAstralRange  + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');
-
   /**
    * Creates a function like `_.lowerFirst`.
    *
@@ -26,9 +14,17 @@ define(['./_stringToArray', './toString'], function(stringToArray, toString) {
     return function(string) {
       string = toString(string);
 
-      var strSymbols = reHasComplexSymbol.test(string) ? stringToArray(string) : undefined,
-          chr = strSymbols ? strSymbols[0] : string.charAt(0),
-          trailing = strSymbols ? strSymbols.slice(1).join('') : string.slice(1);
+      var strSymbols = reHasComplexSymbol.test(string)
+        ? stringToArray(string)
+        : undefined;
+
+      var chr = strSymbols
+        ? strSymbols[0]
+        : string.charAt(0);
+
+      var trailing = strSymbols
+        ? castSlice(strSymbols, 1).join('')
+        : string.slice(1);
 
       return chr[methodName]() + trailing;
     };

_createCompounder.js

@@ -1,5 +1,11 @@
 define(['./_arrayReduce', './deburr', './words'], function(arrayReduce, deburr, words) {
 
+  /** Used to compose unicode capture groups. */
+  var rsApos = "['\u2019]";
+
+  /** Used to match apostrophes. */
+  var reApos = RegExp(rsApos, 'g');
+
   /**
    * Creates a function like `_.camelCase`.
    *
@@ -9,7 +15,7 @@ define(['./_arrayReduce', './deburr', './words'], function(arrayReduce, deburr,
    */
   function createCompounder(callback) {
     return function(string) {
-      return arrayReduce(words(deburr(string)), callback, '');
+      return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
     };
   }
 

_createCtorWrapper.js

@@ -10,8 +10,8 @@ define(['./_baseCreate', './isObject'], function(baseCreate, isObject) {
    */
   function createCtorWrapper(Ctor) {
     return function() {
-      // Use a `switch` statement to work with class constructors.
-      // See http://ecma-international.org/ecma-262/6.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
+      // Use a `switch` statement to work with class constructors. See
+      // http://ecma-international.org/ecma-262/6.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
       // for more details.
       var args = arguments;
       switch (args.length) {

_createCurryWrapper.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_createRecurryWrapper', './_replaceHolders', './_root'], function(apply, createCtorWrapper, createHybridWrapper, createRecurryWrapper, replaceHolders, root) {
+define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_createRecurryWrapper', './_getPlaceholder', './_replaceHolders', './_root'], function(apply, createCtorWrapper, createHybridWrapper, createRecurryWrapper, getPlaceholder, replaceHolders, root) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -8,7 +8,8 @@ define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_create
    *
    * @private
    * @param {Function} func The function to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper` for more details.
+   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
+   *  for more details.
    * @param {number} arity The arity of `func`.
    * @returns {Function} Returns the new wrapped function.
    */
@@ -17,10 +18,9 @@ define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_create
 
     function wrapper() {
       var length = arguments.length,
-          index = length,
           args = Array(length),
-          fn = (this && this !== root && this instanceof wrapper) ? Ctor : func,
-          placeholder = wrapper.placeholder;
+          index = length,
+          placeholder = getPlaceholder(wrapper);
 
       while (index--) {
         args[index] = arguments[index];
@@ -30,9 +30,13 @@ define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_create
         : replaceHolders(args, placeholder);
 
       length -= holders.length;
-      return length < arity
-        ? createRecurryWrapper(func, bitmask, createHybridWrapper, placeholder, undefined, args, holders, undefined, undefined, arity - length)
-        : apply(fn, this, args);
+      if (length < arity) {
+        return createRecurryWrapper(
+          func, bitmask, createHybridWrapper, wrapper.placeholder, undefined,
+          args, holders, undefined, undefined, arity - length);
+      }
+      var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
+      return apply(fn, this, args);
     }
     return wrapper;
   }

_createFlow.js

@@ -3,18 +3,18 @@ define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', '.
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for wrapper metadata. */
-  var CURRY_FLAG = 8,
-      PARTIAL_FLAG = 32,
-      ARY_FLAG = 128,
-      REARG_FLAG = 256;
-
   /** Used as the size to enable large array optimizations. */
   var LARGE_ARRAY_SIZE = 200;
 
   /** Used as the `TypeError` message for "Functions" methods. */
   var FUNC_ERROR_TEXT = 'Expected a function';
 
+  /** Used to compose bitmasks for wrapper metadata. */
+  var CURRY_FLAG = 8,
+      PARTIAL_FLAG = 32,
+      ARY_FLAG = 128,
+      REARG_FLAG = 256;
+
   /**
    * Creates a `_.flow` or `_.flowRight` function.
    *
@@ -24,7 +24,7 @@ define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', '.
    */
   function createFlow(fromRight) {
     return rest(function(funcs) {
-      funcs = baseFlatten(funcs);
+      funcs = baseFlatten(funcs, 1);
 
       var length = funcs.length,
           index = length,
@@ -49,17 +49,23 @@ define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', '.
         var funcName = getFuncName(func),
             data = funcName == 'wrapper' ? getData(func) : undefined;
 
-        if (data && isLaziable(data[0]) && data[1] == (ARY_FLAG | CURRY_FLAG | PARTIAL_FLAG | REARG_FLAG) && !data[4].length && data[9] == 1) {
+        if (data && isLaziable(data[0]) &&
+              data[1] == (ARY_FLAG | CURRY_FLAG | PARTIAL_FLAG | REARG_FLAG) &&
+              !data[4].length && data[9] == 1
+            ) {
           wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
         } else {
-          wrapper = (func.length == 1 && isLaziable(func)) ? wrapper[funcName]() : wrapper.thru(func);
+          wrapper = (func.length == 1 && isLaziable(func))
+            ? wrapper[funcName]()
+            : wrapper.thru(func);
         }
       }
       return function() {
         var args = arguments,
             value = args[0];
 
-        if (wrapper && args.length == 1 && isArray(value) && value.length >= LARGE_ARRAY_SIZE) {
+        if (wrapper && args.length == 1 &&
+            isArray(value) && value.length >= LARGE_ARRAY_SIZE) {
           return wrapper.plant(value).value();
         }
         var index = 0,

_createHybridWrapper.js

@@ -1,4 +1,4 @@
-define(['./_composeArgs', './_composeArgsRight', './_createCtorWrapper', './_createRecurryWrapper', './_reorder', './_replaceHolders', './_root'], function(composeArgs, composeArgsRight, createCtorWrapper, createRecurryWrapper, reorder, replaceHolders, root) {
+define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCtorWrapper', './_createRecurryWrapper', './_getPlaceholder', './_reorder', './_replaceHolders', './_root'], function(composeArgs, composeArgsRight, countHolders, createCtorWrapper, createRecurryWrapper, getPlaceholder, reorder, replaceHolders, root) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -17,11 +17,14 @@ define(['./_composeArgs', './_composeArgsRight', './_createCtorWrapper', './_cre
    *
    * @private
    * @param {Function|string} func The function or method name to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper` for more details.
+   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
+   *  for more details.
    * @param {*} [thisArg] The `this` binding of `func`.
-   * @param {Array} [partials] The arguments to prepend to those provided to the new function.
+   * @param {Array} [partials] The arguments to prepend to those provided to
+   *  the new function.
    * @param {Array} [holders] The `partials` placeholder indexes.
-   * @param {Array} [partialsRight] The arguments to append to those provided to the new function.
+   * @param {Array} [partialsRight] The arguments to append to those provided
+   *  to the new function.
    * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
    * @param {Array} [argPos] The argument positions of the new function.
    * @param {number} [ary] The arity cap of `func`.
@@ -32,8 +35,7 @@ define(['./_composeArgs', './_composeArgsRight', './_createCtorWrapper', './_cre
     var isAry = bitmask & ARY_FLAG,
         isBind = bitmask & BIND_FLAG,
         isBindKey = bitmask & BIND_KEY_FLAG,
-        isCurry = bitmask & CURRY_FLAG,
-        isCurryRight = bitmask & CURRY_RIGHT_FLAG,
+        isCurried = bitmask & (CURRY_FLAG | CURRY_RIGHT_FLAG),
         isFlip = bitmask & FLIP_FLAG,
         Ctor = isBindKey ? undefined : createCtorWrapper(func);
 
@@ -45,30 +47,34 @@ define(['./_composeArgs', './_composeArgsRight', './_createCtorWrapper', './_cre
       while (index--) {
         args[index] = arguments[index];
       }
+      if (isCurried) {
+        var placeholder = getPlaceholder(wrapper),
+            holdersCount = countHolders(args, placeholder);
+      }
       if (partials) {
-        args = composeArgs(args, partials, holders);
+        args = composeArgs(args, partials, holders, isCurried);
       }
       if (partialsRight) {
-        args = composeArgsRight(args, partialsRight, holdersRight);
+        args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
       }
-      if (isCurry || isCurryRight) {
-        var placeholder = wrapper.placeholder,
-            argsHolders = replaceHolders(args, placeholder);
-
-        length -= argsHolders.length;
-        if (length < arity) {
-          return createRecurryWrapper(func, bitmask, createHybridWrapper, placeholder, thisArg, args, argsHolders, argPos, ary, arity - length);
-        }
+      length -= holdersCount;
+      if (isCurried && length < arity) {
+        var newHolders = replaceHolders(args, placeholder);
+        return createRecurryWrapper(
+          func, bitmask, createHybridWrapper, wrapper.placeholder, thisArg,
+          args, newHolders, argPos, ary, arity - length
+        );
       }
       var thisBinding = isBind ? thisArg : this,
           fn = isBindKey ? thisBinding[func] : func;
 
+      length = args.length;
       if (argPos) {
         args = reorder(args, argPos);
-      } else if (isFlip && args.length > 1) {
+      } else if (isFlip && length > 1) {
         args.reverse();
       }
-      if (isAry && ary < args.length) {
+      if (isAry && ary < length) {
         args.length = ary;
       }
       if (this && this !== root && this instanceof wrapper) {

_createMathOperation.js

@@ -0,0 +1,30 @@
+define([], function() {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * Creates a function that performs a mathematical operation on two values.
+   *
+   * @private
+   * @param {Function} operator The function to perform the operation.
+   * @returns {Function} Returns the new mathematical operation function.
+   */
+  function createMathOperation(operator) {
+    return function(value, other) {
+      var result;
+      if (value === undefined && other === undefined) {
+        return 0;
+      }
+      if (value !== undefined) {
+        result = value;
+      }
+      if (other !== undefined) {
+        result = result === undefined ? other : operator(result, other);
+      }
+      return result;
+    };
+  }
+
+  return createMathOperation;
+});

_createOver.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './rest'], function(apply, arrayMap, baseFlatten, baseIteratee, rest) {
+define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './_baseUnary', './isArray', './_isFlattenableIteratee', './rest'], function(apply, arrayMap, baseFlatten, baseIteratee, baseUnary, isArray, isFlattenableIteratee, rest) {
 
   /**
    * Creates a function like `_.over`.
@@ -9,7 +9,10 @@ define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './rest'
    */
   function createOver(arrayFunc) {
     return rest(function(iteratees) {
-      iteratees = arrayMap(baseFlatten(iteratees), baseIteratee);
+      iteratees = (iteratees.length == 1 && isArray(iteratees[0]))
+        ? arrayMap(iteratees[0], baseUnary(baseIteratee))
+        : arrayMap(baseFlatten(iteratees, 1, isFlattenableIteratee), baseUnary(baseIteratee));
+
       return rest(function(args) {
         var thisArg = this;
         return arrayFunc(iteratees, function(iteratee) {

_createPadding.js

@@ -1,20 +1,8 @@
-define(['./repeat', './_stringSize', './_stringToArray', './toInteger'], function(repeat, stringSize, stringToArray, toInteger) {
+define(['./_baseRepeat', './_castSlice', './_reHasComplexSymbol', './_stringSize', './_stringToArray'], function(baseRepeat, castSlice, reHasComplexSymbol, stringSize, stringToArray) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose unicode character classes. */
-  var rsAstralRange = '\\ud800-\\udfff',
-      rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
-      rsComboSymbolsRange = '\\u20d0-\\u20f0',
-      rsVarRange = '\\ufe0e\\ufe0f';
-
-  /** Used to compose unicode capture groups. */
-  var rsZWJ = '\\u200d';
-
-  /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
-  var reHasComplexSymbol = RegExp('[' + rsZWJ + rsAstralRange  + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');
-
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeCeil = Math.ceil;
 
@@ -23,25 +11,21 @@ define(['./repeat', './_stringSize', './_stringToArray', './toInteger'], functio
    * is truncated if the number of characters exceeds `length`.
    *
    * @private
-   * @param {string} string The string to create padding for.
-   * @param {number} [length=0] The padding length.
+   * @param {number} length The padding length.
    * @param {string} [chars=' '] The string used as padding.
    * @returns {string} Returns the padding for `string`.
    */
-  function createPadding(string, length, chars) {
-    length = toInteger(length);
-
-    var strLength = stringSize(string);
-    if (!length || strLength >= length) {
-      return '';
-    }
-    var padLength = length - strLength;
+  function createPadding(length, chars) {
     chars = chars === undefined ? ' ' : (chars + '');
 
-    var result = repeat(chars, nativeCeil(padLength / stringSize(chars)));
+    var charsLength = chars.length;
+    if (charsLength < 2) {
+      return charsLength ? baseRepeat(chars, length) : chars;
+    }
+    var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
     return reHasComplexSymbol.test(chars)
-      ? stringToArray(result).slice(0, padLength).join('')
-      : result.slice(0, padLength);
+      ? castSlice(stringToArray(result), 0, length).join('')
+      : result.slice(0, length);
   }
 
   return createPadding;

_createPartialWrapper.js

@@ -4,15 +4,16 @@ define(['./_apply', './_createCtorWrapper', './_root'], function(apply, createCt
   var BIND_FLAG = 1;
 
   /**
-   * Creates a function that wraps `func` to invoke it with the optional `this`
-   * binding of `thisArg` and the `partials` prepended to those provided to
-   * the wrapper.
+   * Creates a function that wraps `func` to invoke it with the `this` binding
+   * of `thisArg` and `partials` prepended to the arguments it receives.
    *
    * @private
    * @param {Function} func The function to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper` for more details.
+   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
+   *  for more details.
    * @param {*} thisArg The `this` binding of `func`.
-   * @param {Array} partials The arguments to prepend to those provided to the new function.
+   * @param {Array} partials The arguments to prepend to those provided to
+   *  the new function.
    * @returns {Function} Returns the new wrapped function.
    */
   function createPartialWrapper(func, bitmask, thisArg, partials) {

_createRecurryWrapper.js

@@ -1,4 +1,4 @@
-define(['./_copyArray', './_isLaziable', './_setData'], function(copyArray, isLaziable, setData) {
+define(['./_isLaziable', './_setData'], function(isLaziable, setData) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -16,11 +16,13 @@ define(['./_copyArray', './_isLaziable', './_setData'], function(copyArray, isLa
    *
    * @private
    * @param {Function} func The function to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper` for more details.
+   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
+   *  for more details.
    * @param {Function} wrapFunc The function to create the `func` wrapper.
-   * @param {*} placeholder The placeholder to replace.
+   * @param {*} placeholder The placeholder value.
    * @param {*} [thisArg] The `this` binding of `func`.
-   * @param {Array} [partials] The arguments to prepend to those provided to the new function.
+   * @param {Array} [partials] The arguments to prepend to those provided to
+   *  the new function.
    * @param {Array} [holders] The `partials` placeholder indexes.
    * @param {Array} [argPos] The argument positions of the new function.
    * @param {number} [ary] The arity cap of `func`.
@@ -29,8 +31,7 @@ define(['./_copyArray', './_isLaziable', './_setData'], function(copyArray, isLa
    */
   function createRecurryWrapper(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
     var isCurry = bitmask & CURRY_FLAG,
-        newArgPos = argPos ? copyArray(argPos) : undefined,
-        newsHolders = isCurry ? holders : undefined,
+        newHolders = isCurry ? holders : undefined,
         newHoldersRight = isCurry ? undefined : holders,
         newPartials = isCurry ? partials : undefined,
         newPartialsRight = isCurry ? undefined : partials;
@@ -41,9 +42,12 @@ define(['./_copyArray', './_isLaziable', './_setData'], function(copyArray, isLa
     if (!(bitmask & CURRY_BOUND_FLAG)) {
       bitmask &= ~(BIND_FLAG | BIND_KEY_FLAG);
     }
-    var newData = [func, bitmask, thisArg, newPartials, newsHolders, newPartialsRight, newHoldersRight, newArgPos, ary, arity],
-        result = wrapFunc.apply(undefined, newData);
+    var newData = [
+      func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
+      newHoldersRight, argPos, ary, arity
+    ];
 
+    var result = wrapFunc.apply(undefined, newData);
     if (isLaziable(func)) {
       setData(result, newData);
     }