Bump to v4.11.1.

README.md

@@ -1,4 +1,4 @@
-# lodash-amd v4.8.0
+# lodash-amd v4.11.1
 
 The [Lodash](https://lodash.com/) library exported as [AMD](https://github.com/amdjs/amdjs-api/wiki/AMD) modules.
 
@@ -27,4 +27,4 @@ require({
 });
 ```
 
-See the [package source](https://github.com/lodash/lodash/tree/4.8.0-amd) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.11.1-amd) for more details.

_Hash.js

@@ -4,7 +4,7 @@ define(['./_nativeCreate'], function(nativeCreate) {
   var objectProto = Object.prototype;
 
   /**
-   * Creates an hash object.
+   * Creates a hash object.
    *
    * @private
    * @constructor

_baseFlatten.js

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

_baseFor.js

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

_baseGet.js

@@ -1,4 +1,4 @@
-define(['./_baseCastPath', './_isKey'], function(baseCastPath, 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(['./_baseCastPath', './_isKey'], function(baseCastPath, isKey) {
    * @returns {*} Returns the resolved value.
    */
   function baseGet(object, path) {
-    path = isKey(path, object) ? [path] : baseCastPath(path);
+    path = isKey(path, object) ? [path] : castPath(path);
 
     var index = 0,
         length = path.length;

_baseInvoke.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_baseCastPath', './_isKey', './last', './_parent'], function(apply, baseCastPath, 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', './_baseCastPath', './_isKey', './last', './_parent'], funct
    */
   function baseInvoke(object, path, args) {
     if (!isKey(path, object)) {
-      path = baseCastPath(path);
+      path = castPath(path);
       object = parent(object, path);
       path = last(path);
     }

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

_basePullAt.js

@@ -1,4 +1,4 @@
-define(['./_baseCastPath', './_isIndex', './_isKey', './last', './_parent'], function(baseCastPath, 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(['./_baseCastPath', './_isIndex', './_isKey', './last', './_parent'], fun
           splice.call(array, index, 1);
         }
         else if (!isKey(index, array)) {
-          var path = baseCastPath(index),
+          var path = castPath(index),
               object = parent(array, path);
 
           if (object != null) {

_baseSet.js

@@ -1,4 +1,4 @@
-define(['./_assignValue', './_baseCastPath', './_isIndex', './_isKey', './isObject'], function(assignValue, baseCastPath, 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', './_baseCastPath', './_isIndex', './_isKey', './isObje
    * @returns {Object} Returns `object`.
    */
   function baseSet(object, path, value, customizer) {
-    path = isKey(path, object) ? [path] : baseCastPath(path);
+    path = isKey(path, object) ? [path] : castPath(path);
 
     var index = -1,
         length = path.length,

_baseUnset.js

@@ -1,4 +1,4 @@
-define(['./_baseCastPath', './has', './_isKey', './last', './_parent'], function(baseCastPath, 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(['./_baseCastPath', './has', './_isKey', './last', './_parent'], function
    * @returns {boolean} Returns `true` if the property is deleted, else `false`.
    */
   function baseUnset(object, path) {
-    path = isKey(path, object) ? [path] : baseCastPath(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;

_castArrayLikeObject.js

@@ -7,9 +7,9 @@ define(['./isArrayLikeObject'], function(isArrayLikeObject) {
    * @param {*} value The value to inspect.
    * @returns {Array|Object} Returns the cast array-like object.
    */
-  function baseCastArrayLikeObject(value) {
+  function castArrayLikeObject(value) {
     return isArrayLikeObject(value) ? value : [];
   }
 
-  return baseCastArrayLikeObject;
+  return castArrayLikeObject;
 });

_castFunction.js

@@ -7,9 +7,9 @@ define(['./identity'], function(identity) {
    * @param {*} value The value to inspect.
    * @returns {Function} Returns cast function.
    */
-  function baseCastFunction(value) {
+  function castFunction(value) {
     return typeof value == 'function' ? value : identity;
   }
 
-  return baseCastFunction;
+  return castFunction;
 });

_castPath.js

@@ -7,9 +7,9 @@ define(['./isArray', './_stringToPath'], function(isArray, stringToPath) {
    * @param {*} value The value to inspect.
    * @returns {Array} Returns the cast property path array.
    */
-  function baseCastPath(value) {
+  function castPath(value) {
     return isArray(value) ? value : stringToPath(value);
   }
 
-  return baseCastPath;
+  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;
+});

_copyObject.js

@@ -1,4 +1,4 @@
-define(['./_copyObjectWith'], function(copyObjectWith) {
+define(['./_assignValue'], function(assignValue) {
 
   /**
    * Copies properties of `source` to `object`.
@@ -7,10 +7,25 @@ define(['./_copyObjectWith'], function(copyObjectWith) {
    * @param {Object} source The object to copy properties from.
    * @param {Array} props The property identifiers to copy.
    * @param {Object} [object={}] The object to copy properties to.
+   * @param {Function} [customizer] The function to customize copied values.
    * @returns {Object} Returns `object`.
    */
-  function copyObject(source, props, object) {
-    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,33 +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 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 copyObjectWith(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 copyObjectWith;
-});

_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`.
    *
@@ -30,8 +18,13 @@ define(['./_stringToArray', './toString'], function(stringToArray, toString) {
         ? stringToArray(string)
         : undefined;
 
-      var chr = strSymbols ? strSymbols[0] : string.charAt(0),
-          trailing = strSymbols ? strSymbols.slice(1).join('') : string.slice(1);
+      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, '');
     };
   }
 

_createOver.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_arrayMap', './_baseIteratee', './rest'], function(apply, arrayMap, 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', './_baseIteratee', './rest'], function(apply,
    */
   function createOver(arrayFunc) {
     return rest(function(iteratees) {
-      iteratees = arrayMap(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(['./_baseRepeat', './_stringSize', './_stringToArray'], function(baseRepeat, stringSize, stringToArray) {
+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;
 
@@ -36,7 +24,7 @@ define(['./_baseRepeat', './_stringSize', './_stringToArray'], function(baseRepe
     }
     var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
     return reHasComplexSymbol.test(chars)
-      ? stringToArray(result).slice(0, length).join('')
+      ? castSlice(stringToArray(result), 0, length).join('')
       : result.slice(0, length);
   }
 

_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;
@@ -31,7 +31,6 @@ 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,
         newHolders = isCurry ? holders : undefined,
         newHoldersRight = isCurry ? undefined : holders,
         newPartials = isCurry ? partials : undefined,
@@ -45,7 +44,7 @@ define(['./_copyArray', './_isLaziable', './_setData'], function(copyArray, isLa
     }
     var newData = [
       func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
-      newHoldersRight, newArgPos, ary, arity
+      newHoldersRight, argPos, ary, arity
     ];
 
     var result = wrapFunc.apply(undefined, newData);

_getTag.js

@@ -1,5 +1,8 @@
 define(['./_DataView', './_Map', './_Promise', './_Set', './_WeakMap', './_toSource'], function(DataView, Map, Promise, Set, WeakMap, toSource) {
 
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
   /** `Object#toString` result references. */
   var mapTag = '[object Map]',
       objectTag = '[object Object]',
@@ -46,8 +49,8 @@ define(['./_DataView', './_Map', './_Promise', './_Set', './_WeakMap', './_toSou
       (WeakMap && getTag(new WeakMap) != weakMapTag)) {
     getTag = function(value) {
       var result = objectToString.call(value),
-          Ctor = result == objectTag ? value.constructor : null,
-          ctorString = toSource(Ctor);
+          Ctor = result == objectTag ? value.constructor : undefined,
+          ctorString = Ctor ? toSource(Ctor) : undefined;
 
       if (ctorString) {
         switch (ctorString) {

_hasPath.js

@@ -1,4 +1,4 @@
-define(['./_baseCastPath', './isArguments', './isArray', './_isIndex', './_isKey', './isLength', './isString'], function(baseCastPath, isArguments, isArray, isIndex, isKey, isLength, isString) {
+define(['./_castPath', './isArguments', './isArray', './_isIndex', './_isKey', './isLength', './isString'], function(castPath, isArguments, isArray, isIndex, isKey, isLength, isString) {
 
   /**
    * Checks if `path` exists on `object`.
@@ -10,7 +10,7 @@ define(['./_baseCastPath', './isArguments', './isArray', './_isIndex', './_isKey
    * @returns {boolean} Returns `true` if `path` exists, else `false`.
    */
   function hasPath(object, path, hasFunc) {
-    path = isKey(path, object) ? [path] : baseCastPath(path);
+    path = isKey(path, object) ? [path] : castPath(path);
 
     var result,
         index = -1,

_isFlattenable.js

@@ -0,0 +1,15 @@
+define(['./isArguments', './isArray', './isArrayLikeObject'], function(isArguments, isArray, isArrayLikeObject) {
+
+  /**
+   * Checks if `value` is a flattenable `arguments` object or array.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
+   */
+  function isFlattenable(value) {
+    return isArrayLikeObject(value) && (isArray(value) || isArguments(value));
+  }
+
+  return isFlattenable;
+});

_isFlattenableIteratee.js

@@ -0,0 +1,16 @@
+define(['./isArray', './isFunction'], function(isArray, isFunction) {
+
+  /**
+   * Checks if `value` is a flattenable array and not a `_.matchesProperty`
+   * iteratee shorthand.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
+   */
+  function isFlattenableIteratee(value) {
+    return isArray(value) && !(value.length == 2 && !isFunction(value[0]));
+  }
+
+  return isFlattenableIteratee;
+});

_mergeData.js

@@ -1,4 +1,4 @@
-define(['./_composeArgs', './_composeArgsRight', './_copyArray', './_replaceHolders'], function(composeArgs, composeArgsRight, copyArray, replaceHolders) {
+define(['./_composeArgs', './_composeArgsRight', './_replaceHolders'], function(composeArgs, composeArgsRight, replaceHolders) {
 
   /** Used as the internal argument placeholder. */
   var PLACEHOLDER = '__lodash_placeholder__';
@@ -55,20 +55,20 @@ define(['./_composeArgs', './_composeArgsRight', './_copyArray', './_replaceHold
     var value = source[3];
     if (value) {
       var partials = data[3];
-      data[3] = partials ? composeArgs(partials, value, source[4]) : copyArray(value);
-      data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : copyArray(source[4]);
+      data[3] = partials ? composeArgs(partials, value, source[4]) : value;
+      data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
     }
     // Compose partial right arguments.
     value = source[5];
     if (value) {
       partials = data[5];
-      data[5] = partials ? composeArgsRight(partials, value, source[6]) : copyArray(value);
-      data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : copyArray(source[6]);
+      data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
+      data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
     }
     // Use source `argPos` if available.
     value = source[7];
     if (value) {
-      data[7] = copyArray(value);
+      data[7] = value;
     }
     // Use source `ary` if it's smaller.
     if (srcBitmask & ARY_FLAG) {

_reHasComplexSymbol.js

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

_stringSize.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_reHasComplexSymbol'], function(reHasComplexSymbol) {
 
   /** Used to compose unicode character classes. */
   var rsAstralRange = '\\ud800-\\udfff',
@@ -26,9 +26,6 @@ define([], function() {
   /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
   var reComplexSymbol = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
 
-  /** 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 + ']');
-
   /**
    * Gets the number of symbols in `string`.
    *

_toKey.js

@@ -1,15 +1,15 @@
 define(['./isSymbol'], function(isSymbol) {
 
   /**
-   * Casts `value` to a string if it's not a string or symbol.
+   * Converts `value` to a string key if it's not a string or symbol.
    *
    * @private
    * @param {*} value The value to inspect.
-   * @returns {string|symbol} Returns the cast key.
+   * @returns {string|symbol} Returns the key.
    */
-  function baseCastKey(key) {
+  function toKey(key) {
     return (typeof key == 'string' || isSymbol(key)) ? key : (key + '');
   }
 
-  return baseCastKey;
+  return toKey;
 });

_toSource.js

@@ -1,4 +1,4 @@
-define(['./isFunction', './toString'], function(isFunction, toString) {
+define([], function() {
 
   /** Used to resolve the decompiled source of functions. */
   var funcToString = Function.prototype.toString;
@@ -11,12 +11,15 @@ define(['./isFunction', './toString'], function(isFunction, toString) {
    * @returns {string} Returns the source code.
    */
   function toSource(func) {
-    if (isFunction(func)) {
+    if (func != null) {
       try {
         return funcToString.call(func);
       } catch (e) {}
+      try {
+        return (func + '');
+      } catch (e) {}
     }
-    return toString(func);
+    return '';
   }
 
   return toSource;

array.js

@@ -1,4 +1,4 @@
-define(['./chunk', './compact', './concat', './difference', './differenceBy', './differenceWith', './drop', './dropRight', './dropRightWhile', './dropWhile', './fill', './findIndex', './findLastIndex', './flatten', './flattenDeep', './flattenDepth', './fromPairs', './head', './indexOf', './initial', './intersection', './intersectionBy', './intersectionWith', './join', './last', './lastIndexOf', './pull', './pullAll', './pullAllBy', './pullAllWith', './pullAt', './remove', './reverse', './slice', './sortedIndex', './sortedIndexBy', './sortedIndexOf', './sortedLastIndex', './sortedLastIndexBy', './sortedLastIndexOf', './sortedUniq', './sortedUniqBy', './tail', './take', './takeRight', './takeRightWhile', './takeWhile', './union', './unionBy', './unionWith', './uniq', './uniqBy', './uniqWith', './unzip', './unzipWith', './without', './xor', './xorBy', './xorWith', './zip', './zipObject', './zipObjectDeep', './zipWith'], function(chunk, compact, concat, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, fill, findIndex, findLastIndex, flatten, flattenDeep, flattenDepth, fromPairs, head, indexOf, initial, intersection, intersectionBy, intersectionWith, join, last, lastIndexOf, pull, pullAll, pullAllBy, pullAllWith, pullAt, remove, reverse, slice, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, tail, take, takeRight, takeRightWhile, takeWhile, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, without, xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, zipWith) {
+define(['./chunk', './compact', './concat', './difference', './differenceBy', './differenceWith', './drop', './dropRight', './dropRightWhile', './dropWhile', './fill', './findIndex', './findLastIndex', './flatten', './flattenDeep', './flattenDepth', './fromPairs', './head', './indexOf', './initial', './intersection', './intersectionBy', './intersectionWith', './join', './last', './lastIndexOf', './nth', './pull', './pullAll', './pullAllBy', './pullAllWith', './pullAt', './remove', './reverse', './slice', './sortedIndex', './sortedIndexBy', './sortedIndexOf', './sortedLastIndex', './sortedLastIndexBy', './sortedLastIndexOf', './sortedUniq', './sortedUniqBy', './tail', './take', './takeRight', './takeRightWhile', './takeWhile', './union', './unionBy', './unionWith', './uniq', './uniqBy', './uniqWith', './unzip', './unzipWith', './without', './xor', './xorBy', './xorWith', './zip', './zipObject', './zipObjectDeep', './zipWith'], function(chunk, compact, concat, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, fill, findIndex, findLastIndex, flatten, flattenDeep, flattenDepth, fromPairs, head, indexOf, initial, intersection, intersectionBy, intersectionWith, join, last, lastIndexOf, nth, pull, pullAll, pullAllBy, pullAllWith, pullAt, remove, reverse, slice, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, tail, take, takeRight, takeRightWhile, takeWhile, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, without, xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, zipWith) {
   return {
     'chunk': chunk,
     'compact': compact,
@@ -26,6 +26,7 @@ define(['./chunk', './compact', './concat', './difference', './differenceBy', '.
     'join': join,
     'last': last,
     'lastIndexOf': lastIndexOf,
+    'nth': nth,
     'pull': pull,
     'pullAll': pullAll,
     'pullAllBy': pullAllBy,

assignInWith.js

@@ -1,9 +1,9 @@
-define(['./_copyObjectWith', './_createAssigner', './keysIn'], function(copyObjectWith, createAssigner, keysIn) {
+define(['./_copyObject', './_createAssigner', './keysIn'], function(copyObject, createAssigner, keysIn) {
 
   /**
    * This method is like `_.assignIn` except that it accepts `customizer`
    * which is invoked to produce the assigned values. If `customizer` returns
-   * `undefined` assignment is handled by the method instead. The `customizer`
+   * `undefined`, assignment is handled by the method instead. The `customizer`
    * is invoked with five arguments: (objValue, srcValue, key, object, source).
    *
    * **Note:** This method mutates `object`.
@@ -29,7 +29,7 @@ define(['./_copyObjectWith', './_createAssigner', './keysIn'], function(copyObje
    * // => { 'a': 1, 'b': 2 }
    */
   var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
-    copyObjectWith(source, keysIn(source), object, customizer);
+    copyObject(source, keysIn(source), object, customizer);
   });
 
   return assignInWith;

assignWith.js

@@ -1,9 +1,9 @@
-define(['./_copyObjectWith', './_createAssigner', './keys'], function(copyObjectWith, createAssigner, keys) {
+define(['./_copyObject', './_createAssigner', './keys'], function(copyObject, createAssigner, keys) {
 
   /**
    * This method is like `_.assign` except that it accepts `customizer`
    * which is invoked to produce the assigned values. If `customizer` returns
-   * `undefined` assignment is handled by the method instead. The `customizer`
+   * `undefined`, assignment is handled by the method instead. The `customizer`
    * is invoked with five arguments: (objValue, srcValue, key, object, source).
    *
    * **Note:** This method mutates `object`.
@@ -28,7 +28,7 @@ define(['./_copyObjectWith', './_createAssigner', './keys'], function(copyObject
    * // => { 'a': 1, 'b': 2 }
    */
   var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
-    copyObjectWith(source, keys(source), object, customizer);
+    copyObject(source, keys(source), object, customizer);
   });
 
   return assignWith;

at.js

@@ -8,8 +8,7 @@ define(['./_baseAt', './_baseFlatten', './rest'], function(baseAt, baseFlatten,
    * @since 1.0.0
    * @category Object
    * @param {Object} object The object to iterate over.
-   * @param {...(string|string[])} [paths] The property paths of elements to pick,
-   *  specified individually or in arrays.
+   * @param {...(string|string[])} [paths] The property paths of elements to pick.
    * @returns {Array} Returns the new array of picked elements.
    * @example
    *

bindAll.js

@@ -11,8 +11,7 @@ define(['./_arrayEach', './_baseFlatten', './bind', './rest'], function(arrayEac
    * @memberOf _
    * @category Util
    * @param {Object} object The object to bind and assign the bound methods to.
-   * @param {...(string|string[])} methodNames The object method names to bind,
-   *  specified individually or in arrays.
+   * @param {...(string|string[])} methodNames The object method names to bind.
    * @returns {Object} Returns `object`.
    * @example
    *

cloneWith.js

@@ -2,7 +2,7 @@ define(['./_baseClone'], function(baseClone) {
 
   /**
    * This method is like `_.clone` except that it accepts `customizer` which
-   * is invoked to produce the cloned value. If `customizer` returns `undefined`
+   * is invoked to produce the cloned value. If `customizer` returns `undefined`,
    * cloning is handled by the method instead. The `customizer` is invoked with
    * up to four arguments; (value [, index|key, object, stack]).
    *

cond.js

@@ -4,7 +4,7 @@ define(['./_apply', './_arrayMap', './_baseIteratee', './rest'], function(apply,
   var FUNC_ERROR_TEXT = 'Expected a function';
 
   /**
-   * Creates a function that iterates over `pairs` invoking the corresponding
+   * Creates a function that iterates over `pairs` and invokes the corresponding
    * function of the first predicate to return truthy. The predicate-function
    * pairs are invoked with the `this` binding and arguments of the created
    * function.

create.js

@@ -2,7 +2,7 @@ define(['./_baseAssign', './_baseCreate'], function(baseAssign, baseCreate) {
 
   /**
    * Creates an object that inherits from the `prototype` object. If a
-   * `properties` object is given its own enumerable string keyed properties
+   * `properties` object is given, its own enumerable string keyed properties
    * are assigned to the created object.
    *
    * @static

debounce.js

@@ -24,7 +24,7 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
    * on the trailing edge of the timeout only if the debounced function is
    * invoked more than once during the `wait` timeout.
    *
-   * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)
+   * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
    * for details over the differences between `_.debounce` and `_.throttle`.
    *
    * @static
@@ -63,12 +63,13 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
   function debounce(func, wait, options) {
     var lastArgs,
         lastThis,
+        maxWait,
         result,
         timerId,
         lastCallTime = 0,
         lastInvokeTime = 0,
         leading = false,
-        maxWait = false,
+        maxing = false,
         trailing = true;
 
     if (typeof func != 'function') {
@@ -77,7 +78,8 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
     wait = toNumber(wait) || 0;
     if (isObject(options)) {
       leading = !!options.leading;
-      maxWait = 'maxWait' in options && nativeMax(toNumber(options.maxWait) || 0, wait);
+      maxing = 'maxWait' in options;
+      maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
       trailing = 'trailing' in options ? !!options.trailing : trailing;
     }
 
@@ -105,7 +107,7 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
           timeSinceLastInvoke = time - lastInvokeTime,
           result = wait - timeSinceLastCall;
 
-      return maxWait === false ? result : nativeMin(result, maxWait - timeSinceLastInvoke);
+      return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
     }
 
     function shouldInvoke(time) {
@@ -116,7 +118,7 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
       // trailing edge, the system time has gone backwards and we're treating
       // it as the trailing edge, or we've hit the `maxWait` limit.
       return (!lastCallTime || (timeSinceLastCall >= wait) ||
-        (timeSinceLastCall < 0) || (maxWait !== false && timeSinceLastInvoke >= maxWait));
+        (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
     }
 
     function timerExpired() {
@@ -165,10 +167,15 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
         if (timerId === undefined) {
           return leadingEdge(lastCallTime);
         }
-        // Handle invocations in a tight loop.
-        clearTimeout(timerId);
+        if (maxing) {
+          // Handle invocations in a tight loop.
+          clearTimeout(timerId);
+          timerId = setTimeout(timerExpired, wait);
+          return invokeFunc(lastCallTime);
+        }
+      }
+      if (timerId === undefined) {
         timerId = setTimeout(timerExpired, wait);
-        return invokeFunc(lastCallTime);
       }
       return result;
     }

difference.js

@@ -20,7 +20,7 @@ define(['./_baseDifference', './_baseFlatten', './isArrayLikeObject', './rest'],
    */
   var difference = rest(function(array, values) {
     return isArrayLikeObject(array)
-      ? baseDifference(array, baseFlatten(values, 1, true))
+      ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
       : [];
   });
 

differenceBy.js

@@ -33,7 +33,7 @@ define(['./_baseDifference', './_baseFlatten', './_baseIteratee', './isArrayLike
       iteratee = undefined;
     }
     return isArrayLikeObject(array)
-      ? baseDifference(array, baseFlatten(values, 1, true), baseIteratee(iteratee))
+      ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), baseIteratee(iteratee))
       : [];
   });
 

differenceWith.js

@@ -30,7 +30,7 @@ define(['./_baseDifference', './_baseFlatten', './isArrayLikeObject', './last',
       comparator = undefined;
     }
     return isArrayLikeObject(array)
-      ? baseDifference(array, baseFlatten(values, 1, true), undefined, comparator)
+      ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)
       : [];
   });
 

forEach.js

@@ -1,7 +1,7 @@
 define(['./_arrayEach', './_baseEach', './_baseIteratee', './isArray'], function(arrayEach, baseEach, baseIteratee, isArray) {
 
   /**
-   * Iterates over elements of `collection` invoking `iteratee` for each element.
+   * Iterates over elements of `collection` and invokes `iteratee` for each element.
    * The iteratee is invoked with three arguments: (value, index|key, collection).
    * Iteratee functions may exit iteration early by explicitly returning `false`.
    *

forIn.js

@@ -2,9 +2,9 @@ define(['./_baseFor', './_baseIteratee', './keysIn'], function(baseFor, baseIter
 
   /**
    * Iterates over own and inherited enumerable string keyed properties of an
-   * object invoking `iteratee` for each property. The iteratee is invoked with
-   * three arguments: (value, key, object). Iteratee functions may exit iteration
-   * early by explicitly returning `false`.
+   * object and invokes `iteratee` for each property. The iteratee is invoked
+   * with three arguments: (value, key, object). Iteratee functions may exit
+   * iteration early by explicitly returning `false`.
    *
    * @static
    * @memberOf _

forOwn.js

@@ -1,10 +1,10 @@
 define(['./_baseForOwn', './_baseIteratee'], function(baseForOwn, baseIteratee) {
 
   /**
-   * Iterates over own enumerable string keyed properties of an object invoking
-   * `iteratee` for each property. The iteratee is invoked with three arguments:
-   * (value, key, object). Iteratee functions may exit iteration early by
-   * explicitly returning `false`.
+   * Iterates over own enumerable string keyed properties of an object and
+   * invokes `iteratee` for each property. The iteratee is invoked with three
+   * arguments: (value, key, object). Iteratee functions may exit iteration
+   * early by explicitly returning `false`.
    *
    * @static
    * @memberOf _

get.js

@@ -5,7 +5,7 @@ define(['./_baseGet'], function(baseGet) {
 
   /**
    * Gets the value at `path` of `object`. If the resolved value is
-   * `undefined` the `defaultValue` is used in its place.
+   * `undefined`, the `defaultValue` is used in its place.
    *
    * @static
    * @memberOf _

groupBy.js

@@ -8,9 +8,10 @@ define(['./_createAggregator'], function(createAggregator) {
 
   /**
    * Creates an object composed of keys generated from the results of running
-   * each element of `collection` thru `iteratee`. The corresponding value of
-   * each key is an array of elements responsible for generating the key. The
-   * iteratee is invoked with one argument: (value).
+   * each element of `collection` thru `iteratee`. The order of grouped values
+   * is determined by the order they occur in `collection`. The corresponding
+   * value of each key is an array of elements responsible for generating the
+   * key. The iteratee is invoked with one argument: (value).
    *
    * @static
    * @memberOf _

has.js

@@ -12,16 +12,16 @@ define(['./_baseHas', './_hasPath'], function(baseHas, hasPath) {
    * @returns {boolean} Returns `true` if `path` exists, else `false`.
    * @example
    *
-   * var object = { 'a': { 'b': { 'c': 3 } } };
-   * var other = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) });
+   * var object = { 'a': { 'b': 2 } };
+   * var other = _.create({ 'a': _.create({ 'b': 2 }) });
    *
    * _.has(object, 'a');
    * // => true
    *
-   * _.has(object, 'a.b.c');
+   * _.has(object, 'a.b');
    * // => true
    *
-   * _.has(object, ['a', 'b', 'c']);
+   * _.has(object, ['a', 'b']);
    * // => true
    *
    * _.has(other, 'a');

hasIn.js

@@ -12,15 +12,15 @@ define(['./_baseHasIn', './_hasPath'], function(baseHasIn, hasPath) {
    * @returns {boolean} Returns `true` if `path` exists, else `false`.
    * @example
    *
-   * var object = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) });
+   * var object = _.create({ 'a': _.create({ 'b': 2 }) });
    *
    * _.hasIn(object, 'a');
    * // => true
    *
-   * _.hasIn(object, 'a.b.c');
+   * _.hasIn(object, 'a.b');
    * // => true
    *
-   * _.hasIn(object, ['a', 'b', 'c']);
+   * _.hasIn(object, ['a', 'b']);
    * // => true
    *
    * _.hasIn(object, 'b');

head.js

@@ -22,7 +22,7 @@ define([], function() {
    * // => undefined
    */
   function head(array) {
-    return array ? array[0] : undefined;
+    return (array && array.length) ? array[0] : undefined;
   }
 
   return head;

inRange.js

@@ -5,7 +5,7 @@ define(['./_baseInRange', './toNumber'], function(baseInRange, toNumber) {
 
   /**
    * Checks if `n` is between `start` and up to but not including, `end`. If
-   * `end` is not specified it's set to `start` with `start` then set to `0`.
+   * `end` is not specified, it's set to `start` with `start` then set to `0`.
    * If `start` is greater than `end` the params are swapped to support
    * negative ranges.
    *

includes.js

@@ -4,7 +4,7 @@ define(['./_baseIndexOf', './isArrayLike', './isString', './toInteger', './value
   var nativeMax = Math.max;
 
   /**
-   * Checks if `value` is in `collection`. If `collection` is a string it's
+   * Checks if `value` is in `collection`. If `collection` is a string, it's
    * checked for a substring of `value`, otherwise
    * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
    * is used for equality comparisons. If `fromIndex` is negative, it's used as

indexOf.js

@@ -6,8 +6,8 @@ define(['./_baseIndexOf', './toInteger'], function(baseIndexOf, toInteger) {
   /**
    * Gets the index at which the first occurrence of `value` is found in `array`
    * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
-   * for equality comparisons. If `fromIndex` is negative, it's used as the offset
-   * from the end of `array`.
+   * for equality comparisons. If `fromIndex` is negative, it's used as the
+   * offset from the end of `array`.
    *
    * @static
    * @memberOf _

intersection.js

@@ -1,4 +1,4 @@
-define(['./_arrayMap', './_baseCastArrayLikeObject', './_baseIntersection', './rest'], function(arrayMap, baseCastArrayLikeObject, baseIntersection, rest) {
+define(['./_arrayMap', './_baseIntersection', './_castArrayLikeObject', './rest'], function(arrayMap, baseIntersection, castArrayLikeObject, rest) {
 
   /**
    * Creates an array of unique values that are included in all given arrays
@@ -18,7 +18,7 @@ define(['./_arrayMap', './_baseCastArrayLikeObject', './_baseIntersection', './r
    * // => [2]
    */
   var intersection = rest(function(arrays) {
-    var mapped = arrayMap(arrays, baseCastArrayLikeObject);
+    var mapped = arrayMap(arrays, castArrayLikeObject);
     return (mapped.length && mapped[0] === arrays[0])
       ? baseIntersection(mapped)
       : [];

intersectionBy.js

@@ -1,4 +1,4 @@
-define(['./_arrayMap', './_baseCastArrayLikeObject', './_baseIntersection', './_baseIteratee', './last', './rest'], function(arrayMap, baseCastArrayLikeObject, baseIntersection, baseIteratee, last, rest) {
+define(['./_arrayMap', './_baseIntersection', './_baseIteratee', './_castArrayLikeObject', './last', './rest'], function(arrayMap, baseIntersection, baseIteratee, castArrayLikeObject, last, rest) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -28,7 +28,7 @@ define(['./_arrayMap', './_baseCastArrayLikeObject', './_baseIntersection', './_
    */
   var intersectionBy = rest(function(arrays) {
     var iteratee = last(arrays),
-        mapped = arrayMap(arrays, baseCastArrayLikeObject);
+        mapped = arrayMap(arrays, castArrayLikeObject);
 
     if (iteratee === last(mapped)) {
       iteratee = undefined;

intersectionWith.js

@@ -1,4 +1,4 @@
-define(['./_arrayMap', './_baseCastArrayLikeObject', './_baseIntersection', './last', './rest'], function(arrayMap, baseCastArrayLikeObject, baseIntersection, last, rest) {
+define(['./_arrayMap', './_baseIntersection', './_castArrayLikeObject', './last', './rest'], function(arrayMap, baseIntersection, castArrayLikeObject, last, rest) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -26,7 +26,7 @@ define(['./_arrayMap', './_baseCastArrayLikeObject', './_baseIntersection', './l
    */
   var intersectionWith = rest(function(arrays) {
     var comparator = last(arrays),
-        mapped = arrayMap(arrays, baseCastArrayLikeObject);
+        mapped = arrayMap(arrays, castArrayLikeObject);
 
     if (comparator === last(mapped)) {
       comparator = undefined;

invokeMap.js

@@ -6,8 +6,8 @@ define(['./_apply', './_baseEach', './_baseInvoke', './isArrayLike', './_isKey',
   /**
    * Invokes the method at `path` of each element in `collection`, returning
    * an array of the results of each invoked method. Any additional arguments
-   * are provided to each invoked method. If `methodName` is a function it's
-   * invoked for, and `this` bound to, each element in `collection`.
+   * are provided to each invoked method. If `methodName` is a function, it's
+   * invoked for and `this` bound to, each element in `collection`.
    *
    * @static
    * @memberOf _

isEqualWith.js

@@ -5,7 +5,7 @@ define(['./_baseIsEqual'], function(baseIsEqual) {
 
   /**
    * This method is like `_.isEqual` except that it accepts `customizer` which
-   * is invoked to compare values. If `customizer` returns `undefined` comparisons
+   * is invoked to compare values. If `customizer` returns `undefined`, comparisons
    * are handled by the method instead. The `customizer` is invoked with up to
    * six arguments: (objValue, othValue [, index|key, object, other, stack]).
    *

isMatchWith.js

@@ -5,7 +5,7 @@ define(['./_baseIsMatch', './_getMatchData'], function(baseIsMatch, getMatchData
 
   /**
    * This method is like `_.isMatch` except that it accepts `customizer` which
-   * is invoked to compare values. If `customizer` returns `undefined` comparisons
+   * is invoked to compare values. If `customizer` returns `undefined`, comparisons
    * are handled by the method instead. The `customizer` is invoked with five
    * arguments: (objValue, srcValue, index|key, object, source).
    *

iteratee.js

@@ -2,8 +2,8 @@ define(['./_baseClone', './_baseIteratee'], function(baseClone, baseIteratee) {
 
   /**
    * Creates a function that invokes `func` with the arguments of the created
-   * function. If `func` is a property name the created function returns the
-   * property value for a given element. If `func` is an array or object the
+   * function. If `func` is a property name, the created function returns the
+   * property value for a given element. If `func` is an array or object, the
    * created function returns `true` for elements that contain the equivalent
    * source properties, otherwise it returns `false`.
    *

map.js

@@ -11,8 +11,8 @@ define(['./_arrayMap', './_baseIteratee', './_baseMap', './isArray'], function(a
    * The guarded methods are:
    * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
    * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
-   * `sampleSize`, `slice`, `some`, `sortBy`, `take`, `takeRight`, `template`,
-   * `trim`, `trimEnd`, `trimStart`, and `words`
+   * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
+   * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
    *
    * @static
    * @memberOf _

max.js

@@ -4,7 +4,7 @@ define(['./_baseExtremum', './gt', './identity'], function(baseExtremum, gt, ide
   var undefined;
 
   /**
-   * Computes the maximum value of `array`. If `array` is empty or falsey
+   * Computes the maximum value of `array`. If `array` is empty or falsey,
    * `undefined` is returned.
    *
    * @static

memoize.js

@@ -5,7 +5,7 @@ define(['./_MapCache'], function(MapCache) {
 
   /**
    * Creates a function that memoizes the result of `func`. If `resolver` is
-   * provided it determines the cache key for storing the result based on the
+   * provided, it determines the cache key for storing the result based on the
    * arguments provided to the memoized function. By default, the first argument
    * provided to the memoized function is used as the map cache key. The `func`
    * is invoked with the `this` binding of the memoized function.

mergeWith.js

@@ -3,7 +3,7 @@ define(['./_baseMerge', './_createAssigner'], function(baseMerge, createAssigner
   /**
    * This method is like `_.merge` except that it accepts `customizer` which
    * is invoked to produce the merged values of the destination and source
-   * properties. If `customizer` returns `undefined` merging is handled by the
+   * properties. If `customizer` returns `undefined`, merging is handled by the
    * method instead. The `customizer` is invoked with seven arguments:
    * (objValue, srcValue, key, object, source, stack).
    *

method.js

@@ -14,14 +14,14 @@ define(['./_baseInvoke', './rest'], function(baseInvoke, rest) {
    * @example
    *
    * var objects = [
-   *   { 'a': { 'b': { 'c': _.constant(2) } } },
-   *   { 'a': { 'b': { 'c': _.constant(1) } } }
+   *   { 'a': { 'b': _.constant(2) } },
+   *   { 'a': { 'b': _.constant(1) } }
    * ];
    *
-   * _.map(objects, _.method('a.b.c'));
+   * _.map(objects, _.method('a.b'));
    * // => [2, 1]
    *
-   * _.map(objects, _.method(['a', 'b', 'c']));
+   * _.map(objects, _.method(['a', 'b']));
    * // => [2, 1]
    */
   var method = rest(function(path, args) {

min.js

@@ -4,7 +4,7 @@ define(['./_baseExtremum', './identity', './lt'], function(baseExtremum, identit
   var undefined;
 
   /**
-   * Computes the minimum value of `array`. If `array` is empty or falsey
+   * Computes the minimum value of `array`. If `array` is empty or falsey,
    * `undefined` is returned.
    *
    * @static

mixin.js

@@ -2,7 +2,7 @@ define(['./_arrayEach', './_arrayPush', './_baseFunctions', './_copyArray', './i
 
   /**
    * Adds all own enumerable string keyed function properties of a source
-   * object to the destination object. If `object` is a function then methods
+   * object to the destination object. If `object` is a function, then methods
    * are added to its prototype as well.
    *
    * **Note:** Use `_.runInContext` to create a pristine `lodash` function to
@@ -40,7 +40,7 @@ define(['./_arrayEach', './_arrayPush', './_baseFunctions', './_copyArray', './i
     var props = keys(source),
         methodNames = baseFunctions(source, props);
 
-    var chain = (isObject(options) && 'chain' in options) ? options.chain : true,
+    var chain = !(isObject(options) && 'chain' in options) || !!options.chain,
         isFunc = isFunction(object);
 
     arrayEach(methodNames, function(methodName) {

nth.js

@@ -0,0 +1,32 @@
+define(['./_baseNth', './toInteger'], function(baseNth, toInteger) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * Gets the nth element of `array`. If `n` is negative, the nth element
+   * from the end is returned.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.11.0
+   * @category Array
+   * @param {Array} array The array to query.
+   * @param {number} [n=0] The index of the element to return.
+   * @returns {*} Returns the nth element of `array`.
+   * @example
+   *
+   * var array = ['a', 'b', 'c', 'd'];
+   *
+   * _.nth(array, 1);
+   * // => 'b'
+   *
+   * _.nth(array, -2);
+   * // => 'c';
+   */
+  function nth(array, n) {
+    return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;
+  }
+
+  return nth;
+});

nthArg.js

@@ -1,7 +1,8 @@
-define(['./toInteger'], function(toInteger) {
+define(['./_baseNth', './rest', './toInteger'], function(baseNth, rest, toInteger) {
 
   /**
-   * Creates a function that returns its nth argument.
+   * Creates a function that returns its nth argument. If `n` is negative,
+   * the nth argument from the end is returned.
    *
    * @static
    * @memberOf _
@@ -12,15 +13,18 @@ define(['./toInteger'], function(toInteger) {
    * @example
    *
    * var func = _.nthArg(1);
-   *
-   * func('a', 'b', 'c');
+   * func('a', 'b', 'c', 'd');
    * // => 'b'
+   *
+   * var func = _.nthArg(-2);
+   * func('a', 'b', 'c', 'd');
+   * // => 'c'
    */
   function nthArg(n) {
     n = toInteger(n);
-    return function() {
-      return arguments[n];
-    };
+    return rest(function(args) {
+      return baseNth(args, n);
+    });
   }
 
   return nthArg;

omit.js

@@ -1,4 +1,4 @@
-define(['./_arrayMap', './_baseCastKey', './_baseDifference', './_baseFlatten', './_basePick', './_getAllKeysIn', './rest'], function(arrayMap, baseCastKey, baseDifference, baseFlatten, basePick, getAllKeysIn, rest) {
+define(['./_arrayMap', './_baseDifference', './_baseFlatten', './_basePick', './_getAllKeysIn', './rest', './_toKey'], function(arrayMap, baseDifference, baseFlatten, basePick, getAllKeysIn, rest, toKey) {
 
   /**
    * The opposite of `_.pick`; this method creates an object composed of the
@@ -10,8 +10,7 @@ define(['./_arrayMap', './_baseCastKey', './_baseDifference', './_baseFlatten',
    * @memberOf _
    * @category Object
    * @param {Object} object The source object.
-   * @param {...(string|string[])} [props] The property identifiers to omit,
-   *  specified individually or in arrays.
+   * @param {...(string|string[])} [props] The property identifiers to omit.
    * @returns {Object} Returns the new object.
    * @example
    *
@@ -24,7 +23,7 @@ define(['./_arrayMap', './_baseCastKey', './_baseDifference', './_baseFlatten',
     if (object == null) {
       return {};
     }
-    props = arrayMap(baseFlatten(props, 1), baseCastKey);
+    props = arrayMap(baseFlatten(props, 1), toKey);
     return basePick(object, baseDifference(getAllKeysIn(object), props));
   });
 

over.js

@@ -8,7 +8,8 @@ define(['./_arrayMap', './_createOver'], function(arrayMap, createOver) {
    * @memberOf _
    * @since 4.0.0
    * @category Util
-   * @param {...Function} iteratees The iteratees to invoke.
+   * @param {...(Array|Array[]|Function|Function[]|Object|Object[]|string|string[])}
+   *  [iteratees=[_.identity]] The iteratees to invoke.
    * @returns {Function} Returns the new function.
    * @example
    *

overArgs.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_arrayMap', './_baseIteratee', './rest'], function(apply, arrayMap, baseIteratee, rest) {
+define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './_baseUnary', './isArray', './_isFlattenableIteratee', './rest'], function(apply, arrayMap, baseFlatten, baseIteratee, baseUnary, isArray, isFlattenableIteratee, rest) {
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeMin = Math.min;
@@ -12,8 +12,8 @@ define(['./_apply', './_arrayMap', './_baseIteratee', './rest'], function(apply,
    * @memberOf _
    * @category Function
    * @param {Function} func The function to wrap.
-   * @param {...Function} [transforms] The functions to transform
-   * arguments, specified individually or in arrays.
+   * @param {...(Array|Array[]|Function|Function[]|Object|Object[]|string|string[])}
+   *  [transforms[_.identity]] The functions to transform.
    * @returns {Function} Returns the new function.
    * @example
    *
@@ -36,7 +36,9 @@ define(['./_apply', './_arrayMap', './_baseIteratee', './rest'], function(apply,
    * // => [100, 10]
    */
   var overArgs = rest(function(func, transforms) {
-    transforms = arrayMap(transforms, baseIteratee);
+    transforms = (transforms.length == 1 && isArray(transforms[0]))
+      ? arrayMap(transforms[0], baseUnary(baseIteratee))
+      : arrayMap(baseFlatten(transforms, 1, isFlattenableIteratee), baseUnary(baseIteratee));
 
     var funcsLength = transforms.length;
     return rest(function(args) {

overEvery.js

@@ -8,7 +8,8 @@ define(['./_arrayEvery', './_createOver'], function(arrayEvery, createOver) {
    * @memberOf _
    * @since 4.0.0
    * @category Util
-   * @param {...Function} predicates The predicates to check.
+   * @param {...(Array|Array[]|Function|Function[]|Object|Object[]|string|string[])}
+   *  [predicates=[_.identity]] The predicates to check.
    * @returns {Function} Returns the new function.
    * @example
    *

overSome.js

@@ -8,7 +8,8 @@ define(['./_arraySome', './_createOver'], function(arraySome, createOver) {
    * @memberOf _
    * @since 4.0.0
    * @category Util
-   * @param {...Function} predicates The predicates to check.
+   * @param {...(Array|Array[]|Function|Function[]|Object|Object[]|string|string[])}
+   *  [predicates=[_.identity]] The predicates to check.
    * @returns {Function} Returns the new function.
    * @example
    *

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lodash-amd",
-  "version": "4.8.0",
+  "version": "4.11.1",
   "description": "Lodash exported as AMD modules.",
   "homepage": "https://lodash.com/custom-builds",
   "license": "MIT",

pick.js

@@ -8,8 +8,7 @@ define(['./_baseFlatten', './_basePick', './rest'], function(baseFlatten, basePi
    * @memberOf _
    * @category Object
    * @param {Object} object The source object.
-   * @param {...(string|string[])} [props] The property identifiers to pick,
-   *  specified individually or in arrays.
+   * @param {...(string|string[])} [props] The property identifiers to pick.
    * @returns {Object} Returns the new object.
    * @example
    *

property.js

@@ -12,14 +12,14 @@ define(['./_baseProperty', './_basePropertyDeep', './_isKey'], function(baseProp
    * @example
    *
    * var objects = [
-   *   { 'a': { 'b': { 'c': 2 } } },
-   *   { 'a': { 'b': { 'c': 1 } } }
+   *   { 'a': { 'b': 2 } },
+   *   { 'a': { 'b': 1 } }
    * ];
    *
-   * _.map(objects, _.property('a.b.c'));
+   * _.map(objects, _.property('a.b'));
    * // => [2, 1]
    *
-   * _.map(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c');
+   * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
    * // => [1, 2]
    */
   function property(path) {

pullAt.js

@@ -11,8 +11,7 @@ define(['./_arrayMap', './_baseAt', './_baseFlatten', './_basePullAt', './_compa
    * @since 3.0.0
    * @category Array
    * @param {Array} array The array to modify.
-   * @param {...(number|number[])} [indexes] The indexes of elements to remove,
-   *  specified individually or in arrays.
+   * @param {...(number|number[])} [indexes] The indexes of elements to remove.
    * @returns {Array} Returns the new array of removed elements.
    * @example
    *

range.js

@@ -3,7 +3,7 @@ define(['./_createRange'], function(createRange) {
   /**
    * Creates an array of numbers (positive and/or negative) progressing from
    * `start` up to, but not including, `end`. A step of `-1` is used if a negative
-   * `start` is specified without an `end` or `step`. If `end` is not specified
+   * `start` is specified without an `end` or `step`. If `end` is not specified,
    * it's set to `start` with `start` then set to `0`.
    *
    * **Note:** JavaScript follows the IEEE-754 standard for resolving

rearg.js

@@ -17,8 +17,7 @@ define(['./_baseFlatten', './_createWrapper', './rest'], function(baseFlatten, c
    * @since 3.0.0
    * @category Function
    * @param {Function} func The function to rearrange arguments for.
-   * @param {...(number|number[])} indexes The arranged argument indexes,
-   *  specified individually or in arrays.
+   * @param {...(number|number[])} indexes The arranged argument indexes.
    * @returns {Function} Returns the new function.
    * @example
    *

reduce.js

@@ -4,7 +4,7 @@ define(['./_arrayReduce', './_baseEach', './_baseIteratee', './_baseReduce', './
    * Reduces `collection` to a value which is the accumulated result of running
    * each element in `collection` thru `iteratee`, where each successive
    * invocation is supplied the return value of the previous. If `accumulator`
-   * is not given the first element of `collection` is used as the initial
+   * is not given, the first element of `collection` is used as the initial
    * value. The iteratee is invoked with four arguments:
    * (accumulator, value, index|key, collection).
    *

replace.js

@@ -1,5 +1,11 @@
 define(['./toString'], function(toString) {
 
+  /** Used for built-in method references. */
+  var stringProto = String.prototype;
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeReplace = stringProto.replace;
+
   /**
    * Replaces matches for `pattern` in `string` with `replacement`.
    *
@@ -23,7 +29,7 @@ define(['./toString'], function(toString) {
     var args = arguments,
         string = toString(args[0]);
 
-    return args.length < 3 ? string : string.replace(args[1], args[2]);
+    return args.length < 3 ? string : nativeReplace.call(string, args[1], args[2]);
   }
 
   return replace;

result.js

@@ -1,4 +1,4 @@
-define(['./_baseCastPath', './isFunction', './_isKey'], function(baseCastPath, isFunction, isKey) {
+define(['./_castPath', './isFunction', './_isKey'], function(castPath, isFunction, isKey) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -33,7 +33,7 @@ define(['./_baseCastPath', './isFunction', './_isKey'], function(baseCastPath, i
    * // => 'default'
    */
   function result(object, path, defaultValue) {
-    path = isKey(path, object) ? [path] : baseCastPath(path);
+    path = isKey(path, object) ? [path] : castPath(path);
 
     var index = -1,
         length = path.length;

set.js

@@ -1,7 +1,7 @@
 define(['./_baseSet'], function(baseSet) {
 
   /**
-   * Sets the value at `path` of `object`. If a portion of `path` doesn't exist
+   * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
    * it's created. Arrays are created for missing index properties while objects
    * are created for all other missing properties. Use `_.setWith` to customize
    * `path` creation.

sortBy.js

@@ -1,4 +1,4 @@
-define(['./_baseFlatten', './_baseOrderBy', './_isIterateeCall', './rest'], function(baseFlatten, baseOrderBy, isIterateeCall, rest) {
+define(['./_baseFlatten', './_baseOrderBy', './isArray', './_isFlattenableIteratee', './_isIterateeCall', './rest'], function(baseFlatten, baseOrderBy, isArray, isFlattenableIteratee, isIterateeCall, rest) {
 
   /**
    * Creates an array of elements, sorted in ascending order by the results of
@@ -12,8 +12,7 @@ define(['./_baseFlatten', './_baseOrderBy', './_isIterateeCall', './rest'], func
    * @category Collection
    * @param {Array|Object} collection The collection to iterate over.
    * @param {...(Array|Array[]|Function|Function[]|Object|Object[]|string|string[])}
-   *  [iteratees=[_.identity]] The iteratees to sort by, specified individually
-   *  or in arrays.
+   *  [iteratees=[_.identity]] The iteratees to sort by.
    * @returns {Array} Returns the new sorted array.
    * @example
    *
@@ -43,9 +42,13 @@ define(['./_baseFlatten', './_baseOrderBy', './_isIterateeCall', './rest'], func
     if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
       iteratees = [];
     } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
-      iteratees.length = 1;
+      iteratees = [iteratees[0]];
     }
-    return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
+    iteratees = (iteratees.length == 1 && isArray(iteratees[0]))
+      ? iteratees[0]
+      : baseFlatten(iteratees, 1, isFlattenableIteratee);
+
+    return baseOrderBy(collection, iteratees, []);
   });
 
   return sortBy;

split.js

@@ -1,4 +1,16 @@
-define(['./toString'], function(toString) {
+define(['./_castSlice', './_isIterateeCall', './isRegExp', './_reHasComplexSymbol', './_stringToArray', './toString'], function(castSlice, isIterateeCall, isRegExp, reHasComplexSymbol, stringToArray, toString) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /** Used as references for the maximum length and index of an array. */
+  var MAX_ARRAY_LENGTH = 4294967295;
+
+  /** Used for built-in method references. */
+  var stringProto = String.prototype;
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeSplit = stringProto.split;
 
   /**
    * Splits `string` by `separator`.
@@ -20,7 +32,24 @@ define(['./toString'], function(toString) {
    * // => ['a', 'b']
    */
   function split(string, separator, limit) {
-    return toString(string).split(separator, limit);
+    if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {
+      separator = limit = undefined;
+    }
+    limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;
+    if (!limit) {
+      return [];
+    }
+    string = toString(string);
+    if (string && (
+          typeof separator == 'string' ||
+          (separator != null && !isRegExp(separator))
+        )) {
+      separator += '';
+      if (separator == '' && reHasComplexSymbol.test(string)) {
+        return castSlice(stringToArray(string), 0, limit);
+      }
+    }
+    return nativeSplit.call(string, separator, limit);
   }
 
   return split;

spread.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_arrayPush', './rest', './toInteger'], function(apply, arrayPush, rest, toInteger) {
+define(['./_apply', './_arrayPush', './_castSlice', './rest', './toInteger'], function(apply, arrayPush, castSlice, rest, toInteger) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -50,7 +50,7 @@ define(['./_apply', './_arrayPush', './rest', './toInteger'], function(apply, ar
     start = start === undefined ? 0 : nativeMax(toInteger(start), 0);
     return rest(function(args) {
       var array = args[start],
-          otherArgs = args.slice(0, start);
+          otherArgs = castSlice(args, 0, start);
 
       if (array) {
         arrayPush(otherArgs, array);

template.js

@@ -25,7 +25,7 @@ define(['./_assignInDefaults', './assignInWith', './attempt', './_baseValues', '
    * in "interpolate" delimiters, HTML-escape interpolated data properties in
    * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
    * properties may be accessed as free variables in the template. If a setting
-   * object is given it takes precedence over `_.templateSettings` values.
+   * object is given, it takes precedence over `_.templateSettings` values.
    *
    * **Note:** In the development build `_.template` utilizes
    * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)

throttle.js

@@ -17,7 +17,7 @@ define(['./debounce', './isObject'], function(debounce, isObject) {
    * invoked on the trailing edge of the timeout only if the throttled function
    * is invoked more than once during the `wait` timeout.
    *
-   * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)
+   * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
    * for details over the differences between `_.throttle` and `_.debounce`.
    *
    * @static

toPath.js

@@ -1,4 +1,4 @@
-define(['./_arrayMap', './_baseCastKey', './_copyArray', './isArray', './isSymbol', './_stringToPath'], function(arrayMap, baseCastKey, copyArray, isArray, isSymbol, stringToPath) {
+define(['./_arrayMap', './_copyArray', './isArray', './isSymbol', './_stringToPath', './_toKey'], function(arrayMap, copyArray, isArray, isSymbol, stringToPath, toKey) {
 
   /**
    * Converts `value` to a property path array.
@@ -28,7 +28,7 @@ define(['./_arrayMap', './_baseCastKey', './_copyArray', './isArray', './isSymbo
    */
   function toPath(value) {
     if (isArray(value)) {
-      return arrayMap(value, baseCastKey);
+      return arrayMap(value, toKey);
     }
     return isSymbol(value) ? [value] : copyArray(stringToPath(value));
   }

toString.js

@@ -11,8 +11,8 @@ define(['./_Symbol', './isSymbol'], function(Symbol, isSymbol) {
       symbolToString = symbolProto ? symbolProto.toString : undefined;
 
   /**
-   * Converts `value` to a string if it's not one. An empty string is returned
-   * for `null` and `undefined` values. The sign of `-0` is preserved.
+   * Converts `value` to a string. An empty string is returned for `null`
+   * and `undefined` values. The sign of `-0` is preserved.
    *
    * @static
    * @memberOf _

trim.js

@@ -1,4 +1,4 @@
-define(['./_charsEndIndex', './_charsStartIndex', './_stringToArray', './toString'], function(charsEndIndex, charsStartIndex, stringToArray, toString) {
+define(['./_castSlice', './_charsEndIndex', './_charsStartIndex', './_stringToArray', './toString'], function(castSlice, charsEndIndex, charsStartIndex, stringToArray, toString) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -36,16 +36,15 @@ define(['./_charsEndIndex', './_charsStartIndex', './_stringToArray', './toStrin
     if (guard || chars === undefined) {
       return string.replace(reTrim, '');
     }
-    chars = (chars + '');
-    if (!chars) {
+    if (!(chars += '')) {
       return string;
     }
     var strSymbols = stringToArray(string),
-        chrSymbols = stringToArray(chars);
+        chrSymbols = stringToArray(chars),
+        start = charsStartIndex(strSymbols, chrSymbols),
+        end = charsEndIndex(strSymbols, chrSymbols) + 1;
 
-    return strSymbols
-      .slice(charsStartIndex(strSymbols, chrSymbols), charsEndIndex(strSymbols, chrSymbols) + 1)
-      .join('');
+    return castSlice(strSymbols, start, end).join('');
   }
 
   return trim;

trimEnd.js

@@ -1,4 +1,4 @@
-define(['./_charsEndIndex', './_stringToArray', './toString'], function(charsEndIndex, stringToArray, toString) {
+define(['./_castSlice', './_charsEndIndex', './_stringToArray', './toString'], function(castSlice, charsEndIndex, stringToArray, toString) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -33,14 +33,13 @@ define(['./_charsEndIndex', './_stringToArray', './toString'], function(charsEnd
     if (guard || chars === undefined) {
       return string.replace(reTrimEnd, '');
     }
-    chars = (chars + '');
-    if (!chars) {
+    if (!(chars += '')) {
       return string;
     }
-    var strSymbols = stringToArray(string);
-    return strSymbols
-      .slice(0, charsEndIndex(strSymbols, stringToArray(chars)) + 1)
-      .join('');
+    var strSymbols = stringToArray(string),
+        end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;
+
+    return castSlice(strSymbols, 0, end).join('');
   }
 
   return trimEnd;

trimStart.js

@@ -1,4 +1,4 @@
-define(['./_charsStartIndex', './_stringToArray', './toString'], function(charsStartIndex, stringToArray, toString) {
+define(['./_castSlice', './_charsStartIndex', './_stringToArray', './toString'], function(castSlice, charsStartIndex, stringToArray, toString) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -33,14 +33,13 @@ define(['./_charsStartIndex', './_stringToArray', './toString'], function(charsS
     if (guard || chars === undefined) {
       return string.replace(reTrimStart, '');
     }
-    chars = (chars + '');
-    if (!chars) {
+    if (!(chars += '')) {
       return string;
     }
-    var strSymbols = stringToArray(string);
-    return strSymbols
-      .slice(charsStartIndex(strSymbols, stringToArray(chars)))
-      .join('');
+    var strSymbols = stringToArray(string),
+        start = charsStartIndex(strSymbols, stringToArray(chars));
+
+    return castSlice(strSymbols, start).join('');
   }
 
   return trimStart;

truncate.js

@@ -1,4 +1,4 @@
-define(['./isObject', './isRegExp', './_stringSize', './_stringToArray', './toInteger', './toString'], function(isObject, isRegExp, stringSize, stringToArray, toInteger, toString) {
+define(['./_castSlice', './isObject', './isRegExp', './_reHasComplexSymbol', './_stringSize', './_stringToArray', './toInteger', './toString'], function(castSlice, isObject, isRegExp, reHasComplexSymbol, stringSize, stringToArray, toInteger, toString) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -10,18 +10,6 @@ define(['./isObject', './isRegExp', './_stringSize', './_stringToArray', './toIn
   /** Used to match `RegExp` flags from their coerced string values. */
   var reFlags = /\w*$/;
 
-  /** 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 + ']');
-
   /**
    * Truncates `string` if it's longer than the given maximum string length.
    * The last characters of the truncated string are replaced with the omission
@@ -83,7 +71,7 @@ define(['./isObject', './isRegExp', './_stringSize', './_stringToArray', './toIn
       return omission;
     }
     var result = strSymbols
-      ? strSymbols.slice(0, end).join('')
+      ? castSlice(strSymbols, 0, end).join('')
       : string.slice(0, end);
 
     if (separator === undefined) {

union.js

@@ -1,4 +1,4 @@
-define(['./_baseFlatten', './_baseUniq', './rest'], function(baseFlatten, baseUniq, rest) {
+define(['./_baseFlatten', './_baseUniq', './isArrayLikeObject', './rest'], function(baseFlatten, baseUniq, isArrayLikeObject, rest) {
 
   /**
    * Creates an array of unique values, in order, from all given arrays using
@@ -17,7 +17,7 @@ define(['./_baseFlatten', './_baseUniq', './rest'], function(baseFlatten, baseUn
    * // => [2, 1, 4]
    */
   var union = rest(function(arrays) {
-    return baseUniq(baseFlatten(arrays, 1, true));
+    return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
   });
 
   return union;

unionBy.js

@@ -31,7 +31,7 @@ define(['./_baseFlatten', './_baseIteratee', './_baseUniq', './isArrayLikeObject
     if (isArrayLikeObject(iteratee)) {
       iteratee = undefined;
     }
-    return baseUniq(baseFlatten(arrays, 1, true), baseIteratee(iteratee));
+    return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), baseIteratee(iteratee));
   });
 
   return unionBy;

unionWith.js

@@ -28,7 +28,7 @@ define(['./_baseFlatten', './_baseUniq', './isArrayLikeObject', './last', './res
     if (isArrayLikeObject(comparator)) {
       comparator = undefined;
     }
-    return baseUniq(baseFlatten(arrays, 1, true), undefined, comparator);
+    return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);
   });
 
   return unionWith;