Bump to v4.14.1.

README.md

@@ -1,4 +1,4 @@
-# lodash-amd v4.13.0
+# lodash-amd v4.14.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.13.0-amd) for more details.
+See the [package source](https://github.com/lodash/lodash/tree/4.14.1-amd) for more details.

_addMapEntry.js

@@ -9,7 +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.
+    // Don't return `map.set` because it's not chainable in IE 11.
     map.set(pair[0], pair[1]);
     return map;
   }

_addSetEntry.js

@@ -9,6 +9,7 @@ define([], function() {
    * @returns {Object} Returns `set`.
    */
   function addSetEntry(set, value) {
+    // Don't return `set.add` because it's not chainable in IE 11.
     set.add(value);
     return set;
   }

_apply.js

@@ -11,8 +11,7 @@ define([], function() {
    * @returns {*} Returns the result of `func`.
    */
   function apply(func, thisArg, args) {
-    var length = args.length;
+    switch (args.length) {
-    switch (length) {
       case 0: return func.call(thisArg);
       case 1: return func.call(thisArg, args[0]);
       case 2: return func.call(thisArg, args[0], args[1]);

_baseClamp.js

@@ -4,7 +4,7 @@ define([], function() {
   var undefined;
 
   /**
-   * The base implementation of `_.clamp` which doesn't coerce arguments to numbers.
+   * The base implementation of `_.clamp` which doesn't coerce arguments.
    *
    * @private
    * @param {number} number The number to clamp.

_baseClone.js

@@ -112,12 +112,12 @@ define(['./_Stack', './_arrayEach', './_assignValue', './_baseAssign', './_clone
     if (!isArr) {
       var props = isFull ? getAllKeys(value) : keys(value);
     }
-    // Recursively populate clone (susceptible to call stack limits).
     arrayEach(props || value, function(subValue, key) {
       if (props) {
         key = subValue;
         subValue = value[key];
       }
+      // Recursively populate clone (susceptible to call stack limits).
       assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
     });
     return result;

_baseConforms.js

@@ -1,7 +1,4 @@
-define(['./keys'], function(keys) {
+define(['./_baseConformsTo', './keys'], function(baseConformsTo, keys) {
-
-  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
-  var undefined;
 
   /**
    * The base implementation of `_.conforms` which doesn't clone `source`.
@@ -11,25 +8,9 @@ define(['./keys'], function(keys) {
    * @returns {Function} Returns the new spec function.
    */
   function baseConforms(source) {
-    var props = keys(source),
+    var props = keys(source);
-        length = props.length;
-
     return function(object) {
-      if (object == null) {
+      return baseConformsTo(object, source, props);
-        return !length;
-      }
-      var index = length;
-      while (index--) {
-        var key = props[index],
-            predicate = source[key],
-            value = object[key];
-
-        if ((value === undefined &&
-            !(key in Object(object))) || !predicate(value)) {
-          return false;
-        }
-      }
-      return true;
     };
   }
 

_baseConformsTo.js

@@ -0,0 +1,34 @@
+define([], function() {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.conformsTo` which accepts `props` to check.
+   *
+   * @private
+   * @param {Object} object The object to inspect.
+   * @param {Object} source The object of property predicates to conform to.
+   * @returns {boolean} Returns `true` if `object` conforms, else `false`.
+   */
+  function baseConformsTo(object, source, props) {
+    var length = props.length;
+    if (object == null) {
+      return !length;
+    }
+    var index = length;
+    while (index--) {
+      var key = props[index],
+          predicate = source[key],
+          value = object[key];
+
+      if ((value === undefined &&
+          !(key in Object(object))) || !predicate(value)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  return baseConformsTo;
+});

_baseDelay.js

@@ -7,13 +7,13 @@ define([], function() {
   var FUNC_ERROR_TEXT = 'Expected a function';
 
   /**
-   * The base implementation of `_.delay` and `_.defer` which accepts an array
+   * The base implementation of `_.delay` and `_.defer` which accepts `args`
-   * of `func` arguments.
+   * to provide to `func`.
    *
    * @private
    * @param {Function} func The function to delay.
    * @param {number} wait The number of milliseconds to delay invocation.
-   * @param {Object} args The arguments to provide to `func`.
+   * @param {Array} args The arguments to provide to `func`.
    * @returns {number} Returns the timer id.
    */
   function baseDelay(func, wait, args) {

_baseGetTag.js

@@ -0,0 +1,25 @@
+define([], function() {
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var objectToString = objectProto.toString;
+
+  /**
+   * The base implementation of `getTag`.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the `toStringTag`.
+   */
+  function baseGetTag(value) {
+    return objectToString.call(value);
+  }
+
+  return baseGetTag;
+});

_baseGt.js

@@ -1,7 +1,7 @@
 define([], function() {
 
   /**
-   * The base implementation of `_.gt` which doesn't coerce arguments to numbers.
+   * The base implementation of `_.gt` which doesn't coerce arguments.
    *
    * @private
    * @param {*} value The value to compare.

_baseInRange.js

@@ -5,7 +5,7 @@ define([], function() {
       nativeMin = Math.min;
 
   /**
-   * The base implementation of `_.inRange` which doesn't coerce arguments to numbers.
+   * The base implementation of `_.inRange` which doesn't coerce arguments.
    *
    * @private
    * @param {number} number The number to check.

_baseIndexOf.js

@@ -1,4 +1,4 @@
-define(['./_indexOfNaN'], function(indexOfNaN) {
+define(['./_baseFindIndex', './_baseIsNaN'], function(baseFindIndex, baseIsNaN) {
 
   /**
    * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
@@ -11,7 +11,7 @@ define(['./_indexOfNaN'], function(indexOfNaN) {
    */
   function baseIndexOf(array, value, fromIndex) {
     if (value !== value) {
-      return indexOfNaN(array, fromIndex);
+      return baseFindIndex(array, baseIsNaN, fromIndex);
     }
     var index = fromIndex - 1,
         length = array.length;

_baseIsArrayBuffer.js

@@ -0,0 +1,27 @@
+define(['./isObjectLike'], function(isObjectLike) {
+
+  var arrayBufferTag = '[object ArrayBuffer]';
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var objectToString = objectProto.toString;
+
+  /**
+   * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
+   */
+  function baseIsArrayBuffer(value) {
+    return isObjectLike(value) && objectToString.call(value) == arrayBufferTag;
+  }
+
+  return baseIsArrayBuffer;
+});

_baseIsDate.js

@@ -0,0 +1,28 @@
+define(['./isObjectLike'], function(isObjectLike) {
+
+  /** `Object#toString` result references. */
+  var dateTag = '[object Date]';
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var objectToString = objectProto.toString;
+
+  /**
+   * The base implementation of `_.isDate` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
+   */
+  function baseIsDate(value) {
+    return isObjectLike(value) && objectToString.call(value) == dateTag;
+  }
+
+  return baseIsDate;
+});

_baseIsMap.js

@@ -0,0 +1,18 @@
+define(['./_getTag', './isObjectLike'], function(getTag, isObjectLike) {
+
+  /** `Object#toString` result references. */
+  var mapTag = '[object Map]';
+
+  /**
+   * The base implementation of `_.isMap` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+   */
+  function baseIsMap(value) {
+    return isObjectLike(value) && getTag(value) == mapTag;
+  }
+
+  return baseIsMap;
+});

_baseIsNaN.js

@@ -0,0 +1,15 @@
+define([], function() {
+
+  /**
+   * The base implementation of `_.isNaN` without support for number objects.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
+   */
+  function baseIsNaN(value) {
+    return value !== value;
+  }
+
+  return baseIsNaN;
+});

_baseIsRegExp.js

@@ -0,0 +1,28 @@
+define(['./isObject'], function(isObject) {
+
+  /** `Object#toString` result references. */
+  var regexpTag = '[object RegExp]';
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var objectToString = objectProto.toString;
+
+  /**
+   * The base implementation of `_.isRegExp` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
+   */
+  function baseIsRegExp(value) {
+    return isObject(value) && objectToString.call(value) == regexpTag;
+  }
+
+  return baseIsRegExp;
+});

_baseIsSet.js

@@ -0,0 +1,18 @@
+define(['./_getTag', './isObjectLike'], function(getTag, isObjectLike) {
+
+  /** `Object#toString` result references. */
+  var setTag = '[object Set]';
+
+  /**
+   * The base implementation of `_.isSet` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+   */
+  function baseIsSet(value) {
+    return isObjectLike(value) && getTag(value) == setTag;
+  }
+
+  return baseIsSet;
+});

_baseIsTypedArray.js

@@ -0,0 +1,69 @@
+define(['./isLength', './isObjectLike'], function(isLength, isObjectLike) {
+
+  /** `Object#toString` result references. */
+  var argsTag = '[object Arguments]',
+      arrayTag = '[object Array]',
+      boolTag = '[object Boolean]',
+      dateTag = '[object Date]',
+      errorTag = '[object Error]',
+      funcTag = '[object Function]',
+      mapTag = '[object Map]',
+      numberTag = '[object Number]',
+      objectTag = '[object Object]',
+      regexpTag = '[object RegExp]',
+      setTag = '[object Set]',
+      stringTag = '[object String]',
+      weakMapTag = '[object WeakMap]';
+
+  var arrayBufferTag = '[object ArrayBuffer]',
+      dataViewTag = '[object DataView]',
+      float32Tag = '[object Float32Array]',
+      float64Tag = '[object Float64Array]',
+      int8Tag = '[object Int8Array]',
+      int16Tag = '[object Int16Array]',
+      int32Tag = '[object Int32Array]',
+      uint8Tag = '[object Uint8Array]',
+      uint8ClampedTag = '[object Uint8ClampedArray]',
+      uint16Tag = '[object Uint16Array]',
+      uint32Tag = '[object Uint32Array]';
+
+  /** Used to identify `toStringTag` values of typed arrays. */
+  var typedArrayTags = {};
+  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+  typedArrayTags[uint32Tag] = true;
+  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
+  typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+  typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+  typedArrayTags[setTag] = typedArrayTags[stringTag] =
+  typedArrayTags[weakMapTag] = false;
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var objectToString = objectProto.toString;
+
+  /**
+   * The base implementation of `_.isTypedArray` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+   */
+  function baseIsTypedArray(value) {
+    return isObjectLike(value) &&
+      isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
+  }
+
+  return baseIsTypedArray;
+});

_baseKeys.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_overArg'], function(overArg) {
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeKeys = Object.keys;
@@ -11,9 +11,7 @@ define([], function() {
    * @param {Object} object The object to query.
    * @returns {Array} Returns the array of property names.
    */
-  function baseKeys(object) {
+  var baseKeys = overArg(nativeKeys, Object);
-    return nativeKeys(Object(object));
-  }
 
   return baseKeys;
 });

_baseLt.js

@@ -1,7 +1,7 @@
 define([], function() {
 
   /**
-   * The base implementation of `_.lt` which doesn't coerce arguments to numbers.
+   * The base implementation of `_.lt` which doesn't coerce arguments.
    *
    * @private
    * @param {*} value The value to compare.

_baseMergeDeep.js

@@ -63,13 +63,12 @@ define(['./_assignMergeValue', './_baseClone', './_copyArray', './isArguments',
         isCommon = false;
       }
     }
-    stack.set(srcValue, newValue);
-
     if (isCommon) {
       // Recursively merge objects and arrays (susceptible to call stack limits).
+      stack.set(srcValue, newValue);
       mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+      stack['delete'](srcValue);
     }
-    stack['delete'](srcValue);
     assignMergeValue(object, key, newValue);
   }
 

_baseNth.js

@@ -4,7 +4,7 @@ define(['./_isIndex'], function(isIndex) {
   var undefined;
 
   /**
-   * The base implementation of `_.nth` which doesn't coerce `n` to an integer.
+   * The base implementation of `_.nth` which doesn't coerce arguments.
    *
    * @private
    * @param {Array} array The array to query.

_basePick.js

@@ -1,4 +1,4 @@
-define(['./_arrayReduce'], function(arrayReduce) {
+define(['./_basePickBy'], function(basePickBy) {
 
   /**
    * The base implementation of `_.pick` without support for individual
@@ -11,12 +11,9 @@ define(['./_arrayReduce'], function(arrayReduce) {
    */
   function basePick(object, props) {
     object = Object(object);
-    return arrayReduce(props, function(result, key) {
+    return basePickBy(object, props, function(value, key) {
-      if (key in object) {
+      return key in object;
-        result[key] = object[key];
+    });
-      }
-      return result;
-    }, {});
   }
 
   return basePick;

_basePickBy.js

@@ -1,16 +1,16 @@
-define(['./_getAllKeysIn'], function(getAllKeysIn) {
+define([], function() {
 
   /**
    * The base implementation of  `_.pickBy` without support for iteratee shorthands.
    *
    * @private
    * @param {Object} object The source object.
+   * @param {string[]} props The property identifiers to pick from.
    * @param {Function} predicate The function invoked per property.
    * @returns {Object} Returns the new object.
    */
-  function basePickBy(object, predicate) {
+  function basePickBy(object, props, predicate) {
     var index = -1,
-        props = getAllKeysIn(object),
         length = props.length,
         result = {};
 

_basePropertyOf.js

@@ -0,0 +1,20 @@
+define([], function() {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * The base implementation of `_.propertyOf` without support for deep paths.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @returns {Function} Returns the new accessor function.
+   */
+  function basePropertyOf(object) {
+    return function(key) {
+      return object == null ? undefined : object[key];
+    };
+  }
+
+  return basePropertyOf;
+});

_baseRange.js

@@ -6,7 +6,7 @@ define([], function() {
 
   /**
    * The base implementation of `_.range` and `_.rangeRight` which doesn't
-   * coerce arguments to numbers.
+   * coerce arguments.
    *
    * @private
    * @param {number} start The start of the range.

_baseRest.js

@@ -0,0 +1,39 @@
+define(['./_apply'], function(apply) {
+
+  /** 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 nativeMax = Math.max;
+
+  /**
+   * The base implementation of `_.rest` which doesn't validate or coerce arguments.
+   *
+   * @private
+   * @param {Function} func The function to apply a rest parameter to.
+   * @param {number} [start=func.length-1] The start position of the rest parameter.
+   * @returns {Function} Returns the new function.
+   */
+  function baseRest(func, start) {
+    start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
+    return function() {
+      var args = arguments,
+          index = -1,
+          length = nativeMax(args.length - start, 0),
+          array = Array(length);
+
+      while (++index < length) {
+        array[index] = args[start + index];
+      }
+      index = -1;
+      var otherArgs = Array(start + 1);
+      while (++index < start) {
+        otherArgs[index] = args[index];
+      }
+      otherArgs[start] = array;
+      return apply(func, this, otherArgs);
+    };
+  }
+
+  return baseRest;
+});

_baseUnary.js

@@ -1,7 +1,7 @@
 define([], function() {
 
   /**
-   * The base implementation of `_.unary` without support for storing wrapper metadata.
+   * The base implementation of `_.unary` without support for storing metadata.
    *
    * @private
    * @param {Function} func The function to cap arguments for.

_checkGlobal.js

@@ -1,15 +0,0 @@
-define([], function() {
-
-  /**
-   * Checks if `value` is a global object.
-   *
-   * @private
-   * @param {*} value The value to check.
-   * @returns {null|Object} Returns `value` if it's a global object, else `null`.
-   */
-  function checkGlobal(value) {
-    return (value && value.Object === Object) ? value : null;
-  }
-
-  return checkGlobal;
-});

_copyObject.js

@@ -1,5 +1,8 @@
 define(['./_assignValue'], function(assignValue) {
 
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
   /**
    * Copies properties of `source` to `object`.
    *
@@ -21,9 +24,9 @@ define(['./_assignValue'], function(assignValue) {
 
       var newValue = customizer
         ? customizer(object[key], source[key], key, object, source)
-        : source[key];
+        : undefined;
 
-      assignValue(object, key, newValue);
+      assignValue(object, key, newValue === undefined ? source[key] : newValue);
     }
     return object;
   }

_createAggregator.js

@@ -13,7 +13,7 @@ define(['./_arrayAggregator', './_baseAggregator', './_baseIteratee', './isArray
       var func = isArray(collection) ? arrayAggregator : baseAggregator,
           accumulator = initializer ? initializer() : {};
 
-      return func(collection, setter, baseIteratee(iteratee), accumulator);
+      return func(collection, setter, baseIteratee(iteratee, 2), accumulator);
     };
   }
 

_createAssigner.js

@@ -1,4 +1,4 @@
-define(['./_isIterateeCall', './rest'], function(isIterateeCall, rest) {
+define(['./_baseRest', './_isIterateeCall'], function(baseRest, isIterateeCall) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -11,7 +11,7 @@ define(['./_isIterateeCall', './rest'], function(isIterateeCall, rest) {
    * @returns {Function} Returns the new assigner function.
    */
   function createAssigner(assigner) {
-    return rest(function(object, sources) {
+    return baseRest(function(object, sources) {
       var index = -1,
           length = sources.length,
           customizer = length > 1 ? sources[length - 1] : undefined,

_createBind.js

@@ -1,6 +1,6 @@
-define(['./_createCtorWrapper', './_root'], function(createCtorWrapper, root) {
+define(['./_createCtor', './_root'], function(createCtor, root) {
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1;
 
   /**
@@ -9,14 +9,13 @@ define(['./_createCtorWrapper', './_root'], function(createCtorWrapper, root) {
    *
    * @private
    * @param {Function} func The function to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
+   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
-   *  for more details.
    * @param {*} [thisArg] The `this` binding of `func`.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createBaseWrapper(func, bitmask, thisArg) {
+  function createBind(func, bitmask, thisArg) {
     var isBind = bitmask & BIND_FLAG,
-        Ctor = createCtorWrapper(func);
+        Ctor = createCtor(func);
 
     function wrapper() {
       var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
@@ -25,5 +24,5 @@ define(['./_createCtorWrapper', './_root'], function(createCtorWrapper, root) {
     return wrapper;
   }
 
-  return createBaseWrapper;
+  return createBind;
 });

_createCtor.js

@@ -8,7 +8,7 @@ define(['./_baseCreate', './isObject'], function(baseCreate, isObject) {
    * @param {Function} Ctor The constructor to wrap.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createCtorWrapper(Ctor) {
+  function createCtor(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
@@ -33,5 +33,5 @@ define(['./_baseCreate', './isObject'], function(baseCreate, isObject) {
     };
   }
 
-  return createCtorWrapper;
+  return createCtor;
 });

_createCurry.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_createRecurryWrapper', './_getHolder', './_replaceHolders', './_root'], function(apply, createCtorWrapper, createHybridWrapper, createRecurryWrapper, getHolder, replaceHolders, root) {
+define(['./_apply', './_createCtor', './_createHybrid', './_createRecurry', './_getHolder', './_replaceHolders', './_root'], function(apply, createCtor, createHybrid, createRecurry, getHolder, replaceHolders, root) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -8,13 +8,12 @@ define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_create
    *
    * @private
    * @param {Function} func The function to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
+   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
-   *  for more details.
    * @param {number} arity The arity of `func`.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createCurryWrapper(func, bitmask, arity) {
+  function createCurry(func, bitmask, arity) {
-    var Ctor = createCtorWrapper(func);
+    var Ctor = createCtor(func);
 
     function wrapper() {
       var length = arguments.length,
@@ -31,8 +30,8 @@ define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_create
 
       length -= holders.length;
       if (length < arity) {
-        return createRecurryWrapper(
+        return createRecurry(
-          func, bitmask, createHybridWrapper, wrapper.placeholder, undefined,
+          func, bitmask, createHybrid, wrapper.placeholder, undefined,
           args, holders, undefined, undefined, arity - length);
       }
       var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
@@ -41,5 +40,5 @@ define(['./_apply', './_createCtorWrapper', './_createHybridWrapper', './_create
     return wrapper;
   }
 
-  return createCurryWrapper;
+  return createCurry;
 });

_createFind.js

@@ -0,0 +1,27 @@
+define(['./_baseIteratee', './isArrayLike', './keys'], function(baseIteratee, isArrayLike, keys) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /**
+   * Creates a `_.find` or `_.findLast` function.
+   *
+   * @private
+   * @param {Function} findIndexFunc The function to find the collection index.
+   * @returns {Function} Returns the new find function.
+   */
+  function createFind(findIndexFunc) {
+    return function(collection, predicate, fromIndex) {
+      var iterable = Object(collection);
+      if (!isArrayLike(collection)) {
+        var iteratee = baseIteratee(predicate, 3);
+        collection = keys(collection);
+        predicate = function(key) { return iteratee(iterable[key], key, iterable); };
+      }
+      var index = findIndexFunc(collection, predicate, fromIndex);
+      return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
+    };
+  }
+
+  return createFind;
+});

_createFlow.js

@@ -1,4 +1,4 @@
-define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', './isArray', './_isLaziable', './rest'], function(LodashWrapper, baseFlatten, getData, getFuncName, isArray, isLaziable, rest) {
+define(['./_LodashWrapper', './_baseFlatten', './_baseRest', './_getData', './_getFuncName', './isArray', './_isLaziable'], function(LodashWrapper, baseFlatten, baseRest, getData, getFuncName, isArray, isLaziable) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -9,7 +9,7 @@ define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', '.
   /** Used as the `TypeError` message for "Functions" methods. */
   var FUNC_ERROR_TEXT = 'Expected a function';
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var CURRY_FLAG = 8,
       PARTIAL_FLAG = 32,
       ARY_FLAG = 128,
@@ -23,7 +23,7 @@ define(['./_LodashWrapper', './_baseFlatten', './_getData', './_getFuncName', '.
    * @returns {Function} Returns the new flow function.
    */
   function createFlow(fromRight) {
-    return rest(function(funcs) {
+    return baseRest(function(funcs) {
       funcs = baseFlatten(funcs, 1);
 
       var length = funcs.length,

_createHybrid.js

@@ -1,9 +1,9 @@
-define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCtorWrapper', './_createRecurryWrapper', './_getHolder', './_reorder', './_replaceHolders', './_root'], function(composeArgs, composeArgsRight, countHolders, createCtorWrapper, createRecurryWrapper, getHolder, reorder, replaceHolders, root) {
+define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCtor', './_createRecurry', './_getHolder', './_reorder', './_replaceHolders', './_root'], function(composeArgs, composeArgsRight, countHolders, createCtor, createRecurry, getHolder, reorder, replaceHolders, root) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1,
       BIND_KEY_FLAG = 2,
       CURRY_FLAG = 8,
@@ -17,8 +17,7 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
    *
    * @private
    * @param {Function|string} func The function or method name to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
+   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
-   *  for more details.
    * @param {*} [thisArg] The `this` binding of `func`.
    * @param {Array} [partials] The arguments to prepend to those provided to
    *  the new function.
@@ -31,13 +30,13 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
    * @param {number} [arity] The arity of `func`.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createHybridWrapper(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
+  function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
     var isAry = bitmask & ARY_FLAG,
         isBind = bitmask & BIND_FLAG,
         isBindKey = bitmask & BIND_KEY_FLAG,
         isCurried = bitmask & (CURRY_FLAG | CURRY_RIGHT_FLAG),
         isFlip = bitmask & FLIP_FLAG,
-        Ctor = isBindKey ? undefined : createCtorWrapper(func);
+        Ctor = isBindKey ? undefined : createCtor(func);
 
     function wrapper() {
       var length = arguments.length,
@@ -60,8 +59,8 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
       length -= holdersCount;
       if (isCurried && length < arity) {
         var newHolders = replaceHolders(args, placeholder);
-        return createRecurryWrapper(
+        return createRecurry(
-          func, bitmask, createHybridWrapper, wrapper.placeholder, thisArg,
+          func, bitmask, createHybrid, wrapper.placeholder, thisArg,
           args, newHolders, argPos, ary, arity - length
         );
       }
@@ -78,12 +77,12 @@ define(['./_composeArgs', './_composeArgsRight', './_countHolders', './_createCt
         args.length = ary;
       }
       if (this && this !== root && this instanceof wrapper) {
-        fn = Ctor || createCtorWrapper(fn);
+        fn = Ctor || createCtor(fn);
       }
       return fn.apply(thisBinding, args);
     }
     return wrapper;
   }
 
-  return createHybridWrapper;
+  return createHybrid;
 });

_createMathOperation.js

@@ -8,13 +8,14 @@ define(['./_baseToNumber', './_baseToString'], function(baseToNumber, baseToStri
    *
    * @private
    * @param {Function} operator The function to perform the operation.
+   * @param {number} [defaultValue] The value used for `undefined` arguments.
    * @returns {Function} Returns the new mathematical operation function.
    */
-  function createMathOperation(operator) {
+  function createMathOperation(operator, defaultValue) {
     return function(value, other) {
       var result;
       if (value === undefined && other === undefined) {
-        return 0;
+        return defaultValue;
       }
       if (value !== undefined) {
         result = value;

_createOver.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './_baseUnary', './isArray', './_isFlattenableIteratee', './rest'], function(apply, arrayMap, baseFlatten, baseIteratee, baseUnary, isArray, isFlattenableIteratee, rest) {
+define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './_baseRest', './_baseUnary', './isArray'], function(apply, arrayMap, baseFlatten, baseIteratee, baseRest, baseUnary, isArray) {
 
   /**
    * Creates a function like `_.over`.
@@ -8,12 +8,12 @@ define(['./_apply', './_arrayMap', './_baseFlatten', './_baseIteratee', './_base
    * @returns {Function} Returns the new over function.
    */
   function createOver(arrayFunc) {
-    return rest(function(iteratees) {
+    return baseRest(function(iteratees) {
       iteratees = (iteratees.length == 1 && isArray(iteratees[0]))
         ? arrayMap(iteratees[0], baseUnary(baseIteratee))
-        : arrayMap(baseFlatten(iteratees, 1, isFlattenableIteratee), baseUnary(baseIteratee));
+        : arrayMap(baseFlatten(iteratees, 1), baseUnary(baseIteratee));
 
-      return rest(function(args) {
+      return baseRest(function(args) {
         var thisArg = this;
         return arrayFunc(iteratees, function(iteratee) {
           return apply(iteratee, thisArg, args);

_createPartial.js

@@ -1,6 +1,6 @@
-define(['./_apply', './_createCtorWrapper', './_root'], function(apply, createCtorWrapper, root) {
+define(['./_apply', './_createCtor', './_root'], function(apply, createCtor, root) {
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1;
 
   /**
@@ -9,16 +9,15 @@ define(['./_apply', './_createCtorWrapper', './_root'], function(apply, createCt
    *
    * @private
    * @param {Function} func The function to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
+   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
-   *  for more details.
    * @param {*} thisArg The `this` binding of `func`.
    * @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) {
+  function createPartial(func, bitmask, thisArg, partials) {
     var isBind = bitmask & BIND_FLAG,
-        Ctor = createCtorWrapper(func);
+        Ctor = createCtor(func);
 
     function wrapper() {
       var argsIndex = -1,
@@ -39,5 +38,5 @@ define(['./_apply', './_createCtorWrapper', './_root'], function(apply, createCt
     return wrapper;
   }
 
-  return createPartialWrapper;
+  return createPartial;
 });

_createRange.js

@@ -1,4 +1,4 @@
-define(['./_baseRange', './_isIterateeCall', './toNumber'], function(baseRange, isIterateeCall, toNumber) {
+define(['./_baseRange', './_isIterateeCall', './toFinite'], function(baseRange, isIterateeCall, toFinite) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -16,15 +16,14 @@ define(['./_baseRange', './_isIterateeCall', './toNumber'], function(baseRange,
         end = step = undefined;
       }
       // Ensure the sign of `-0` is preserved.
-      start = toNumber(start);
+      start = toFinite(start);
-      start = start === start ? start : 0;
       if (end === undefined) {
         end = start;
         start = 0;
       } else {
-        end = toNumber(end) || 0;
+        end = toFinite(end);
       }
-      step = step === undefined ? (start < end ? 1 : -1) : (toNumber(step) || 0);
+      step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);
       return baseRange(start, end, step, fromRight);
     };
   }

_createRecurry.js

@@ -1,9 +1,9 @@
-define(['./_isLaziable', './_setData'], function(isLaziable, setData) {
+define(['./_isLaziable', './_setData', './_setWrapToString'], function(isLaziable, setData, setWrapToString) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1,
       BIND_KEY_FLAG = 2,
       CURRY_BOUND_FLAG = 4,
@@ -16,8 +16,7 @@ define(['./_isLaziable', './_setData'], function(isLaziable, setData) {
    *
    * @private
    * @param {Function} func The function to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags. See `createWrapper`
+   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
-   *  for more details.
    * @param {Function} wrapFunc The function to create the `func` wrapper.
    * @param {*} placeholder The placeholder value.
    * @param {*} [thisArg] The `this` binding of `func`.
@@ -29,7 +28,7 @@ define(['./_isLaziable', './_setData'], function(isLaziable, setData) {
    * @param {number} [arity] The arity of `func`.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createRecurryWrapper(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
+  function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
     var isCurry = bitmask & CURRY_FLAG,
         newHolders = isCurry ? holders : undefined,
         newHoldersRight = isCurry ? undefined : holders,
@@ -52,8 +51,8 @@ define(['./_isLaziable', './_setData'], function(isLaziable, setData) {
       setData(result, newData);
     }
     result.placeholder = placeholder;
-    return result;
+    return setWrapToString(result, func, bitmask);
   }
 
-  return createRecurryWrapper;
+  return createRecurry;
 });

_createSet.js

@@ -4,7 +4,7 @@ define(['./_Set', './noop', './_setToArray'], function(Set, noop, setToArray) {
   var INFINITY = 1 / 0;
 
   /**
-   * Creates a set of `values`.
+   * Creates a set object of `values`.
    *
    * @private
    * @param {Array} values The values to add to the set.

_createWrap.js

@@ -1,4 +1,4 @@
-define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_createHybridWrapper', './_createPartialWrapper', './_getData', './_mergeData', './_setData', './toInteger'], function(baseSetData, createBaseWrapper, createCurryWrapper, createHybridWrapper, createPartialWrapper, getData, mergeData, setData, toInteger) {
+define(['./_baseSetData', './_createBind', './_createCurry', './_createHybrid', './_createPartial', './_getData', './_mergeData', './_setData', './_setWrapToString', './toInteger'], function(baseSetData, createBind, createCurry, createHybrid, createPartial, getData, mergeData, setData, setWrapToString, toInteger) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -6,7 +6,7 @@ define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_c
   /** Used as the `TypeError` message for "Functions" methods. */
   var FUNC_ERROR_TEXT = 'Expected a function';
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1,
       BIND_KEY_FLAG = 2,
       CURRY_FLAG = 8,
@@ -23,7 +23,7 @@ define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_c
    *
    * @private
    * @param {Function|string} func The function or method name to wrap.
-   * @param {number} bitmask The bitmask of wrapper flags.
+   * @param {number} bitmask The bitmask flags.
    *  The bitmask may be composed of the following flags:
    *     1 - `_.bind`
    *     2 - `_.bindKey`
@@ -43,7 +43,7 @@ define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_c
    * @param {number} [arity] The arity of `func`.
    * @returns {Function} Returns the new wrapped function.
    */
-  function createWrapper(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
+  function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
     var isBindKey = bitmask & BIND_KEY_FLAG;
     if (!isBindKey && typeof func != 'function') {
       throw new TypeError(FUNC_ERROR_TEXT);
@@ -86,17 +86,17 @@ define(['./_baseSetData', './_createBaseWrapper', './_createCurryWrapper', './_c
       bitmask &= ~(CURRY_FLAG | CURRY_RIGHT_FLAG);
     }
     if (!bitmask || bitmask == BIND_FLAG) {
-      var result = createBaseWrapper(func, bitmask, thisArg);
+      var result = createBind(func, bitmask, thisArg);
     } else if (bitmask == CURRY_FLAG || bitmask == CURRY_RIGHT_FLAG) {
-      result = createCurryWrapper(func, bitmask, arity);
+      result = createCurry(func, bitmask, arity);
     } else if ((bitmask == PARTIAL_FLAG || bitmask == (BIND_FLAG | PARTIAL_FLAG)) && !holders.length) {
-      result = createPartialWrapper(func, bitmask, thisArg, partials);
+      result = createPartial(func, bitmask, thisArg, partials);
     } else {
-      result = createHybridWrapper.apply(undefined, newData);
+      result = createHybrid.apply(undefined, newData);
     }
     var setter = data ? baseSetData : setData;
-    return setter(result, newData);
+    return setWrapToString(setter(result, newData), func, bitmask);
   }
 
-  return createWrapper;
+  return createWrap;
 });

_deburrLetter.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_basePropertyOf'], function(basePropertyOf) {
 
   /** Used to map latin-1 supplementary letters to basic latin letters. */
   var deburredLetters = {
@@ -28,9 +28,7 @@ define([], function() {
    * @param {string} letter The matched letter to deburr.
    * @returns {string} Returns the deburred letter.
    */
-  function deburrLetter(letter) {
+  var deburrLetter = basePropertyOf(deburredLetters);
-    return deburredLetters[letter];
-  }
 
   return deburrLetter;
 });

_defineProperty.js

@@ -0,0 +1,15 @@
+define(['./_getNative'], function(getNative) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /* Used to set `toString` methods. */
+  var defineProperty = (function() {
+    var func = getNative(Object, 'defineProperty'),
+        name = getNative.name;
+
+    return (name && name.length > 2) ? func : undefined;
+  }());
+
+  return defineProperty;
+});

_equalArrays.js

@@ -31,7 +31,7 @@ define(['./_SetCache', './_arraySome'], function(SetCache, arraySome) {
     }
     // Assume cyclic values are equal.
     var stacked = stack.get(array);
-    if (stacked) {
+    if (stacked && stack.get(other)) {
       return stacked == other;
     }
     var index = -1,
@@ -39,6 +39,7 @@ define(['./_SetCache', './_arraySome'], function(SetCache, arraySome) {
         seen = (bitmask & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined;
 
     stack.set(array, other);
+    stack.set(other, array);
 
     // Ignore non-index properties.
     while (++index < arrLength) {
@@ -77,6 +78,7 @@ define(['./_SetCache', './_arraySome'], function(SetCache, arraySome) {
       }
     }
     stack['delete'](array);
+    stack['delete'](other);
     return result;
   }
 

_equalByTag.js

@@ -1,4 +1,4 @@
-define(['./_Symbol', './_Uint8Array', './_equalArrays', './_mapToArray', './_setToArray'], function(Symbol, Uint8Array, equalArrays, mapToArray, setToArray) {
+define(['./_Symbol', './_Uint8Array', './eq', './_equalArrays', './_mapToArray', './_setToArray'], function(Symbol, Uint8Array, eq, equalArrays, mapToArray, setToArray) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -62,18 +62,14 @@ define(['./_Symbol', './_Uint8Array', './_equalArrays', './_mapToArray', './_set
 
       case boolTag:
       case dateTag:
-        // Coerce dates and booleans to numbers, dates to milliseconds and
+      case numberTag:
-        // booleans to `1` or `0` treating invalid dates coerced to `NaN` as
+        // Coerce booleans to `1` or `0` and dates to milliseconds.
-        // not equal.
+        // Invalid dates are coerced to `NaN`.
-        return +object == +other;
+        return eq(+object, +other);
 
       case errorTag:
         return object.name == other.name && object.message == other.message;
 
-      case numberTag:
-        // Treat `NaN` vs. `NaN` as equal.
-        return (object != +object) ? other != +other : object == +other;
-
       case regexpTag:
       case stringTag:
         // Coerce regexes to strings and treat strings, primitives and objects,
@@ -97,10 +93,12 @@ define(['./_Symbol', './_Uint8Array', './_equalArrays', './_mapToArray', './_set
           return stacked == other;
         }
         bitmask |= UNORDERED_COMPARE_FLAG;
-        stack.set(object, other);
 
         // Recursively compare objects (susceptible to call stack limits).
-        return equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
+        stack.set(object, other);
+        var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
+        stack['delete'](object);
+        return result;
 
       case symbolTag:
         if (symbolValueOf) {

_equalObjects.js

@@ -39,11 +39,12 @@ define(['./_baseHas', './keys'], function(baseHas, keys) {
     }
     // Assume cyclic values are equal.
     var stacked = stack.get(object);
-    if (stacked) {
+    if (stacked && stack.get(other)) {
       return stacked == other;
     }
     var result = true;
     stack.set(object, other);
+    stack.set(other, object);
 
     var skipCtor = isPartial;
     while (++index < objLength) {
@@ -79,6 +80,7 @@ define(['./_baseHas', './keys'], function(baseHas, keys) {
       }
     }
     stack['delete'](object);
+    stack['delete'](other);
     return result;
   }
 

_escapeHtmlChar.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_basePropertyOf'], function(basePropertyOf) {
 
   /** Used to map characters to HTML entities. */
   var htmlEscapes = {
@@ -17,9 +17,7 @@ define([], function() {
    * @param {string} chr The matched character to escape.
    * @returns {string} Returns the escaped character.
    */
-  function escapeHtmlChar(chr) {
+  var escapeHtmlChar = basePropertyOf(htmlEscapes);
-    return htmlEscapes[chr];
-  }
 
   return escapeHtmlChar;
 });

_freeGlobal.js

@@ -0,0 +1,7 @@
+define([], function() {
+
+  /** Detect free variable `global` from Node.js. */
+  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+  return freeGlobal;
+});

_getPrototype.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_overArg'], function(overArg) {
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeGetPrototype = Object.getPrototypeOf;
@@ -10,9 +10,7 @@ define([], function() {
    * @param {*} value The value to query.
    * @returns {null|Object} Returns the `[[Prototype]]`.
    */
-  function getPrototype(value) {
+  var getPrototype = overArg(nativeGetPrototype, Object);
-    return nativeGetPrototype(Object(value));
-  }
 
   return getPrototype;
 });

_getSymbols.js

@@ -1,7 +1,7 @@
-define(['./stubArray'], function(stubArray) {
+define(['./_overArg', './stubArray'], function(overArg, stubArray) {
 
-  /** Built-in value references. */
+  /* Built-in method references for those with the same name as other `lodash` methods. */
-  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  var nativeGetSymbols = Object.getOwnPropertySymbols;
 
   /**
    * Creates an array of the own enumerable symbol properties of `object`.
@@ -10,16 +10,7 @@ define(['./stubArray'], function(stubArray) {
    * @param {Object} object The object to query.
    * @returns {Array} Returns the array of symbols.
    */
-  function getSymbols(object) {
+  var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;
-    // Coerce `object` to an object to avoid non-object errors in V8.
-    // See https://bugs.chromium.org/p/v8/issues/detail?id=3443 for more details.
-    return getOwnPropertySymbols(Object(object));
-  }
-
-  // Fallback for IE < 11.
-  if (!getOwnPropertySymbols) {
-    getSymbols = stubArray;
-  }
 
   return getSymbols;
 });

_getSymbolsIn.js

@@ -1,7 +1,7 @@
-define(['./_arrayPush', './_getPrototype', './_getSymbols'], function(arrayPush, getPrototype, getSymbols) {
+define(['./_arrayPush', './_getPrototype', './_getSymbols', './stubArray'], function(arrayPush, getPrototype, getSymbols, stubArray) {
 
-  /** Built-in value references. */
+  /* Built-in method references for those with the same name as other `lodash` methods. */
-  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  var nativeGetSymbols = Object.getOwnPropertySymbols;
 
   /**
    * Creates an array of the own and inherited enumerable symbol properties
@@ -11,7 +11,7 @@ define(['./_arrayPush', './_getPrototype', './_getSymbols'], function(arrayPush,
    * @param {Object} object The object to query.
    * @returns {Array} Returns the array of symbols.
    */
-  var getSymbolsIn = !getOwnPropertySymbols ? getSymbols : function(object) {
+  var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
     var result = [];
     while (object) {
       arrayPush(result, getSymbols(object));

_getTag.js

@@ -1,4 +1,4 @@
-define(['./_DataView', './_Map', './_Promise', './_Set', './_WeakMap', './_toSource'], function(DataView, Map, Promise, Set, WeakMap, toSource) {
+define(['./_DataView', './_Map', './_Promise', './_Set', './_WeakMap', './_baseGetTag', './_toSource'], function(DataView, Map, Promise, Set, WeakMap, baseGetTag, toSource) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -36,9 +36,7 @@ define(['./_DataView', './_Map', './_Promise', './_Set', './_WeakMap', './_toSou
    * @param {*} value The value to query.
    * @returns {string} Returns the `toStringTag`.
    */
-  function getTag(value) {
+  var getTag = baseGetTag;
-    return objectToString.call(value);
-  }
 
   // Fallback for data views, maps, sets, and weak maps in IE 11,
   // for data views in Edge, and promises in Node.js.

_getWrapDetails.js

@@ -0,0 +1,20 @@
+define([], function() {
+
+  /** Used to match wrap detail comments. */
+  var reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
+      reSplitDetails = /,? & /;
+
+  /**
+   * Extracts wrapper details from the `source` body comment.
+   *
+   * @private
+   * @param {string} source The source to inspect.
+   * @returns {Array} Returns the wrapper details.
+   */
+  function getWrapDetails(source) {
+    var match = source.match(reWrapDetails);
+    return match ? match[1].split(reSplitDetails) : [];
+  }
+
+  return getWrapDetails;
+});

_indexOfNaN.js

@@ -1,26 +0,0 @@
-define([], function() {
-
-  /**
-   * Gets the index at which the first occurrence of `NaN` is found in `array`.
-   *
-   * @private
-   * @param {Array} array The array to search.
-   * @param {number} fromIndex The index to search from.
-   * @param {boolean} [fromRight] Specify iterating from right to left.
-   * @returns {number} Returns the index of the matched `NaN`, else `-1`.
-   */
-  function indexOfNaN(array, fromIndex, fromRight) {
-    var length = array.length,
-        index = fromIndex + (fromRight ? 1 : -1);
-
-    while ((fromRight ? index-- : ++index < length)) {
-      var other = array[index];
-      if (other !== other) {
-        return index;
-      }
-    }
-    return -1;
-  }
-
-  return indexOfNaN;
-});

_insertWrapDetails.js

@@ -0,0 +1,24 @@
+define([], function() {
+
+  /** Used to match wrap detail comments. */
+  var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/;
+
+  /**
+   * Inserts wrapper `details` in a comment at the top of the `source` body.
+   *
+   * @private
+   * @param {string} source The source to modify.
+   * @returns {Array} details The details to insert.
+   * @returns {string} Returns the modified source.
+   */
+  function insertWrapDetails(source, details) {
+    var length = details.length,
+        lastIndex = length - 1;
+
+    details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
+    details = details.join(length > 2 ? ', ' : ' ');
+    return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');
+  }
+
+  return insertWrapDetails;
+});

_isFlattenable.js

@@ -1,4 +1,10 @@
-define(['./isArguments', './isArray'], function(isArguments, isArray) {
+define(['./_Symbol', './isArguments', './isArray'], function(Symbol, isArguments, isArray) {
+
+  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+  var undefined;
+
+  /** Built-in value references. */
+  var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;
 
   /**
    * Checks if `value` is a flattenable `arguments` object or array.
@@ -8,7 +14,8 @@ define(['./isArguments', './isArray'], function(isArguments, isArray) {
    * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
    */
   function isFlattenable(value) {
-    return isArray(value) || isArguments(value);
+    return isArray(value) || isArguments(value) ||
+      !!(spreadableSymbol && value && value[spreadableSymbol]);
   }
 
   return isFlattenable;

_isFlattenableIteratee.js

@@ -1,16 +0,0 @@
-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;
-});

_isMaskable.js

@@ -7,7 +7,7 @@ define(['./_coreJsData', './isFunction', './stubFalse'], function(coreJsData, is
    * @param {*} value The value to check.
    * @returns {boolean} Returns `true` if `func` is maskable, else `false`.
    */
-  var isMaskable = !coreJsData ? stubFalse : isFunction;
+  var isMaskable = coreJsData ? isFunction : stubFalse;
 
   return isMaskable;
 });

_mergeData.js

@@ -3,7 +3,7 @@ define(['./_composeArgs', './_composeArgsRight', './_replaceHolders'], function(
   /** Used as the internal argument placeholder. */
   var PLACEHOLDER = '__lodash_placeholder__';
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1,
       BIND_KEY_FLAG = 2,
       CURRY_BOUND_FLAG = 4,

_mergeDefaults.js

@@ -18,7 +18,10 @@ define(['./_baseMerge', './isObject'], function(baseMerge, isObject) {
    */
   function mergeDefaults(objValue, srcValue, key, object, source, stack) {
     if (isObject(objValue) && isObject(srcValue)) {
-      baseMerge(objValue, srcValue, undefined, mergeDefaults, stack.set(srcValue, objValue));
+      // Recursively merge objects and arrays (susceptible to call stack limits).
+      stack.set(srcValue, objValue);
+      baseMerge(objValue, srcValue, undefined, mergeDefaults, stack);
+      stack['delete'](srcValue);
     }
     return objValue;
   }

_nodeUtil.js

@@ -0,0 +1,23 @@
+define(['./_freeGlobal'], function(freeGlobal) {
+
+  /** Detect free variable `exports`. */
+  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+  /** Detect free variable `module`. */
+  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+  /** Detect the popular CommonJS extension `module.exports`. */
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+
+  /** Detect free variable `process` from Node.js. */
+  var freeProcess = moduleExports && freeGlobal.process;
+
+  /** Used to access faster Node.js helpers. */
+  var nodeUtil = (function() {
+    try {
+      return freeProcess && freeProcess.binding('util');
+    } catch (e) {}
+  }());
+
+  return nodeUtil;
+});

_overArg.js

@@ -0,0 +1,18 @@
+define([], function() {
+
+  /**
+   * Creates a function that invokes `func` with its first argument transformed.
+   *
+   * @private
+   * @param {Function} func The function to wrap.
+   * @param {Function} transform The argument transform.
+   * @returns {Function} Returns the new function.
+   */
+  function overArg(func, transform) {
+    return function(arg) {
+      return func(transform(arg));
+    };
+  }
+
+  return overArg;
+});

_root.js

@@ -1,16 +1,10 @@
-define(['./_checkGlobal'], function(checkGlobal) {
+define(['./_freeGlobal'], function(freeGlobal) {
-
-  /** Detect free variable `global` from Node.js. */
-  var freeGlobal = checkGlobal(typeof global == 'object' && global);
 
   /** Detect free variable `self`. */
-  var freeSelf = checkGlobal(typeof self == 'object' && self);
+  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
-
-  /** Detect `this` as the global object. */
-  var thisGlobal = checkGlobal(typeof this == 'object' && this);
 
   /** Used as a reference to the global object. */
-  var root = freeGlobal || freeSelf || thisGlobal || Function('return this')();
+  var root = freeGlobal || freeSelf || Function('return this')();
 
   return root;
 });

_setWrapToString.js

@@ -0,0 +1,23 @@
+define(['./constant', './_defineProperty', './_getWrapDetails', './identity', './_insertWrapDetails', './_updateWrapDetails'], function(constant, defineProperty, getWrapDetails, identity, insertWrapDetails, updateWrapDetails) {
+
+  /**
+   * Sets the `toString` method of `wrapper` to mimic the source of `reference`
+   * with wrapper details in a comment at the top of the source body.
+   *
+   * @private
+   * @param {Function} wrapper The function to modify.
+   * @param {Function} reference The reference function.
+   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
+   * @returns {Function} Returns `wrapper`.
+   */
+  var setWrapToString = !defineProperty ? identity : function(wrapper, reference, bitmask) {
+    var source = (reference + '');
+    return defineProperty(wrapper, 'toString', {
+      'configurable': true,
+      'enumerable': false,
+      'value': constant(insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)))
+    });
+  };
+
+  return setWrapToString;
+});

_stackSet.js

@@ -1,4 +1,4 @@
-define(['./_ListCache', './_MapCache'], function(ListCache, MapCache) {
+define(['./_ListCache', './_Map', './_MapCache'], function(ListCache, Map, MapCache) {
 
   /** Used as the size to enable large array optimizations. */
   var LARGE_ARRAY_SIZE = 200;
@@ -15,8 +15,13 @@ define(['./_ListCache', './_MapCache'], function(ListCache, MapCache) {
    */
   function stackSet(key, value) {
     var cache = this.__data__;
-    if (cache instanceof ListCache && cache.__data__.length == LARGE_ARRAY_SIZE) {
+    if (cache instanceof ListCache) {
-      cache = this.__data__ = new MapCache(cache.__data__);
+      var pairs = cache.__data__;
+      if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+        pairs.push([key, value]);
+        return this;
+      }
+      cache = this.__data__ = new MapCache(pairs);
     }
     cache.set(key, value);
     return this;

_stringToPath.js

@@ -1,7 +1,8 @@
 define(['./memoize', './toString'], function(memoize, toString) {
 
   /** Used to match property names within property paths. */
-  var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(\.|\[\])(?:\4|$))/g;
+  var reLeadingDot = /^\./,
+      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
 
   /** Used to match backslashes in property paths. */
   var reEscapeChar = /\\(\\)?/g;
@@ -14,8 +15,13 @@ define(['./memoize', './toString'], function(memoize, toString) {
    * @returns {Array} Returns the property path array.
    */
   var stringToPath = memoize(function(string) {
+    string = toString(string);
+
     var result = [];
-    toString(string).replace(rePropName, function(match, number, quote, string) {
+    if (reLeadingDot.test(string)) {
+      result.push('');
+    }
+    string.replace(rePropName, function(match, number, quote, string) {
       result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
     });
     return result;

_unescapeHtmlChar.js

@@ -1,4 +1,4 @@
-define([], function() {
+define(['./_basePropertyOf'], function(basePropertyOf) {
 
   /** Used to map HTML entities to characters. */
   var htmlUnescapes = {
@@ -17,9 +17,7 @@ define([], function() {
    * @param {string} chr The matched character to unescape.
    * @returns {string} Returns the unescaped character.
    */
-  function unescapeHtmlChar(chr) {
+  var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
-    return htmlUnescapes[chr];
-  }
 
   return unescapeHtmlChar;
 });

_updateWrapDetails.js

@@ -0,0 +1,46 @@
+define(['./_arrayEach', './_arrayIncludes'], function(arrayEach, arrayIncludes) {
+
+  /** Used to compose bitmasks for function metadata. */
+  var BIND_FLAG = 1,
+      BIND_KEY_FLAG = 2,
+      CURRY_FLAG = 8,
+      CURRY_RIGHT_FLAG = 16,
+      PARTIAL_FLAG = 32,
+      PARTIAL_RIGHT_FLAG = 64,
+      ARY_FLAG = 128,
+      REARG_FLAG = 256,
+      FLIP_FLAG = 512;
+
+  /** Used to associate wrap methods with their bit flags. */
+  var wrapFlags = [
+    ['ary', ARY_FLAG],
+    ['bind', BIND_FLAG],
+    ['bindKey', BIND_KEY_FLAG],
+    ['curry', CURRY_FLAG],
+    ['curryRight', CURRY_RIGHT_FLAG],
+    ['flip', FLIP_FLAG],
+    ['partial', PARTIAL_FLAG],
+    ['partialRight', PARTIAL_RIGHT_FLAG],
+    ['rearg', REARG_FLAG]
+  ];
+
+  /**
+   * Updates wrapper `details` based on `bitmask` flags.
+   *
+   * @private
+   * @returns {Array} details The details to modify.
+   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
+   * @returns {Array} Returns `details`.
+   */
+  function updateWrapDetails(details, bitmask) {
+    arrayEach(wrapFlags, function(pair) {
+      var value = '_.' + pair[0];
+      if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
+        details.push(value);
+      }
+    });
+    return details.sort();
+  }
+
+  return updateWrapDetails;
+});

add.js

@@ -17,7 +17,7 @@ define(['./_createMathOperation'], function(createMathOperation) {
    */
   var add = createMathOperation(function(augend, addend) {
     return augend + addend;
-  });
+  }, 0);
 
   return add;
 });

ary.js

@@ -1,9 +1,9 @@
-define(['./_createWrapper'], function(createWrapper) {
+define(['./_createWrap'], function(createWrap) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var ARY_FLAG = 128;
 
   /**
@@ -26,7 +26,7 @@ define(['./_createWrapper'], function(createWrapper) {
   function ary(func, n, guard) {
     n = guard ? undefined : n;
     n = (func && n == null) ? func.length : n;
-    return createWrapper(func, ARY_FLAG, undefined, undefined, undefined, undefined, n);
+    return createWrap(func, ARY_FLAG, undefined, undefined, undefined, undefined, n);
   }
 
   return ary;

assign.js

@@ -31,18 +31,18 @@ define(['./_assignValue', './_copyObject', './_createAssigner', './isArrayLike',
    * @example
    *
    * function Foo() {
-   *   this.c = 3;
+   *   this.a = 1;
    * }
    *
    * function Bar() {
-   *   this.e = 5;
+   *   this.c = 3;
    * }
    *
-   * Foo.prototype.d = 4;
+   * Foo.prototype.b = 2;
-   * Bar.prototype.f = 6;
+   * Bar.prototype.d = 4;
    *
-   * _.assign({ 'a': 1 }, new Foo, new Bar);
+   * _.assign({ 'a': 0 }, new Foo, new Bar);
-   * // => { 'a': 1, 'c': 3, 'e': 5 }
+   * // => { 'a': 1, 'c': 3 }
    */
   var assign = createAssigner(function(object, source) {
     if (nonEnumShadows || isPrototype(source) || isArrayLike(source)) {

assignIn.js

@@ -27,18 +27,18 @@ define(['./_assignValue', './_copyObject', './_createAssigner', './isArrayLike',
    * @example
    *
    * function Foo() {
-   *   this.b = 2;
+   *   this.a = 1;
    * }
    *
    * function Bar() {
-   *   this.d = 4;
+   *   this.c = 3;
    * }
    *
-   * Foo.prototype.c = 3;
+   * Foo.prototype.b = 2;
-   * Bar.prototype.e = 5;
+   * Bar.prototype.d = 4;
    *
-   * _.assignIn({ 'a': 1 }, new Foo, new Bar);
+   * _.assignIn({ 'a': 0 }, new Foo, new Bar);
-   * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5 }
+   * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
    */
   var assignIn = createAssigner(function(object, source) {
     if (nonEnumShadows || isPrototype(source) || isArrayLike(source)) {

at.js

@@ -1,4 +1,4 @@
-define(['./_baseAt', './_baseFlatten', './rest'], function(baseAt, baseFlatten, rest) {
+define(['./_baseAt', './_baseFlatten', './_baseRest'], function(baseAt, baseFlatten, baseRest) {
 
   /**
    * Creates an array of values corresponding to `paths` of `object`.
@@ -17,7 +17,7 @@ define(['./_baseAt', './_baseFlatten', './rest'], function(baseAt, baseFlatten,
    * _.at(object, ['a[0].b.c', 'a[1]']);
    * // => [3, 4]
    */
-  var at = rest(function(object, paths) {
+  var at = baseRest(function(object, paths) {
     return baseAt(object, baseFlatten(paths, 1));
   });
 

attempt.js

@@ -1,4 +1,4 @@
-define(['./_apply', './isError', './rest'], function(apply, isError, rest) {
+define(['./_apply', './_baseRest', './isError'], function(apply, baseRest, isError) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -25,7 +25,7 @@ define(['./_apply', './isError', './rest'], function(apply, isError, rest) {
    *   elements = [];
    * }
    */
-  var attempt = rest(function(func, args) {
+  var attempt = baseRest(function(func, args) {
     try {
       return apply(func, undefined, args);
     } catch (e) {

before.js

@@ -21,7 +21,7 @@ define(['./toInteger'], function(toInteger) {
    * @example
    *
    * jQuery(element).on('click', _.before(5, addContactToList));
-   * // => allows adding up to 4 contacts to the list
+   * // => Allows adding up to 4 contacts to the list.
    */
   function before(n, func) {
     var result;

bind.js

@@ -1,6 +1,6 @@
-define(['./_createWrapper', './_getHolder', './_replaceHolders', './rest'], function(createWrapper, getHolder, replaceHolders, rest) {
+define(['./_baseRest', './_createWrap', './_getHolder', './_replaceHolders'], function(baseRest, createWrap, getHolder, replaceHolders) {
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1,
       PARTIAL_FLAG = 32;
 
@@ -24,9 +24,9 @@ define(['./_createWrapper', './_getHolder', './_replaceHolders', './rest'], func
    * @returns {Function} Returns the new bound function.
    * @example
    *
-   * var greet = function(greeting, punctuation) {
+   * function greet(greeting, punctuation) {
    *   return greeting + ' ' + this.user + punctuation;
-   * };
+   * }
    *
    * var object = { 'user': 'fred' };
    *
@@ -39,13 +39,13 @@ define(['./_createWrapper', './_getHolder', './_replaceHolders', './rest'], func
    * bound('hi');
    * // => 'hi fred!'
    */
-  var bind = rest(function(func, thisArg, partials) {
+  var bind = baseRest(function(func, thisArg, partials) {
     var bitmask = BIND_FLAG;
     if (partials.length) {
       var holders = replaceHolders(partials, getHolder(bind));
       bitmask |= PARTIAL_FLAG;
     }
-    return createWrapper(func, bitmask, thisArg, partials, holders);
+    return createWrap(func, bitmask, thisArg, partials, holders);
   });
 
   // Assign default placeholders.

bindAll.js

@@ -1,4 +1,4 @@
-define(['./_arrayEach', './_baseFlatten', './bind', './rest', './_toKey'], function(arrayEach, baseFlatten, bind, rest, toKey) {
+define(['./_arrayEach', './_baseFlatten', './_baseRest', './bind', './_toKey'], function(arrayEach, baseFlatten, baseRest, bind, toKey) {
 
   /**
    * Binds methods of an object to the object itself, overwriting the existing
@@ -17,16 +17,16 @@ define(['./_arrayEach', './_baseFlatten', './bind', './rest', './_toKey'], funct
    *
    * var view = {
    *   'label': 'docs',
-   *   'onClick': function() {
+   *   'click': function() {
    *     console.log('clicked ' + this.label);
    *   }
    * };
    *
-   * _.bindAll(view, ['onClick']);
+   * _.bindAll(view, ['click']);
-   * jQuery(element).on('click', view.onClick);
+   * jQuery(element).on('click', view.click);
    * // => Logs 'clicked docs' when clicked.
    */
-  var bindAll = rest(function(object, methodNames) {
+  var bindAll = baseRest(function(object, methodNames) {
     arrayEach(baseFlatten(methodNames, 1), function(key) {
       key = toKey(key);
       object[key] = bind(object[key], object);

bindKey.js

@@ -1,6 +1,6 @@
-define(['./_createWrapper', './_getHolder', './_replaceHolders', './rest'], function(createWrapper, getHolder, replaceHolders, rest) {
+define(['./_baseRest', './_createWrap', './_getHolder', './_replaceHolders'], function(baseRest, createWrap, getHolder, replaceHolders) {
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var BIND_FLAG = 1,
       BIND_KEY_FLAG = 2,
       PARTIAL_FLAG = 32;
@@ -50,13 +50,13 @@ define(['./_createWrapper', './_getHolder', './_replaceHolders', './rest'], func
    * bound('hi');
    * // => 'hiya fred!'
    */
-  var bindKey = rest(function(object, key, partials) {
+  var bindKey = baseRest(function(object, key, partials) {
     var bitmask = BIND_FLAG | BIND_KEY_FLAG;
     if (partials.length) {
       var holders = replaceHolders(partials, getHolder(bindKey));
       bitmask |= PARTIAL_FLAG;
     }
-    return createWrapper(key, bitmask, object, partials, holders);
+    return createWrap(key, bitmask, object, partials, holders);
   });
 
   // Assign default placeholders.

collection.js

@@ -1,6 +1,5 @@
-define(['./at', './countBy', './each', './eachRight', './every', './filter', './find', './findLast', './flatMap', './flatMapDeep', './flatMapDepth', './forEach', './forEachRight', './groupBy', './includes', './invokeMap', './keyBy', './map', './orderBy', './partition', './reduce', './reduceRight', './reject', './sample', './sampleSize', './shuffle', './size', './some', './sortBy'], function(at, countBy, each, eachRight, every, filter, find, findLast, flatMap, flatMapDeep, flatMapDepth, forEach, forEachRight, groupBy, includes, invokeMap, keyBy, map, orderBy, partition, reduce, reduceRight, reject, sample, sampleSize, shuffle, size, some, sortBy) {
+define(['./countBy', './each', './eachRight', './every', './filter', './find', './findLast', './flatMap', './flatMapDeep', './flatMapDepth', './forEach', './forEachRight', './groupBy', './includes', './invokeMap', './keyBy', './map', './orderBy', './partition', './reduce', './reduceRight', './reject', './sample', './sampleSize', './shuffle', './size', './some', './sortBy'], function(countBy, each, eachRight, every, filter, find, findLast, flatMap, flatMapDeep, flatMapDepth, forEach, forEachRight, groupBy, includes, invokeMap, keyBy, map, orderBy, partition, reduce, reduceRight, reject, sample, sampleSize, shuffle, size, some, sortBy) {
   return {
-    'at': at,
     'countBy': countBy,
     'each': each,
     'eachRight': eachRight,

cond.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_arrayMap', './_baseIteratee', './rest'], function(apply, arrayMap, baseIteratee, rest) {
+define(['./_apply', './_arrayMap', './_baseIteratee', './_baseRest'], function(apply, arrayMap, baseIteratee, baseRest) {
 
   /** Used as the `TypeError` message for "Functions" methods. */
   var FUNC_ERROR_TEXT = 'Expected a function';
@@ -20,7 +20,7 @@ define(['./_apply', './_arrayMap', './_baseIteratee', './rest'], function(apply,
    * var func = _.cond([
    *   [_.matches({ 'a': 1 }),           _.constant('matches A')],
    *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],
-   *   [_.constant(true),                _.constant('no match')]
+   *   [_.stubTrue,                      _.constant('no match')]
    * ]);
    *
    * func({ 'a': 1, 'b': 2 });
@@ -43,7 +43,7 @@ define(['./_apply', './_arrayMap', './_baseIteratee', './rest'], function(apply,
       return [toIteratee(pair[0]), pair[1]];
     });
 
-    return rest(function(args) {
+    return baseRest(function(args) {
       var index = -1;
       while (++index < length) {
         var pair = pairs[index];

conforms.js

@@ -5,6 +5,9 @@ define(['./_baseClone', './_baseConforms'], function(baseClone, baseConforms) {
    * the corresponding property values of a given object, returning `true` if
    * all predicates return truthy, else `false`.
    *
+   * **Note:** The created function is equivalent to `_.conformsTo` with
+   * `source` partially applied.
+   *
    * @static
    * @memberOf _
    * @since 4.0.0
@@ -13,13 +16,13 @@ define(['./_baseClone', './_baseConforms'], function(baseClone, baseConforms) {
    * @returns {Function} Returns the new spec function.
    * @example
    *
-   * var users = [
+   * var objects = [
-   *   { 'user': 'barney', 'age': 36 },
+   *   { 'a': 2, 'b': 1 },
-   *   { 'user': 'fred',   'age': 40 }
+   *   { 'a': 1, 'b': 2 }
    * ];
    *
-   * _.filter(users, _.conforms({ 'age': function(n) { return n > 38; } }));
+   * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));
-   * // => [{ 'user': 'fred', 'age': 40 }]
+   * // => [{ 'a': 1, 'b': 2 }]
    */
   function conforms(source) {
     return baseConforms(baseClone(source, true));

conformsTo.js

@@ -0,0 +1,32 @@
+define(['./_baseConformsTo', './keys'], function(baseConformsTo, keys) {
+
+  /**
+   * Checks if `object` conforms to `source` by invoking the predicate
+   * properties of `source` with the corresponding property values of `object`.
+   *
+   * **Note:** This method is equivalent to `_.conforms` when `source` is
+   * partially applied.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.14.0
+   * @category Lang
+   * @param {Object} object The object to inspect.
+   * @param {Object} source The object of property predicates to conform to.
+   * @returns {boolean} Returns `true` if `object` conforms, else `false`.
+   * @example
+   *
+   * var object = { 'a': 1, 'b': 2 };
+   *
+   * _.conformsTo(object, { 'b': function(n) { return n > 1; } });
+   * // => true
+   *
+   * _.conformsTo(object, { 'b': function(n) { return n > 2; } });
+   * // => false
+   */
+  function conformsTo(object, source) {
+    return source == null || baseConformsTo(object, source, keys(source));
+  }
+
+  return conformsTo;
+});

countBy.js

@@ -17,7 +17,7 @@ define(['./_createAggregator'], function(createAggregator) {
    * @since 0.5.0
    * @category Collection
    * @param {Array|Object} collection The collection to iterate over.
-   * @param {Array|Function|Object|string} [iteratee=_.identity]
+   * @param {Function} [iteratee=_.identity]
    *  The iteratee to transform keys.
    * @returns {Object} Returns the composed aggregate object.
    * @example

curry.js

@@ -1,9 +1,9 @@
-define(['./_createWrapper'], function(createWrapper) {
+define(['./_createWrap'], function(createWrap) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var CURRY_FLAG = 8;
 
   /**
@@ -49,7 +49,7 @@ define(['./_createWrapper'], function(createWrapper) {
    */
   function curry(func, arity, guard) {
     arity = guard ? undefined : arity;
-    var result = createWrapper(func, CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
+    var result = createWrap(func, CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
     result.placeholder = curry.placeholder;
     return result;
   }

curryRight.js

@@ -1,9 +1,9 @@
-define(['./_createWrapper'], function(createWrapper) {
+define(['./_createWrap'], function(createWrap) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
 
-  /** Used to compose bitmasks for wrapper metadata. */
+  /** Used to compose bitmasks for function metadata. */
   var CURRY_RIGHT_FLAG = 16;
 
   /**
@@ -46,7 +46,7 @@ define(['./_createWrapper'], function(createWrapper) {
    */
   function curryRight(func, arity, guard) {
     arity = guard ? undefined : arity;
-    var result = createWrapper(func, CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
+    var result = createWrap(func, CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
     result.placeholder = curryRight.placeholder;
     return result;
   }

debounce.js

@@ -15,14 +15,18 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
    * milliseconds have elapsed since the last time the debounced function was
    * invoked. The debounced function comes with a `cancel` method to cancel
    * delayed `func` invocations and a `flush` method to immediately invoke them.
-   * Provide an options object to indicate whether `func` should be invoked on
+   * Provide `options` to indicate whether `func` should be invoked on the
-   * the leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+   * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
-   * with the last arguments provided to the debounced function. Subsequent calls
+   * with the last arguments provided to the debounced function. Subsequent
-   * to the debounced function return the result of the last `func` invocation.
+   * calls to the debounced function return the result of the last `func`
+   * invocation.
    *
-   * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked
+   * **Note:** If `leading` and `trailing` options are `true`, `func` is
-   * on the trailing edge of the timeout only if the debounced function is
+   * invoked on the trailing edge of the timeout only if the debounced function
-   * invoked more than once during the `wait` timeout.
+   * is invoked more than once during the `wait` timeout.
+   *
+   * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+   * until to the next tick, similar to `setTimeout` with a timeout of `0`.
    *
    * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
    * for details over the differences between `_.debounce` and `_.throttle`.
@@ -143,6 +147,9 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
     }
 
     function cancel() {
+      if (timerId !== undefined) {
+        clearTimeout(timerId);
+      }
       lastInvokeTime = 0;
       lastArgs = lastCallTime = lastThis = timerId = undefined;
     }

defaultTo.js

@@ -0,0 +1,28 @@
+define([], function() {
+
+  /**
+   * Checks `value` to determine whether a default value should be returned in
+   * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
+   * or `undefined`.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.14.0
+   * @category Util
+   * @param {*} value The value to check.
+   * @param {*} defaultValue The default value.
+   * @returns {*} Returns the resolved value.
+   * @example
+   *
+   * _.defaultTo(1, 10);
+   * // => 1
+   *
+   * _.defaultTo(undefined, 10);
+   * // => 10
+   */
+  function defaultTo(value, defaultValue) {
+    return (value == null || value !== value) ? defaultValue : value;
+  }
+
+  return defaultTo;
+});

defaults.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_assignInDefaults', './assignInWith', './rest'], function(apply, assignInDefaults, assignInWith, rest) {
+define(['./_apply', './_assignInDefaults', './assignInWith', './_baseRest'], function(apply, assignInDefaults, assignInWith, baseRest) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -21,10 +21,10 @@ define(['./_apply', './_assignInDefaults', './assignInWith', './rest'], function
    * @see _.defaultsDeep
    * @example
    *
-   * _.defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });
+   * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
-   * // => { 'user': 'barney', 'age': 36 }
+   * // => { 'a': 1, 'b': 2 }
    */
-  var defaults = rest(function(args) {
+  var defaults = baseRest(function(args) {
     args.push(undefined, assignInDefaults);
     return apply(assignInWith, undefined, args);
   });

defaultsDeep.js

@@ -1,4 +1,4 @@
-define(['./_apply', './_mergeDefaults', './mergeWith', './rest'], function(apply, mergeDefaults, mergeWith, rest) {
+define(['./_apply', './_baseRest', './_mergeDefaults', './mergeWith'], function(apply, baseRest, mergeDefaults, mergeWith) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -19,11 +19,10 @@ define(['./_apply', './_mergeDefaults', './mergeWith', './rest'], function(apply
    * @see _.defaults
    * @example
    *
-   * _.defaultsDeep({ 'user': { 'name': 'barney' } }, { 'user': { 'name': 'fred', 'age': 36 } });
+   * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });
-   * // => { 'user': { 'name': 'barney', 'age': 36 } }
+   * // => { 'a': { 'b': 2, 'c': 3 } }
-   *
    */
-  var defaultsDeep = rest(function(args) {
+  var defaultsDeep = baseRest(function(args) {
     args.push(undefined, mergeDefaults);
     return apply(mergeWith, undefined, args);
   });

defer.js

@@ -1,4 +1,4 @@
-define(['./_baseDelay', './rest'], function(baseDelay, rest) {
+define(['./_baseDelay', './_baseRest'], function(baseDelay, baseRest) {
 
   /**
    * Defers invoking the `func` until the current call stack has cleared. Any
@@ -18,7 +18,7 @@ define(['./_baseDelay', './rest'], function(baseDelay, rest) {
    * }, 'deferred');
    * // => Logs 'deferred' after one or more milliseconds.
    */
-  var defer = rest(function(func, args) {
+  var defer = baseRest(function(func, args) {
     return baseDelay(func, 1, args);
   });
 

delay.js

@@ -1,4 +1,4 @@
-define(['./_baseDelay', './rest', './toNumber'], function(baseDelay, rest, toNumber) {
+define(['./_baseDelay', './_baseRest', './toNumber'], function(baseDelay, baseRest, toNumber) {
 
   /**
    * Invokes `func` after `wait` milliseconds. Any additional arguments are
@@ -19,7 +19,7 @@ define(['./_baseDelay', './rest', './toNumber'], function(baseDelay, rest, toNum
    * }, 1000, 'later');
    * // => Logs 'later' after one second.
    */
-  var delay = rest(function(func, wait, args) {
+  var delay = baseRest(function(func, wait, args) {
     return baseDelay(func, toNumber(wait) || 0, args);
   });
 

difference.js

@@ -1,11 +1,13 @@
-define(['./_baseDifference', './_baseFlatten', './isArrayLikeObject', './rest'], function(baseDifference, baseFlatten, isArrayLikeObject, rest) {
+define(['./_baseDifference', './_baseFlatten', './_baseRest', './isArrayLikeObject'], function(baseDifference, baseFlatten, baseRest, isArrayLikeObject) {
 
   /**
-   * Creates an array of unique `array` values not included in the other given
+   * Creates an array of `array` values not included in the other given arrays
-   * arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+   * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
    * for equality comparisons. The order of result values is determined by the
    * order they occur in the first array.
    *
+   * **Note:** Unlike `_.pullAll`, this method returns a new array.
+   *
    * @static
    * @memberOf _
    * @since 0.1.0
@@ -19,7 +21,7 @@ define(['./_baseDifference', './_baseFlatten', './isArrayLikeObject', './rest'],
    * _.difference([2, 1], [2, 3]);
    * // => [1]
    */
-  var difference = rest(function(array, values) {
+  var difference = baseRest(function(array, values) {
     return isArrayLikeObject(array)
       ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
       : [];

differenceBy.js

@@ -1,4 +1,4 @@
-define(['./_baseDifference', './_baseFlatten', './_baseIteratee', './isArrayLikeObject', './last', './rest'], function(baseDifference, baseFlatten, baseIteratee, isArrayLikeObject, last, rest) {
+define(['./_baseDifference', './_baseFlatten', './_baseIteratee', './_baseRest', './isArrayLikeObject', './last'], function(baseDifference, baseFlatten, baseIteratee, baseRest, isArrayLikeObject, last) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -9,14 +9,15 @@ define(['./_baseDifference', './_baseFlatten', './_baseIteratee', './isArrayLike
    * by which they're compared. Result values are chosen from the first array.
    * The iteratee is invoked with one argument: (value).
    *
+   * **Note:** Unlike `_.pullAllBy`, this method returns a new array.
+   *
    * @static
    * @memberOf _
    * @since 4.0.0
    * @category Array
    * @param {Array} array The array to inspect.
    * @param {...Array} [values] The values to exclude.
-   * @param {Array|Function|Object|string} [iteratee=_.identity]
+   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
-   *  The iteratee invoked per element.
    * @returns {Array} Returns the new array of filtered values.
    * @example
    *
@@ -27,13 +28,13 @@ define(['./_baseDifference', './_baseFlatten', './_baseIteratee', './isArrayLike
    * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
    * // => [{ 'x': 2 }]
    */
-  var differenceBy = rest(function(array, values) {
+  var differenceBy = baseRest(function(array, values) {
     var iteratee = last(values);
     if (isArrayLikeObject(iteratee)) {
       iteratee = undefined;
     }
     return isArrayLikeObject(array)
-      ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), baseIteratee(iteratee))
+      ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), baseIteratee(iteratee, 2))
       : [];
   });
 

differenceWith.js

@@ -1,4 +1,4 @@
-define(['./_baseDifference', './_baseFlatten', './isArrayLikeObject', './last', './rest'], function(baseDifference, baseFlatten, isArrayLikeObject, last, rest) {
+define(['./_baseDifference', './_baseFlatten', './_baseRest', './isArrayLikeObject', './last'], function(baseDifference, baseFlatten, baseRest, isArrayLikeObject, last) {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
   var undefined;
@@ -9,6 +9,8 @@ define(['./_baseDifference', './_baseFlatten', './isArrayLikeObject', './last',
    * are chosen from the first array. The comparator is invoked with two arguments:
    * (arrVal, othVal).
    *
+   * **Note:** Unlike `_.pullAllWith`, this method returns a new array.
+   *
    * @static
    * @memberOf _
    * @since 4.0.0
@@ -24,7 +26,7 @@ define(['./_baseDifference', './_baseFlatten', './isArrayLikeObject', './last',
    * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
    * // => [{ 'x': 2, 'y': 1 }]
    */
-  var differenceWith = rest(function(array, values) {
+  var differenceWith = baseRest(function(array, values) {
     var comparator = last(values);
     if (isArrayLikeObject(comparator)) {
       comparator = undefined;