From fdf6478bc92ed566eb4d51d335b6ef82aabf8cd7 Mon Sep 17 00:00:00 2001
From: John-David Dalton <john.david.dalton@gmail.com>
Date: Mon, 19 Oct 2015 20:59:12 -0700
Subject: [PATCH] Use helper methods from the stable lodash release to test
 unstable bits.

---
 package.json    |    1 +
 test/index.html |    2 +
 test/test.js    | 2189 +++++++++++++++++++++++------------------------
 3 files changed, 1096 insertions(+), 1096 deletions(-)

diff --git a/package.json b/package.json
index 3fde0a2fe..8a2c8ae81 100644
--- a/package.json
+++ b/package.json
@@ -13,6 +13,7 @@
     "istanbul": "0.3.22",
     "jquery": "~1.11.0",
     "jscs": "^2.3.1",
+    "lodash": "^3.10.1",
     "platform": "~1.3.0",
     "qunit-extras": "~1.4.0",
     "qunitjs": "~1.19.0",
diff --git a/test/index.html b/test/index.html
index c5ccd10ad..d53a1ddc5 100644
--- a/test/index.html
+++ b/test/index.html
@@ -22,6 +22,8 @@
         };
       }
     </script>
+    <script src="../node_modules/lodash/index.js"></script>
+    <script>var lodashStable = _.noConflict();</script>
     <script src="../node_modules/qunitjs/qunit/qunit.js"></script>
     <script src="../node_modules/qunit-extras/qunit-extras.js"></script>
     <script src="../node_modules/platform/platform.js"></script>
diff --git a/test/test.js b/test/test.js
index 46dbb4473..50f8364a9 100644
--- a/test/test.js
+++ b/test/test.js
@@ -214,22 +214,15 @@
     QUnit = QUnit.QUnit || QUnit
   ));
 
-  /** Load QUnit Extras and ES6 shims. */
-  (function() {
-    var paths = [
-      '../node_modules/qunit-extras/qunit-extras.js'
-    ];
-
-    var index = -1,
-        length = paths.length;
-
-    while (++index < length) {
-      var object = load(paths[index]);
-      if (object) {
-        object.runInContext(root);
-      }
-    }
-  }());
+  /** Load stable Lodash and QUnit Extras. */
+  var lodashStable = root.lodashStable || load('../node_modules/lodash/index.js');
+  if (lodashStable) {
+    lodashStable.runInContext(root);
+  }
+  var QUnitExtras = load('../node_modules/qunit-extras/qunit-extras.js');
+  if (QUnitExtras) {
+    QUnitExtras.runInContext(root);
+  }
 
   /** The `lodash` function to test. */
   var _ = root._ || (root._ = (
@@ -347,7 +340,7 @@
    * @param {Object} object The object to empty.
    */
   function emptyObject(object) {
-    _.forOwn(object, function(value, key, object) {
+    lodashStable.forOwn(object, function(value, key, object) {
       delete object[key];
     });
   }
@@ -403,7 +396,7 @@
         reToString = /toString/g;
 
     function createToString(funcName) {
-      return _.constant(nativeString.replace(reToString, funcName));
+      return lodashStable.constant(nativeString.replace(reToString, funcName));
     }
 
     // Allow bypassing native checks.
@@ -415,7 +408,7 @@
     });
 
     // Add prototype extensions.
-    funcProto._method = _.noop;
+    funcProto._method = noop;
 
     // Set bad shims.
     var _propertyIsEnumerable = objectProto.propertyIsEnumerable;
@@ -438,9 +431,9 @@
 
       setProperty(root.Map, 'toString', createToString('Map'));
     }
-    setProperty(Object, 'create', _.noop);
-    setProperty(root, 'Set', _.noop);
-    setProperty(root, 'WeakMap', _.noop);
+    setProperty(Object, 'create', noop);
+    setProperty(root, 'Set', noop);
+    setProperty(root, 'WeakMap', noop);
 
     // Fake `WinRTError`.
     setProperty(root, 'WinRTError', Error);
@@ -476,8 +469,8 @@
   }());
 
   // Add other realm values from the `vm` module.
-  _.attempt(function() {
-    _.extend(realm, require('vm').runInNewContext([
+  lodashStable.attempt(function() {
+    lodashStable.assign(realm, require('vm').runInNewContext([
       '(function() {',
       '  var root = this;',
       '',
@@ -513,7 +506,7 @@
   });
 
   // Add other realm values from an iframe.
-  _.attempt(function() {
+  lodashStable.attempt(function() {
     _._realm = realm;
 
     var iframe = document.createElement('iframe');
@@ -523,7 +516,7 @@
     var idoc = (idoc = iframe.contentDocument || iframe.contentWindow).document || idoc;
     idoc.write([
       '<script>',
-      'var _ = parent._;',
+      'var _ = parent.lodashStable;',
       '',
       'var root = this;',
       '',
@@ -553,7 +546,7 @@
       '  }',
       '});',
       '',
-      '_.extend(_._realm, object);',
+      '_.assign(_._realm, object);',
       '<\/script>'
     ].join('\n'));
 
@@ -562,7 +555,7 @@
   });
 
   // Add a web worker.
-  _.attempt(function() {
+  lodashStable.attempt(function() {
     var worker = new Worker('./asset/worker.js?t=' + (+new Date));
     worker.addEventListener('message', function(e) {
       _._VERSION = e.data || '';
@@ -572,12 +565,12 @@
   });
 
   // Expose internal modules for better code coverage.
-  _.attempt(function() {
+  lodashStable.attempt(function() {
     var path = require('path'),
         basePath = path.dirname(filePath);
 
     if (isModularize && !(amd || isNpm)) {
-      _.each(['internal/baseEach', 'internal/isIndex',
+      lodashStable.each(['internal/baseEach', 'internal/isIndex',
               'internal/isIterateeCall', 'internal/isLength'], function(relPath) {
         var func = require(path.join(basePath, relPath)),
             funcName = path.basename(relPath);
@@ -610,7 +603,7 @@
     QUnit.test('should support loading ' + basename + ' with the Require.js "shim" configuration option', function(assert) {
       assert.expect(1);
 
-      if (amd && _.includes(ui.loaderPath, 'requirejs')) {
+      if (amd && lodashStable.includes(ui.loaderPath, 'requirejs')) {
         assert.strictEqual((shimmedModule || {}).moduleName, 'shimmed');
       } else {
         skipTest(assert);
@@ -678,7 +671,7 @@
 
       var object = { 'a': 1 },
           otherObject = { 'b': 2 },
-          largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(object));
+          largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(object));
 
       if (lodashBizarro) {
         try {
@@ -874,13 +867,13 @@
 
   (function() {
     var values = empties.concat(true, 1, 'a'),
-        expected = _.map(values, _.constant(true));
+        expected = lodashStable.map(values, lodashStable.constant(true));
 
     QUnit.test('should create a new instance when called without the `new` operator', function(assert) {
       assert.expect(1);
 
       if (!isNpm) {
-        var actual = _.map(values, function(value) {
+        var actual = lodashStable.map(values, function(value) {
           return _(value) instanceof _;
         });
 
@@ -895,7 +888,7 @@
       assert.expect(1);
 
       if (!isNpm) {
-        var actual = _.map(values, function(value) {
+        var actual = lodashStable.map(values, function(value) {
           var wrapped = _(value);
           return _(wrapped) === wrapped;
         });
@@ -911,7 +904,7 @@
       assert.expect(1);
 
       if (!isNpm && lodashBizarro) {
-        var actual = _.map(values, function(value) {
+        var actual = lodashStable.map(values, function(value) {
           var wrapped = _(lodashBizarro(value)),
               unwrapped = wrapped.value();
 
@@ -975,7 +968,7 @@
   (function() {
     function after(n, times) {
       var count = 0;
-      _.times(times, _.after(n, function() { count++; }));
+      lodashStable.times(times, _.after(n, function() { count++; }));
       return count;
     }
 
@@ -1018,7 +1011,7 @@
     QUnit.test('should cap the number of params provided to `func`', function(assert) {
       assert.expect(2);
 
-      var actual = _.map(['6', '8', '10'], _.ary(parseInt, 1));
+      var actual = lodashStable.map(['6', '8', '10'], _.ary(parseInt, 1));
       assert.deepEqual(actual, [6, 8, 10]);
 
       var capped = _.ary(fn, 2);
@@ -1050,7 +1043,7 @@
       var values = ['1', 1.6, 'xyz'],
           expected = [['a'], ['a'], []];
 
-      var actual = _.map(values, function(n) {
+      var actual = lodashStable.map(values, function(n) {
         var capped = _.ary(fn, n);
         return capped('a', 'b');
       });
@@ -1068,7 +1061,7 @@
     QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) {
       assert.expect(1);
 
-      var funcs = _.map([fn], _.ary),
+      var funcs = lodashStable.map([fn], _.ary),
           actual = funcs[0]('a', 'b', 'c');
 
       assert.deepEqual(actual, ['a', 'b', 'c']);
@@ -1096,7 +1089,7 @@
 
   QUnit.module('lodash.assign and lodash.extend');
 
-  _.each(['assign', 'extend'], function(methodName) {
+  lodashStable.each(['assign', 'extend'], function(methodName) {
     var func = _[methodName];
 
     QUnit.test('`_.' + methodName + '` should assign properties of a source object to the destination object', function(assert) {
@@ -1132,7 +1125,7 @@
 
   QUnit.module('lodash.assignWith and lodash.extendWith');
 
-  _.each(['assignWith', 'extendWith'], function(methodName) {
+  lodashStable.each(['assignWith', 'extendWith'], function(methodName) {
     var func = _[methodName];
 
     QUnit.test('`_.' + methodName + '` should work with a `customizer` callback', function(assert) {
@@ -1149,7 +1142,7 @@
       assert.expect(1);
 
       var expected = { 'a': undefined };
-      assert.deepEqual(func({}, expected, _.constant(undefined)), expected);
+      assert.deepEqual(func({}, expected, lodashStable.constant(undefined)), expected);
     });
   });
 
@@ -1178,15 +1171,15 @@
     QUnit.test('should work with non-index keys on array values', function(assert) {
       assert.expect(1);
 
-      var values = _.reject(empties, function(value) {
-        return value === 0 || _.isArray(value);
+      var values = lodashStable.reject(empties, function(value) {
+        return value === 0 || lodashStable.isArray(value);
       }).concat(-1, 1.1);
 
-      var array = _.transform(values, function(result, value) {
+      var array = lodashStable.transform(values, function(result, value) {
         result[value] = 1;
       }, []);
 
-      var expected = _.map(values, _.constant(1)),
+      var expected = lodashStable.map(values, lodashStable.constant(1)),
           actual = _.at(array, values);
 
       assert.deepEqual(actual, expected);
@@ -1209,9 +1202,9 @@
     QUnit.test('should work with a falsey `object` argument when keys are provided', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant(Array(4)));
+      var expected = lodashStable.map(falsey, lodashStable.constant(Array(4)));
 
-      var actual = _.map(falsey, function(object) {
+      var actual = lodashStable.map(falsey, function(object) {
         try {
           return _.at(object, 0, 1, 'pop', 'push');
         } catch (e) {}
@@ -1260,7 +1253,7 @@
     QUnit.test('should return the result of `func`', function(assert) {
       assert.expect(1);
 
-      assert.strictEqual(_.attempt(_.constant('x')), 'x');
+      assert.strictEqual(_.attempt(lodashStable.constant('x')), 'x');
     });
 
     QUnit.test('should provide additional arguments to `func`', function(assert) {
@@ -1273,9 +1266,9 @@
     QUnit.test('should return the caught error', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(errors, _.constant(true));
+      var expected = lodashStable.map(errors, lodashStable.constant(true));
 
-      var actual = _.map(errors, function(error) {
+      var actual = lodashStable.map(errors, function(error) {
         return _.attempt(function() { throw error; }) === error;
       });
 
@@ -1286,16 +1279,16 @@
       assert.expect(1);
 
       var actual = _.attempt(function() { throw 'x'; });
-      assert.ok(_.isEqual(actual, Error('x')));
+      assert.ok(lodashStable.isEqual(actual, Error('x')));
     });
 
     QUnit.test('should work with an error object from another realm', function(assert) {
       assert.expect(1);
 
       if (realm.errors) {
-        var expected = _.map(realm.errors, _.constant(true));
+        var expected = lodashStable.map(realm.errors, lodashStable.constant(true));
 
-        var actual = _.map(realm.errors, function(error) {
+        var actual = lodashStable.map(realm.errors, function(error) {
           return _.attempt(function() { throw error; }) === error;
         });
 
@@ -1310,7 +1303,7 @@
       assert.expect(1);
 
       if (!isNpm) {
-        assert.strictEqual(_(_.constant('x')).attempt(), 'x');
+        assert.strictEqual(_(lodashStable.constant('x')).attempt(), 'x');
       }
       else {
         skipTest(assert);
@@ -1321,7 +1314,7 @@
       assert.expect(1);
 
       if (!isNpm) {
-        assert.ok(_(_.constant('x')).chain().attempt() instanceof _);
+        assert.ok(_(lodashStable.constant('x')).chain().attempt() instanceof _);
       }
       else {
         skipTest(assert);
@@ -1336,7 +1329,7 @@
   (function() {
     function before(n, times) {
       var count = 0;
-      _.times(times, _.before(n, function() { count++; }));
+      lodashStable.times(times, _.before(n, function() { count++; }));
       return count;
     }
 
@@ -1390,18 +1383,18 @@
     QUnit.test('should accept a falsey `thisArg` argument', function(assert) {
       assert.expect(1);
 
-      var values = _.reject(falsey.slice(1), function(value) { return value == null; }),
-          expected = _.map(values, function(value) { return [value]; });
+      var values = lodashStable.reject(falsey.slice(1), function(value) { return value == null; }),
+          expected = lodashStable.map(values, function(value) { return [value]; });
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         try {
           var bound = _.bind(fn, value);
           return bound();
         } catch (e) {}
       });
 
-      assert.ok(_.every(actual, function(value, index) {
-        return _.isEqual(value, expected[index]);
+      assert.ok(lodashStable.every(actual, function(value, index) {
+        return lodashStable.isEqual(value, expected[index]);
       }));
     });
 
@@ -1414,7 +1407,7 @@
       assert.ok(actual[0] === null || (actual[0] && actual[0].Array));
       assert.strictEqual(actual[1], 'a');
 
-      _.times(2, function(index) {
+      lodashStable.times(2, function(index) {
         bound = index ? _.bind(fn, undefined) : _.bind(fn);
         actual = bound('b');
 
@@ -1488,9 +1481,9 @@
 
       var bound = _.bind(Foo, { 'a': 1 }),
           count = 9,
-          expected = _.times(count, _.constant(undefined));
+          expected = lodashStable.times(count, lodashStable.constant(undefined));
 
-      var actual = _.times(count, function(index) {
+      var actual = lodashStable.times(count, function(index) {
         try {
           switch (index) {
             case 0: return (new bound).a;
@@ -1572,14 +1565,14 @@
     QUnit.test('should not error when calling bound class constructors with the `new` operator', function(assert) {
       assert.expect(1);
 
-      var createCtor = _.attempt(Function, '"use strict";return class A{}');
+      var createCtor = lodashStable.attempt(Function, '"use strict";return class A{}');
 
       if (typeof createCtor == 'function') {
         var bound = _.bind(createCtor()),
             count = 8,
-            expected = _.times(count, _.constant(true));
+            expected = lodashStable.times(count, lodashStable.constant(true));
 
-        var actual = _.times(count, function(index) {
+        var actual = lodashStable.times(count, function(index) {
           try {
             switch (index) {
               case 0: return !!(new bound);
@@ -1640,10 +1633,10 @@
     QUnit.test('should accept individual method names', function(assert) {
       assert.expect(1);
 
-      var object = _.clone(source);
+      var object = lodashStable.cloneDeep(source);
       _.bindAll(object, 'a', 'b');
 
-      var actual = _.map(['a', 'b', 'c'], function(methodName) {
+      var actual = lodashStable.map(['a', 'b', 'c'], function(methodName) {
         return object[methodName].call({});
       });
 
@@ -1653,10 +1646,10 @@
     QUnit.test('should accept arrays of method names', function(assert) {
       assert.expect(1);
 
-      var object = _.clone(source);
+      var object = lodashStable.cloneDeep(source);
       _.bindAll(object, ['a', 'b'], ['c']);
 
-      var actual = _.map(['a', 'b', 'c', 'd'], function(methodName) {
+      var actual = lodashStable.map(['a', 'b', 'c', 'd'], function(methodName) {
         return object[methodName].call({});
       });
 
@@ -1674,10 +1667,10 @@
     QUnit.test('should work with `arguments` objects as secondary arguments', function(assert) {
       assert.expect(1);
 
-      var object = _.clone(source);
+      var object = lodashStable.cloneDeep(source);
       _.bindAll(object, args);
 
-      var actual = _.map(args, function(methodName) {
+      var actual = lodashStable.map(args, function(methodName) {
         return object[methodName].call({});
       });
 
@@ -1733,7 +1726,7 @@
 
   QUnit.module('case methods');
 
-  _.each(['camel', 'kebab', 'lower', 'snake', 'start', 'upper'], function(caseName) {
+  lodashStable.each(['camel', 'kebab', 'lower', 'snake', 'start', 'upper'], function(caseName) {
     var methodName = caseName + 'Case',
         func = _[methodName];
 
@@ -1756,30 +1749,30 @@
     QUnit.test('`_.' + methodName + '` should convert `string` to ' + caseName + ' case', function(assert) {
       assert.expect(1);
 
-      var actual = _.map(strings, function(string) {
+      var actual = lodashStable.map(strings, function(string) {
         return func(string) === converted;
       });
 
-      assert.deepEqual(actual, _.map(strings, _.constant(true)));
+      assert.deepEqual(actual, lodashStable.map(strings, lodashStable.constant(true)));
     });
 
     QUnit.test('`_.' + methodName + '` should handle double-converting strings', function(assert) {
       assert.expect(1);
 
-      var actual = _.map(strings, function(string) {
+      var actual = lodashStable.map(strings, function(string) {
         return func(func(string)) === converted;
       });
 
-      assert.deepEqual(actual, _.map(strings, _.constant(true)));
+      assert.deepEqual(actual, lodashStable.map(strings, lodashStable.constant(true)));
     });
 
     QUnit.test('`_.' + methodName + '` should deburr letters', function(assert) {
       assert.expect(1);
 
-      var actual = _.map(burredLetters, function(burred, index) {
+      var actual = lodashStable.map(burredLetters, function(burred, index) {
         var letter = deburredLetters[index];
         if (caseName == 'start') {
-          letter = _.capitalize(letter);
+          letter = lodashStable.capitalize(letter);
         } else if (caseName == 'upper') {
           letter = letter.toUpperCase();
         } else {
@@ -1788,13 +1781,13 @@
         return func(burred) === letter;
       });
 
-      assert.deepEqual(actual, _.map(burredLetters, _.constant(true)));
+      assert.deepEqual(actual, lodashStable.map(burredLetters, lodashStable.constant(true)));
     });
 
     QUnit.test('`_.' + methodName + '` should trim latin-1 mathematical operators', function(assert) {
       assert.expect(1);
 
-      var actual = _.map(['\xd7', '\xf7'], func);
+      var actual = lodashStable.map(['\xd7', '\xf7'], func);
       assert.deepEqual(actual, ['', '']);
     });
 
@@ -1803,7 +1796,7 @@
 
       var string = 'foo bar';
       assert.strictEqual(func(Object(string)), converted);
-      assert.strictEqual(func({ 'toString': _.constant(string) }), converted);
+      assert.strictEqual(func({ 'toString': lodashStable.constant(string) }), converted);
     });
 
     QUnit.test('`_.' + methodName + '` should return an unwrapped value implicitly when chaining', function(assert) {
@@ -1835,7 +1828,7 @@
 
       var funcs = [_.camelCase, _.kebabCase, _.snakeCase, _.startCase, _.camelCase];
 
-      var actual = _.reduce(funcs, function(result, func) {
+      var actual = lodashStable.reduce(funcs, function(result, func) {
         return func(result);
       }, 'enable 24h format');
 
@@ -1861,15 +1854,15 @@
     QUnit.test('should handle acronyms', function(assert) {
       assert.expect(6);
 
-      _.each(['safe HTML', 'safeHTML'], function(string) {
+      lodashStable.each(['safe HTML', 'safeHTML'], function(string) {
         assert.strictEqual(_.camelCase(string), 'safeHtml');
       });
 
-      _.each(['escape HTML entities', 'escapeHTMLEntities'], function(string) {
+      lodashStable.each(['escape HTML entities', 'escapeHTMLEntities'], function(string) {
         assert.strictEqual(_.camelCase(string), 'escapeHtmlEntities');
       });
 
-      _.each(['XMLHttpRequest', 'XmlHTTPRequest'], function(string) {
+      lodashStable.each(['XMLHttpRequest', 'XmlHTTPRequest'], function(string) {
         assert.strictEqual(_.camelCase(string), 'xmlHttpRequest');
       });
     });
@@ -1943,7 +1936,7 @@
       assert.expect(6);
 
       if (!isNpm) {
-        _.times(2, function(index) {
+        lodashStable.times(2, function(index) {
           var array = ['one two three four', 'five six seven eight', 'nine ten eleven twelve'],
               expected = { ' ': 9, 'e': 14, 'f': 2, 'g': 1, 'h': 2, 'i': 4, 'l': 2, 'n': 6, 'o': 3, 'r': 2, 's': 2, 't': 5, 'u': 1, 'v': 4, 'w': 2, 'x': 1 },
               wrapped = index ? _(array).chain() : _.chain(array);
@@ -2016,9 +2009,9 @@
       assert.expect(1);
 
       var values = falsey.concat(-1, -Infinity),
-          expected = _.map(values, _.constant([]));
+          expected = lodashStable.map(values, lodashStable.constant([]));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.chunk(array, value) : _.chunk(array);
       });
 
@@ -2079,7 +2072,7 @@
       'functions': Foo
     };
 
-    _.each(errors, function(error) {
+    lodashStable.each(errors, function(error) {
       uncloneable[error.name + 's'] = error;
     });
 
@@ -2112,7 +2105,7 @@
       assert.expect(2);
 
       var cyclical = {};
-      _.times(LARGE_ARRAY_SIZE + 1, function(index) {
+      lodashStable.times(LARGE_ARRAY_SIZE + 1, function(index) {
         cyclical['v' + index] = [index ? cyclical['v' + (index - 1)] : cyclical];
       });
 
@@ -2152,18 +2145,20 @@
       assert.strictEqual(stack['delete']('a'), false);
     });
 
-    _.each(['clone', 'cloneDeep'], function(methodName) {
+    lodashStable.each(['clone', 'cloneDeep'], function(methodName) {
       var func = _[methodName],
           isDeep = methodName == 'cloneDeep';
 
-      _.forOwn(objects, function(object, key) {
+      lodashStable.forOwn(objects, function(object, key) {
         QUnit.test('`_.' + methodName + '` should clone ' + key, function(assert) {
           assert.expect(2);
 
-          var actual = func(object);
-          assert.ok(_.isEqual(actual, object));
+          var isEqual = (key == 'maps' || key == 'sets') ? _.isEqual : lodashStable,
+              actual = func(object);
 
-          if (_.isObject(object)) {
+          assert.ok(isEqual(actual, object));
+
+          if (lodashStable.isObject(object)) {
             assert.notStrictEqual(actual, object);
           } else {
             assert.strictEqual(actual, object);
@@ -2228,7 +2223,7 @@
         assert.expect(2);
 
         var expected = [{ 'a': [0] }, { 'b': [1] }],
-            actual = _.map(expected, func);
+            actual = lodashStable.map(expected, func);
 
         assert.deepEqual(actual, expected);
 
@@ -2244,16 +2239,16 @@
 
         var props = [];
 
-        var objects = _.transform(_, function(result, value, key) {
-          if (_.startsWith(key, '_') && _.isObject(value) && !_.isArguments(value) && !_.isElement(value) && !_.isFunction(value)) {
-            props.push(_.capitalize(_.camelCase(key)));
+        var objects = lodashStable.transform(_, function(result, value, key) {
+          if (lodashStable.startsWith(key, '_') && lodashStable.isObject(value) && !lodashStable.isArguments(value) && !lodashStable.isElement(value) && !lodashStable.isFunction(value)) {
+            props.push(lodashStable.capitalize(lodashStable.camelCase(key)));
             result.push(value);
           }
         }, []);
 
-        var expected = _.times(objects.length, _.constant(true));
+        var expected = lodashStable.times(objects.length, lodashStable.constant(true));
 
-        var actual = _.map(objects, function(object) {
+        var actual = lodashStable.map(objects, function(object) {
           var Ctor = object.constructor,
               result = func(object);
 
@@ -2278,13 +2273,13 @@
         }
       });
 
-      _.each(typedArrays, function(type) {
+      lodashStable.each(typedArrays, function(type) {
         QUnit.test('`_.' + methodName + '` should clone ' + type + ' arrays', function(assert) {
           assert.expect(10);
 
           var Ctor = root[type];
 
-          _.times(2, function(index) {
+          lodashStable.times(2, function(index) {
             if (Ctor) {
               var buffer = new ArrayBuffer(24),
                   array = index ? new Ctor(buffer, 8, 1) : new Ctor(buffer),
@@ -2303,7 +2298,7 @@
         });
       });
 
-      _.forOwn(uncloneable, function(value, key) {
+      lodashStable.forOwn(uncloneable, function(value, key) {
         QUnit.test('`_.' + methodName + '` should not clone ' + key, function(assert) {
           assert.expect(3);
 
@@ -2319,7 +2314,7 @@
       });
     });
 
-    _.each(['cloneWith', 'cloneDeepWith'], function(methodName) {
+    lodashStable.each(['cloneWith', 'cloneDeepWith'], function(methodName) {
       var func = _[methodName],
           isDeepWith = methodName == 'cloneDeepWith';
 
@@ -2342,16 +2337,16 @@
       QUnit.test('`_.' + methodName + '` should handle cloning if `customizer` returns `undefined`', function(assert) {
         assert.expect(1);
 
-        var actual = func({ 'a': { 'b': 'c' } }, _.noop);
+        var actual = func({ 'a': { 'b': 'c' } }, noop);
         assert.deepEqual(actual, { 'a': { 'b': 'c' } });
       });
 
-      _.forOwn(uncloneable, function(value, key) {
+      lodashStable.forOwn(uncloneable, function(value, key) {
         QUnit.test('`_.' + methodName + '` should work with a `customizer` callback and ' + key, function(assert) {
           assert.expect(4);
 
           var customizer = function(value) {
-            return _.isPlainObject(value) ? undefined : value;
+            return lodashStable.isPlainObject(value) ? undefined : value;
           };
 
           var actual = func(value, customizer);
@@ -2400,7 +2395,7 @@
       assert.expect(1);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE).concat(null),
+        var array = lodashStable.range(LARGE_ARRAY_SIZE).concat(null),
             actual = _(array).slice(1).compact().reverse().take().value();
 
         assert.deepEqual(actual, _.take(_.compact(_.slice(array, 1)).reverse()));
@@ -2415,7 +2410,7 @@
 
   QUnit.module('flow methods');
 
-  _.each(['flow', 'flowRight'], function(methodName) {
+  lodashStable.each(['flow', 'flowRight'], function(methodName) {
     var func = _[methodName],
         isFlow = methodName == 'flow';
 
@@ -2431,7 +2426,7 @@
     QUnit.test('`_.' + methodName + '` should return a new function', function(assert) {
       assert.expect(1);
 
-      assert.notStrictEqual(func(_.noop), _.noop);
+      assert.notStrictEqual(func(noop), noop);
     });
 
     QUnit.test('`_.' + methodName + '` should return an identity function when no arguments are provided', function(assert) {
@@ -2445,13 +2440,13 @@
         assert.ok(false, e.message);
       }
       assert.strictEqual(combined.length, 0);
-      assert.notStrictEqual(combined, _.identity);
+      assert.notStrictEqual(combined, lodashStable.identity);
     });
 
     QUnit.test('`_.' + methodName + '` should work with a curried function and `_.head`', function(assert) {
       assert.expect(1);
 
-      var curried = _.curry(_.identity);
+      var curried = _.curry(lodashStable.identity);
 
       var combined = isFlow
         ? func(_.head, curried)
@@ -2465,11 +2460,11 @@
 
       var filterCount,
           mapCount,
-          array = _.range(LARGE_ARRAY_SIZE),
+          array = lodashStable.range(LARGE_ARRAY_SIZE),
           iteratee = function(value) { mapCount++; return square(value); },
           predicate = function(value) { filterCount++; return isEven(value); };
 
-      _.times(2, function(index) {
+      lodashStable.times(2, function(index) {
         var filter1 = _.filter,
             filter2 = _.curry(_.rearg(_.ary(_.filter, 2), 1, 0), 2),
             filter3 = (_.filter = index ? filter2 : filter1, filter2(predicate));
@@ -2520,7 +2515,7 @@
       assert.expect(1);
 
       if (!isNpm) {
-        var wrapped = _(_.noop)[methodName]();
+        var wrapped = _(noop)[methodName]();
         assert.ok(wrapped instanceof _);
       }
       else {
@@ -2537,7 +2532,7 @@
     QUnit.test('should create a function that returns `true` if all predicates return truthy', function(assert) {
       assert.expect(1);
 
-      var conjed = _.conj(_.constant(true), _.constant(1), _.constant('a'));
+      var conjed = _.conj(lodashStable.constant(true), lodashStable.constant(1), lodashStable.constant('a'));
       assert.strictEqual(conjed(), true);
     });
 
@@ -2588,7 +2583,7 @@
     QUnit.test('should flatten `predicates`', function(assert) {
       assert.expect(1);
 
-      var conjed = _.conj(_.constant(true), [_.constant(false)]);
+      var conjed = _.conj(lodashStable.constant(true), [lodashStable.constant(false)]);
       assert.strictEqual(conjed(), false);
     });
 
@@ -2629,9 +2624,9 @@
       var object = { 'a': 1 },
           values = Array(2).concat(empties, true, 1, 'a'),
           constant = _.constant(object),
-          expected = _.map(values, function() { return true; });
+          expected = lodashStable.map(values, function() { return true; });
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         if (index == 0) {
           var result = constant();
         } else if (index == 1) {
@@ -2648,9 +2643,9 @@
     QUnit.test('should work with falsey values', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, function() { return true; });
+      var expected = lodashStable.map(falsey, function() { return true; });
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         var constant = index ? _.constant(value) : _.constant(),
             result = constant();
 
@@ -2695,9 +2690,9 @@
 
       var array = [4, 6, 6],
           values = [, null, undefined],
-          expected = _.map(values, _.constant({ '4': 1, '6':  2 }));
+          expected = lodashStable.map(values, lodashStable.constant({ '4': 1, '6':  2 }));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.countBy(array, value) : _.countBy(array);
       });
 
@@ -2749,9 +2744,9 @@
       assert.expect(1);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE).concat(
-          _.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE),
-          _.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE)
+        var array = lodashStable.range(LARGE_ARRAY_SIZE).concat(
+          lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE),
+          lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE)
         );
 
         var actual = _(array).countBy().map(square).filter(isEven).take().value();
@@ -2781,7 +2776,7 @@
     QUnit.test('should create an object that inherits from the given `prototype` object', function(assert) {
       assert.expect(3);
 
-      Circle.prototype = _.create(Shape.prototype);
+      Circle.prototype = lodashStable.create(Shape.prototype);
       Circle.prototype.constructor = Circle;
 
       var actual = new Circle;
@@ -2795,7 +2790,7 @@
       assert.expect(3);
 
       var expected = { 'constructor': Circle, 'radius': 0 };
-      Circle.prototype = _.create(Shape.prototype, expected);
+      Circle.prototype = lodashStable.create(Shape.prototype, expected);
 
       var actual = new Circle;
 
@@ -2813,16 +2808,16 @@
       }
       Foo.prototype.b = 2;
 
-      assert.deepEqual(_.create({}, new Foo), { 'a': 1, 'c': 3 });
+      assert.deepEqual(lodashStable.create({}, new Foo), { 'a': 1, 'c': 3 });
     });
 
     QUnit.test('should accept a falsey `prototype` argument', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant({}));
+      var expected = lodashStable.map(falsey, lodashStable.constant({}));
 
-      var actual = _.map(falsey, function(prototype, index) {
-        return index ? _.create(prototype) : _.create();
+      var actual = lodashStable.map(falsey, function(prototype, index) {
+        return index ? lodashStable.create(prototype) : lodashStable.create();
       });
 
       assert.deepEqual(actual, expected);
@@ -2832,10 +2827,10 @@
       assert.expect(1);
 
       var primitives = [true, null, 1, 'a', undefined],
-          expected = _.map(primitives, _.constant(true));
+          expected = lodashStable.map(primitives, lodashStable.constant(true));
 
-      var actual = _.map(primitives, function(value, index) {
-        return _.isPlainObject(index ? _.create(value) : _.create());
+      var actual = lodashStable.map(primitives, function(value, index) {
+        return lodashStable.isPlainObject(index ? lodashStable.create(value) : lodashStable.create());
       });
 
       assert.deepEqual(actual, expected);
@@ -2845,10 +2840,10 @@
       assert.expect(1);
 
       var array = [{ 'a': 1 }, { 'a': 1 }, { 'a': 1 }],
-          expected = _.map(array, _.constant(true)),
-          objects = _.map(array, _.create);
+          expected = lodashStable.map(array, lodashStable.constant(true)),
+          objects = lodashStable.map(array, lodashStable.create);
 
-      var actual = _.map(objects, function(object) {
+      var actual = lodashStable.map(objects, function(object) {
         return object.a === 1 && !_.keys(object).length;
       });
 
@@ -2891,9 +2886,9 @@
       assert.expect(2);
 
       var values = ['0', 0.6, 'xyz'],
-          expected = _.map(values, _.constant([]));
+          expected = lodashStable.map(values, lodashStable.constant([]));
 
-      var actual = _.map(values, function(arity) {
+      var actual = lodashStable.map(values, function(arity) {
         return _.curry(fn, arity)();
       });
 
@@ -2925,7 +2920,7 @@
     QUnit.test('should return a function with a `length` of `0`', function(assert) {
       assert.expect(6);
 
-      _.times(2, function(index) {
+      lodashStable.times(2, function(index) {
         var curried = index ? _.curry(fn, 4) : _.curry(fn);
         assert.strictEqual(curried.length, 0);
         assert.strictEqual(curried(1).length, 0);
@@ -3023,9 +3018,9 @@
       assert.expect(2);
 
       var values = ['0', 0.6, 'xyz'],
-          expected = _.map(values, _.constant([]));
+          expected = lodashStable.map(values, lodashStable.constant([]));
 
-      var actual = _.map(values, function(arity) {
+      var actual = lodashStable.map(values, function(arity) {
         return _.curryRight(fn, arity)();
       });
 
@@ -3058,7 +3053,7 @@
     QUnit.test('should return a function with a `length` of `0`', function(assert) {
       assert.expect(6);
 
-      _.times(2, function(index) {
+      lodashStable.times(2, function(index) {
         var curried = index ? _.curryRight(fn, 4) : _.curryRight(fn);
         assert.strictEqual(curried.length, 0);
         assert.strictEqual(curried(4).length, 0);
@@ -3125,7 +3120,7 @@
 
   QUnit.module('curry methods');
 
-  _.each(['curry', 'curryRight'], function(methodName) {
+  lodashStable.each(['curry', 'curryRight'], function(methodName) {
     var func = _[methodName],
         fn = function(a, b) { return slice.call(arguments); },
         isCurry = methodName == 'curry';
@@ -3152,11 +3147,11 @@
       var array = [fn, fn, fn],
           object = { 'a': fn, 'b': fn, 'c': fn };
 
-      _.each([array, object], function(collection) {
-        var curries = _.map(collection, func),
-            expected = _.map(collection, _.constant(isCurry ? ['a', 'b'] : ['b', 'a']));
+      lodashStable.each([array, object], function(collection) {
+        var curries = lodashStable.map(collection, func),
+            expected = lodashStable.map(collection, lodashStable.constant(isCurry ? ['a', 'b'] : ['b', 'a']));
 
-        var actual = _.map(curries, function(curried) {
+        var actual = lodashStable.map(curries, function(curried) {
           return curried('a')('b');
         });
 
@@ -3202,7 +3197,7 @@
       var done = assert.async();
 
       if (!(isRhino && isModularize)) {
-        var debounced = _.debounce(_.identity, 32);
+        var debounced = _.debounce(lodashStable.identity, 32);
         debounced('x');
 
         setTimeout(function() {
@@ -3226,7 +3221,7 @@
       var done = assert.async();
 
       if (!(isRhino && isModularize)) {
-        var debounced = _.debounce(_.identity, 32, { 'leading': true, 'trailing': false }),
+        var debounced = _.debounce(lodashStable.identity, 32, { 'leading': true, 'trailing': false }),
             result = [debounced('x'), debounced('y')];
 
         assert.deepEqual(result, ['x', 'x']);
@@ -3284,7 +3279,7 @@
 
         assert.strictEqual(withLeading('x'), 'x');
 
-        var withoutLeading = _.debounce(_.identity, 32, { 'leading': false });
+        var withoutLeading = _.debounce(lodashStable.identity, 32, { 'leading': false });
         assert.strictEqual(withoutLeading('x'), undefined);
 
         var withLeadingAndTrailing = _.debounce(function() {
@@ -3448,7 +3443,7 @@
     QUnit.test('should convert latin-1 supplementary letters to basic latin', function(assert) {
       assert.expect(1);
 
-      var actual = _.map(burredLetters, _.deburr);
+      var actual = lodashStable.map(burredLetters, _.deburr);
       assert.deepEqual(actual, deburredLetters);
     });
 
@@ -3456,7 +3451,7 @@
       assert.expect(1);
 
       var operators = ['\xd7', '\xf7'],
-          actual = _.map(operators, _.deburr);
+          actual = lodashStable.map(operators, _.deburr);
 
       assert.deepEqual(actual, operators);
     });
@@ -3464,9 +3459,9 @@
     QUnit.test('should deburr combining diacritical marks', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(comboMarks, _.constant('ei'));
+      var expected = lodashStable.map(comboMarks, lodashStable.constant('ei'));
 
-      var actual = _.map(comboMarks, function(chr) {
+      var actual = lodashStable.map(comboMarks, function(chr) {
         return _.deburr('e' + chr + 'i');
       });
 
@@ -3747,7 +3742,7 @@
 
   QUnit.module('difference methods');
 
-  _.each(['difference', 'differenceBy'], function(methodName) {
+  lodashStable.each(['difference', 'differenceBy'], function(methodName) {
     var args = (function() { return arguments; }(1, 2, 3)),
         func = _[methodName];
 
@@ -3770,8 +3765,8 @@
     QUnit.test('`_.' + methodName + '` should work with large arrays', function(assert) {
       assert.expect(1);
 
-      var array1 = _.range(LARGE_ARRAY_SIZE + 1),
-          array2 = _.range(LARGE_ARRAY_SIZE),
+      var array1 = lodashStable.range(LARGE_ARRAY_SIZE + 1),
+          array2 = lodashStable.range(LARGE_ARRAY_SIZE),
           a = {},
           b = {},
           c = {};
@@ -3787,7 +3782,7 @@
 
       var object1 = {},
           object2 = {},
-          largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(object1));
+          largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(object1));
 
       assert.deepEqual(func([object1, object2], largeArray), [object2]);
     });
@@ -3795,7 +3790,7 @@
     QUnit.test('`_.' + methodName + '` should work with large arrays of `NaN`', function(assert) {
       assert.expect(1);
 
-      var largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(NaN));
+      var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(NaN));
       assert.deepEqual(func([1, NaN, 3], largeArray), [1, 3]);
     });
 
@@ -3845,10 +3840,10 @@
     QUnit.test('should create a function that returns `true` if any predicates return truthy', function(assert) {
       assert.expect(2);
 
-      var disjed = _.disj(_.constant(false), _.constant(1), _.constant(''));
+      var disjed = _.disj(lodashStable.constant(false), lodashStable.constant(1), lodashStable.constant(''));
       assert.strictEqual(disjed(), true);
 
-      disjed = _.disj(_.constant(null), _.constant('x'), _.constant(0));
+      disjed = _.disj(lodashStable.constant(null), lodashStable.constant('x'), lodashStable.constant(0));
       assert.strictEqual(disjed(), true);
     });
 
@@ -3867,10 +3862,10 @@
     QUnit.test('should return `false` if all predicates return falsey', function(assert) {
       assert.expect(2);
 
-      var disjed = _.disj(_.constant(false), _.constant(false), _.constant(false));
+      var disjed = _.disj(lodashStable.constant(false), lodashStable.constant(false), lodashStable.constant(false));
       assert.strictEqual(disjed(), false);
 
-      disjed = _.disj(_.constant(null), _.constant(0), _.constant(''));
+      disjed = _.disj(lodashStable.constant(null), lodashStable.constant(0), lodashStable.constant(''));
       assert.strictEqual(disjed(), false);
     });
 
@@ -3909,7 +3904,7 @@
     QUnit.test('should flatten `predicates`', function(assert) {
       assert.expect(1);
 
-      var disjed = _.disj(_.constant(false), [_.constant(true)]);
+      var disjed = _.disj(lodashStable.constant(false), [lodashStable.constant(true)]);
       assert.strictEqual(disjed(), true);
     });
 
@@ -3955,11 +3950,11 @@
     QUnit.test('should treat falsey `n` values, except `undefined`, as `0`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === undefined ? [2, 3] : array;
       });
 
-      var actual = _.map(falsey, function(n) {
+      var actual = lodashStable.map(falsey, function(n) {
         return _.drop(array, n);
       });
 
@@ -3969,7 +3964,7 @@
     QUnit.test('should return all elements when `n` < `1`', function(assert) {
       assert.expect(3);
 
-      _.each([0, -1, -Infinity], function(n) {
+      lodashStable.each([0, -1, -Infinity], function(n) {
         assert.deepEqual(_.drop(array, n), array);
       });
     });
@@ -3977,7 +3972,7 @@
     QUnit.test('should return an empty array when `n` >= `array.length`', function(assert) {
       assert.expect(4);
 
-      _.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
+      lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
         assert.deepEqual(_.drop(array, n), []);
       });
     });
@@ -3992,7 +3987,7 @@
       assert.expect(1);
 
       var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-          actual = _.map(array, _.drop);
+          actual = lodashStable.map(array, _.drop);
 
       assert.deepEqual(actual, [[2, 3], [5, 6], [8, 9]]);
     });
@@ -4001,7 +3996,7 @@
       assert.expect(6);
 
       if (!isNpm) {
-        var array = _.range(1, LARGE_ARRAY_SIZE + 1),
+        var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
             predicate = function(value) { values.push(value); return isEven(value); },
             values = [],
             actual = _(array).drop(2).drop().value();
@@ -4043,11 +4038,11 @@
     QUnit.test('should treat falsey `n` values, except `undefined`, as `0`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === undefined ? [1, 2] : array;
       });
 
-      var actual = _.map(falsey, function(n) {
+      var actual = lodashStable.map(falsey, function(n) {
         return _.dropRight(array, n);
       });
 
@@ -4057,7 +4052,7 @@
     QUnit.test('should return all elements when `n` < `1`', function(assert) {
       assert.expect(3);
 
-      _.each([0, -1, -Infinity], function(n) {
+      lodashStable.each([0, -1, -Infinity], function(n) {
         assert.deepEqual(_.dropRight(array, n), array);
       });
     });
@@ -4065,7 +4060,7 @@
     QUnit.test('should return an empty array when `n` >= `array.length`', function(assert) {
       assert.expect(4);
 
-      _.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
+      lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
         assert.deepEqual(_.dropRight(array, n), []);
       });
     });
@@ -4080,7 +4075,7 @@
       assert.expect(1);
 
       var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-          actual = _.map(array, _.dropRight);
+          actual = lodashStable.map(array, _.dropRight);
 
       assert.deepEqual(actual, [[1, 2], [4, 5], [7, 8]]);
     });
@@ -4089,7 +4084,7 @@
       assert.expect(6);
 
       if (!isNpm) {
-        var array = _.range(1, LARGE_ARRAY_SIZE + 1),
+        var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
             predicate = function(value) { values.push(value); return isEven(value); },
             values = [],
             actual = _(array).dropRight(2).dropRight().value();
@@ -4242,7 +4237,7 @@
       assert.expect(3);
 
       if (!isNpm) {
-        var array = _.range(1, LARGE_ARRAY_SIZE + 3),
+        var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 3),
             predicate = function(num) { return num < 3; },
             expected = _.dropWhile(array, predicate),
             wrapped = _(array).dropWhile(predicate);
@@ -4260,7 +4255,7 @@
       assert.expect(1);
 
       if (!isNpm) {
-        var array = _.range(1, LARGE_ARRAY_SIZE + 3);
+        var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 3);
 
         var actual = _(array)
           .dropWhile(function(num) { return num == 1; })
@@ -4304,7 +4299,7 @@
     QUnit.test('should work with `position` >= `string.length`', function(assert) {
       assert.expect(4);
 
-      _.each([3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
+      lodashStable.each([3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
         assert.strictEqual(_.endsWith(string, 'c', position), true);
       });
     });
@@ -4312,9 +4307,9 @@
     QUnit.test('should treat falsey `position` values, except `undefined`, as `0`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant(true));
+      var expected = lodashStable.map(falsey, lodashStable.constant(true));
 
-      var actual = _.map(falsey, function(position) {
+      var actual = lodashStable.map(falsey, function(position) {
         return _.endsWith(string, position === undefined ? 'c' : '', position);
       });
 
@@ -4324,8 +4319,8 @@
     QUnit.test('should treat a negative `position` as `0`', function(assert) {
       assert.expect(6);
 
-      _.each([-1, -3, -Infinity], function(position) {
-        assert.ok(_.every(string, function(chr) {
+      lodashStable.each([-1, -3, -Infinity], function(position) {
+        assert.ok(lodashStable.every(string, function(chr) {
           return _.endsWith(string, chr, position) === false;
         }));
         assert.strictEqual(_.endsWith(string, '', position), true);
@@ -4341,7 +4336,7 @@
     QUnit.test('should return `true` when `target` is an empty string regardless of `position`', function(assert) {
       assert.expect(1);
 
-      assert.ok(_.every([-Infinity, NaN, -3, -1, 0, 1, 2, 3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
+      assert.ok(lodashStable.every([-Infinity, NaN, -3, -1, 0, 1, 2, 3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
         return _.endsWith(string, '', position, true);
       }));
     });
@@ -4432,9 +4427,9 @@
       assert.expect(1);
 
       var values = [, null, undefined, ''],
-          expected = _.map(values, _.constant(''));
+          expected = lodashStable.map(values, lodashStable.constant(''));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.escapeRegExp(value) : _.escapeRegExp();
       });
 
@@ -4450,17 +4445,17 @@
     QUnit.test('should return `true` if `predicate` returns truthy for all elements', function(assert) {
       assert.expect(1);
 
-      assert.strictEqual(_.every([true, 1, 'a'], _.identity), true);
+      assert.strictEqual(lodashStable.every([true, 1, 'a'], lodashStable.identity), true);
     });
 
     QUnit.test('should return `true` for empty collections', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(empties, _.constant(true));
+      var expected = lodashStable.map(empties, lodashStable.constant(true));
 
-      var actual = _.map(empties, function(value) {
+      var actual = lodashStable.map(empties, function(value) {
         try {
-          return _.every(value, _.identity);
+          return _.every(value, lodashStable.identity);
         } catch (e) {}
       });
 
@@ -4483,24 +4478,24 @@
     QUnit.test('should work with collections of `undefined` values (test in IE < 9)', function(assert) {
       assert.expect(1);
 
-      assert.strictEqual(_.every([undefined, undefined, undefined], _.identity), false);
+      assert.strictEqual(_.every([undefined, undefined, undefined], lodashStable.identity), false);
     });
 
     QUnit.test('should use `_.identity` when `predicate` is nullish', function(assert) {
       assert.expect(2);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         var array = [0];
         return index ? _.every(array, value) : _.every(array);
       });
 
       assert.deepEqual(actual, expected);
 
-      expected = _.map(values, _.constant(true));
-      actual = _.map(values, function(value, index) {
+      expected = lodashStable.map(values, lodashStable.constant(true));
+      actual = lodashStable.map(values, function(value, index) {
         var array = [1];
         return index ? _.every(array, value) : _.every(array);
       });
@@ -4527,7 +4522,7 @@
     QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) {
       assert.expect(1);
 
-      var actual = _.map([[1]], _.every);
+      var actual = lodashStable.map([[1]], _.every);
       assert.deepEqual(actual, [true]);
     });
   }());
@@ -4536,7 +4531,7 @@
 
   QUnit.module('strict mode checks');
 
-  _.each(['assign', 'extend', 'bindAll', 'defaults'], function(methodName) {
+  lodashStable.each(['assign', 'extend', 'bindAll', 'defaults'], function(methodName) {
     var func = _[methodName],
         isBindAll = methodName == 'bindAll';
 
@@ -4579,7 +4574,7 @@
           actual = _.fill(array);
 
       assert.deepEqual(actual, Array(3));
-      assert.ok(_.every(actual, function(value, index) {
+      assert.ok(lodashStable.every(actual, function(value, index) {
         return index in actual;
       }));
     });
@@ -4594,7 +4589,7 @@
     QUnit.test('should work with a `start` >= `array.length`', function(assert) {
       assert.expect(4);
 
-      _.each([3, 4, Math.pow(2, 32), Infinity], function(start) {
+      lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(start) {
         var array = [1, 2, 3];
         assert.deepEqual(_.fill(array, 'a', start), [1, 2, 3]);
       });
@@ -4603,9 +4598,9 @@
     QUnit.test('should treat falsey `start` values as `0`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant(['a', 'a', 'a']));
+      var expected = lodashStable.map(falsey, lodashStable.constant(['a', 'a', 'a']));
 
-      var actual = _.map(falsey, function(start) {
+      var actual = lodashStable.map(falsey, function(start) {
         var array = [1, 2, 3];
         return _.fill(array, 'a', start);
       });
@@ -4623,7 +4618,7 @@
     QUnit.test('should work with a negative `start` <= negative `array.length`', function(assert) {
       assert.expect(3);
 
-      _.each([-3, -4, -Infinity], function(start) {
+      lodashStable.each([-3, -4, -Infinity], function(start) {
         var array = [1, 2, 3];
         assert.deepEqual(_.fill(array, 'a', start), ['a', 'a', 'a']);
       });
@@ -4632,7 +4627,7 @@
     QUnit.test('should work with `start` >= `end`', function(assert) {
       assert.expect(2);
 
-      _.each([2, 3], function(start) {
+      lodashStable.each([2, 3], function(start) {
         var array = [1, 2, 3];
         assert.deepEqual(_.fill(array, 'a', start, 2), [1, 2, 3]);
       });
@@ -4648,7 +4643,7 @@
     QUnit.test('should work with a `end` >= `array.length`', function(assert) {
       assert.expect(4);
 
-      _.each([3, 4, Math.pow(2, 32), Infinity], function(end) {
+      lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(end) {
         var array = [1, 2, 3];
         assert.deepEqual(_.fill(array, 'a', 0, end), ['a', 'a', 'a']);
       });
@@ -4657,11 +4652,11 @@
     QUnit.test('should treat falsey `end` values, except `undefined`, as `0`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === undefined ? ['a', 'a', 'a'] : [1, 2, 3];
       });
 
-      var actual = _.map(falsey, function(end) {
+      var actual = lodashStable.map(falsey, function(end) {
         var array = [1, 2, 3];
         return _.fill(array, 'a', 0, end);
       });
@@ -4679,7 +4674,7 @@
     QUnit.test('should work with a negative `end` <= negative `array.length`', function(assert) {
       assert.expect(3);
 
-      _.each([-3, -4, -Infinity], function(end) {
+      lodashStable.each([-3, -4, -Infinity], function(end) {
         var array = [1, 2, 3];
         assert.deepEqual(_.fill(array, 'a', 0, end), [1, 2, 3]);
       });
@@ -4690,7 +4685,7 @@
 
       var positions = [[0.1, 1.6], ['0', 1], [0, '1'], ['1'], [NaN, 1], [1, NaN]];
 
-      var actual = _.map(positions, function(pos) {
+      var actual = lodashStable.map(positions, function(pos) {
         var array = [1, 2, 3];
         return _.fill.apply(_, [array, 'a'].concat(pos));
       });
@@ -4702,7 +4697,7 @@
       assert.expect(1);
 
       var array = [[1, 2], [3, 4]],
-          actual = _.map(array, _.fill);
+          actual = lodashStable.map(array, _.fill);
 
       assert.deepEqual(actual, [[0, 0], [1, 1]]);
     });
@@ -4746,8 +4741,8 @@
       var counter = 0,
           object = { '1': 'foo', '8': 'bar', '50': 'baz' };
 
-      _.times(1000, function(assert) {
-        _.filter([], _.constant(true));
+      lodashStable.times(1000, function(assert) {
+        _.filter([], lodashStable.constant(true));
       });
 
       _.filter(object, function() {
@@ -4761,7 +4756,7 @@
 
   /*--------------------------------------------------------------------------*/
 
-  _.each(['find', 'findLast', 'findIndex', 'findLastIndex', 'findKey', 'findLastKey'], function(methodName) {
+  lodashStable.each(['find', 'findLast', 'findIndex', 'findLastIndex', 'findKey', 'findLastKey'], function(methodName) {
     QUnit.module('lodash.' + methodName);
 
     var func = _[methodName],
@@ -4816,10 +4811,10 @@
       QUnit.test('should return `' + expected[1] + '` for empty collections', function(assert) {
         assert.expect(1);
 
-        var emptyValues = _.endsWith(methodName, 'Index') ? _.reject(empties, _.isPlainObject) : empties,
-            expecting = _.map(emptyValues, _.constant(expected[1]));
+        var emptyValues = lodashStable.endsWith(methodName, 'Index') ? lodashStable.reject(empties, lodashStable.isPlainObject) : empties,
+            expecting = lodashStable.map(emptyValues, lodashStable.constant(expected[1]));
 
-        var actual = _.map(emptyValues, function(value) {
+        var actual = lodashStable.map(emptyValues, function(value) {
           try {
             return func(value, { 'a': 3 });
           } catch (e) {}
@@ -4879,14 +4874,14 @@
         assert.expect(2);
 
         if (!isNpm) {
-          var largeArray = _.range(1, LARGE_ARRAY_SIZE + 1),
+          var largeArray = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
               smallArray = array;
 
-          _.times(2, function(index) {
+          lodashStable.times(2, function(index) {
             var array = index ? largeArray : smallArray,
                 wrapped = _(array).filter(isEven);
 
-            assert.strictEqual(wrapped[methodName](), func(_.filter(array, isEven)));
+            assert.strictEqual(wrapped[methodName](), func(lodashStable.filter(array, isEven)));
           });
         }
         else {
@@ -4921,7 +4916,7 @@
 
   QUnit.module('lodash.find and lodash.findLast');
 
-  _.each(['find', 'findLast'], function(methodName) {
+  lodashStable.each(['find', 'findLast'], function(methodName) {
     var isFind = methodName == 'find';
 
     QUnit.test('`_.' + methodName + '` should support shortcut fusion', function(assert) {
@@ -4930,7 +4925,7 @@
       if (!isNpm) {
         var findCount = 0,
             mapCount = 0,
-            array = _.range(1, LARGE_ARRAY_SIZE + 1),
+            array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
             iteratee = function(value) { mapCount++; return square(value); },
             predicate = function(value) { findCount++; return isEven(value); },
             actual = _(array).map(iteratee)[methodName](predicate);
@@ -4993,7 +4988,7 @@
 
       expected.push(undefined, undefined, undefined);
 
-      _.each([_.flatten(array), _.flatten(array, true), _.flattenDeep(array)], function(actual) {
+      lodashStable.each([_.flatten(array), _.flatten(array, true), _.flattenDeep(array)], function(actual) {
         assert.deepEqual(actual, expected);
         assert.ok('4' in actual);
       });
@@ -5003,7 +4998,7 @@
       assert.expect(3);
 
       // Test in modern browsers only to avoid browser hangs.
-      _.times(3, function(index) {
+      lodashStable.times(3, function(index) {
         if (freeze) {
           var expected = Array(5e5);
 
@@ -5101,7 +5096,7 @@
 
   QUnit.module('forIn methods');
 
-  _.each(['forIn', 'forInRight'], function(methodName) {
+  lodashStable.each(['forIn', 'forInRight'], function(methodName) {
     var func = _[methodName];
 
     QUnit.test('`_.' + methodName + '` iterates over inherited properties', function(assert) {
@@ -5120,7 +5115,7 @@
 
   QUnit.module('forOwn methods');
 
-  _.each(['forOwn', 'forOwnRight'], function(methodName) {
+  lodashStable.each(['forOwn', 'forOwnRight'], function(methodName) {
     var func = _[methodName];
 
     QUnit.test('should iterate over `length` properties', function(assert) {
@@ -5256,7 +5251,7 @@
       'some'
     ];
 
-    _.each(methods, function(methodName) {
+    lodashStable.each(methods, function(methodName) {
       var array = [1, 2, 3],
           func = _[methodName],
           isBy = /(^partition|By)$/.test(methodName),
@@ -5274,11 +5269,11 @@
             args || (args = slice.call(arguments));
           });
 
-          if (_.includes(rightMethods, methodName)) {
+          if (lodashStable.includes(rightMethods, methodName)) {
             expected[0] = 3;
             expected[1] = 2;
           }
-          if (_.includes(objectMethods, methodName)) {
+          if (lodashStable.includes(objectMethods, methodName)) {
             expected[1] += '';
           }
           if (isBy) {
@@ -5301,17 +5296,17 @@
           var expected = [[1, 0, array], [undefined, 1, array], [3, 2, array]];
 
           if (isBy) {
-            expected = _.map(expected, function(args) {
+            expected = lodashStable.map(expected, function(args) {
               return args.slice(0, 1);
             });
           }
-          else if (_.includes(objectMethods, methodName)) {
-            expected = _.map(expected, function(args) {
+          else if (lodashStable.includes(objectMethods, methodName)) {
+            expected = lodashStable.map(expected, function(args) {
               args[1] += '';
               return args;
             });
           }
-          if (_.includes(rightMethods, methodName)) {
+          if (lodashStable.includes(rightMethods, methodName)) {
             expected.reverse();
           }
           var argsList = [];
@@ -5328,7 +5323,7 @@
       });
     });
 
-    _.each(_.difference(methods, objectMethods), function(methodName) {
+    lodashStable.each(lodashStable.difference(methods, objectMethods), function(methodName) {
       var array = [1, 2, 3],
           func = _[methodName],
           isEvery = methodName == 'every';
@@ -5345,7 +5340,7 @@
             return isEvery;
           });
 
-          assert.notOk(_.includes(keys, 'a'));
+          assert.notOk(lodashStable.includes(keys, 'a'));
         }
         else {
           skipTest(assert);
@@ -5353,7 +5348,7 @@
       });
     });
 
-    _.each(_.difference(methods, unwrappedMethods), function(methodName) {
+    lodashStable.each(lodashStable.difference(methods, unwrappedMethods), function(methodName) {
       var array = [1, 2, 3],
           func = _[methodName],
           isBaseEach = methodName == '_baseEach';
@@ -5362,7 +5357,7 @@
         assert.expect(1);
 
         if (!(isBaseEach || isNpm)) {
-          var wrapped = _(array)[methodName](_.noop);
+          var wrapped = _(array)[methodName](noop);
           assert.ok(wrapped instanceof _);
         }
         else {
@@ -5371,7 +5366,7 @@
       });
     });
 
-    _.each(unwrappedMethods, function(methodName) {
+    lodashStable.each(unwrappedMethods, function(methodName) {
       var array = [1, 2, 3],
           func = _[methodName];
 
@@ -5379,7 +5374,7 @@
         assert.expect(1);
 
         if (!isNpm) {
-          var actual = _(array)[methodName](_.noop);
+          var actual = _(array)[methodName](noop);
           assert.notOk(actual instanceof _);
         }
         else {
@@ -5392,7 +5387,7 @@
 
         if (!isNpm) {
           var wrapped = _(array).chain(),
-              actual = wrapped[methodName](_.noop);
+              actual = wrapped[methodName](noop);
 
           assert.ok(actual instanceof _);
           assert.notStrictEqual(actual, wrapped);
@@ -5403,7 +5398,7 @@
       });
     });
 
-    _.each(_.difference(methods, arrayMethods, forInMethods), function(methodName) {
+    lodashStable.each(lodashStable.difference(methods, arrayMethods, forInMethods), function(methodName) {
       var array = [1, 2, 3],
           func = _[methodName];
 
@@ -5424,7 +5419,7 @@
       });
     });
 
-    _.each(iterationMethods, function(methodName) {
+    lodashStable.each(iterationMethods, function(methodName) {
       var array = [1, 2, 3],
           func = _[methodName];
 
@@ -5440,7 +5435,7 @@
       });
     });
 
-    _.each(collectionMethods, function(methodName) {
+    lodashStable.each(collectionMethods, function(methodName) {
       var func = _[methodName];
 
       QUnit.test('`_.' + methodName + '` should use `isArrayLike` to determine whether a value is array-like', function(assert) {
@@ -5454,9 +5449,9 @@
           };
 
           var values = [-1, '1', 1.1, Object(1), MAX_SAFE_INTEGER + 1],
-              expected = _.map(values, _.constant(true));
+              expected = lodashStable.map(values, lodashStable.constant(true));
 
-          var actual = _.map(values, function(length) {
+          var actual = lodashStable.map(values, function(length) {
             return isIteratedAsObject({ 'length': length });
           });
 
@@ -5473,7 +5468,7 @@
       });
     });
 
-    _.each(methods, function(methodName) {
+    lodashStable.each(methods, function(methodName) {
       var array = [1, 2, 3],
           func = _[methodName],
           isFind = /^find/.test(methodName),
@@ -5502,7 +5497,7 @@
       });
     });
 
-    _.each(_.difference(_.union(methods, collectionMethods), arrayMethods), function(methodName) {
+    lodashStable.each(lodashStable.difference(lodashStable.union(methods, collectionMethods), arrayMethods), function(methodName) {
       var func = _[methodName],
           isFind = /^find/.test(methodName),
           isSome = methodName == 'some',
@@ -5535,7 +5530,7 @@
 
   QUnit.module('object assignments');
 
-  _.each(['assign', 'defaults', 'extend', 'merge'], function(methodName) {
+  lodashStable.each(['assign', 'defaults', 'extend', 'merge'], function(methodName) {
     var func = _[methodName],
         isAssign = methodName == 'assign',
         isDefaults = methodName == 'defaults';
@@ -5543,11 +5538,11 @@
     QUnit.test('`_.' + methodName + '` should coerce primitives to objects', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant(true));
+      var expected = lodashStable.map(falsey, lodashStable.constant(true));
 
-      var actual = _.map(falsey, function(object, index) {
+      var actual = lodashStable.map(falsey, function(object, index) {
         var result = index ? func(object) : func();
-        return _.isEqual(result, Object(object));
+        return lodashStable.isEqual(result, Object(object));
       });
 
       assert.deepEqual(actual, expected);
@@ -5576,11 +5571,11 @@
     QUnit.test('`_.' + methodName + '` should not error when `object` is nullish and source objects are provided', function(assert) {
       assert.expect(1);
 
-      var expected = _.times(2, _.constant(true));
+      var expected = lodashStable.times(2, lodashStable.constant(true));
 
-      var actual = _.map([null, undefined], function(value) {
+      var actual = lodashStable.map([null, undefined], function(value) {
         try {
-          return _.isEqual(func(value, { 'a': 1 }), {});
+          return lodashStable.isEqual(func(value, { 'a': 1 }), {});
         } catch (e) {
           return false;
         }
@@ -5596,7 +5591,7 @@
           expected = { 'a': 1, 'b': 2, 'c': 3 };
 
       expected.a = isDefaults ? 0 : 1;
-      assert.deepEqual(_.reduce(array, func, { 'a': 0 }), expected);
+      assert.deepEqual(lodashStable.reduce(array, func, { 'a': 0 }), expected);
     });
 
     QUnit.test('`_.' + methodName + '` should not return the existing wrapped value when chaining', function(assert) {
@@ -5614,7 +5609,7 @@
     });
   });
 
-  _.each(['assign', 'extend', 'merge'], function(methodName) {
+  lodashStable.each(['assign', 'extend', 'merge'], function(methodName) {
     var func = _[methodName];
 
     QUnit.test('`_.' + methodName + '` should not treat `object` as `source`', function(assert) {
@@ -5628,13 +5623,13 @@
     });
   });
 
-  _.each(['assign', 'assignWith', 'defaults', 'extend', 'extendWith', 'merge', 'mergeWith'], function(methodName) {
+  lodashStable.each(['assign', 'assignWith', 'defaults', 'extend', 'extendWith', 'merge', 'mergeWith'], function(methodName) {
     var func = _[methodName];
 
     QUnit.test('`_.' + methodName + '` should not assign values that are the same as their destinations', function(assert) {
       assert.expect(4);
 
-      _.each(['a', ['a'], { 'a': 1 }, NaN], function(value) {
+      lodashStable.each(['a', ['a'], { 'a': 1 }, NaN], function(value) {
         if (defineProperty) {
           var object = {},
               pass = true;
@@ -5642,7 +5637,7 @@
           defineProperty(object, 'a', {
             'enumerable': true,
             'configurable': true,
-            'get': _.constant(value),
+            'get': lodashStable.constant(value),
             'set': function() { pass = false; }
           });
 
@@ -5656,7 +5651,7 @@
     });
   });
 
-  _.each(['assignWith', 'extendWith', 'mergeWith'], function(methodName) {
+  lodashStable.each(['assignWith', 'extendWith', 'mergeWith'], function(methodName) {
     var func = _[methodName],
         isMergeWith = methodName == 'mergeWith';
 
@@ -5666,10 +5661,10 @@
       var args,
           object = { 'a': 1 },
           source = { 'a': 2 },
-          expected = _.map([1, 2, 'a', object, source], _.clone);
+          expected = lodashStable.map([1, 2, 'a', object, source], lodashStable.cloneDeep);
 
       func(object, source, function() {
-        args || (args = _.map(slice.call(arguments, 0, 5), _.clone));
+        args || (args = lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
       });
 
       assert.deepEqual(args, expected, 'primitive property values');
@@ -5677,10 +5672,10 @@
       args = null;
       object = { 'a': 1 };
       source = { 'b': 2 };
-      expected = _.map([undefined, 2, 'b', object, source], _.clone);
+      expected = lodashStable.map([undefined, 2, 'b', object, source], lodashStable.cloneDeep);
 
       func(object, source, function() {
-        args || (args = _.map(slice.call(arguments, 0, 5), _.clone));
+        args || (args = lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
       });
 
       assert.deepEqual(args, expected, 'missing destination property');
@@ -5691,13 +5686,13 @@
 
       object = { 'a': objectValue };
       source = { 'a': sourceValue };
-      expected = [_.map([objectValue, sourceValue, 'a', object, source], _.cloneDeep)];
+      expected = [lodashStable.map([objectValue, sourceValue, 'a', object, source], lodashStable.cloneDeep)];
 
       if (isMergeWith) {
-        expected.push(_.map([undefined, 2, 'b', objectValue, sourceValue], _.cloneDeep));
+        expected.push(lodashStable.map([undefined, 2, 'b', objectValue, sourceValue], lodashStable.cloneDeep));
       }
       func(object, source, function() {
-        argsList.push(_.map(slice.call(arguments, 0, 5), _.cloneDeep));
+        argsList.push(lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
       });
 
       assert.deepEqual(argsList, expected, 'object property values');
@@ -5721,7 +5716,7 @@
 
   QUnit.module('exit early');
 
-  _.each(['_baseEach', 'forEach', 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight', 'transform'], function(methodName) {
+  lodashStable.each(['_baseEach', 'forEach', 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight', 'transform'], function(methodName) {
     var func = _[methodName];
 
     QUnit.test('`_.' + methodName + '` can exit early when iterating arrays', function(assert) {
@@ -5732,11 +5727,11 @@
             values = [];
 
         func(array, function(value, other) {
-          values.push(_.isArray(value) ? other : value);
+          values.push(lodashStable.isArray(value) ? other : value);
           return false;
         });
 
-        assert.deepEqual(values, [_.endsWith(methodName, 'Right') ? 3 : 1]);
+        assert.deepEqual(values, [lodashStable.endsWith(methodName, 'Right') ? 3 : 1]);
       }
       else {
         skipTest(assert);
@@ -5751,7 +5746,7 @@
             values = [];
 
         func(object, function(value, other) {
-          values.push(_.isArray(value) ? other : value);
+          values.push(lodashStable.isArray(value) ? other : value);
           return false;
         });
 
@@ -5775,7 +5770,7 @@
           stringObject = Object(stringLiteral),
           expected = [stringLiteral, stringObject];
 
-      var largeArray = _.times(LARGE_ARRAY_SIZE, function(count) {
+      var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function(count) {
         return isEven(count) ? stringLiteral : stringObject;
       });
 
@@ -5794,7 +5789,7 @@
     QUnit.test('should return the function names of an object', function(assert) {
       assert.expect(1);
 
-      var object = { 'a': 'a', 'b': _.identity, 'c': /x/, 'd': _.each };
+      var object = { 'a': 'a', 'b': lodashStable.identity, 'c': /x/, 'd': lodashStable.each };
       assert.deepEqual(_.functions(object).sort(), ['b', 'd']);
     });
 
@@ -5802,10 +5797,10 @@
       assert.expect(1);
 
       function Foo() {
-        this.a = _.identity;
+        this.a = lodashStable.identity;
         this.b = 'b';
       }
-      Foo.prototype.c = _.noop;
+      Foo.prototype.c = noop;
       assert.deepEqual(_.functions(new Foo).sort(), ['a', 'c']);
     });
   }());
@@ -5822,9 +5817,9 @@
 
       var array = [4, 6, 6],
           values = [, null, undefined],
-          expected = _.map(values, _.constant({ '4': [4], '6':  [6, 6] }));
+          expected = lodashStable.map(values, lodashStable.constant({ '4': [4], '6':  [6, 6] }));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.groupBy(array, value) : _.groupBy(array);
       });
 
@@ -5876,16 +5871,16 @@
       assert.expect(1);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE).concat(
-          _.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE),
-          _.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE)
+        var array = lodashStable.range(LARGE_ARRAY_SIZE).concat(
+          lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE),
+          lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE)
         );
 
         var iteratee = function(value) { value.push(value[0]); return value; },
             predicate = function(value) { return isEven(value[0]); },
             actual = _(array).groupBy().map(iteratee).filter(predicate).take().value();
 
-        assert.deepEqual(actual, _.take(_.filter(_.map(_.groupBy(array), iteratee), predicate)));
+        assert.deepEqual(actual, _.take(_.filter(lodashStable.map(_.groupBy(array), iteratee), predicate)));
       }
       else {
         skipTest(assert);
@@ -5941,7 +5936,7 @@
 
   QUnit.module('has methods');
 
-  _.each(['has', 'hasIn'], function(methodName) {
+  lodashStable.each(['has', 'hasIn'], function(methodName) {
     var args = (function() { return arguments; }(1, 2, 3)),
         func = _[methodName],
         isHas = methodName == 'has';
@@ -5951,7 +5946,7 @@
 
       var object = { 'a': 1 };
 
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         assert.strictEqual(func(object, path), true);
       });
     });
@@ -5968,7 +5963,7 @@
 
       var object = { 'a': { 'b': { 'c': 3 } } };
 
-      _.each(['a.b.c', ['a', 'b', 'c']], function(path) {
+      lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path) {
         assert.strictEqual(func(object, path), true);
       });
     });
@@ -5977,15 +5972,15 @@
       assert.expect(1);
 
       function fn() {}
-      fn.toString = _.constant('fn');
+      fn.toString = lodashStable.constant('fn');
 
       var expected = [1, 1, 2, 2, 3, 3, 4, 4],
           objects = [{ 'null': 1 }, { 'undefined': 2 }, { 'fn': 3 }, { '[object Object]': 4 }],
           values = [null, undefined, fn, {}];
 
-      var actual = _.transform(objects, function(result, object, index) {
+      var actual = lodashStable.transform(objects, function(result, object, index) {
         var key = values[index];
-        _.each([key, [key]], function(path) {
+        lodashStable.each([key, [key]], function(path) {
           var prop = _.property(key);
           result.push(prop(object));
         });
@@ -6000,7 +5995,7 @@
       function Foo() {}
       Foo.prototype.a = 1;
 
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         assert.strictEqual(func(new Foo, path), !isHas);
       });
     });
@@ -6016,7 +6011,7 @@
 
       var object = { 'a.b.c': 3, 'a': { 'b': { 'c': 4 } } };
 
-      _.each(['a.b.c', ['a.b.c']], function(path) {
+      lodashStable.each(['a.b.c', ['a.b.c']], function(path) {
         assert.strictEqual(func(object, path), true);
       });
     });
@@ -6025,10 +6020,10 @@
       assert.expect(2);
 
       var values = [null, undefined],
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      _.each(['constructor', ['constructor']], function(path) {
-        var actual = _.map(values, function(value) {
+      lodashStable.each(['constructor', ['constructor']], function(path) {
+        var actual = lodashStable.map(values, function(value) {
           return func(value, path);
         });
 
@@ -6040,10 +6035,10 @@
       assert.expect(2);
 
       var values = [null, undefined],
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      _.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
-        var actual = _.map(values, function(value) {
+      lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
+        var actual = lodashStable.map(values, function(value) {
           return func(value, path);
         });
 
@@ -6056,7 +6051,7 @@
 
       var object = {};
 
-      _.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
+      lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
         assert.strictEqual(func(object, path), false);
       });
     });
@@ -6066,7 +6061,7 @@
 
       var array = [1, 2, 3];
 
-      _.each([1, [1]], function(path) {
+      lodashStable.each([1, [1]], function(path) {
         assert.strictEqual(func(array, path), true);
       });
     });
@@ -6117,7 +6112,7 @@
       assert.expect(1);
 
       var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-          actual = _.map(array, _.head);
+          actual = lodashStable.map(array, _.head);
 
       assert.deepEqual(actual, [1, 4, 7]);
     });
@@ -6160,10 +6155,10 @@
       assert.expect(2);
 
       if (!isNpm) {
-        var largeArray = _.range(LARGE_ARRAY_SIZE),
+        var largeArray = lodashStable.range(LARGE_ARRAY_SIZE),
             smallArray = array;
 
-        _.times(2, function(index) {
+        lodashStable.times(2, function(index) {
           var array = index ? largeArray : smallArray,
               wrapped = _(array).filter(isEven);
 
@@ -6200,7 +6195,7 @@
   QUnit.module('lodash.includes');
 
   (function() {
-    _.each({
+    lodashStable.each({
       'an `arguments` object': arguments,
       'an array': [1, 2, 3, 4],
       'an object': { 'a': 1, 'b': 2, 'c': 3, 'd': 4 },
@@ -6233,7 +6228,7 @@
       QUnit.test('should work with ' + key + ' and a `fromIndex` >= `collection.length`', function(assert) {
         assert.expect(12);
 
-        _.each([4, 6, Math.pow(2, 32), Infinity], function(fromIndex) {
+        lodashStable.each([4, 6, Math.pow(2, 32), Infinity], function(fromIndex) {
           assert.strictEqual(_.includes(collection, 1, fromIndex), false);
           assert.strictEqual(_.includes(collection, undefined, fromIndex), false);
           assert.strictEqual(_.includes(collection, '', fromIndex), (isStr && fromIndex == length));
@@ -6243,9 +6238,9 @@
       QUnit.test('should work with ' + key + ' and treat falsey `fromIndex` values as `0`', function(assert) {
         assert.expect(1);
 
-        var expected = _.map(falsey, _.constant(true));
+        var expected = lodashStable.map(falsey, lodashStable.constant(true));
 
-        var actual = _.map(falsey, function(fromIndex) {
+        var actual = lodashStable.map(falsey, function(fromIndex) {
           return _.includes(collection, values[0], fromIndex);
         });
 
@@ -6270,7 +6265,7 @@
       QUnit.test('should work with ' + key + ' and a negative `fromIndex` <= negative `collection.length`', function(assert) {
         assert.expect(3);
 
-        _.each([-4, -6, -Infinity], function(fromIndex) {
+        lodashStable.each([-4, -6, -Infinity], function(fromIndex) {
           assert.strictEqual(_.includes(collection, values[0], fromIndex), true);
         });
       });
@@ -6304,7 +6299,7 @@
       });
     });
 
-    _.each({
+    lodashStable.each({
       'literal': 'abc',
       'object': Object('abc')
     },
@@ -6320,9 +6315,9 @@
     QUnit.test('should return `false` for empty collections', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(empties, _.constant(false));
+      var expected = lodashStable.map(empties, lodashStable.constant(false));
 
-      var actual = _.map(empties, function(value) {
+      var actual = lodashStable.map(empties, function(value) {
         try {
           return _.includes(value);
         } catch (e) {}
@@ -6344,13 +6339,13 @@
       assert.strictEqual(_.includes([0], -0), true);
     });
 
-    QUnit.test('should work as an iteratee for methods like `_.reduce`', function(assert) {
+    QUnit.test('should work as an iteratee for methods like `_.every`', function(assert) {
       assert.expect(1);
 
       var array1 = [1, 2, 3],
           array2 = [2, 3, 1];
 
-      assert.ok(_.every(array1, _.partial(_.includes, array2)));
+      assert.ok(lodashStable.every(array1, lodashStable.partial(_.includes, array2)));
     });
   }(1, 2, 3, 4));
 
@@ -6377,9 +6372,9 @@
       assert.expect(1);
 
       var values = [6, 8, Math.pow(2, 32), Infinity],
-          expected = _.map(values, _.constant([-1, -1, -1]));
+          expected = lodashStable.map(values, lodashStable.constant([-1, -1, -1]));
 
-      var actual = _.map(values, function(fromIndex) {
+      var actual = lodashStable.map(values, function(fromIndex) {
         return [
           _.indexOf(array, undefined, fromIndex),
           _.indexOf(array, 1, fromIndex),
@@ -6400,9 +6395,9 @@
       assert.expect(1);
 
       var values = [-6, -8, -Infinity],
-          expected = _.map(values, _.constant(0));
+          expected = lodashStable.map(values, lodashStable.constant(0));
 
-      var actual = _.map(values, function(fromIndex) {
+      var actual = lodashStable.map(values, function(fromIndex) {
         return _.indexOf(array, 1, fromIndex);
       });
 
@@ -6412,9 +6407,9 @@
     QUnit.test('should treat falsey `fromIndex` values as `0`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant(0));
+      var expected = lodashStable.map(falsey, lodashStable.constant(0));
 
-      var actual = _.map(falsey, function(fromIndex) {
+      var actual = lodashStable.map(falsey, function(fromIndex) {
         return _.indexOf(array, 1, fromIndex);
       });
 
@@ -6438,9 +6433,9 @@
     QUnit.test('should accept a falsey `array` argument', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant([]));
+      var expected = lodashStable.map(falsey, lodashStable.constant([]));
 
-      var actual = _.map(falsey, function(array, index) {
+      var actual = lodashStable.map(falsey, function(array, index) {
         try {
           return index ? _.initial(array) : _.initial();
         } catch (e) {}
@@ -6465,7 +6460,7 @@
       assert.expect(1);
 
       var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-          actual = _.map(array, _.initial);
+          actual = lodashStable.map(array, _.initial);
 
       assert.deepEqual(actual, [[1, 2], [4, 5], [7, 8]]);
     });
@@ -6474,7 +6469,7 @@
       assert.expect(4);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE),
+        var array = lodashStable.range(LARGE_ARRAY_SIZE),
             values = [];
 
         var actual = _(array).initial().filter(function(value) {
@@ -6495,7 +6490,7 @@
         .initial()
         .value();
 
-        assert.deepEqual(actual, _.initial(_.filter(array, isEven)));
+        assert.deepEqual(actual, _.initial(lodashStable.filter(array, isEven)));
         assert.deepEqual(values, array);
       }
       else {
@@ -6529,7 +6524,7 @@
     QUnit.test('should treat falsey `start` arguments as `0`', function(assert) {
       assert.expect(13);
 
-      _.each(falsey, function(value, index) {
+      lodashStable.each(falsey, function(value, index) {
         if (index) {
           assert.strictEqual(_.inRange(0, value), false);
           assert.strictEqual(_.inRange(0, value, 1), true);
@@ -6559,7 +6554,7 @@
       assert.expect(1);
 
       var actual = [_.inRange(0, '0', 1), _.inRange(0, '1'), _.inRange(0, 0, '1'), _.inRange(0, NaN, 1), _.inRange(-1, -1, NaN)],
-          expected = _.map(actual, _.constant(true));
+          expected = lodashStable.map(actual, lodashStable.constant(true));
 
       assert.deepEqual(actual, expected);
     });
@@ -6569,7 +6564,7 @@
 
   QUnit.module('intersection methods');
 
-  _.each(['intersection', 'intersectionBy'], function(methodName) {
+  lodashStable.each(['intersection', 'intersectionBy'], function(methodName) {
     var args = (function() { return arguments; }(1, 2, 3)),
         func = _[methodName];
 
@@ -6598,16 +6593,16 @@
       assert.expect(2);
 
       var object = {},
-          largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(object));
+          largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(object));
 
       assert.deepEqual(func([object], largeArray), [object]);
-      assert.deepEqual(func(_.range(LARGE_ARRAY_SIZE), [1]), [1]);
+      assert.deepEqual(func(lodashStable.range(LARGE_ARRAY_SIZE), [1]), [1]);
     });
 
     QUnit.test('`_.' + methodName + '` should work with large arrays of `NaN`', function(assert) {
       assert.expect(1);
 
-      var largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(NaN));
+      var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(NaN));
       assert.deepEqual(func([1, NaN, 3], largeArray), [NaN]);
     });
 
@@ -6714,7 +6709,7 @@
       var object = { 'a': 'hasOwnProperty', 'b': 'constructor' };
 
       assert.deepEqual(_.invert(object), { 'hasOwnProperty': 'a', 'constructor': 'b' });
-      assert.ok(_.isEqual(_.invert(object, true), { 'hasOwnProperty': ['a'], 'constructor': ['b'] }));
+      assert.ok(lodashStable.isEqual(_.invert(object, true), { 'hasOwnProperty': ['a'], 'constructor': ['b'] }));
     });
 
     QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) {
@@ -6725,10 +6720,10 @@
 
       var array = [regular, regular, regular],
           object = { 'a': regular, 'b': regular, 'c': regular },
-          expected = _.map(array, _.constant(inverted));
+          expected = lodashStable.map(array, lodashStable.constant(inverted));
 
-      _.each([array, object], function(collection) {
-        var actual = _.map(collection, _.invert);
+      lodashStable.each([array, object], function(collection) {
+        var actual = lodashStable.map(collection, _.invert);
         assert.deepEqual(actual, expected);
       });
     });
@@ -6810,11 +6805,11 @@
     QUnit.test('should not error on elements with missing properties', function(assert) {
       assert.expect(1);
 
-      var objects = _.map([null, undefined, _.constant(1)], function(value) {
+      var objects = lodashStable.map([null, undefined, lodashStable.constant(1)], function(value) {
         return { 'a': value };
       });
 
-      var expected = _.times(objects.length - 1, _.constant(undefined)).concat(1);
+      var expected = lodashStable.times(objects.length - 1, lodashStable.constant(undefined)).concat(1);
 
       try {
         var actual = _.invoke(objects, 'a');
@@ -6828,7 +6823,7 @@
 
       var object = { 'a': { 'b': function() { return this.c; }, 'c': 1 } };
 
-      _.each(['a.b', ['a', 'b']], function(path) {
+      lodashStable.each(['a.b', ['a', 'b']], function(path) {
         assert.deepEqual(_.invoke([object], path), [1]);
       });
     });
@@ -6852,9 +6847,9 @@
     QUnit.test('should return `false` for non `arguments` objects', function(assert) {
       assert.expect(11);
 
-      var expected = _.map(falsey, _.constant(false));
+      var expected = lodashStable.map(falsey, lodashStable.constant(false));
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isArguments(value) : _.isArguments();
       });
 
@@ -6866,7 +6861,7 @@
       assert.strictEqual(_.isArguments(new Error), false);
       assert.strictEqual(_.isArguments(_), false);
       assert.strictEqual(_.isArguments(slice), false);
-      assert.strictEqual(_.isArguments({ '0': 1, 'callee': _.noop, 'length': 1 }), false);
+      assert.strictEqual(_.isArguments({ '0': 1, 'callee': noop, 'length': 1 }), false);
       assert.strictEqual(_.isArguments(1), false);
       assert.strictEqual(_.isArguments(/x/), false);
       assert.strictEqual(_.isArguments('a'), false);
@@ -6900,9 +6895,9 @@
     QUnit.test('should return `false` for non-arrays', function(assert) {
       assert.expect(11);
 
-      var expected = _.map(falsey, _.constant(false));
+      var expected = lodashStable.map(falsey, lodashStable.constant(false));
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isArray(value) : _.isArray();
       });
 
@@ -6943,8 +6938,8 @@
       assert.expect(1);
 
       var values = [args, [1, 2, 3], { '0': 1, 'length': 1 }, 'a'],
-          expected = _.map(values, _.constant(true)),
-          actual = _.map(values, _.isArrayLike);
+          expected = lodashStable.map(values, lodashStable.constant(true)),
+          actual = lodashStable.map(values, _.isArrayLike);
 
       assert.deepEqual(actual, expected);
     });
@@ -6952,15 +6947,15 @@
     QUnit.test('should return `false` for non-arrays', function(assert) {
       assert.expect(10);
 
-      var generator = _.attempt(function() {
+      var generator = lodashStable.attempt(function() {
         return Function('return function*(){}');
       });
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === '';
       });
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isArrayLike(value) : _.isArrayLike();
       });
 
@@ -6982,8 +6977,8 @@
 
       if (realm.object) {
         var values = [realm.arguments, realm.array, realm.string],
-            expected = _.map(values, _.constant(true)),
-            actual = _.map(values, _.isArrayLike);
+            expected = lodashStable.map(values, lodashStable.constant(true)),
+            actual = lodashStable.map(values, _.isArrayLike);
 
         assert.deepEqual(actual, expected);
       }
@@ -7012,11 +7007,11 @@
     QUnit.test('should return `false` for non-booleans', function(assert) {
       assert.expect(11);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === false;
       });
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isBoolean(value) : _.isBoolean();
       });
 
@@ -7062,9 +7057,9 @@
     QUnit.test('should return `false` for non-dates', function(assert) {
       assert.expect(11);
 
-      var expected = _.map(falsey, _.constant(false));
+      var expected = lodashStable.map(falsey, lodashStable.constant(false));
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isDate(value) : _.isDate();
       });
 
@@ -7122,9 +7117,9 @@
     QUnit.test('should return `false` for non DOM elements', function(assert) {
       assert.expect(12);
 
-      var expected = _.map(falsey, _.constant(false));
+      var expected = lodashStable.map(falsey, lodashStable.constant(false));
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isElement(value) : _.isElement();
       });
 
@@ -7165,9 +7160,9 @@
     QUnit.test('should return `true` for empty values', function(assert) {
       assert.expect(7);
 
-      var expected = _.map(empties, _.constant(true));
+      var expected = lodashStable.map(empties, lodashStable.constant(true));
 
-      var actual = _.map(empties, function(value) {
+      var actual = lodashStable.map(empties, function(value) {
         return _.isEmpty(value);
       });
 
@@ -7276,11 +7271,11 @@
         [undefined, undefined, true], [undefined, null, false], [undefined, '', false]
       ];
 
-      var expected = _.map(pairs, function(pair) {
+      var expected = lodashStable.map(pairs, function(pair) {
         return pair[2];
       });
 
-      var actual = _.map(pairs, function(pair) {
+      var actual = lodashStable.map(pairs, function(pair) {
         return _.isEqual(pair[0], pair[1]);
       });
 
@@ -7406,7 +7401,7 @@
           'f': ['a', Object('b'), 'c'],
           'g': Object(false),
           'h': new Date(2012, 4, 23),
-          'i': _.noop,
+          'i': noop,
           'j': 'a'
         }
       };
@@ -7420,7 +7415,7 @@
           'f': ['a', 'b', 'c'],
           'g': false,
           'h': new Date(2012, 4, 23),
-          'i': _.noop,
+          'i': noop,
           'j': 'a'
         }
       };
@@ -7595,9 +7590,9 @@
       var primitive,
           object = { 'toString': function() { return primitive; } },
           values = [true, null, 1, 'a', undefined],
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         primitive = value;
         return _.isEqual(object, value);
       });
@@ -7651,14 +7646,14 @@
 
       assert.strictEqual(_.isEqual(new Date(2012, 4, 23), new Date(2012, 4, 23)), true);
       assert.strictEqual(_.isEqual(new Date(2012, 4, 23), new Date(2013, 3, 25)), false);
-      assert.strictEqual(_.isEqual(new Date(2012, 4, 23), { 'getTime': _.constant(1337756400000) }), false);
+      assert.strictEqual(_.isEqual(new Date(2012, 4, 23), { 'getTime': lodashStable.constant(1337756400000) }), false);
       assert.strictEqual(_.isEqual(new Date('a'), new Date('a')), false);
     });
 
     QUnit.test('should compare error objects', function(assert) {
       assert.expect(1);
 
-      var pairs = _.map([
+      var pairs = lodashStable.map([
         'Error',
         'EvalError',
         'RangeError',
@@ -7674,9 +7669,9 @@
         return [new CtorA('a'), new CtorA('a'), new CtorB('a'), new CtorB('b')];
       });
 
-      var expected = _.times(pairs.length, _.constant([true, false, false]));
+      var expected = lodashStable.times(pairs.length, lodashStable.constant([true, false, false]));
 
-      var actual = _.map(pairs, function(pair) {
+      var actual = lodashStable.map(pairs, function(pair) {
         return [_.isEqual(pair[0], pair[1]), _.isEqual(pair[0], pair[2]), _.isEqual(pair[2], pair[3])];
       });
 
@@ -7760,7 +7755,7 @@
     QUnit.test('should compare typed arrays', function(assert) {
       assert.expect(1);
 
-      var pairs = _.map(typedArrays, function(type, index) {
+      var pairs = lodashStable.map(typedArrays, function(type, index) {
         var otherType = typedArrays[(index + 1) % typedArrays.length],
             CtorA = root[type] || function(n) { this.n = n; },
             CtorB = root[otherType] || function(n) { this.n = n; },
@@ -7771,9 +7766,9 @@
         return [new CtorA(bufferA), new CtorA(bufferA), new CtorB(bufferB), new CtorB(bufferC)];
       });
 
-      var expected = _.times(pairs.length, _.constant([true, false, false]));
+      var expected = lodashStable.times(pairs.length, lodashStable.constant([true, false, false]));
 
-      var actual = _.map(pairs, function(pair) {
+      var actual = lodashStable.map(pairs, function(pair) {
         return [_.isEqual(pair[0], pair[1]), _.isEqual(pair[0], pair[2]), _.isEqual(pair[2], pair[3])];
       });
 
@@ -7783,7 +7778,7 @@
     QUnit.test('should work as an iteratee for `_.every`', function(assert) {
       assert.expect(1);
 
-      var actual = _.every([1, 1, 1], _.partial(_.isEqual, 1));
+      var actual = lodashStable.every([1, 1, 1], lodashStable.partial(_.isEqual, 1));
       assert.ok(actual);
     });
 
@@ -7835,7 +7830,7 @@
         ['a', 'a', 'A']
       ];
 
-      _.each(values, function(vals) {
+      lodashStable.each(values, function(vals) {
         if (!isNpm) {
           var wrapped1 = _(vals[0]),
               wrapped2 = _(vals[1]),
@@ -7941,9 +7936,9 @@
     QUnit.test('should handle comparisons if `customizer` returns `undefined`', function(assert) {
       assert.expect(3);
 
-      assert.strictEqual(_.isEqualWith('a', 'a', _.noop), true);
-      assert.strictEqual(_.isEqualWith(['a'], ['a'], _.noop), true);
-      assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'a' }, _.noop), true);
+      assert.strictEqual(_.isEqualWith('a', 'a', noop), true);
+      assert.strictEqual(_.isEqualWith(['a'], ['a'], noop), true);
+      assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'a' }, noop), true);
     });
 
     QUnit.test('should not handle comparisons if `customizer` returns `true`', function(assert) {
@@ -7973,15 +7968,15 @@
     QUnit.test('should return a boolean value even if `customizer` does not', function(assert) {
       assert.expect(2);
 
-      var actual = _.isEqualWith('a', 'b', _.constant('c'));
+      var actual = _.isEqualWith('a', 'b', lodashStable.constant('c'));
       assert.strictEqual(actual, true);
 
       var values = _.without(falsey, undefined),
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
       actual = [];
-      _.each(values, function(value) {
-        actual.push(_.isEqualWith('a', 'a', _.constant(value)));
+      lodashStable.each(values, function(value) {
+        actual.push(_.isEqualWith('a', 'a', lodashStable.constant(value)));
       });
 
       assert.deepEqual(actual, expected);
@@ -7992,7 +7987,7 @@
 
       var array = [1, 2, 3],
           eq = _.partial(_.isEqualWith, array),
-          actual = _.map([array, [1, 0, 3]], eq);
+          actual = lodashStable.map([array, [1, 0, 3]], eq);
 
       assert.deepEqual(actual, [true, false]);
     });
@@ -8016,7 +8011,7 @@
         var set2 = new Set;
         set2.add(value);
       }
-      _.each([[map1, map2], [set1, set2]], function(pair, index) {
+      lodashStable.each([[map1, map2], [set1, set2]], function(pair, index) {
         if (pair[0]) {
           var argsList = [],
               array = _.toArray(pair[0]);
@@ -8057,9 +8052,9 @@
     QUnit.test('should return `true` for error objects', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(errors, _.constant(true));
+      var expected = lodashStable.map(errors, lodashStable.constant(true));
 
-      var actual = _.map(errors, function(error) {
+      var actual = lodashStable.map(errors, function(error) {
         return _.isError(error) === true;
       });
 
@@ -8069,9 +8064,9 @@
     QUnit.test('should return `false` for non error objects', function(assert) {
       assert.expect(11);
 
-      var expected = _.map(falsey, _.constant(false));
+      var expected = lodashStable.map(falsey, lodashStable.constant(false));
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isError(value) : _.isError();
       });
 
@@ -8093,9 +8088,9 @@
       assert.expect(1);
 
       if (realm.errors) {
-        var expected = _.map(realm.errors, _.constant(true));
+        var expected = lodashStable.map(realm.errors, lodashStable.constant(true));
 
-        var actual = _.map(realm.errors, function(error) {
+        var actual = lodashStable.map(realm.errors, function(error) {
           return _.isError(error) === true;
         });
 
@@ -8118,9 +8113,9 @@
       assert.expect(1);
 
       var values = [0, 1, 3.14, -1],
-          expected = _.map(values, _.constant(true));
+          expected = lodashStable.map(values, lodashStable.constant(true));
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return _.isFinite(value);
       });
 
@@ -8131,9 +8126,9 @@
       assert.expect(1);
 
       var values = [NaN, Infinity, -Infinity, Object(1)],
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return _.isFinite(value);
       });
 
@@ -8144,9 +8139,9 @@
       assert.expect(9);
 
       var values = [undefined, [], true, '', ' ', '2px'],
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return _.isFinite(value);
       });
 
@@ -8166,9 +8161,9 @@
       assert.expect(1);
 
       var values = ['2', '0', '08'],
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return _.isFinite(value);
       });
 
@@ -8193,7 +8188,7 @@
     QUnit.test('should return `true` for generator functions', function(assert) {
       assert.expect(1);
 
-      var generator = _.attempt(function() {
+      var generator = lodashStable.attempt(function() {
         return Function('return function*(){}');
       });
 
@@ -8203,11 +8198,11 @@
     QUnit.test('should return `true` for typed array constructors', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(typedArrays, function(type) {
+      var expected = lodashStable.map(typedArrays, function(type) {
         return objToString.call(root[type]) == funcTag;
       });
 
-      var actual = _.map(typedArrays, function(type) {
+      var actual = lodashStable.map(typedArrays, function(type) {
         return _.isFunction(root[type]);
       });
 
@@ -8217,9 +8212,9 @@
     QUnit.test('should return `false` for non-functions', function(assert) {
       assert.expect(11);
 
-      var expected = _.map(falsey, _.constant(false));
+      var expected = lodashStable.map(falsey, lodashStable.constant(false));
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isFunction(value) : _.isFunction();
       });
 
@@ -8247,9 +8242,9 @@
 
       // Trigger a Chakra JIT bug.
       // See https://github.com/jashkenas/underscore/issues/1621.
-      _.each([body, xml], function(object) {
+      lodashStable.each([body, xml], function(object) {
         if (object) {
-          _.times(100, _.isFunction);
+          lodashStable.times(100, _.isFunction);
           assert.strictEqual(_.isFunction(object), false);
         }
         else {
@@ -8274,7 +8269,7 @@
 
   QUnit.module('isInteger methods');
 
-  _.each(['isInteger', 'isSafeInteger'], function(methodName) {
+  lodashStable.each(['isInteger', 'isSafeInteger'], function(methodName) {
     var args = arguments,
         func = _[methodName],
         isSafe = methodName == 'isSafeInteger';
@@ -8283,9 +8278,9 @@
       assert.expect(2);
 
       var values = [-1, 0, 1],
-          expected = _.map(values, _.constant(true));
+          expected = lodashStable.map(values, lodashStable.constant(true));
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return func(value);
       });
 
@@ -8297,9 +8292,9 @@
       assert.expect(1);
 
       var values = [NaN, Infinity, -Infinity, Object(1), 3.14],
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return func(value);
       });
 
@@ -8309,11 +8304,11 @@
     QUnit.test('should return `false` for non-numeric values', function(assert) {
       assert.expect(9);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === 0;
       });
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? func(value) : func();
       });
 
@@ -8365,9 +8360,9 @@
 
       var objects = [{ 'a': 1 }, { 'a': 1, 'b': 2 }],
           source = new Foo,
-          expected = _.map(objects, _.constant(true));
+          expected = lodashStable.map(objects, lodashStable.constant(true));
 
-      var actual = _.map(objects, function(object) {
+      var actual = lodashStable.map(objects, function(object) {
         return _.isMatch(object, source);
       });
 
@@ -8397,7 +8392,7 @@
     QUnit.test('should compare functions by reference', function(assert) {
       assert.expect(3);
 
-      var object1 = { 'a': _.noop },
+      var object1 = { 'a': lodashStable.noop },
           object2 = { 'a': noop },
           object3 = { 'a': {} };
 
@@ -8425,7 +8420,7 @@
 
       var objects = [{ 'a': 1 }, { 'a': 1, 'b': Foo.b, 'c': 3 }];
 
-      var actual = _.map(objects, function(object) {
+      var actual = lodashStable.map(objects, function(object) {
         return _.isMatch(object, Foo);
       });
 
@@ -8438,17 +8433,17 @@
       var objects = [{ 'a': ['b'] }, { 'a': ['c', 'd'] }],
           source = { 'a': ['d'] },
           predicate = function(object) { return _.isMatch(object, source); },
-          actual = _.filter(objects, predicate);
+          actual = lodashStable.filter(objects, predicate);
 
       assert.deepEqual(actual, [objects[1]]);
 
       source = { 'a': ['b', 'd'] };
-      actual = _.filter(objects, predicate);
+      actual = lodashStable.filter(objects, predicate);
 
       assert.deepEqual(actual, []);
 
       source = { 'a': ['d', 'b'] };
-      actual = _.filter(objects, predicate);
+      actual = lodashStable.filter(objects, predicate);
       assert.deepEqual(actual, []);
     });
 
@@ -8462,7 +8457,7 @@
         { 'a': [{ 'b': 1, 'c': 2 }, { 'b': 4, 'c': 6, 'd': 7 }] }
       ];
 
-      var actual = _.filter(objects, function(object) {
+      var actual = lodashStable.filter(objects, function(object) {
         return _.isMatch(object, source);
       });
 
@@ -8483,17 +8478,17 @@
 
         var source = { 'a': map },
             predicate = function(object) { return _.isMatch(object, source); },
-            actual = _.filter(objects, predicate);
+            actual = lodashStable.filter(objects, predicate);
 
         assert.deepEqual(actual, [objects[1]]);
 
         map['delete']('b');
-        actual = _.filter(objects, predicate);
+        actual = lodashStable.filter(objects, predicate);
 
         assert.deepEqual(actual, objects);
 
         map.set('c', 3);
-        actual = _.filter(objects, predicate);
+        actual = lodashStable.filter(objects, predicate);
 
         assert.deepEqual(actual, []);
       }
@@ -8516,17 +8511,17 @@
 
         var source = { 'a': set },
             predicate = function(object) { return _.isMatch(object, source); },
-            actual = _.filter(objects, predicate);
+            actual = lodashStable.filter(objects, predicate);
 
         assert.deepEqual(actual, [objects[1]]);
 
         set['delete'](2);
-        actual = _.filter(objects, predicate);
+        actual = lodashStable.filter(objects, predicate);
 
         assert.deepEqual(actual, objects);
 
         set.add(3);
-        actual = _.filter(objects, predicate);
+        actual = lodashStable.filter(objects, predicate);
 
         assert.deepEqual(actual, []);
       }
@@ -8538,7 +8533,7 @@
     QUnit.test('should match properties when `object` is not a plain object', function(assert) {
       assert.expect(1);
 
-      function Foo(object) { _.assign(this, object); }
+      function Foo(object) { lodashStable.assign(this, object); }
 
       var object = new Foo({ 'a': new Foo({ 'b': 1, 'c': 2 }) });
       assert.strictEqual(_.isMatch(object, { 'a': { 'b': 1 } }), true);
@@ -8550,19 +8545,19 @@
       var objects = [{ 'a': 1 }, { 'a': 1, 'b': 1 }, { 'a': 1, 'b': undefined }],
           source = { 'b': undefined },
           predicate = function(object) { return _.isMatch(object, source); },
-          actual = _.map(objects, predicate),
+          actual = lodashStable.map(objects, predicate),
           expected = [false, false, true];
 
       assert.deepEqual(actual, expected);
 
       source = { 'a': 1, 'b': undefined };
-      actual = _.map(objects, predicate);
+      actual = lodashStable.map(objects, predicate);
 
       assert.deepEqual(actual, expected);
 
       objects = [{ 'a': { 'b': 1 } }, { 'a':{ 'b': 1, 'c': 1 } }, { 'a': { 'b': 1, 'c': undefined } }];
       source = { 'a': { 'c': undefined } };
-      actual = _.map(objects, predicate);
+      actual = lodashStable.map(objects, predicate);
 
       assert.deepEqual(actual, expected);
     });
@@ -8597,10 +8592,10 @@
       assert.expect(1);
 
       var values = [null, undefined],
-          expected = _.map(values, _.constant(false)),
+          expected = lodashStable.map(values, lodashStable.constant(false)),
           source = { 'a': 1 };
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         try {
           return _.isMatch(value, source);
         } catch (e) {}
@@ -8613,10 +8608,10 @@
       assert.expect(1);
 
       var values = [null, undefined],
-          expected = _.map(values, _.constant(true)),
+          expected = lodashStable.map(values, lodashStable.constant(true)),
           source = {};
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         try {
           return _.isMatch(value, source);
         } catch (e) {}
@@ -8629,9 +8624,9 @@
       assert.expect(1);
 
       var object = { 'a': 1 },
-          expected = _.map(empties, _.constant(true));
+          expected = lodashStable.map(empties, lodashStable.constant(true));
 
-      var actual = _.map(empties, function(value) {
+      var actual = lodashStable.map(empties, function(value) {
         return _.isMatch(object, value);
       });
 
@@ -8644,7 +8639,7 @@
       var objects = [{ 'a': [1], 'b': { 'c': 1 } }, { 'a': [2, 3], 'b': { 'd': 2 } }],
           source = { 'a': [], 'b': {} };
 
-      var actual = _.filter(objects, function(object) {
+      var actual = lodashStable.filter(objects, function(object) {
         return _.isMatch(object, source);
       });
 
@@ -8692,7 +8687,7 @@
     QUnit.test('should handle comparisons if `customizer` returns `undefined`', function(assert) {
       assert.expect(1);
 
-      assert.strictEqual(_.isMatchWith({ 'a': 1 }, { 'a': 1 }, _.noop), true);
+      assert.strictEqual(_.isMatchWith({ 'a': 1 }, { 'a': 1 }, noop), true);
     });
 
     QUnit.test('should not handle comparisons if `customizer` returns `true`', function(assert) {
@@ -8721,15 +8716,15 @@
       assert.expect(2);
 
       var object = { 'a': 1 },
-          actual = _.isMatchWith(object, { 'a': 1 }, _.constant('a'));
+          actual = _.isMatchWith(object, { 'a': 1 }, lodashStable.constant('a'));
 
       assert.strictEqual(actual, true);
 
-      var expected = _.map(falsey, _.constant(false));
+      var expected = lodashStable.map(falsey, lodashStable.constant(false));
 
       actual = [];
-      _.each(falsey, function(value) {
-        actual.push(_.isMatchWith(object, { 'a': 2 }, _.constant(value)));
+      lodashStable.each(falsey, function(value) {
+        actual.push(_.isMatchWith(object, { 'a': 2 }, lodashStable.constant(value)));
       });
 
       assert.deepEqual(actual, expected);
@@ -8740,7 +8735,7 @@
 
       var object = { 'a': 1 },
           matches = _.partial(_.isMatchWith, object),
-          actual = _.map([object, { 'a': 2 }], matches);
+          actual = lodashStable.map([object, { 'a': 2 }], matches);
 
       assert.deepEqual(actual, [true, false]);
     });
@@ -8764,7 +8759,7 @@
         var set2 = new Set;
         set2.add(value);
       }
-      _.each([[map1, map2], [set1, set2]], function(pair, index) {
+      lodashStable.each([[map1, map2], [set1, set2]], function(pair, index) {
         if (pair[0]) {
           var argsList = [],
               array = _.toArray(pair[0]),
@@ -8811,11 +8806,11 @@
     QUnit.test('should return `false` for non-NaNs', function(assert) {
       assert.expect(13);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value !== value;
       });
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isNaN(value) : _.isNaN();
       });
 
@@ -8857,7 +8852,7 @@
     QUnit.test('should return `true` for native methods', function(assert) {
       assert.expect(6);
 
-      _.each([Array, create, root.encodeURI, slice, Uint8Array], function(func) {
+      lodashStable.each([Array, create, root.encodeURI, slice, Uint8Array], function(func) {
         if (func) {
           assert.strictEqual(_.isNative(func), true);
         }
@@ -8877,9 +8872,9 @@
     QUnit.test('should return `false` for non-native methods', function(assert) {
       assert.expect(11);
 
-      var expected = _.map(falsey, _.constant(false));
+      var expected = lodashStable.map(falsey, lodashStable.constant(false));
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isNative(value) : _.isNative();
       });
 
@@ -8931,11 +8926,11 @@
     QUnit.test('should return `false` for non `null` values', function(assert) {
       assert.expect(12);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === null;
       });
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isNull(value) : _.isNull();
       });
 
@@ -8984,11 +8979,11 @@
     QUnit.test('should return `false` for non-nullish values', function(assert) {
       assert.expect(12);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value == null;
       });
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isNil(value) : _.isNil();
       });
 
@@ -9038,11 +9033,11 @@
     QUnit.test('should return `false` for non-numbers', function(assert) {
       assert.expect(11);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return typeof value == 'number';
       });
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isNumber(value) : _.isNumber();
       });
 
@@ -9112,9 +9107,9 @@
 
       var symbol = (Symbol || noop)(),
           values = falsey.concat(true, 1, 'a', symbol),
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.isObject(value) : _.isObject();
       });
 
@@ -9187,9 +9182,9 @@
 
       var symbol = (Symbol || noop)(),
           values = falsey.concat(true, _, slice, 1, 'a', symbol),
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.isObjectLike(value) : _.isObjectLike();
       });
 
@@ -9287,9 +9282,9 @@
     QUnit.test('should return `false` for non-objects', function(assert) {
       assert.expect(3);
 
-      var expected = _.map(falsey, _.constant(false));
+      var expected = lodashStable.map(falsey, lodashStable.constant(false));
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isPlainObject(value) : _.isPlainObject();
       });
 
@@ -9328,9 +9323,9 @@
     QUnit.test('should return `false` for non-regexes', function(assert) {
       assert.expect(11);
 
-      var expected = _.map(falsey, _.constant(false));
+      var expected = lodashStable.map(falsey, lodashStable.constant(false));
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isRegExp(value) : _.isRegExp();
       });
 
@@ -9377,11 +9372,11 @@
     QUnit.test('should return `false` for non-strings', function(assert) {
       assert.expect(11);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === '';
       });
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isString(value) : _.isString();
       });
 
@@ -9421,11 +9416,11 @@
     QUnit.test('should return `true` for typed arrays', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(typedArrays, function(type) {
+      var expected = lodashStable.map(typedArrays, function(type) {
         return type in root;
       });
 
-      var actual = _.map(typedArrays, function(type) {
+      var actual = lodashStable.map(typedArrays, function(type) {
         var Ctor = root[type];
         return Ctor ? _.isTypedArray(new Ctor(new ArrayBuffer(8))) : false;
       });
@@ -9436,9 +9431,9 @@
     QUnit.test('should return `false` for non typed arrays', function(assert) {
       assert.expect(12);
 
-      var expected = _.map(falsey, _.constant(false));
+      var expected = lodashStable.map(falsey, lodashStable.constant(false));
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isTypedArray(value) : _.isTypedArray();
       });
 
@@ -9463,11 +9458,11 @@
       if (realm.object) {
         var props = _.invoke(typedArrays, 'toLowerCase');
 
-        var expected = _.map(props, function(key) {
+        var expected = lodashStable.map(props, function(key) {
           return key in realm;
         });
 
-        var actual = _.map(props, function(key) {
+        var actual = lodashStable.map(props, function(key) {
           var value = realm[key];
           return value ? _.isTypedArray(value) : false;
         });
@@ -9497,11 +9492,11 @@
     QUnit.test('should return `false` for non `undefined` values', function(assert) {
       assert.expect(12);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === undefined;
       });
 
-      var actual = _.map(falsey, function(value, index) {
+      var actual = lodashStable.map(falsey, function(value, index) {
         return index ? _.isUndefined(value) : _.isUndefined();
       });
 
@@ -9545,7 +9540,7 @@
         'isFunction', 'isNumber', 'isRegExp', 'isString'
       ];
 
-      _.each(funcs, function(methodName) {
+      lodashStable.each(funcs, function(methodName) {
         function Foo() {}
         Foo.prototype = root[methodName.slice(2)].prototype;
 
@@ -9568,7 +9563,7 @@
         'isSafeInteger', 'isString', 'isUndefined'
       ];
 
-      _.each(funcs, function(methodName) {
+      lodashStable.each(funcs, function(methodName) {
         if (xml) {
           var pass = true;
 
@@ -9606,9 +9601,9 @@
 
       var object = {},
           values = [, null, undefined],
-          expected = _.map(values, _.constant([!isNpm && _.identity, object]));
+          expected = lodashStable.map(values, lodashStable.constant([!isNpm && _.identity, object]));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         var identity = index ? _.iteratee(value) : _.iteratee();
         return [!isNpm && identity, identity(object)];
       });
@@ -9633,8 +9628,8 @@
         { 'a': 1 }
       ];
 
-      _.each(sources, function(source, index) {
-        var object = _.cloneDeep(source),
+      lodashStable.each(sources, function(source, index) {
+        var object = lodashStable.cloneDeep(source),
             matches = _.iteratee(source);
 
         assert.strictEqual(matches(object), true);
@@ -9721,10 +9716,10 @@
 
       var fn = function() { return this instanceof Number; },
           array = [fn, fn, fn],
-          iteratees = _.map(array, _.iteratee),
-          expected = _.map(array, _.constant(false));
+          iteratees = lodashStable.map(array, _.iteratee),
+          expected = lodashStable.map(array, lodashStable.constant(false));
 
-      var actual = _.map(iteratees, function(iteratee) {
+      var actual = lodashStable.map(iteratees, function(iteratee) {
         return iteratee();
       });
 
@@ -10265,9 +10260,9 @@
 
       var array = [4, 6, 6],
           values = [, null, undefined],
-          expected = _.map(values, _.constant({ '4': 4, '6': 6 }));
+          expected = lodashStable.map(values, lodashStable.constant({ '4': 4, '6': 6 }));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.keyBy(array, value) : _.keyBy(array);
       });
 
@@ -10319,9 +10314,9 @@
       assert.expect(1);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE).concat(
-          _.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE),
-          _.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE)
+        var array = lodashStable.range(LARGE_ARRAY_SIZE).concat(
+          lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE),
+          lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE)
         );
 
         var actual = _(array).keyBy().map(square).filter(isEven).take().value();
@@ -10338,7 +10333,7 @@
 
   QUnit.module('keys methods');
 
-  _.each(['keys', 'keysIn'], function(methodName) {
+  lodashStable.each(['keys', 'keysIn'], function(methodName) {
     var args = arguments,
         func = _[methodName],
         isKeys = methodName == 'keys';
@@ -10373,7 +10368,7 @@
       assert.expect(2);
 
       objectProto.a = 1;
-      _.each([null, undefined], function(value) {
+      lodashStable.each([null, undefined], function(value) {
         assert.deepEqual(func(value), []);
       });
       delete objectProto.a;
@@ -10501,7 +10496,7 @@
       assert.expect(1);
 
       var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-          actual = _.map(array, _.last);
+          actual = lodashStable.map(array, _.last);
 
       assert.deepEqual(actual, [3, 6, 9]);
     });
@@ -10544,10 +10539,10 @@
       assert.expect(2);
 
       if (!isNpm) {
-        var largeArray = _.range(LARGE_ARRAY_SIZE),
+        var largeArray = lodashStable.range(LARGE_ARRAY_SIZE),
             smallArray = array;
 
-        _.times(2, function(index) {
+        lodashStable.times(2, function(index) {
           var array = index ? largeArray : smallArray,
               wrapped = _(array).filter(isEven);
 
@@ -10655,9 +10650,9 @@
       assert.expect(1);
 
       var values = [6, 8, Math.pow(2, 32), Infinity],
-          expected = _.map(values, _.constant([-1, 3, -1]));
+          expected = lodashStable.map(values, lodashStable.constant([-1, 3, -1]));
 
-      var actual = _.map(values, function(fromIndex) {
+      var actual = lodashStable.map(values, function(fromIndex) {
         return [
           _.lastIndexOf(array, undefined, fromIndex),
           _.lastIndexOf(array, 1, fromIndex),
@@ -10678,9 +10673,9 @@
       assert.expect(1);
 
       var values = [-6, -8, -Infinity],
-          expected = _.map(values, _.constant(0));
+          expected = lodashStable.map(values, lodashStable.constant(0));
 
-      var actual = _.map(values, function(fromIndex) {
+      var actual = lodashStable.map(values, function(fromIndex) {
         return _.lastIndexOf(array, 1, fromIndex);
       });
 
@@ -10690,11 +10685,11 @@
     QUnit.test('should treat falsey `fromIndex` values correctly', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === undefined ? 5 : -1;
       });
 
-      var actual = _.map(falsey, function(fromIndex) {
+      var actual = lodashStable.map(falsey, function(fromIndex) {
         return _.lastIndexOf(array, 3, fromIndex);
       });
 
@@ -10712,7 +10707,7 @@
 
   QUnit.module('indexOf methods');
 
-  _.each(['indexOf', 'lastIndexOf', 'sortedIndexOf', 'sortedLastIndexOf'], function(methodName) {
+  lodashStable.each(['indexOf', 'lastIndexOf', 'sortedIndexOf', 'sortedLastIndexOf'], function(methodName) {
     var func = _[methodName],
         isIndexOf = !/last/i.test(methodName),
         isSorted = /^sorted/.test(methodName);
@@ -10720,9 +10715,9 @@
     QUnit.test('`_.' + methodName + '` should accept a falsey `array` argument', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant(-1));
+      var expected = lodashStable.map(falsey, lodashStable.constant(-1));
 
-      var actual = _.map(falsey, function(array, index) {
+      var actual = lodashStable.map(falsey, function(array, index) {
         try {
           return index ? func(array) : func();
         } catch (e) {}
@@ -10886,7 +10881,7 @@
       var value = { 'value': 'x' },
           object = { 'length': { 'value': 'x' } };
 
-      assert.deepEqual(_.map(object, _.identity), [value]);
+      assert.deepEqual(_.map(object, lodashStable.identity), [value]);
     });
 
     QUnit.test('should treat a nodelist as an array-like object', function(assert) {
@@ -10907,9 +10902,9 @@
     QUnit.test('should accept a falsey `collection` argument', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant([]));
+      var expected = lodashStable.map(falsey, lodashStable.constant([]));
 
-      var actual = _.map(falsey, function(collection, index) {
+      var actual = lodashStable.map(falsey, function(collection, index) {
         try {
           return index ? _.map(collection) : _.map();
         } catch (e) {}
@@ -10928,7 +10923,7 @@
       assert.expect(1);
 
       if (!isNpm) {
-        assert.ok(_(array).map(_.noop) instanceof _);
+        assert.ok(_(array).map(noop) instanceof _);
       }
       else {
         skipTest(assert);
@@ -10940,7 +10935,7 @@
 
       if (!isNpm) {
         var args,
-            array = _.range(LARGE_ARRAY_SIZE + 1),
+            array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
             expected = [1, 0, _.map(array.slice(1), square)];
 
         _(array).slice(1).map(function(value, index, array) {
@@ -11062,7 +11057,7 @@
 
   QUnit.module('lodash.mapKeys and lodash.mapValues');
 
-  _.each(['mapKeys', 'mapValues'], function(methodName) {
+  lodashStable.each(['mapKeys', 'mapValues'], function(methodName) {
     var array = [1, 2],
         func = _[methodName],
         object = { 'a': 1, 'b': 2, 'c': 3 };
@@ -11080,9 +11075,9 @@
     QUnit.test('should accept a falsey `object` argument', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant({}));
+      var expected = lodashStable.map(falsey, lodashStable.constant({}));
 
-      var actual = _.map(falsey, function(object, index) {
+      var actual = lodashStable.map(falsey, function(object, index) {
         try {
           return index ? func(object) : func();
         } catch (e) {}
@@ -11095,7 +11090,7 @@
       assert.expect(1);
 
       if (!isNpm) {
-        assert.ok(_(object)[methodName](_.noop) instanceof _);
+        assert.ok(_(object)[methodName](noop) instanceof _);
       }
       else {
         skipTest(assert);
@@ -11152,8 +11147,8 @@
 
       var objects = [{ 'a': 1 }, { 'a': 1, 'b': 2 }],
           source = new Foo,
-          actual = _.map(objects, _.matches(source)),
-          expected = _.map(objects, _.constant(true));
+          actual = lodashStable.map(objects, _.matches(source)),
+          expected = lodashStable.map(objects, lodashStable.constant(true));
 
       assert.deepEqual(actual, expected);
     });
@@ -11185,7 +11180,7 @@
     QUnit.test('should compare functions by reference', function(assert) {
       assert.expect(3);
 
-      var object1 = { 'a': _.noop },
+      var object1 = { 'a': lodashStable.noop },
           object2 = { 'a': noop },
           object3 = { 'a': {} },
           matches = _.matches(object1);
@@ -11214,7 +11209,7 @@
       Foo.c = 3;
 
       var objects = [{ 'a': 1 }, { 'a': 1, 'b': Foo.b, 'c': 3 }],
-          actual = _.map(objects, _.matches(Foo));
+          actual = lodashStable.map(objects, _.matches(Foo));
 
       assert.deepEqual(actual, [false, true]);
     });
@@ -11223,14 +11218,14 @@
       assert.expect(3);
 
       var objects = [{ 'a': ['b'] }, { 'a': ['c', 'd'] }],
-          actual = _.filter(objects, _.matches({ 'a': ['d'] }));
+          actual = lodashStable.filter(objects, _.matches({ 'a': ['d'] }));
 
       assert.deepEqual(actual, [objects[1]]);
 
-      actual = _.filter(objects, _.matches({ 'a': ['b', 'd'] }));
+      actual = lodashStable.filter(objects, _.matches({ 'a': ['b', 'd'] }));
       assert.deepEqual(actual, []);
 
-      actual = _.filter(objects, _.matches({ 'a': ['d', 'b'] }));
+      actual = lodashStable.filter(objects, _.matches({ 'a': ['d', 'b'] }));
       assert.deepEqual(actual, []);
     });
 
@@ -11242,7 +11237,7 @@
         { 'a': [{ 'b': 1, 'c': 2 }, { 'b': 4, 'c': 6, 'd': 7 }] }
       ];
 
-      var actual = _.filter(objects, _.matches({ 'a': [{ 'b': 1 }, { 'b': 4, 'c': 5 }] }));
+      var actual = lodashStable.filter(objects, _.matches({ 'a': [{ 'b': 1 }, { 'b': 4, 'c': 5 }] }));
       assert.deepEqual(actual, [objects[0]]);
     });
 
@@ -11257,17 +11252,17 @@
 
         var map = new Map;
         map.set('b', 2);
-        var actual = _.filter(objects, _.matches({ 'a': map }));
+        var actual = lodashStable.filter(objects, _.matches({ 'a': map }));
 
         assert.deepEqual(actual, [objects[1]]);
 
         map['delete']('b');
-        actual = _.filter(objects, _.matches({ 'a': map }));
+        actual = lodashStable.filter(objects, _.matches({ 'a': map }));
 
         assert.deepEqual(actual, objects);
 
         map.set('c', 3);
-        actual = _.filter(objects, _.matches({ 'a': map }));
+        actual = lodashStable.filter(objects, _.matches({ 'a': map }));
 
         assert.deepEqual(actual, []);
       }
@@ -11287,17 +11282,17 @@
 
         var set = new Set;
         set.add(2);
-        var actual = _.filter(objects, _.matches({ 'a': set }));
+        var actual = lodashStable.filter(objects, _.matches({ 'a': set }));
 
         assert.deepEqual(actual, [objects[1]]);
 
         set['delete'](2);
-        actual = _.filter(objects, _.matches({ 'a': set }));
+        actual = lodashStable.filter(objects, _.matches({ 'a': set }));
 
         assert.deepEqual(actual, objects);
 
         set.add(3);
-        actual = _.filter(objects, _.matches({ 'a': set }));
+        actual = lodashStable.filter(objects, _.matches({ 'a': set }));
 
         assert.deepEqual(actual, []);
       }
@@ -11309,7 +11304,7 @@
     QUnit.test('should match properties when `object` is not a plain object', function(assert) {
       assert.expect(1);
 
-      function Foo(object) { _.assign(this, object); }
+      function Foo(object) { lodashStable.assign(this, object); }
 
       var object = new Foo({ 'a': new Foo({ 'b': 1, 'c': 2 }) }),
           matches = _.matches({ 'a': { 'b': 1 } });
@@ -11321,17 +11316,17 @@
       assert.expect(3);
 
       var objects = [{ 'a': 1 }, { 'a': 1, 'b': 1 }, { 'a': 1, 'b': undefined }],
-          actual = _.map(objects, _.matches({ 'b': undefined })),
+          actual = lodashStable.map(objects, _.matches({ 'b': undefined })),
           expected = [false, false, true];
 
       assert.deepEqual(actual, expected);
 
-      actual = _.map(objects, _.matches({ 'a': 1, 'b': undefined }));
+      actual = lodashStable.map(objects, _.matches({ 'a': 1, 'b': undefined }));
 
       assert.deepEqual(actual, expected);
 
       objects = [{ 'a': { 'b': 1 } }, { 'a': { 'b': 1, 'c': 1 } }, { 'a': { 'b': 1, 'c': undefined } }];
-      actual = _.map(objects, _.matches({ 'a': { 'c': undefined } }));
+      actual = lodashStable.map(objects, _.matches({ 'a': { 'c': undefined } }));
 
       assert.deepEqual(actual, expected);
     });
@@ -11369,10 +11364,10 @@
       assert.expect(1);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(false)),
+          expected = lodashStable.map(values, lodashStable.constant(false)),
           matches = _.matches({ 'a': 1 });
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         try {
           return index ? matches(value) : matches();
         } catch (e) {}
@@ -11385,10 +11380,10 @@
       assert.expect(1);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(true)),
+          expected = lodashStable.map(values, lodashStable.constant(true)),
           matches = _.matches({});
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         try {
           return index ? matches(value) : matches();
         } catch (e) {}
@@ -11401,9 +11396,9 @@
       assert.expect(1);
 
       var object = { 'a': 1 },
-          expected = _.map(empties, _.constant(true));
+          expected = lodashStable.map(empties, lodashStable.constant(true));
 
-      var actual = _.map(empties, function(value) {
+      var actual = lodashStable.map(empties, function(value) {
         var matches = _.matches(value);
         return matches(object);
       });
@@ -11415,7 +11410,7 @@
       assert.expect(1);
 
       var objects = [{ 'a': [1], 'b': { 'c': 1 } }, { 'a': [2, 3], 'b': { 'd': 2 } }],
-          actual = _.filter(objects, _.matches({ 'a': [], 'b': {} }));
+          actual = lodashStable.filter(objects, _.matches({ 'a': [], 'b': {} }));
 
       assert.deepEqual(actual, objects);
     });
@@ -11429,8 +11424,8 @@
         { 'a': 1 }
       ];
 
-      _.each(sources, function(source, index) {
-        var object = _.cloneDeep(source),
+      lodashStable.each(sources, function(source, index) {
+        var object = lodashStable.cloneDeep(source),
             matches = _.matches(source);
 
         assert.strictEqual(matches(object), true);
@@ -11484,7 +11479,7 @@
 
       var object = { 'a': { 'b': { 'c': 3 } } };
 
-      _.each(['a.b.c', ['a', 'b', 'c']], function(path) {
+      lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path) {
         var matches = _.matchesProperty(path, 3);
         assert.strictEqual(matches(object), true);
       });
@@ -11494,18 +11489,18 @@
       assert.expect(1);
 
       function fn() {}
-      fn.toString = _.constant('fn');
+      fn.toString = lodashStable.constant('fn');
 
       var objects = [{ 'null': 1 }, { 'undefined': 2 }, { 'fn': 3 }, { '[object Object]': 4 }],
           values = [null, undefined, fn, {}];
 
-      var expected = _.transform(values, function(result) {
+      var expected = lodashStable.transform(values, function(result) {
         result.push(true, true);
       });
 
-      var actual = _.transform(objects, function(result, object, index) {
+      var actual = lodashStable.transform(objects, function(result, object, index) {
         var key = values[index];
-        _.each([key, [key]], function(path) {
+        lodashStable.each([key, [key]], function(path) {
           var matches = _.matchesProperty(path, object[key]);
           result.push(matches(object));
         });
@@ -11519,7 +11514,7 @@
 
       var object = { 'a.b.c': 3, 'a': { 'b': { 'c': 4 } } };
 
-      _.each(['a.b.c', ['a.b.c']], function(path) {
+      lodashStable.each(['a.b.c', ['a.b.c']], function(path) {
         var matches = _.matchesProperty(path, 3);
         assert.strictEqual(matches(object), true);
       });
@@ -11530,7 +11525,7 @@
 
       var array = [1, 2, 3];
 
-      _.each([1, [1]], function(path) {
+      lodashStable.each([1, [1]], function(path) {
         var matches = _.matchesProperty(path, 2);
         assert.strictEqual(matches(array), true);
       });
@@ -11541,7 +11536,7 @@
 
       var object = {};
 
-      _.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
+      lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
         var matches = _.matchesProperty(path, 1);
         assert.strictEqual(matches(object), false);
       });
@@ -11551,12 +11546,12 @@
       assert.expect(2);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      _.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
+      lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
         var matches = _.matchesProperty(path, 1);
 
-        var actual = _.map(values, function(value, index) {
+        var actual = lodashStable.map(values, function(value, index) {
           try {
             return index ? matches(value) : matches();
           } catch (e) {}
@@ -11574,7 +11569,7 @@
 
       var object = { 'a': new Foo };
 
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         var matches = _.matchesProperty(path, { 'b': 2 });
         assert.strictEqual(matches(object), true);
       });
@@ -11587,10 +11582,10 @@
       Foo.prototype.b = 2;
 
       var objects = [{ 'a': { 'a': 1 } }, { 'a': { 'a': 1, 'b': 2 } }],
-          expected = _.map(objects, _.constant(true));
+          expected = lodashStable.map(objects, lodashStable.constant(true));
 
-      _.each(['a', ['a']], function(path) {
-        assert.deepEqual(_.map(objects, _.matchesProperty(path, new Foo)), expected);
+      lodashStable.each(['a', ['a']], function(path) {
+        assert.deepEqual(lodashStable.map(objects, _.matchesProperty(path, new Foo)), expected);
       });
     });
 
@@ -11618,7 +11613,7 @@
     QUnit.test('should compare functions by reference', function(assert) {
       assert.expect(3);
 
-      var object1 = { 'a': _.noop },
+      var object1 = { 'a': lodashStable.noop },
           object2 = { 'a': noop },
           object3 = { 'a': {} },
           matches = _.matchesProperty('a', object1);
@@ -11637,7 +11632,7 @@
       Foo.c = 3;
 
       var objects = [{ 'a': { 'a': 1 } }, { 'a': { 'a': 1, 'b': Foo.b, 'c': 3 } }],
-          actual = _.map(objects, _.matchesProperty('a', Foo));
+          actual = lodashStable.map(objects, _.matchesProperty('a', Foo));
 
       assert.deepEqual(actual, [false, true]);
     });
@@ -11646,14 +11641,14 @@
       assert.expect(3);
 
       var objects = [{ 'a': ['b'] }, { 'a': ['c', 'd'] }],
-          actual = _.filter(objects, _.matchesProperty('a', ['d']));
+          actual = lodashStable.filter(objects, _.matchesProperty('a', ['d']));
 
       assert.deepEqual(actual, [objects[1]]);
 
-      actual = _.filter(objects, _.matchesProperty('a', ['b', 'd']));
+      actual = lodashStable.filter(objects, _.matchesProperty('a', ['b', 'd']));
       assert.deepEqual(actual, []);
 
-      actual = _.filter(objects, _.matchesProperty('a', ['d', 'b']));
+      actual = lodashStable.filter(objects, _.matchesProperty('a', ['d', 'b']));
       assert.deepEqual(actual, []);
     });
 
@@ -11665,7 +11660,7 @@
         { 'a': [{ 'a': 1, 'b': 2 }, { 'a': 4, 'b': 6, 'c': 7 }] }
       ];
 
-      var actual = _.filter(objects, _.matchesProperty('a', [{ 'a': 1 }, { 'a': 4, 'b': 5 }]));
+      var actual = lodashStable.filter(objects, _.matchesProperty('a', [{ 'a': 1 }, { 'a': 4, 'b': 5 }]));
       assert.deepEqual(actual, [objects[0]]);
     });
     QUnit.test('should partial match maps', function(assert) {
@@ -11679,17 +11674,17 @@
 
         var map = new Map;
         map.set('b', 2);
-        var actual = _.filter(objects, _.matchesProperty('a', map));
+        var actual = lodashStable.filter(objects, _.matchesProperty('a', map));
 
         assert.deepEqual(actual, [objects[1]]);
 
         map['delete']('b');
-        actual = _.filter(objects, _.matchesProperty('a', map));
+        actual = lodashStable.filter(objects, _.matchesProperty('a', map));
 
         assert.deepEqual(actual, objects);
 
         map.set('c', 3);
-        actual = _.filter(objects, _.matchesProperty('a', map));
+        actual = lodashStable.filter(objects, _.matchesProperty('a', map));
 
         assert.deepEqual(actual, []);
       }
@@ -11709,17 +11704,17 @@
 
         var set = new Set;
         set.add(2);
-        var actual = _.filter(objects, _.matchesProperty('a', set));
+        var actual = lodashStable.filter(objects, _.matchesProperty('a', set));
 
         assert.deepEqual(actual, [objects[1]]);
 
         set['delete'](2);
-        actual = _.filter(objects, _.matchesProperty('a', set));
+        actual = lodashStable.filter(objects, _.matchesProperty('a', set));
 
         assert.deepEqual(actual, objects);
 
         set.add(3);
-        actual = _.filter(objects, _.matchesProperty('a', set));
+        actual = lodashStable.filter(objects, _.matchesProperty('a', set));
 
         assert.deepEqual(actual, []);
       }
@@ -11731,7 +11726,7 @@
     QUnit.test('should match properties when `srcValue` is not a plain object', function(assert) {
       assert.expect(1);
 
-      function Foo(object) { _.assign(this, object); }
+      function Foo(object) { lodashStable.assign(this, object); }
 
       var object = new Foo({ 'a': new Foo({ 'b': 1, 'c': 2 }) }),
           matches = _.matchesProperty('a', { 'b': 1 });
@@ -11743,13 +11738,13 @@
       assert.expect(2);
 
       var objects = [{ 'a': 1 }, { 'a': 1, 'b': 1 }, { 'a': 1, 'b': undefined }],
-          actual = _.map(objects, _.matchesProperty('b', undefined)),
+          actual = lodashStable.map(objects, _.matchesProperty('b', undefined)),
           expected = [false, false, true];
 
       assert.deepEqual(actual, expected);
 
       objects = [{ 'a': { 'a': 1 } }, { 'a': { 'a': 1, 'b': 1 } }, { 'a': { 'a': 1, 'b': undefined } }];
-      actual = _.map(objects, _.matchesProperty('a', { 'b': undefined }));
+      actual = lodashStable.map(objects, _.matchesProperty('a', { 'b': undefined }));
 
       assert.deepEqual(actual, expected);
     });
@@ -11758,12 +11753,12 @@
       assert.expect(2);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      _.each(['constructor', ['constructor']], function(path) {
+      lodashStable.each(['constructor', ['constructor']], function(path) {
         var matches = _.matchesProperty(path, 1);
 
-        var actual = _.map(values, function(value, index) {
+        var actual = lodashStable.map(values, function(value, index) {
           try {
             return index ? matches(value) : matches();
           } catch (e) {}
@@ -11802,7 +11797,7 @@
       var objects = [{ 'a': [1], 'b': { 'c': 1 } }, { 'a': [2, 3], 'b': { 'd': 2 } }],
           matches = _.matchesProperty('a', { 'a': [], 'b': {} });
 
-      var actual = _.filter(objects, function(object) {
+      var actual = lodashStable.filter(objects, function(object) {
         return matches({ 'a': object });
       });
 
@@ -11812,8 +11807,8 @@
     QUnit.test('should not change match behavior if `srcValue` is modified', function(assert) {
       assert.expect(9);
 
-      _.each([{ 'a': { 'b': 2, 'c': 3 } }, { 'a': 1, 'b': 2 }, { 'a': 1 }], function(source, index) {
-        var object = _.cloneDeep(source),
+      lodashStable.each([{ 'a': { 'b': 2, 'c': 3 } }, { 'a': 1, 'b': 2 }, { 'a': 1 }], function(source, index) {
+        var object = lodashStable.cloneDeep(source),
             matches = _.matchesProperty('a', source);
 
         assert.strictEqual(matches({ 'a': object }), true);
@@ -11848,9 +11843,9 @@
       assert.expect(1);
 
       var values = falsey.concat([[]]),
-          expected = _.map(values, _.constant(undefined));
+          expected = lodashStable.map(values, lodashStable.constant(undefined));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         try {
           return index ? _.max(value) : _.max();
         } catch (e) {}
@@ -11909,17 +11904,17 @@
     QUnit.test('should throw a TypeError if `resolve` is truthy and not a function', function(assert) {
       assert.expect(1);
 
-      assert.raises(function() { _.memoize(_.noop, {}); }, TypeError);
+      assert.raises(function() { _.memoize(noop, {}); }, TypeError);
     });
 
     QUnit.test('should not error if `resolver` is falsey', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant(true));
+      var expected = lodashStable.map(falsey, lodashStable.constant(true));
 
-      var actual = _.map(falsey, function(resolver, index) {
+      var actual = lodashStable.map(falsey, function(resolver, index) {
         try {
-          return _.isFunction(index ? _.memoize(_.noop, resolver) : _.memoize(_.noop));
+          return _.isFunction(index ? _.memoize(noop, resolver) : _.memoize(noop));
         } catch (e) {}
       });
 
@@ -11939,9 +11934,9 @@
         'valueOf'
       ];
 
-      var memoized = _.memoize(_.identity);
+      var memoized = _.memoize(lodashStable.identity);
 
-      var actual = _.map(props, function(value) {
+      var actual = lodashStable.map(props, function(value) {
         return memoized(value);
       });
 
@@ -11951,8 +11946,8 @@
     QUnit.test('should expose a `cache` object on the `memoized` function which implements `Map` interface', function(assert) {
       assert.expect(12);
 
-      _.times(2, function(index) {
-        var resolver = index ? _.identity : null;
+      lodashStable.times(2, function(index) {
+        var resolver = index ? lodashStable.identity : null;
 
         var memoized = _.memoize(function(value) {
           return 'value:' + value;
@@ -11977,9 +11972,9 @@
       var array = [],
           key = '__proto__';
 
-      _.times(2, function(index) {
+      lodashStable.times(2, function(index) {
         var count = 0,
-            resolver = index && _.identity;
+            resolver = index && lodashStable.identity;
 
         var memoized = _.memoize(function() {
           count++;
@@ -12207,7 +12202,7 @@
 
       var values = [true, 1, '1'];
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return _.merge(value, { 'a': 1 });
       });
 
@@ -12260,7 +12255,7 @@
       var array1 = [0],
           array2 = [0, 0],
           array3 = [0, 0, 0, 0],
-          array4 = _.range(0, 8, 0);
+          array4 = lodashStable.range(0, 8, 0);
 
       var arrays = [array2, array1, array4, array3, array2, array4, array4, array3, array2],
           buffer = ArrayBuffer && new ArrayBuffer(8);
@@ -12269,35 +12264,35 @@
       if (root.Float64Array && (new Float64Array(buffer)).length == 8) {
         arrays[1] = array4;
       }
-      var expected = _.map(typedArrays, function(type, index) {
+      var expected = lodashStable.map(typedArrays, function(type, index) {
         var array = arrays[index].slice();
         array[0] = 1;
         return root[type] ? { 'value': array } : false;
       });
 
-      var actual = _.map(typedArrays, function(type) {
+      var actual = lodashStable.map(typedArrays, function(type) {
         var Ctor = root[type];
         return Ctor ? _.merge({ 'value': new Ctor(buffer) }, { 'value': [1] }) : false;
       });
 
-      assert.ok(_.isArray(actual));
+      assert.ok(lodashStable.isArray(actual));
       assert.deepEqual(actual, expected);
 
-      expected = _.map(typedArrays, function(type, index) {
+      expected = lodashStable.map(typedArrays, function(type, index) {
         var array = arrays[index].slice();
         array.push(1);
         return root[type] ? { 'value': array } : false;
       });
 
-      actual = _.map(typedArrays, function(type, index) {
+      actual = lodashStable.map(typedArrays, function(type, index) {
         var Ctor = root[type],
-            array = _.range(arrays[index].length);
+            array = lodashStable.range(arrays[index].length);
 
         array.push(1);
         return Ctor ? _.merge({ 'value': array }, { 'value': new Ctor(buffer) }) : false;
       });
 
-      assert.ok(_.isArray(actual));
+      assert.ok(lodashStable.isArray(actual));
       assert.deepEqual(actual, expected);
     });
 
@@ -12314,9 +12309,9 @@
       function Foo() {}
 
       var values = [new Foo, new Boolean, new Date, Foo, new Number, new String, new RegExp],
-          expected = _.map(values, _.constant(true));
+          expected = lodashStable.map(values, lodashStable.constant(true));
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         var object = _.merge({}, { 'value': value });
         return object.value === value;
       });
@@ -12328,11 +12323,11 @@
       assert.expect(1);
 
       var values = [[], new (Uint8Array || Object), {}],
-          expected = _.map(values, _.constant(true));
+          expected = lodashStable.map(values, lodashStable.constant(true));
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         var object = _.merge({}, { 'value': value });
-        return object.value !== value && _.isEqual(object.value, value);
+        return object.value !== value && lodashStable.isEqual(object.value, value);
       });
 
       assert.deepEqual(actual, expected);
@@ -12342,7 +12337,7 @@
       assert.expect(4);
 
       function Foo(object) {
-        _.assign(this, object);
+        lodashStable.assign(this, object);
       }
 
       var object = { 'a': 1 },
@@ -12431,9 +12426,9 @@
       var object1 = { 'el': document && document.createElement('div') },
           object2 = { 'el': document && document.createElement('div') },
           pairs = [[{}, object1], [object1, object2]],
-          expected = _.map(pairs, _.constant(true));
+          expected = lodashStable.map(pairs, lodashStable.constant(true));
 
-      var actual = _.map(pairs, function(pair) {
+      var actual = lodashStable.map(pairs, function(pair) {
         try {
           return _.merge(pair[0], pair[1]).el === pair[1].el;
         } catch (e) {}
@@ -12451,10 +12446,10 @@
     QUnit.test('should handle merging if `customizer` returns `undefined`', function(assert) {
       assert.expect(2);
 
-      var actual = _.mergeWith({ 'a': { 'b': [1, 1] } }, { 'a': { 'b': [0] } }, _.noop);
+      var actual = _.mergeWith({ 'a': { 'b': [1, 1] } }, { 'a': { 'b': [0] } }, noop);
       assert.deepEqual(actual, { 'a': { 'b': [0, 1] } });
 
-      actual = _.mergeWith([], [undefined], _.identity);
+      actual = _.mergeWith([], [undefined], lodashStable.identity);
       assert.deepEqual(actual, [undefined]);
     });
 
@@ -12462,7 +12457,7 @@
       assert.expect(1);
 
       var actual = _.mergeWith({ 'a': { 'b': [0, 1] } }, { 'a': { 'b': [2] } }, function(a, b) {
-        return _.isArray(a) ? a.concat(b) : undefined;
+        return lodashStable.isArray(a) ? a.concat(b) : undefined;
       });
 
       assert.deepEqual(actual, { 'a': { 'b': [0, 1, 2] } });
@@ -12477,9 +12472,9 @@
     QUnit.test('should create a function that calls a method of a given object', function(assert) {
       assert.expect(4);
 
-      var object = { 'a': _.constant(1) };
+      var object = { 'a': lodashStable.constant(1) };
 
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         var method = _.method(path);
         assert.strictEqual(method.length, 1);
         assert.strictEqual(method(object), 1);
@@ -12489,9 +12484,9 @@
     QUnit.test('should work with deep property values', function(assert) {
       assert.expect(2);
 
-      var object = { 'a': { 'b': { 'c': _.constant(3) } } };
+      var object = { 'a': { 'b': { 'c': lodashStable.constant(3) } } };
 
-      _.each(['a.b.c', ['a', 'b', 'c']], function(path) {
+      lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path) {
         var method = _.method(path);
         assert.strictEqual(method(object), 3);
       });
@@ -12500,9 +12495,9 @@
     QUnit.test('should work with non-string `path` arguments', function(assert) {
       assert.expect(2);
 
-      var array = _.times(3, _.constant);
+      var array = lodashStable.times(3, _.constant);
 
-      _.each([1, [1]], function(path) {
+      lodashStable.each([1, [1]], function(path) {
         var method = _.method(path);
         assert.strictEqual(method(array), 1);
       });
@@ -12512,15 +12507,15 @@
       assert.expect(1);
 
       function fn() {}
-      fn.toString = _.constant('fn');
+      fn.toString = lodashStable.constant('fn');
 
       var expected = [1, 1, 2, 2, 3, 3, 4, 4],
-          objects = [{ 'null': _.constant(1) }, { 'undefined': _.constant(2) }, { 'fn': _.constant(3) }, { '[object Object]': _.constant(4) }],
+          objects = [{ 'null': lodashStable.constant(1) }, { 'undefined': lodashStable.constant(2) }, { 'fn': lodashStable.constant(3) }, { '[object Object]': lodashStable.constant(4) }],
           values = [null, undefined, fn, {}];
 
-      var actual = _.transform(objects, function(result, object, index) {
+      var actual = lodashStable.transform(objects, function(result, object, index) {
         var key = values[index];
-        _.each([key, [key]], function(path) {
+        lodashStable.each([key, [key]], function(path) {
           var method = _.method(key);
           result.push(method(object));
         });
@@ -12533,9 +12528,9 @@
       assert.expect(2);
 
       function Foo() {}
-      Foo.prototype.a = _.constant(1);
+      Foo.prototype.a = lodashStable.constant(1);
 
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         var method = _.method(path);
         assert.strictEqual(method(new Foo), 1);
       });
@@ -12544,9 +12539,9 @@
     QUnit.test('should use a key over a path', function(assert) {
       assert.expect(2);
 
-      var object = { 'a.b.c': _.constant(3), 'a': { 'b': { 'c': _.constant(4) } } };
+      var object = { 'a.b.c': lodashStable.constant(3), 'a': { 'b': { 'c': lodashStable.constant(4) } } };
 
-      _.each(['a.b.c', ['a.b.c']], function(path) {
+      lodashStable.each(['a.b.c', ['a.b.c']], function(path) {
         var method = _.method(path);
         assert.strictEqual(method(object), 3);
       });
@@ -12556,12 +12551,12 @@
       assert.expect(2);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(undefined));
+          expected = lodashStable.map(values, lodashStable.constant(undefined));
 
-      _.each(['constructor', ['constructor']], function(path) {
+      lodashStable.each(['constructor', ['constructor']], function(path) {
         var method = _.method(path);
 
-        var actual = _.map(values, function(value, index) {
+        var actual = lodashStable.map(values, function(value, index) {
           return index ? method(value) : method();
         });
 
@@ -12573,12 +12568,12 @@
       assert.expect(2);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(undefined));
+          expected = lodashStable.map(values, lodashStable.constant(undefined));
 
-      _.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
+      lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
         var method = _.method(path);
 
-        var actual = _.map(values, function(value, index) {
+        var actual = lodashStable.map(values, function(value, index) {
           return index ? method(value) : method();
         });
 
@@ -12591,7 +12586,7 @@
 
       var object = {};
 
-      _.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
+      lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
         var method = _.method(path);
         assert.strictEqual(method(object), undefined);
       });
@@ -12606,7 +12601,7 @@
         }
       };
 
-      _.each(['fn', ['fn']], function(path) {
+      lodashStable.each(['fn', ['fn']], function(path) {
         var method = _.method(path, 1, 2, 3);
         assert.deepEqual(method(object), [1, 2, 3]);
       });
@@ -12617,7 +12612,7 @@
 
       var object = { 'a': { 'b': function() { return this.c; }, 'c': 1 } };
 
-      _.each(['a.b', ['a', 'b']], function(path) {
+      lodashStable.each(['a.b', ['a', 'b']], function(path) {
         var method = _.method(path);
         assert.strictEqual(method(object), 1);
       });
@@ -12632,9 +12627,9 @@
     QUnit.test('should create a function that calls a method of a given key', function(assert) {
       assert.expect(4);
 
-      var object = { 'a': _.constant(1) };
+      var object = { 'a': lodashStable.constant(1) };
 
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         var methodOf = _.methodOf(object);
         assert.strictEqual(methodOf.length, 1);
         assert.strictEqual(methodOf(path), 1);
@@ -12644,9 +12639,9 @@
     QUnit.test('should work with deep property values', function(assert) {
       assert.expect(2);
 
-      var object = { 'a': { 'b': { 'c': _.constant(3) } } };
+      var object = { 'a': { 'b': { 'c': lodashStable.constant(3) } } };
 
-      _.each(['a.b.c', ['a', 'b', 'c']], function(path) {
+      lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path) {
         var methodOf = _.methodOf(object);
         assert.strictEqual(methodOf(path), 3);
       });
@@ -12655,9 +12650,9 @@
     QUnit.test('should work with non-string `path` arguments', function(assert) {
       assert.expect(2);
 
-      var array = _.times(3, _.constant);
+      var array = lodashStable.times(3, _.constant);
 
-      _.each([1, [1]], function(path) {
+      lodashStable.each([1, [1]], function(path) {
         var methodOf = _.methodOf(array);
         assert.strictEqual(methodOf(path), 1);
       });
@@ -12667,15 +12662,15 @@
       assert.expect(1);
 
       function fn() {}
-      fn.toString = _.constant('fn');
+      fn.toString = lodashStable.constant('fn');
 
       var expected = [1, 1, 2, 2, 3, 3, 4, 4],
-          objects = [{ 'null': _.constant(1) }, { 'undefined': _.constant(2) }, { 'fn': _.constant(3) }, { '[object Object]': _.constant(4) }],
+          objects = [{ 'null': lodashStable.constant(1) }, { 'undefined': lodashStable.constant(2) }, { 'fn': lodashStable.constant(3) }, { '[object Object]': lodashStable.constant(4) }],
           values = [null, undefined, fn, {}];
 
-      var actual = _.transform(objects, function(result, object, index) {
+      var actual = lodashStable.transform(objects, function(result, object, index) {
         var key = values[index];
-        _.each([key, [key]], function(path) {
+        lodashStable.each([key, [key]], function(path) {
           var methodOf = _.methodOf(object);
           result.push(methodOf(key));
         });
@@ -12688,9 +12683,9 @@
       assert.expect(2);
 
       function Foo() {}
-      Foo.prototype.a = _.constant(1);
+      Foo.prototype.a = lodashStable.constant(1);
 
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         var methodOf = _.methodOf(new Foo);
         assert.strictEqual(methodOf(path), 1);
       });
@@ -12699,9 +12694,9 @@
     QUnit.test('should use a key over a path', function(assert) {
       assert.expect(2);
 
-      var object = { 'a.b.c': _.constant(3), 'a': { 'b': { 'c': _.constant(4) } } };
+      var object = { 'a.b.c': lodashStable.constant(3), 'a': { 'b': { 'c': lodashStable.constant(4) } } };
 
-      _.each(['a.b.c', ['a.b.c']], function(path) {
+      lodashStable.each(['a.b.c', ['a.b.c']], function(path) {
         var methodOf = _.methodOf(object);
         assert.strictEqual(methodOf(path), 3);
       });
@@ -12711,10 +12706,10 @@
       assert.expect(2);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(undefined));
+          expected = lodashStable.map(values, lodashStable.constant(undefined));
 
-      _.each(['constructor', ['constructor']], function(path) {
-        var actual = _.map(values, function(value, index) {
+      lodashStable.each(['constructor', ['constructor']], function(path) {
+        var actual = lodashStable.map(values, function(value, index) {
           var methodOf = index ? _.methodOf() : _.methodOf(value);
           return methodOf(path);
         });
@@ -12727,10 +12722,10 @@
       assert.expect(2);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(undefined));
+          expected = lodashStable.map(values, lodashStable.constant(undefined));
 
-      _.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
-        var actual = _.map(values, function(value, index) {
+      lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
+        var actual = lodashStable.map(values, function(value, index) {
           var methodOf = index ? _.methodOf() : _.methodOf(value);
           return methodOf(path);
         });
@@ -12745,7 +12740,7 @@
       var object = {},
           methodOf = _.methodOf(object);
 
-      _.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
+      lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
         assert.strictEqual(methodOf(path), undefined);
       });
     });
@@ -12761,7 +12756,7 @@
 
       var methodOf = _.methodOf(object, 1, 2, 3);
 
-      _.each(['fn', ['fn']], function(path) {
+      lodashStable.each(['fn', ['fn']], function(path) {
         assert.deepEqual(methodOf(path), [1, 2, 3]);
       });
     });
@@ -12772,7 +12767,7 @@
       var object = { 'a': { 'b': function() { return this.c; }, 'c': 1 } },
           methodOf = _.methodOf(object);
 
-      _.each(['a.b', ['a', 'b']], function(path) {
+      lodashStable.each(['a.b', ['a', 'b']], function(path) {
         assert.strictEqual(methodOf(path), 1);
       });
     });
@@ -12793,9 +12788,9 @@
       assert.expect(1);
 
       var values = falsey.concat([[]]),
-          expected = _.map(values, _.constant(undefined));
+          expected = lodashStable.map(values, lodashStable.constant(undefined));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         try {
           return index ? _.min(value) : _.min();
         } catch (e) {}
@@ -12815,7 +12810,7 @@
 
   QUnit.module('extremum methods');
 
-  _.each(['max', 'maxBy', 'min', 'minBy'], function(methodName) {
+  lodashStable.each(['max', 'maxBy', 'min', 'minBy'], function(methodName) {
     var array = [1, 2, 3],
         func = _[methodName],
         isMax = /^max/.test(methodName);
@@ -12832,7 +12827,7 @@
     QUnit.test('`_.' + methodName + '` should work with extremely large arrays', function(assert) {
       assert.expect(1);
 
-      var array = _.range(0, 5e5);
+      var array = lodashStable.range(0, 5e5);
       assert.strictEqual(func(array), isMax ? 499999 : 0);
     });
 
@@ -12849,7 +12844,7 @@
     });
   });
 
-  _.each(['maxBy', 'minBy'], function(methodName) {
+  lodashStable.each(['maxBy', 'minBy'], function(methodName) {
     var array = [1, 2, 3],
         func = _[methodName],
         isMax = methodName == 'maxBy';
@@ -12947,7 +12942,7 @@
 
       if (!isNpm) {
         _.mixin(source);
-        _.a = _.constant('b');
+        _.a = lodashStable.constant('b');
 
         assert.strictEqual(_.a(array), 'b');
         assert.strictEqual(_(array).a().value(), 'a');
@@ -12963,7 +12958,7 @@
     QUnit.test('should use `this` as the default `object` value', function(assert) {
       assert.expect(3);
 
-      var object = _.create(_);
+      var object = lodashStable.create(_);
       object.mixin(source);
 
       assert.strictEqual(object.a(array), 'a');
@@ -13014,7 +13009,7 @@
       assert.expect(1);
 
       function Foo() {}
-      Foo.prototype.a = _.noop;
+      Foo.prototype.a = noop;
 
       var object = {};
       assert.strictEqual(_.mixin(object, new Foo), object);
@@ -13027,8 +13022,8 @@
         return (func === _ ? 'lodash' : 'provided') + ' function should ' + (chain ? '' : 'not ') + 'chain';
       }
 
-      _.each([_, Wrapper], function(func) {
-        _.each([{ 'chain': false }, { 'chain': true }], function(options) {
+      lodashStable.each([_, Wrapper], function(func) {
+        lodashStable.each([{ 'chain': false }, { 'chain': true }], function(options) {
           if (!isNpm) {
             if (func === _) {
               _.mixin(source, options);
@@ -13060,7 +13055,7 @@
     QUnit.test('should not extend lodash when an `object` is provided with an empty `options` object', function(assert) {
       assert.expect(1);
 
-      _.mixin({ 'a': _.noop }, {});
+      _.mixin({ 'a': noop }, {});
       assert.notOk('a' in _);
       delete _.a;
     });
@@ -13095,7 +13090,7 @@
     QUnit.test('should not return the existing wrapped value when chaining', function(assert) {
       assert.expect(2);
 
-      _.each([_, Wrapper], function(func) {
+      lodashStable.each([_, Wrapper], function(func) {
         if (!isNpm) {
           if (func === _) {
             var wrapped = _(source),
@@ -13125,7 +13120,7 @@
       if (!isNpm) {
         _.mixin({ 'a': _.countBy, 'b': _.filter });
 
-        var array = _.range(LARGE_ARRAY_SIZE),
+        var array = lodashStable.range(LARGE_ARRAY_SIZE),
             actual = _(array).a().map(square).b(isEven).take().value();
 
         assert.deepEqual(actual, _.take(_.b(_.map(_.a(array), square), isEven)));
@@ -13145,7 +13140,7 @@
 
   QUnit.module('modArgs methods');
 
-  _.each(['modArgs', 'modArgsSet'], function(methodName) {
+  lodashStable.each(['modArgs', 'modArgsSet'], function(methodName) {
     var func = _[methodName],
         isModArgs = methodName == 'modArgs';
 
@@ -13184,7 +13179,7 @@
     QUnit.test('`_.' + methodName + '` should not pass `undefined` if there are more transforms than arguments', function(assert) {
       assert.expect(1);
 
-      var modded = func(fn, doubled, _.identity);
+      var modded = func(fn, doubled, lodashStable.identity);
       assert.deepEqual(modded(5), [10]);
     });
 
@@ -13193,7 +13188,7 @@
 
       var argsList = [],
           transform = function() { argsList.push(slice.call(arguments)); },
-          modded = func(_.noop, transform, transform, transform);
+          modded = func(noop, transform, transform, transform);
 
       modded('a', 'b');
       assert.deepEqual(argsList, isModArgs ? [['a'], ['b']] : [['a', 'b'], ['a', 'b']]);
@@ -13237,9 +13232,9 @@
       assert.expect(1);
 
       var values = empties.concat(true, new Date, _, 1, /x/, 'a'),
-          expected = _.map(values, _.constant());
+          expected = lodashStable.map(values, lodashStable.constant());
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.noop(value) : _.noop();
       });
 
@@ -13351,7 +13346,7 @@
       assert.expect(2);
 
       objectProto.a = 1;
-      _.each([null, undefined], function(value) {
+      lodashStable.each([null, undefined], function(value) {
         assert.deepEqual(_.omit(value, 'valueOf'), {});
       });
       delete objectProto.a;
@@ -13392,7 +13387,7 @@
 
   QUnit.module('omit methods');
 
-  _.each(['omit', 'omitBy'], function(methodName) {
+  lodashStable.each(['omit', 'omitBy'], function(methodName) {
     var expected = { 'b': 2, 'd': 4 },
         func = _[methodName],
         object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 },
@@ -13503,7 +13498,7 @@
       assert.expect(2);
 
       assert.strictEqual(_.pad(Object('abc'), 4), 'abc ');
-      assert.strictEqual(_.pad({ 'toString': _.constant('abc') }, 5), ' abc ');
+      assert.strictEqual(_.pad({ 'toString': lodashStable.constant('abc') }, 5), ' abc ');
     });
   }());
 
@@ -13528,7 +13523,7 @@
       assert.expect(2);
 
       assert.strictEqual(_.padLeft(Object('abc'), 4), ' abc');
-      assert.strictEqual(_.padLeft({ 'toString': _.constant('abc') }, 5), '  abc');
+      assert.strictEqual(_.padLeft({ 'toString': lodashStable.constant('abc') }, 5), '  abc');
     });
   }());
 
@@ -13553,7 +13548,7 @@
       assert.expect(2);
 
       assert.strictEqual(_.padRight(Object('abc'), 4), 'abc ');
-      assert.strictEqual(_.padRight({ 'toString': _.constant('abc') }, 5), 'abc  ');
+      assert.strictEqual(_.padRight({ 'toString': lodashStable.constant('abc') }, 5), 'abc  ');
     });
   }());
 
@@ -13561,7 +13556,7 @@
 
   QUnit.module('pad methods');
 
-  _.each(['pad', 'padLeft', 'padRight'], function(methodName) {
+  lodashStable.each(['pad', 'padLeft', 'padRight'], function(methodName) {
     var func = _[methodName],
         isPad = methodName == 'pad',
         isPadLeft = methodName == 'padLeft';
@@ -13576,7 +13571,7 @@
     QUnit.test('`_.' + methodName + '` should treat negative `length` as `0`', function(assert) {
       assert.expect(2);
 
-      _.each([0, -2], function(length) {
+      lodashStable.each([0, -2], function(length) {
         assert.strictEqual(func('abc', length), 'abc');
       });
     });
@@ -13584,7 +13579,7 @@
     QUnit.test('`_.' + methodName + '` should coerce `length` to a number', function(assert) {
       assert.expect(2);
 
-      _.each(['', '4'], function(length) {
+      lodashStable.each(['', '4'], function(length) {
         var actual = length ? (isPadLeft ? ' abc' : 'abc ') : 'abc';
         assert.strictEqual(func('abc', length), actual);
       });
@@ -13593,7 +13588,7 @@
     QUnit.test('`_.' + methodName + '` should treat nullish values as empty strings', function(assert) {
       assert.expect(6);
 
-      _.each([undefined, '_-'], function(chars) {
+      lodashStable.each([undefined, '_-'], function(chars) {
         var expected = chars ? (isPad ? '__' : chars) : '  ';
         assert.strictEqual(func(null, 2, chars), expected);
         assert.strictEqual(func(undefined, 2, chars), expected);
@@ -13632,7 +13627,7 @@
     QUnit.test('should work with strings', function(assert) {
       assert.expect(2);
 
-      _.each(['xo', Object('xo')], function(string) {
+      lodashStable.each(['xo', Object('xo')], function(string) {
         assert.deepEqual(_.pairs(string), [['0', 'x'], ['1', 'o']]);
       });
     });
@@ -13646,9 +13641,9 @@
     QUnit.test('should accept a `radix` argument', function(assert) {
       assert.expect(1);
 
-      var expected = _.range(2, 37);
+      var expected = lodashStable.range(2, 37);
 
-      var actual = _.map(expected, function(radix) {
+      var actual = lodashStable.map(expected, function(radix) {
         return _.parseInt('10', radix);
       });
 
@@ -13667,7 +13662,7 @@
     QUnit.test('should use a radix of `16`, for hexadecimals, if `radix` is `undefined` or `0`', function(assert) {
       assert.expect(8);
 
-      _.each(['0x20', '0X20'], function(string) {
+      lodashStable.each(['0x20', '0X20'], function(string) {
         assert.strictEqual(_.parseInt(string), 32);
         assert.strictEqual(_.parseInt(string, 0), 32);
         assert.strictEqual(_.parseInt(string, 16), 32);
@@ -13687,12 +13682,12 @@
 
       var expected = [8, 8, 10, 10, 32, 32, 32, 32];
 
-      _.times(2, function(index) {
+      lodashStable.times(2, function(index) {
         var actual = [],
             func = (index ? (lodashBizarro || {}) : _).parseInt;
 
         if (func) {
-          _.times(2, function(otherIndex) {
+          lodashStable.times(2, function(otherIndex) {
             var string = otherIndex ? '10' : '08';
             actual.push(
               func(whitespace + string, 10),
@@ -13700,7 +13695,7 @@
             );
           });
 
-          _.each(['0x20', '0X20'], function(string) {
+          lodashStable.each(['0x20', '0X20'], function(string) {
             actual.push(
               func(whitespace + string),
               func(whitespace + string, 16)
@@ -13718,7 +13713,7 @@
     QUnit.test('should coerce `radix` to a number', function(assert) {
       assert.expect(2);
 
-      var object = { 'valueOf': _.constant(0) };
+      var object = { 'valueOf': lodashStable.constant(0) };
       assert.strictEqual(_.parseInt('08', object), 8);
       assert.strictEqual(_.parseInt('0x20', object), 32);
     });
@@ -13726,12 +13721,12 @@
     QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) {
       assert.expect(2);
 
-      var strings = _.map(['6', '08', '10'], Object),
-          actual = _.map(strings, _.parseInt);
+      var strings = lodashStable.map(['6', '08', '10'], Object),
+          actual = lodashStable.map(strings, _.parseInt);
 
       assert.deepEqual(actual, [6, 8, 10]);
 
-      actual = _.map('123', _.parseInt);
+      actual = lodashStable.map('123', _.parseInt);
       assert.deepEqual(actual, [1, 2, 3]);
     });
   }());
@@ -13740,7 +13735,7 @@
 
   QUnit.module('partial methods');
 
-  _.each(['partial', 'partialRight'], function(methodName) {
+  lodashStable.each(['partial', 'partialRight'], function(methodName) {
     var func = _[methodName],
         isPartial = methodName == 'partial',
         ph = func.placeholder;
@@ -13748,7 +13743,7 @@
     QUnit.test('`_.' + methodName + '` partially applies arguments', function(assert) {
       assert.expect(1);
 
-      var par = func(_.identity, 'a');
+      var par = func(lodashStable.identity, 'a');
       assert.strictEqual(par(), 'a');
     });
 
@@ -13774,7 +13769,7 @@
     QUnit.test('`_.' + methodName + '` works when there are no partially applied arguments and the created function is invoked with additional arguments', function(assert) {
       assert.expect(1);
 
-      var par = func(_.identity);
+      var par = func(lodashStable.identity);
       assert.strictEqual(par('a'), 'a');
     });
 
@@ -13869,7 +13864,7 @@
           expected = { 'a': { 'b': 1, 'c': 3 } };
 
       var defaultsDeep = _.partialRight(_.mergeWith, function deep(value, other) {
-        return _.isObject(value) ? _.mergeWith(value, other, deep) : value;
+        return lodashStable.isObject(value) ? _.mergeWith(value, other, deep) : value;
       });
 
       assert.deepEqual(defaultsDeep(object, source), expected);
@@ -13998,7 +13993,7 @@
     QUnit.test('should work when hot', function(assert) {
       assert.expect(12);
 
-      _.times(2, function(index) {
+      lodashStable.times(2, function(index) {
         var fn = function() {
           var result = [this];
           push.apply(result, arguments);
@@ -14009,14 +14004,14 @@
             bound1 = index ? _.bind(fn, object, 1) : _.bind(fn, object),
             expected = [object, 1, 2, 3];
 
-        var actual = _.last(_.times(HOT_COUNT, function() {
+        var actual = _.last(lodashStable.times(HOT_COUNT, function() {
           var bound2 = index ? _.bind(bound1, null, 2) : _.bind(bound1);
           return index ? bound2(3) : bound2(1, 2, 3);
         }));
 
         assert.deepEqual(actual, expected);
 
-        actual = _.last(_.times(HOT_COUNT, function() {
+        actual = _.last(lodashStable.times(HOT_COUNT, function() {
           var bound1 = index ? _.bind(fn, object, 1) : _.bind(fn, object),
               bound2 = index ? _.bind(bound1, null, 2) : _.bind(bound1);
 
@@ -14026,18 +14021,18 @@
         assert.deepEqual(actual, expected);
       });
 
-      _.each(['curry', 'curryRight'], function(methodName, index) {
+      lodashStable.each(['curry', 'curryRight'], function(methodName, index) {
         var fn = function(a, b, c) { return [a, b, c]; },
             curried = _[methodName](fn),
             expected = index ? [3, 2, 1] :  [1, 2, 3];
 
-        var actual = _.last(_.times(HOT_COUNT, function() {
+        var actual = _.last(lodashStable.times(HOT_COUNT, function() {
           return curried(1)(2)(3);
         }));
 
         assert.deepEqual(actual, expected);
 
-        actual = _.last(_.times(HOT_COUNT, function() {
+        actual = _.last(lodashStable.times(HOT_COUNT, function() {
           var curried = _[methodName](fn);
           return curried(1)(2)(3);
         }));
@@ -14045,20 +14040,20 @@
         assert.deepEqual(actual, expected);
       });
 
-      _.each(['partial', 'partialRight'], function(methodName, index) {
+      lodashStable.each(['partial', 'partialRight'], function(methodName, index) {
         var func = _[methodName],
             fn = function() { return slice.call(arguments); },
             par1 = func(fn, 1),
             expected = index ? [3, 2, 1] : [1, 2, 3];
 
-        var actual = _.last(_.times(HOT_COUNT, function() {
+        var actual = _.last(lodashStable.times(HOT_COUNT, function() {
           var par2 = func(par1, 2);
           return par2(3);
         }));
 
         assert.deepEqual(actual, expected);
 
-        actual = _.last(_.times(HOT_COUNT, function() {
+        actual = _.last(lodashStable.times(HOT_COUNT, function() {
           var par1 = func(fn, 1),
               par2 = func(par1, 2);
 
@@ -14080,18 +14075,18 @@
     QUnit.test('should return two groups of elements', function(assert) {
       assert.expect(3);
 
-      assert.deepEqual(_.partition([], _.identity), [[], []]);
-      assert.deepEqual(_.partition(array, _.constant(true)), [array, []]);
-      assert.deepEqual(_.partition(array, _.constant(false)), [[], array]);
+      assert.deepEqual(_.partition([], lodashStable.identity), [[], []]);
+      assert.deepEqual(_.partition(array, lodashStable.constant(true)), [array, []]);
+      assert.deepEqual(_.partition(array, lodashStable.constant(false)), [[], array]);
     });
 
     QUnit.test('should use `_.identity` when `predicate` is nullish', function(assert) {
       assert.expect(1);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant([[1, 1], [0]]));
+          expected = lodashStable.map(values, lodashStable.constant([[1, 1], [0]]));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.partition(array, value) : _.partition(array);
       });
 
@@ -14155,7 +14150,7 @@
     QUnit.test('should return an empty object when `object` is nullish', function(assert) {
       assert.expect(2);
 
-      _.each([null, undefined], function(value) {
+      lodashStable.each([null, undefined], function(value) {
         assert.deepEqual(_.pick(value, 'valueOf'), {});
       });
     });
@@ -14195,7 +14190,7 @@
 
   QUnit.module('pick methods');
 
-  _.each(['pick', 'pickBy'], function(methodName) {
+  lodashStable.each(['pick', 'pickBy'], function(methodName) {
     var expected = { 'a': 1, 'c': 3 },
         func = _[methodName],
         object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 },
@@ -14244,7 +14239,7 @@
 
       var object = { 'a': 1 };
 
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         var prop = _.property(path);
         assert.strictEqual(prop.length, 1);
         assert.strictEqual(prop(object), 1);
@@ -14256,7 +14251,7 @@
 
       var object = { 'a': { 'b': { 'c': 3 } } };
 
-      _.each(['a.b.c', ['a', 'b', 'c']], function(path) {
+      lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path) {
         var prop = _.property(path);
         assert.strictEqual(prop(object), 3);
       });
@@ -14267,7 +14262,7 @@
 
       var array = [1, 2, 3];
 
-      _.each([1, [1]], function(path) {
+      lodashStable.each([1, [1]], function(path) {
         var prop = _.property(path);
         assert.strictEqual(prop(array), 2);
       });
@@ -14277,15 +14272,15 @@
       assert.expect(1);
 
       function fn() {}
-      fn.toString = _.constant('fn');
+      fn.toString = lodashStable.constant('fn');
 
       var expected = [1, 1, 2, 2, 3, 3, 4, 4],
           objects = [{ 'null': 1 }, { 'undefined': 2 }, { 'fn': 3 }, { '[object Object]': 4 }],
           values = [null, undefined, fn, {}];
 
-      var actual = _.transform(objects, function(result, object, index) {
+      var actual = lodashStable.transform(objects, function(result, object, index) {
         var key = values[index];
-        _.each([key, [key]], function(path) {
+        lodashStable.each([key, [key]], function(path) {
           var prop = _.property(key);
           result.push(prop(object));
         });
@@ -14300,7 +14295,7 @@
       function Foo() {}
       Foo.prototype.a = 1;
 
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         var prop = _.property(path);
         assert.strictEqual(prop(new Foo), 1);
       });
@@ -14311,7 +14306,7 @@
 
       var object = { 'a.b.c': 3, 'a': { 'b': { 'c': 4 } } };
 
-      _.each(['a.b.c', ['a.b.c']], function(path) {
+      lodashStable.each(['a.b.c', ['a.b.c']], function(path) {
         var prop = _.property(path);
         assert.strictEqual(prop(object), 3);
       });
@@ -14321,12 +14316,12 @@
       assert.expect(2);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(undefined));
+          expected = lodashStable.map(values, lodashStable.constant(undefined));
 
-      _.each(['constructor', ['constructor']], function(path) {
+      lodashStable.each(['constructor', ['constructor']], function(path) {
         var prop = _.property(path);
 
-        var actual = _.map(values, function(value, index) {
+        var actual = lodashStable.map(values, function(value, index) {
           return index ? prop(value) : prop();
         });
 
@@ -14338,12 +14333,12 @@
       assert.expect(2);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(undefined));
+          expected = lodashStable.map(values, lodashStable.constant(undefined));
 
-      _.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
+      lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
         var prop = _.property(path);
 
-        var actual = _.map(values, function(value, index) {
+        var actual = lodashStable.map(values, function(value, index) {
           return index ? prop(value) : prop();
         });
 
@@ -14356,7 +14351,7 @@
 
       var object = {};
 
-      _.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
+      lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
         var prop = _.property(path);
         assert.strictEqual(prop(object), undefined);
       });
@@ -14375,7 +14370,7 @@
           propOf = _.propertyOf(object);
 
       assert.strictEqual(propOf.length, 1);
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         assert.strictEqual(propOf(path), 1);
       });
     });
@@ -14386,7 +14381,7 @@
       var object = { 'a': { 'b': { 'c': 3 } } },
           propOf = _.propertyOf(object);
 
-      _.each(['a.b.c', ['a', 'b', 'c']], function(path) {
+      lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path) {
         assert.strictEqual(propOf(path), 3);
       });
     });
@@ -14397,7 +14392,7 @@
       var array = [1, 2, 3],
           propOf = _.propertyOf(array);
 
-      _.each([1, [1]], function(path) {
+      lodashStable.each([1, [1]], function(path) {
         assert.strictEqual(propOf(path), 2);
       });
     });
@@ -14406,15 +14401,15 @@
       assert.expect(1);
 
       function fn() {}
-      fn.toString = _.constant('fn');
+      fn.toString = lodashStable.constant('fn');
 
       var expected = [1, 1, 2, 2, 3, 3, 4, 4],
           objects = [{ 'null': 1 }, { 'undefined': 2 }, { 'fn': 3 }, { '[object Object]': 4 }],
           values = [null, undefined, fn, {}];
 
-      var actual = _.transform(objects, function(result, object, index) {
+      var actual = lodashStable.transform(objects, function(result, object, index) {
         var key = values[index];
-        _.each([key, [key]], function(path) {
+        lodashStable.each([key, [key]], function(path) {
           var propOf = _.propertyOf(object);
           result.push(propOf(key));
         });
@@ -14431,7 +14426,7 @@
 
       var propOf = _.propertyOf(new Foo);
 
-      _.each(['b', ['b']], function(path) {
+      lodashStable.each(['b', ['b']], function(path) {
         assert.strictEqual(propOf(path), 2);
       });
     });
@@ -14442,7 +14437,7 @@
       var object = { 'a.b.c': 3, 'a': { 'b': { 'c': 4 } } },
           propOf = _.propertyOf(object);
 
-      _.each(['a.b.c', ['a.b.c']], function(path) {
+      lodashStable.each(['a.b.c', ['a.b.c']], function(path) {
         assert.strictEqual(propOf(path), 3);
       });
     });
@@ -14451,10 +14446,10 @@
       assert.expect(2);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(undefined));
+          expected = lodashStable.map(values, lodashStable.constant(undefined));
 
-      _.each(['constructor', ['constructor']], function(path) {
-        var actual = _.map(values, function(value, index) {
+      lodashStable.each(['constructor', ['constructor']], function(path) {
+        var actual = lodashStable.map(values, function(value, index) {
           var propOf = index ? _.propertyOf(value) : _.propertyOf();
           return propOf(path);
         });
@@ -14467,10 +14462,10 @@
       assert.expect(2);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(undefined));
+          expected = lodashStable.map(values, lodashStable.constant(undefined));
 
-      _.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
-        var actual = _.map(values, function(value, index) {
+      lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
+        var actual = lodashStable.map(values, function(value, index) {
           var propOf = index ? _.propertyOf(value) : _.propertyOf();
           return propOf(path);
         });
@@ -14484,7 +14479,7 @@
 
       var propOf = _.propertyOf({});
 
-      _.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
+      lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
         assert.strictEqual(propOf(path), undefined);
       });
     });
@@ -14494,7 +14489,7 @@
 
   QUnit.module('pull methods');
 
-  _.each(['pull', 'pullAll'], function(methodName) {
+  lodashStable.each(['pull', 'pullAll'], function(methodName) {
     var func = _[methodName],
         isPull = methodName == 'pull';
 
@@ -14652,20 +14647,20 @@
     QUnit.test('should work with non-index paths', function(assert) {
       assert.expect(2);
 
-      var values = _.reject(empties, function(value) {
-        return value === 0 || _.isArray(value);
+      var values = lodashStable.reject(empties, function(value) {
+        return value === 0 || lodashStable.isArray(value);
       }).concat(-1, 1.1);
 
-      var array = _.transform(values, function(result, value) {
+      var array = lodashStable.transform(values, function(result, value) {
         result[value] = 1;
       }, []);
 
-      var expected = _.map(values, _.constant(1)),
+      var expected = lodashStable.map(values, lodashStable.constant(1)),
           actual = _.pullAt(array, values);
 
       assert.deepEqual(actual, expected);
 
-      expected = _.map(values, _.constant(undefined)),
+      expected = lodashStable.map(values, lodashStable.constant(undefined)),
       actual = _.at(array, values);
 
       assert.deepEqual(actual, expected);
@@ -14687,9 +14682,9 @@
       assert.expect(1);
 
       var values = falsey.slice(),
-          expected = _.map(values, _.constant(Array(4)));
+          expected = lodashStable.map(values, lodashStable.constant(Array(4)));
 
-      var actual = _.map(values, function(array) {
+      var actual = lodashStable.map(values, function(array) {
         try {
           return _.pullAt(array, 0, 1, 'pop', 'push');
         } catch (e) {}
@@ -14709,7 +14704,7 @@
     QUnit.test('should return `0` or `1` when arguments are not provided', function(assert) {
       assert.expect(1);
 
-      var actual = _.map(array, function() {
+      var actual = lodashStable.map(array, function() {
         return _.random();
       });
 
@@ -14746,7 +14741,7 @@
       var min = Math.pow(2, 31),
           max = Math.pow(2, 62);
 
-      assert.ok(_.every(array, function() {
+      assert.ok(lodashStable.every(array, function() {
         var result = _.random(min, max);
         return result >= min && result <= max;
       }));
@@ -14790,10 +14785,10 @@
       assert.expect(1);
 
       var array = [1, 2, 3],
-          expected = _.map(array, _.constant(true)),
-          randoms = _.map(array, _.random);
+          expected = lodashStable.map(array, lodashStable.constant(true)),
+          randoms = lodashStable.map(array, _.random);
 
-      var actual = _.map(randoms, function(result, index) {
+      var actual = lodashStable.map(randoms, function(result, index) {
         return result >= 0 && result <= array[index] && (result % 1) == 0;
       });
 
@@ -14846,7 +14841,7 @@
     QUnit.test('should treat falsey `start` arguments as `0`', function(assert) {
       assert.expect(13);
 
-      _.each(falsey, function(value, index) {
+      lodashStable.each(falsey, function(value, index) {
         if (index) {
           assert.deepEqual(_.range(value), []);
           assert.deepEqual(_.range(value, 1), [0]);
@@ -14870,8 +14865,8 @@
           object = { 'a': 1, 'b': 2, 'c': 3 },
           expected = [[0], [0, 1], [0, 1, 2]];
 
-      _.each([array, object], function(collection) {
-        var actual = _.map(collection, _.range);
+      lodashStable.each([array, object], function(collection) {
+        var actual = lodashStable.map(collection, _.range);
         assert.deepEqual(actual, expected);
       });
     });
@@ -14910,13 +14905,13 @@
     QUnit.test('should use `undefined` for non-index values', function(assert) {
       assert.expect(1);
 
-      var values = _.reject(empties, function(value) {
-        return value === 0 || _.isArray(value);
+      var values = lodashStable.reject(empties, function(value) {
+        return value === 0 || lodashStable.isArray(value);
       }).concat(-1, 1.1);
 
-      var expected = _.map(values, _.constant([undefined, 'b', 'c']));
+      var expected = lodashStable.map(values, lodashStable.constant([undefined, 'b', 'c']));
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         var rearged = _.rearg(fn, [value]);
         return rearged('a', 'b', 'c');
       });
@@ -15093,7 +15088,7 @@
 
   QUnit.module('reduce methods');
 
-  _.each(['reduce', 'reduceRight'], function(methodName) {
+  lodashStable.each(['reduce', 'reduceRight'], function(methodName) {
     var func = _[methodName],
         array = [1, 2, 3],
         isReduce = methodName == 'reduce';
@@ -15112,11 +15107,11 @@
       assert.expect(1);
 
       var actual = [],
-          expected = _.map(empties, _.constant());
+          expected = lodashStable.map(empties, lodashStable.constant());
 
-      _.each(empties, function(value) {
+      lodashStable.each(empties, function(value) {
         try {
-          actual.push(func(value, _.noop));
+          actual.push(func(value, noop));
         } catch (e) {}
       });
 
@@ -15126,11 +15121,11 @@
     QUnit.test('`_.' + methodName + '` should support empty collections with an initial `accumulator` value', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(empties, _.constant('x'));
+      var expected = lodashStable.map(empties, lodashStable.constant('x'));
 
-      var actual = _.map(empties, function(value) {
+      var actual = lodashStable.map(empties, function(value) {
         try {
-          return func(value, _.noop, 'x');
+          return func(value, noop, 'x');
         } catch (e) {}
       });
 
@@ -15140,7 +15135,7 @@
     QUnit.test('`_.' + methodName + '` should handle an initial `accumulator` value of `undefined`', function(assert) {
       assert.expect(1);
 
-      var actual = func([], _.noop, undefined);
+      var actual = func([], noop, undefined);
       assert.strictEqual(actual, undefined);
     });
 
@@ -15152,12 +15147,12 @@
 
       if ('__proto__' in array) {
         array.__proto__ = object;
-        assert.strictEqual(_.reduce(array, _.noop), undefined);
+        assert.strictEqual(func(array, noop), undefined);
       }
       else {
         skipTest(assert);
       }
-      assert.strictEqual(_.reduce(object, _.noop), undefined);
+      assert.strictEqual(func(object, noop), undefined);
     });
 
     QUnit.test('`_.' + methodName + '` should return an unwrapped value when implicityly chaining', function(assert) {
@@ -15201,7 +15196,7 @@
 
   QUnit.module('filter methods');
 
-  _.each(['filter', 'reject'], function(methodName) {
+  lodashStable.each(['filter', 'reject'], function(methodName) {
     var array = [1, 2, 3, 4],
         func = _[methodName],
         isFilter = methodName == 'filter',
@@ -15257,18 +15252,18 @@
       assert.expect(2);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE + 1),
+        var array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
             predicate = function(value) { return isFilter ? isEven(value) : !isEven(value); },
             actual = _(array).slice(1).map(square)[methodName](predicate).value();
 
-        assert.deepEqual(actual, _[methodName](_.map(array.slice(1), square), predicate));
+        assert.deepEqual(actual, _[methodName](lodashStable.map(array.slice(1), square), predicate));
 
-        var object = _.zipObject(_.times(LARGE_ARRAY_SIZE, function(index) {
+        var object = lodashStable.zipObject(lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
           return ['key' + index, index];
         }));
 
         actual = _(object).mapValues(square)[methodName](predicate).value();
-        assert.deepEqual(actual, _[methodName](_.mapValues(object, square), predicate));
+        assert.deepEqual(actual, _[methodName](lodashStable.mapValues(object, square), predicate));
       }
       else {
         skipTest(assert, 2);
@@ -15280,8 +15275,8 @@
 
       if (!isNpm) {
         var args,
-            array = _.range(LARGE_ARRAY_SIZE + 1),
-            expected = [1, 0, _.map(array.slice(1), square)];
+            array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
+            expected = [1, 0, lodashStable.map(array.slice(1), square)];
 
         _(array).slice(1)[methodName](function(value, index, array) {
           args || (args = slice.call(arguments));
@@ -15437,14 +15432,14 @@
 
       assert.strictEqual(_.repeat('abc'), '');
       assert.strictEqual(_.repeat('abc', '2'), 'abcabc');
-      assert.strictEqual(_.repeat('*', { 'valueOf': _.constant(3) }), '***');
+      assert.strictEqual(_.repeat('*', { 'valueOf': lodashStable.constant(3) }), '***');
     });
 
     QUnit.test('should coerce `string` to a string', function(assert) {
       assert.expect(2);
 
       assert.strictEqual(_.repeat(Object('abc'), 2), 'abcabc');
-      assert.strictEqual(_.repeat({ 'toString': _.constant('*') }, 3), '***');
+      assert.strictEqual(_.repeat({ 'toString': lodashStable.constant('*') }, 3), '***');
     });
   }());
 
@@ -15476,7 +15471,7 @@
 
       var value = { 'a': object };
 
-      _.each(['a.b', ['a', 'b']], function(path) {
+      lodashStable.each(['a.b', ['a', 'b']], function(path) {
         assert.strictEqual(_.result(value, path), 1);
       });
     });
@@ -15486,7 +15481,7 @@
 
   QUnit.module('lodash.get and lodash.result');
 
-  _.each(['get', 'result'], function(methodName) {
+  lodashStable.each(['get', 'result'], function(methodName) {
     var func = _[methodName];
 
     QUnit.test('`_.' + methodName + '` should get property values', function(assert) {
@@ -15494,7 +15489,7 @@
 
       var object = { 'a': 1 };
 
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         assert.strictEqual(func(object, path), 1);
       });
     });
@@ -15504,7 +15499,7 @@
 
       var object = { 'a': { 'b': { 'c': 3 } } };
 
-      _.each(['a.b.c', ['a', 'b', 'c']], function(path) {
+      lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path) {
         assert.strictEqual(func(object, path), 3);
       });
     });
@@ -15514,7 +15509,7 @@
 
       var object = { 'a.b.c': 3, 'a': { 'b': { 'c': 4 } } };
 
-      _.each(['a.b.c', ['a.b.c']], function(path) {
+      lodashStable.each(['a.b.c', ['a.b.c']], function(path) {
         assert.strictEqual(func(object, path), 3);
       });
     });
@@ -15536,7 +15531,7 @@
     QUnit.test('`_.' + methodName + '` should handle empty paths', function(assert) {
       assert.expect(4);
 
-      _.each([['', ''], [[], ['']]], function(pair) {
+      lodashStable.each([['', ''], [[], ['']]], function(pair) {
         assert.strictEqual(func({}, pair[0]), undefined);
         assert.strictEqual(func({ '': 3 }, pair[1]), 3);
       });
@@ -15552,7 +15547,7 @@
         ['a', '-1.23', '["b"]', 'c', "['d']", '\ne\n', 'f', 'g']
       ];
 
-      _.each(paths, function(path) {
+      lodashStable.each(paths, function(path) {
         assert.strictEqual(func(object, path), 8);
       });
     });
@@ -15560,7 +15555,7 @@
     QUnit.test('`_.' + methodName + '` should return `undefined` when `object` is nullish', function(assert) {
       assert.expect(4);
 
-      _.each(['constructor', ['constructor']], function(path) {
+      lodashStable.each(['constructor', ['constructor']], function(path) {
         assert.strictEqual(func(null, path), undefined);
         assert.strictEqual(func(undefined, path), undefined);
       });
@@ -15570,11 +15565,11 @@
       assert.expect(2);
 
       var values = [null, undefined],
-          expected = _.map(values, _.constant(undefined)),
+          expected = lodashStable.map(values, lodashStable.constant(undefined)),
           paths = ['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']];
 
-      _.each(paths, function(path) {
-        var actual = _.map(values, function(value) {
+      lodashStable.each(paths, function(path) {
+        var actual = lodashStable.map(values, function(value) {
           return func(value, path);
         });
 
@@ -15587,7 +15582,7 @@
 
       var object = { 'a': [, null] };
 
-      _.each(['a[1].b.c', ['a', '1', 'b', 'c']], function(path) {
+      lodashStable.each(['a[1].b.c', ['a', '1', 'b', 'c']], function(path) {
         assert.strictEqual(func(object, path), undefined);
       });
     });
@@ -15597,7 +15592,7 @@
 
       var object = { 'a': { 'b': null } };
 
-      _.each(['a.b', ['a', 'b']], function(path) {
+      lodashStable.each(['a.b', ['a', 'b']], function(path) {
         assert.strictEqual(func(object, path), null);
       });
     });
@@ -15608,7 +15603,7 @@
       var object = { 'a': '' },
           paths = ['constructor.prototype.a', ['constructor', 'prototype', 'a']];
 
-      _.each(paths, function(path) {
+      lodashStable.each(paths, function(path) {
         numberProto.a = 1;
 
         var actual = func(0, path);
@@ -15617,7 +15612,7 @@
         delete numberProto.a;
       });
 
-      _.each(['a.replace.b', ['a', 'replace', 'b']], function(path) {
+      lodashStable.each(['a.replace.b', ['a', 'replace', 'b']], function(path) {
         stringProto.replace.b = 1;
 
         var actual = func(object, path);
@@ -15633,12 +15628,12 @@
       var object = { 'a': {} },
           values = empties.concat(true, new Date, 1, /x/, 'a');
 
-      var expected = _.transform(values, function(result, value) {
+      var expected = lodashStable.transform(values, function(result, value) {
         result.push(value, value, value, value);
       });
 
-      var actual = _.transform(values, function(result, value) {
-        _.each(['a.b.c', ['a', 'b', 'c']], function(path) {
+      var actual = lodashStable.transform(values, function(result, value) {
+        lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path) {
           result.push(
             func(object, path, value),
             func(null, path, value)
@@ -15677,9 +15672,9 @@
       assert.expect(1);
 
       var values = [-1, NaN, 'x'],
-          expected = _.map(values, _.constant([[1, 2, 3, 4]]));
+          expected = lodashStable.map(values, lodashStable.constant([[1, 2, 3, 4]]));
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         var rp = _.rest(fn, value);
         return rp(1, 2, 3, 4);
       });
@@ -15732,7 +15727,7 @@
 
   QUnit.module('round methods');
 
-  _.each(['ceil', 'floor', 'round'], function(methodName) {
+  lodashStable.each(['ceil', 'floor', 'round'], function(methodName) {
     var func = _[methodName],
         isCeil = methodName == 'ceil',
         isFloor = methodName == 'floor';
@@ -15826,7 +15821,7 @@
       assert.expect(3);
 
       if (!isModularize) {
-        _.times(2, _.uniqueId);
+        lodashStable.times(2, _.uniqueId);
 
         var oldId = Number(_.uniqueId()),
             lodash = _.runInContext();
@@ -15854,15 +15849,15 @@
       assert.expect(1);
 
       var actual = _.sample(array);
-      assert.ok(_.includes(array, actual));
+      assert.ok(lodashStable.includes(array, actual));
     });
 
     QUnit.test('should return `undefined` when sampling empty collections', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(empties, _.constant(undefined));
+      var expected = lodashStable.map(empties, lodashStable.constant(undefined));
 
-      var actual = _.transform(empties, function(result, value) {
+      var actual = lodashStable.transform(empties, function(result, value) {
         try {
           result.push(_.sample(value));
         } catch (e) {}
@@ -15877,7 +15872,7 @@
       var object = { 'a': 1, 'b': 2, 'c': 3 },
           actual = _.sample(object);
 
-      assert.ok(_.includes(array, actual));
+      assert.ok(lodashStable.includes(array, actual));
     });
   }());
 
@@ -15893,7 +15888,7 @@
 
       var actual = _.sampleSize(array, 2);
       assert.strictEqual(actual.length, 2);
-      assert.deepEqual(_.difference(actual, array), []);
+      assert.deepEqual(lodashStable.difference(actual, array), []);
     });
 
     QUnit.test('should contain elements of the collection', function(assert) {
@@ -15906,9 +15901,9 @@
     QUnit.test('should treat falsey `n` values as `0`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant([]));
+      var expected = lodashStable.map(falsey, lodashStable.constant([]));
 
-      var actual = _.map(falsey, function(n, index) {
+      var actual = lodashStable.map(falsey, function(n, index) {
         return index ? _.sampleSize([1], n) : _.sampleSize([1]);
       });
 
@@ -15918,7 +15913,7 @@
     QUnit.test('should return an empty array when `n` < `1` or `NaN`', function(assert) {
       assert.expect(3);
 
-      _.each([0, -1, -Infinity], function(n) {
+      lodashStable.each([0, -1, -Infinity], function(n) {
         assert.deepEqual(_.sampleSize(array, n), []);
       });
     });
@@ -15926,7 +15921,7 @@
     QUnit.test('should return all elements when `n` >= `array.length`', function(assert) {
       assert.expect(4);
 
-      _.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
+      lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
         assert.deepEqual(_.sampleSize(array, n).sort(), array);
       });
     });
@@ -15941,9 +15936,9 @@
     QUnit.test('should return an empty array for empty collections', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(empties, _.constant([]));
+      var expected = lodashStable.map(empties, lodashStable.constant([]));
 
-      var actual = _.transform(empties, function(result, value) {
+      var actual = lodashStable.transform(empties, function(result, value) {
         try {
           result.push(_.sampleSize(value, 1));
         } catch (e) {}
@@ -15959,7 +15954,7 @@
           actual = _.sampleSize(object, 2);
 
       assert.strictEqual(actual.length, 2);
-      assert.deepEqual(_.difference(actual, _.values(object)), []);
+      assert.deepEqual(lodashStable.difference(actual, lodashStable.values(object)), []);
     });
   }());
 
@@ -15972,7 +15967,7 @@
       assert.expect(1);
 
       var actual = _.setWith({ '0': { 'length': 2 } }, '[0][1][2]', 3, function(value) {
-        if (!_.isObject(value)) {
+        if (!lodashStable.isObject(value)) {
           return {};
         }
       });
@@ -15983,7 +15978,7 @@
     QUnit.test('should work with a `customizer` that returns `undefined`', function(assert) {
       assert.expect(1);
 
-      var actual = _.setWith({}, 'a[0].b.c', 4, _.constant(undefined));
+      var actual = _.setWith({}, 'a[0].b.c', 4, lodashStable.constant(undefined));
       assert.deepEqual(actual, { 'a': [{ 'b': { 'c': 4 } }] });
     });
   }());
@@ -15992,7 +15987,7 @@
 
   QUnit.module('set methods');
 
-  _.each(['set', 'setWith'], function(methodName) {
+  lodashStable.each(['set', 'setWith'], function(methodName) {
     var func = _[methodName];
 
     QUnit.test('`_.' + methodName + '` should set property values', function(assert) {
@@ -16000,7 +15995,7 @@
 
       var object = { 'a': 1 };
 
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         var actual = func(object, path, 2);
 
         assert.strictEqual(actual, object);
@@ -16015,7 +16010,7 @@
 
       var object = { 'a': { 'b': { 'c': 3 } } };
 
-      _.each(['a.b.c', ['a', 'b', 'c']], function(path) {
+      lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path) {
         var actual = func(object, path, 4);
 
         assert.strictEqual(actual, object);
@@ -16030,7 +16025,7 @@
 
       var object = { 'a.b.c': 3 };
 
-      _.each(['a.b.c', ['a.b.c']], function(path) {
+      lodashStable.each(['a.b.c', ['a.b.c']], function(path) {
         var actual = func(object, path, 4);
 
         assert.strictEqual(actual, object);
@@ -16059,7 +16054,7 @@
     QUnit.test('`_.' + methodName + '` should handle empty paths', function(assert) {
       assert.expect(4);
 
-      _.each([['', ''], [[], ['']]], function(pair, index) {
+      lodashStable.each([['', ''], [[], ['']]], function(pair, index) {
         var object = {};
 
         func(object, pair[0], 1);
@@ -16080,7 +16075,7 @@
         ['a', '-1.23', '["b"]', 'c', "['d']", '\ne\n', 'f', 'g']
       ];
 
-      _.each(paths, function(path) {
+      lodashStable.each(paths, function(path) {
         func(object, path, 10);
         assert.strictEqual(object.a[-1.23]['["b"]'].c["['d']"]['\ne\n'].f.g, 10);
         object.a[-1.23]['["b"]'].c["['d']"]['\ne\n'].f.g = 8;
@@ -16092,7 +16087,7 @@
 
       var object = {};
 
-      _.each(['a[1].b.c', ['a', '1', 'b', 'c']], function(path) {
+      lodashStable.each(['a[1].b.c', ['a', '1', 'b', 'c']], function(path) {
         var actual = func(object, path, 4);
 
         assert.strictEqual(actual, object);
@@ -16109,7 +16104,7 @@
       var values = [null, undefined],
           expected = [[null, null], [undefined, undefined]];
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         try {
           return [func(value, 'a.b', 1), func(value, ['a', 'b'], 1)];
         } catch (e) {
@@ -16126,13 +16121,13 @@
       var object = { 'a': '' },
           paths = ['constructor.prototype.a', ['constructor', 'prototype', 'a']];
 
-      _.each(paths, function(path) {
+      lodashStable.each(paths, function(path) {
         func(0, path, 1);
         assert.strictEqual(0..a, 1);
         delete numberProto.a;
       });
 
-      _.each(['a.replace.b', ['a', 'replace', 'b']], function(path) {
+      lodashStable.each(['a.replace.b', ['a', 'replace', 'b']], function(path) {
         func(object, path, 1);
         assert.strictEqual(stringProto.replace.b, 1);
         delete stringProto.replace.b;
@@ -16144,7 +16139,7 @@
 
       numberProto.a = 0;
 
-      _.each(['a', 'a.a.a'], function(path) {
+      lodashStable.each(['a', 'a.a.a'], function(path) {
         try {
           func(0, path, 1);
           assert.strictEqual(0..a, 0);
@@ -16169,7 +16164,7 @@
     QUnit.test('`_.' + methodName + '` should not assign values that are the same as their destinations', function(assert) {
       assert.expect(4);
 
-      _.each(['a', ['a'], { 'a': 1 }, NaN], function(value) {
+      lodashStable.each(['a', ['a'], { 'a': 1 }, NaN], function(value) {
         if (defineProperty) {
           var object = {},
               pass = true;
@@ -16177,7 +16172,7 @@
           defineProperty(object, 'a', {
             'enumerable': true,
             'configurable': true,
-            'get': _.constant(value),
+            'get': lodashStable.constant(value),
             'set': function() { pass = false; }
           });
 
@@ -16215,11 +16210,13 @@
     QUnit.test('should shuffle small collections', function(assert) {
       assert.expect(1);
 
-      var actual = _.times(1000, function(assert) {
+      var uniqBy = lodashStable.uniqBy || lodashStable.uniq;
+
+      var actual = lodashStable.times(1000, function(assert) {
         return _.shuffle([1, 2]);
       });
 
-      assert.deepEqual(_.sortBy(_.uniqBy(actual, String), '0'), [[1, 2], [2, 1]]);
+      assert.deepEqual(lodashStable.sortBy(uniqBy(actual, String), '0'), [[1, 2], [2, 1]]);
     });
 
     QUnit.test('should treat number values for `collection` as empty', function(assert) {
@@ -16252,9 +16249,9 @@
     QUnit.test('should accept a falsey `object` argument', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant(0));
+      var expected = lodashStable.map(falsey, lodashStable.constant(0));
 
-      var actual = _.map(falsey, function(object, index) {
+      var actual = lodashStable.map(falsey, function(object, index) {
         try {
           return index ? _.size(object) : _.size();
         } catch (e) {}
@@ -16322,7 +16319,7 @@
     QUnit.test('should work with a `start` >= `array.length`', function(assert) {
       assert.expect(4);
 
-      _.each([3, 4, Math.pow(2, 32), Infinity], function(start) {
+      lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(start) {
         assert.deepEqual(_.slice(array, start), []);
       });
     });
@@ -16330,9 +16327,9 @@
     QUnit.test('should treat falsey `start` values as `0`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant(array));
+      var expected = lodashStable.map(falsey, lodashStable.constant(array));
 
-      var actual = _.map(falsey, function(start) {
+      var actual = lodashStable.map(falsey, function(start) {
         return _.slice(array, start);
       });
 
@@ -16348,7 +16345,7 @@
     QUnit.test('should work with a negative `start` <= negative `array.length`', function(assert) {
       assert.expect(3);
 
-      _.each([-3, -4, -Infinity], function(start) {
+      lodashStable.each([-3, -4, -Infinity], function(start) {
         assert.deepEqual(_.slice(array, start), array);
       });
     });
@@ -16356,7 +16353,7 @@
     QUnit.test('should work with `start` >= `end`', function(assert) {
       assert.expect(2);
 
-      _.each([2, 3], function(start) {
+      lodashStable.each([2, 3], function(start) {
         assert.deepEqual(_.slice(array, start, 2), []);
       });
     });
@@ -16370,7 +16367,7 @@
     QUnit.test('should work with a `end` >= `array.length`', function(assert) {
       assert.expect(4);
 
-      _.each([3, 4, Math.pow(2, 32), Infinity], function(end) {
+      lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(end) {
         assert.deepEqual(_.slice(array, 0, end), array);
       });
     });
@@ -16378,11 +16375,11 @@
     QUnit.test('should treat falsey `end` values, except `undefined`, as `0`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === undefined ? array : [];
       });
 
-      var actual = _.map(falsey, function(end) {
+      var actual = lodashStable.map(falsey, function(end) {
         return _.slice(array, 0, end);
       });
 
@@ -16398,7 +16395,7 @@
     QUnit.test('should work with a negative `end` <= negative `array.length`', function(assert) {
       assert.expect(3);
 
-      _.each([-3, -4, -Infinity], function(end) {
+      lodashStable.each([-3, -4, -Infinity], function(end) {
         assert.deepEqual(_.slice(array, 0, end), []);
       });
     });
@@ -16408,7 +16405,7 @@
 
       var positions = [[0.1, 1.6], ['0', 1], [0, '1'], ['1'], [NaN, 1], [1, NaN]];
 
-      var actual = _.map(positions, function(pos) {
+      var actual = lodashStable.map(positions, function(pos) {
         return _.slice.apply(_, [array].concat(pos));
       });
 
@@ -16419,7 +16416,7 @@
       assert.expect(2);
 
       var array = [[1], [2, 3]],
-          actual = _.map(array, _.slice);
+          actual = lodashStable.map(array, _.slice);
 
       assert.deepEqual(actual, array);
       assert.notStrictEqual(actual, array);
@@ -16429,11 +16426,11 @@
       assert.expect(38);
 
       if (!isNpm) {
-        var array = _.range(1, LARGE_ARRAY_SIZE + 1),
+        var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
             length = array.length,
             wrapped = _(array);
 
-        _.each(['map', 'filter'], function(methodName) {
+        lodashStable.each(['map', 'filter'], function(methodName) {
           assert.deepEqual(wrapped[methodName]().slice(0, -1).value(), array.slice(0, -1));
           assert.deepEqual(wrapped[methodName]().slice(1).value(), array.slice(1));
           assert.deepEqual(wrapped[methodName]().slice(1, 3).value(), array.slice(1, 3));
@@ -16473,18 +16470,18 @@
     QUnit.test('should return `true` if `predicate` returns truthy for any element', function(assert) {
       assert.expect(2);
 
-      assert.strictEqual(_.some([false, 1, ''], _.identity), true);
-      assert.strictEqual(_.some([null, 'x', 0], _.identity), true);
+      assert.strictEqual(_.some([false, 1, ''], lodashStable.identity), true);
+      assert.strictEqual(_.some([null, 'x', 0], lodashStable.identity), true);
     });
 
     QUnit.test('should return `false` for empty collections', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(empties, _.constant(false));
+      var expected = lodashStable.map(empties, lodashStable.constant(false));
 
-      var actual = _.map(empties, function(value) {
+      var actual = lodashStable.map(empties, function(value) {
         try {
-          return _.some(value, _.identity);
+          return _.some(value, lodashStable.identity);
         } catch (e) {}
       });
 
@@ -16507,25 +16504,25 @@
     QUnit.test('should return `false` if `predicate` returns falsey for all elements', function(assert) {
       assert.expect(2);
 
-      assert.strictEqual(_.some([false, false, false], _.identity), false);
-      assert.strictEqual(_.some([null, 0, ''], _.identity), false);
+      assert.strictEqual(_.some([false, false, false], lodashStable.identity), false);
+      assert.strictEqual(_.some([null, 0, ''], lodashStable.identity), false);
     });
 
     QUnit.test('should use `_.identity` when `predicate` is nullish', function(assert) {
       assert.expect(2);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant(false));
+          expected = lodashStable.map(values, lodashStable.constant(false));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         var array = [0, 0];
         return index ? _.some(array, value) : _.some(array);
       });
 
       assert.deepEqual(actual, expected);
 
-      expected = _.map(values, _.constant(true));
-      actual = _.map(values, function(value, index) {
+      expected = lodashStable.map(values, lodashStable.constant(true));
+      actual = lodashStable.map(values, function(value, index) {
         var array = [0, 1];
         return index ? _.some(array, value) : _.some(array);
       });
@@ -16552,7 +16549,7 @@
     QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) {
       assert.expect(1);
 
-      var actual = _.map([[1]], _.some);
+      var actual = lodashStable.map([[1]], _.some);
       assert.deepEqual(actual, [true]);
     });
   }());
@@ -16572,7 +16569,7 @@
     QUnit.test('should sort in ascending order', function(assert) {
       assert.expect(1);
 
-      var actual = _.map(_.sortBy(objects, function(object) {
+      var actual = lodashStable.map(_.sortBy(objects, function(object) {
         return object.b;
       }), 'b');
 
@@ -16584,9 +16581,9 @@
 
       var array = [3, 2, 1],
           values = [, null, undefined],
-          expected = _.map(values, _.constant([1, 2, 3]));
+          expected = lodashStable.map(values, lodashStable.constant([1, 2, 3]));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.sortBy(array, value) : _.sortBy(array);
       });
 
@@ -16596,7 +16593,7 @@
     QUnit.test('should work with a "_.property" style `iteratee`', function(assert) {
       assert.expect(1);
 
-      var actual = _.map(_.sortBy(objects.concat(undefined), 'b'), 'b');
+      var actual = lodashStable.map(_.sortBy(objects.concat(undefined), 'b'), 'b');
       assert.deepEqual(actual, [1, 2, 3, 4, undefined]);
     });
 
@@ -16641,7 +16638,7 @@
     QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) {
       assert.expect(1);
 
-      var actual = _.map([[2, 1, 3], [3, 2, 1]], _.sortBy);
+      var actual = lodashStable.map([[2, 1, 3], [3, 2, 1]], _.sortBy);
       assert.deepEqual(actual, [[1, 2, 3], [1, 2, 3]]);
     });
   }());
@@ -16677,7 +16674,7 @@
 
   QUnit.module('sortBy methods');
 
-  _.each(['sortBy', 'sortByOrder'], function(methodName) {
+  lodashStable.each(['sortBy', 'sortByOrder'], function(methodName) {
     var func = _[methodName];
 
     function Pair(a, b, c) {
@@ -16725,7 +16722,7 @@
     QUnit.test('`_.' + methodName + '` should perform a stable sort (test in IE > 8, Opera, and V8)', function(assert) {
       assert.expect(2);
 
-      _.each([stableArray, stableObject], function(value, index) {
+      lodashStable.each([stableArray, stableObject], function(value, index) {
         var actual = func(value, ['a', 'c']);
         assert.deepEqual(actual, stableArray, index ? 'object' : 'array');
       });
@@ -16751,16 +16748,16 @@
         { 'a': 'y', '0': 2 }
       ];
 
-      var funcs = [func, _.partialRight(func, 'bogus')];
+      var funcs = [func, lodashStable.partialRight(func, 'bogus')];
 
-      _.each(['a', 0, [0]], function(props, index) {
-        var expected = _.map(funcs, _.constant(index
+      lodashStable.each(['a', 0, [0]], function(props, index) {
+        var expected = lodashStable.map(funcs, lodashStable.constant(index
           ? [objects[2], objects[3], objects[0], objects[1]]
           : [objects[0], objects[2], objects[1], objects[3]]
         ));
 
-        var actual = _.map(funcs, function(func) {
-          return _.reduce([props], func, objects);
+        var actual = lodashStable.map(funcs, function(func) {
+          return lodashStable.reduce([props], func, objects);
         });
 
         assert.deepEqual(actual, expected);
@@ -16772,7 +16769,7 @@
 
   QUnit.module('sortedIndex methods');
 
-  _.each(['sortedIndex', 'sortedLastIndex'], function(methodName) {
+  lodashStable.each(['sortedIndex', 'sortedLastIndex'], function(methodName) {
     var func = _[methodName],
         isSortedIndex = methodName == 'sortedIndex';
 
@@ -16783,7 +16780,7 @@
           values = [30, 40, 50],
           expected = isSortedIndex ? [0, 1, 1] : [1, 1, 2];
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return func(array, value);
       });
 
@@ -16797,7 +16794,7 @@
           values = ['a', 'b', 'c'],
           expected = isSortedIndex ? [0, 1, 1] : [1, 1, 2];
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return func(array, value);
       });
 
@@ -16807,9 +16804,9 @@
     QUnit.test('`_.' + methodName + '` should accept a falsey `array` argument and a `value`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant([0, 0, 0]));
+      var expected = lodashStable.map(falsey, lodashStable.constant([0, 0, 0]));
 
-      var actual = _.map(falsey, function(array) {
+      var actual = lodashStable.map(falsey, function(array) {
         return [func(array, 1), func(array, undefined), func(array, NaN)];
       });
 
@@ -16821,7 +16818,7 @@
 
       var expected = [1, '2', {}, null, undefined, NaN, NaN];
 
-      _.each([
+      lodashStable.each([
         [NaN, null, 1, '2', {}, NaN, undefined],
         ['2', null, 1, NaN, {}, NaN, undefined]
       ], function(array) {
@@ -16838,7 +16835,7 @@
 
   QUnit.module('sortedIndexBy methods');
 
-  _.each(['sortedIndexBy', 'sortedLastIndexBy'], function(methodName) {
+  lodashStable.each(['sortedIndexBy', 'sortedLastIndexBy'], function(methodName) {
     var func = _[methodName],
         isSortedIndexBy = methodName == 'sortedIndexBy';
 
@@ -16866,13 +16863,13 @@
     QUnit.test('`_.' + methodName + '` should support arrays larger than `MAX_ARRAY_LENGTH / 2`', function(assert) {
       assert.expect(12);
 
-      _.each([Math.ceil(MAX_ARRAY_LENGTH / 2), MAX_ARRAY_LENGTH], function(length) {
+      lodashStable.each([Math.ceil(MAX_ARRAY_LENGTH / 2), MAX_ARRAY_LENGTH], function(length) {
         var array = [],
             values = [MAX_ARRAY_LENGTH, NaN, undefined];
 
         array.length = length;
 
-        _.each(values, function(value) {
+        lodashStable.each(values, function(value) {
           var steps = 0,
               actual = func(array, value, function(value) { steps++; return value; });
 
@@ -16897,7 +16894,7 @@
 
   QUnit.module('sortedIndexOf methods');
 
-  _.each(['sortedIndexOf', 'sortedLastIndexOf'], function(methodName) {
+  lodashStable.each(['sortedIndexOf', 'sortedLastIndexOf'], function(methodName) {
     var func = _[methodName],
         isSortedIndexOf = methodName == 'sortedIndexOf';
 
@@ -16919,7 +16916,7 @@
 
       var expected = [1, 2, 3];
 
-      _.each([[1, 2, 3], [1, 1, 2, 2, 3], [1, 2, 3, 3, 3, 3, 3]], function(array) {
+      lodashStable.each([[1, 2, 3], [1, 1, 2, 2, 3], [1, 2, 3, 3, 3, 3, 3]], function(array) {
         assert.deepEqual(_.sortedUniq(array), expected);
       });
     });
@@ -16985,7 +16982,7 @@
     QUnit.test('should work with `position` >= `string.length`', function(assert) {
       assert.expect(4);
 
-      _.each([3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
+      lodashStable.each([3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
         assert.strictEqual(_.startsWith(string, 'a', position), false);
       });
     });
@@ -16993,9 +16990,9 @@
     QUnit.test('should treat falsey `position` values as `0`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant(true));
+      var expected = lodashStable.map(falsey, lodashStable.constant(true));
 
-      var actual = _.map(falsey, function(position) {
+      var actual = lodashStable.map(falsey, function(position) {
         return _.startsWith(string, 'a', position);
       });
 
@@ -17005,7 +17002,7 @@
     QUnit.test('should treat a negative `position` as `0`', function(assert) {
       assert.expect(6);
 
-      _.each([-1, -3, -Infinity], function(position) {
+      lodashStable.each([-1, -3, -Infinity], function(position) {
         assert.strictEqual(_.startsWith(string, 'a', position), true);
         assert.strictEqual(_.startsWith(string, 'b', position), false);
       });
@@ -17020,7 +17017,7 @@
     QUnit.test('should return `true` when `target` is an empty string regardless of `position`', function(assert) {
       assert.expect(1);
 
-      assert.ok(_.every([-Infinity, NaN, -3, -1, 0, 1, 2, 3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
+      assert.ok(lodashStable.every([-Infinity, NaN, -3, -1, 0, 1, 2, 3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
         return _.startsWith(string, '', position, true);
       }));
     });
@@ -17030,7 +17027,7 @@
 
   QUnit.module('lodash.startsWith and lodash.endsWith');
 
-  _.each(['startsWith', 'endsWith'], function(methodName) {
+  lodashStable.each(['startsWith', 'endsWith'], function(methodName) {
     var func = _[methodName],
         isStartsWith = methodName == 'startsWith';
 
@@ -17041,14 +17038,14 @@
       assert.expect(2);
 
       assert.strictEqual(func(Object(string), chr), true);
-      assert.strictEqual(func({ 'toString': _.constant(string) }, chr), true);
+      assert.strictEqual(func({ 'toString': lodashStable.constant(string) }, chr), true);
     });
 
     QUnit.test('`_.' + methodName + '` should coerce `target` to a string', function(assert) {
       assert.expect(2);
 
       assert.strictEqual(func(string, Object(chr)), true);
-      assert.strictEqual(func(string, { 'toString': _.constant(chr) }), true);
+      assert.strictEqual(func(string, { 'toString': lodashStable.constant(chr) }), true);
     });
 
     QUnit.test('`_.' + methodName + '` should coerce `position` to a number', function(assert) {
@@ -17056,7 +17053,7 @@
 
       var position = isStartsWith ? 1 : 2;
       assert.strictEqual(func(string, 'b', Object(position)), true);
-      assert.strictEqual(func(string, 'b', { 'toString': _.constant(String(position)) }), true);
+      assert.strictEqual(func(string, 'b', { 'toString': lodashStable.constant(String(position)) }), true);
     });
   });
 
@@ -17076,9 +17073,9 @@
     QUnit.test('should return `undefined` when passing empty `array` values', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(empties, _.constant(undefined));
+      var expected = lodashStable.map(empties, lodashStable.constant(undefined));
 
-      var actual = _.map(empties, function(value) {
+      var actual = lodashStable.map(empties, function(value) {
         return _.sum(value);
       });
 
@@ -17147,9 +17144,9 @@
     QUnit.test('should accept a falsey `array` argument', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant([]));
+      var expected = lodashStable.map(falsey, lodashStable.constant([]));
 
-      var actual = _.map(falsey, function(array, index) {
+      var actual = lodashStable.map(falsey, function(array, index) {
         try {
           return index ? _.tail(array) : _.tail();
         } catch (e) {}
@@ -17174,7 +17171,7 @@
       assert.expect(1);
 
       var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-          actual = _.map(array, _.tail);
+          actual = lodashStable.map(array, _.tail);
 
       assert.deepEqual(actual, [[2, 3], [5, 6], [8, 9]]);
     });
@@ -17183,7 +17180,7 @@
       assert.expect(4);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE),
+        var array = lodashStable.range(LARGE_ARRAY_SIZE),
             values = [];
 
         var actual = _(array).tail().filter(function(value) {
@@ -17216,7 +17213,7 @@
       assert.expect(4);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE),
+        var array = lodashStable.range(LARGE_ARRAY_SIZE),
             iteratee = function() { pass = false; },
             pass = true,
             actual = _(array).slice(0, 1).tail().map(iteratee).value();
@@ -17252,11 +17249,11 @@
     QUnit.test('should treat falsey `n` values, except `undefined`, as `0`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === undefined ? [1] : [];
       });
 
-      var actual = _.map(falsey, function(n) {
+      var actual = lodashStable.map(falsey, function(n) {
         return _.take(array, n);
       });
 
@@ -17266,7 +17263,7 @@
     QUnit.test('should return an empty array when `n` < `1`', function(assert) {
       assert.expect(3);
 
-      _.each([0, -1, -Infinity], function(n) {
+      lodashStable.each([0, -1, -Infinity], function(n) {
         assert.deepEqual(_.take(array, n), []);
       });
     });
@@ -17274,7 +17271,7 @@
     QUnit.test('should return all elements when `n` >= `array.length`', function(assert) {
       assert.expect(4);
 
-      _.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
+      lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
         assert.deepEqual(_.take(array, n), array);
       });
     });
@@ -17283,7 +17280,7 @@
       assert.expect(1);
 
       var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-          actual = _.map(array, _.take);
+          actual = lodashStable.map(array, _.take);
 
       assert.deepEqual(actual, [[1], [4], [7]]);
     });
@@ -17292,7 +17289,7 @@
       assert.expect(6);
 
       if (!isNpm) {
-        var array = _.range(1, LARGE_ARRAY_SIZE + 1),
+        var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
             predicate = function(value) { values.push(value); return isEven(value); },
             values = [],
             actual = _(array).take(2).take().value();
@@ -17334,11 +17331,11 @@
     QUnit.test('should treat falsey `n` values, except `undefined`, as `0`', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, function(value) {
+      var expected = lodashStable.map(falsey, function(value) {
         return value === undefined ? [3] : [];
       });
 
-      var actual = _.map(falsey, function(n) {
+      var actual = lodashStable.map(falsey, function(n) {
         return _.takeRight(array, n);
       });
 
@@ -17348,7 +17345,7 @@
     QUnit.test('should return an empty array when `n` < `1`', function(assert) {
       assert.expect(3);
 
-      _.each([0, -1, -Infinity], function(n) {
+      lodashStable.each([0, -1, -Infinity], function(n) {
         assert.deepEqual(_.takeRight(array, n), []);
       });
     });
@@ -17356,7 +17353,7 @@
     QUnit.test('should return all elements when `n` >= `array.length`', function(assert) {
       assert.expect(4);
 
-      _.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
+      lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
         assert.deepEqual(_.takeRight(array, n), array);
       });
     });
@@ -17365,7 +17362,7 @@
       assert.expect(1);
 
       var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-          actual = _.map(array, _.takeRight);
+          actual = lodashStable.map(array, _.takeRight);
 
       assert.deepEqual(actual, [[3], [6], [9]]);
     });
@@ -17374,7 +17371,7 @@
       assert.expect(6);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE),
+        var array = lodashStable.range(LARGE_ARRAY_SIZE),
             predicate = function(value) { values.push(value); return isEven(value); },
             values = [],
             actual = _(array).takeRight(2).takeRight().value();
@@ -17457,7 +17454,7 @@
       assert.expect(3);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE),
+        var array = lodashStable.range(LARGE_ARRAY_SIZE),
             predicate = function(num) { return num > 2; },
             expected = _.takeRightWhile(array, predicate),
             wrapped = _(array).takeRightWhile(predicate);
@@ -17476,8 +17473,8 @@
 
       if (!isNpm) {
         var args,
-            array = _.range(LARGE_ARRAY_SIZE + 1),
-            expected = [square(LARGE_ARRAY_SIZE), LARGE_ARRAY_SIZE - 1, _.map(array.slice(1), square)];
+            array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
+            expected = [square(LARGE_ARRAY_SIZE), LARGE_ARRAY_SIZE - 1, lodashStable.map(array.slice(1), square)];
 
         _(array).slice(1).takeRightWhile(function(value, index, array) {
           args = slice.call(arguments);
@@ -17571,7 +17568,7 @@
       assert.expect(3);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE),
+        var array = lodashStable.range(LARGE_ARRAY_SIZE),
             predicate = function(num) { return num < 3; },
             expected = _.takeWhile(array, predicate),
             wrapped = _(array).takeWhile(predicate);
@@ -17589,7 +17586,7 @@
       assert.expect(1);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE);
+        var array = lodashStable.range(LARGE_ARRAY_SIZE);
 
         var actual = _(array)
           .takeWhile(function(num) { return num < 4; })
@@ -17609,8 +17606,8 @@
 
       if (!isNpm) {
         var args,
-            array = _.range(LARGE_ARRAY_SIZE + 1),
-            expected = [1, 0, _.map(array.slice(1), square)];
+            array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
+            expected = [1, 0, lodashStable.map(array.slice(1), square)];
 
         _(array).slice(1).takeWhile(function(value, index, array) {
           args = slice.call(arguments);
@@ -17704,10 +17701,10 @@
       assert.expect(1);
 
       var strings = ['<p><%- value %></p>', '<p><%-value%></p>', '<p><%-\nvalue\n%></p>'],
-          expected = _.map(strings, _.constant('<p>&amp;&lt;&gt;&quot;&#39;&#96;\/</p>')),
+          expected = lodashStable.map(strings, lodashStable.constant('<p>&amp;&lt;&gt;&quot;&#39;&#96;\/</p>')),
           data = { 'value': '&<>"\'`\/' };
 
-      var actual = _.map(strings, function(string) {
+      var actual = lodashStable.map(strings, function(string) {
         return _.template(string)(data);
       });
 
@@ -17734,10 +17731,10 @@
       assert.expect(1);
 
       var strings = ['<%= a %>BC', '<%=a%>BC', '<%=\na\n%>BC'],
-          expected = _.map(strings, _.constant('ABC')),
+          expected = lodashStable.map(strings, lodashStable.constant('ABC')),
           data = { 'a': 'A' };
 
-      var actual = _.map(strings, function(string) {
+      var actual = lodashStable.map(strings, function(string) {
         return _.template(string)(data);
       });
 
@@ -17777,7 +17774,7 @@
     QUnit.test('should work with complex "interpolate" delimiters', function(assert) {
       assert.expect(22);
 
-      _.each({
+      lodashStable.each({
         '<%= a + b %>': '3',
         '<%= b - a %>': '1',
         '<%= a = b %>': '2',
@@ -17845,10 +17842,10 @@
     QUnit.test('should work with custom delimiters', function(assert) {
       assert.expect(2);
 
-      _.times(2, function(index) {
-        var settingsClone = _.clone(_.templateSettings);
+      lodashStable.times(2, function(index) {
+        var settingsClone = lodashStable.clone(_.templateSettings);
 
-        var settings = _.assign(index ? _.templateSettings : {}, {
+        var settings = lodashStable.assign(index ? _.templateSettings : {}, {
           'escape': /\{\{-([\s\S]+?)\}\}/g,
           'evaluate': /\{\{([\s\S]+?)\}\}/g,
           'interpolate': /\{\{=([\s\S]+?)\}\}/g
@@ -17859,17 +17856,17 @@
             data = { 'collection': ['a & A', 'b & B'] };
 
         assert.strictEqual(compiled(data), expected);
-        _.assign(_.templateSettings, settingsClone);
+        lodashStable.assign(_.templateSettings, settingsClone);
       });
     });
 
     QUnit.test('should work with custom delimiters containing special characters', function(assert) {
       assert.expect(2);
 
-      _.times(2, function(index) {
-        var settingsClone = _.clone(_.templateSettings);
+      lodashStable.times(2, function(index) {
+        var settingsClone = lodashStable.clone(_.templateSettings);
 
-        var settings = _.assign(index ? _.templateSettings : {}, {
+        var settings = lodashStable.assign(index ? _.templateSettings : {}, {
           'escape': /<\?-([\s\S]+?)\?>/g,
           'evaluate': /<\?([\s\S]+?)\?>/g,
           'interpolate': /<\?=([\s\S]+?)\?>/g
@@ -17880,7 +17877,7 @@
             data = { 'collection': ['a & A', 'b & B'] };
 
         assert.strictEqual(compiled(data), expected);
-        _.assign(_.templateSettings, settingsClone);
+        lodashStable.assign(_.templateSettings, settingsClone);
       });
     });
 
@@ -18077,7 +18074,7 @@
     QUnit.test('should coerce `text` argument to a string', function(assert) {
       assert.expect(1);
 
-      var object = { 'toString': _.constant('<%= a %>') },
+      var object = { 'toString': lodashStable.constant('<%= a %>') },
           data = { 'a': 1 };
 
       assert.strictEqual(_.template(object)(data), '1');
@@ -18130,10 +18127,10 @@
 
       var compiled = _.template('x'),
           values = [String(compiled), compiled.source],
-          expected = _.map(values, _.constant(true));
+          expected = lodashStable.map(values, lodashStable.constant(true));
 
-      var actual = _.map(values, function(value) {
-        return _.includes(value, '__p');
+      var actual = lodashStable.map(values, function(value) {
+        return lodashStable.includes(value, '__p');
       });
 
       assert.deepEqual(actual, expected);
@@ -18147,7 +18144,7 @@
       } catch (e) {
         var source = e.source;
       }
-      assert.ok(_.includes(source, '__p'));
+      assert.ok(lodashStable.includes(source, '__p'));
     });
 
     QUnit.test('should not include sourceURLs in the source', function(assert) {
@@ -18162,10 +18159,10 @@
       } catch (e) {
         values[1] = e.source;
       }
-      var expected = _.map(values, _.constant(false));
+      var expected = lodashStable.map(values, lodashStable.constant(false));
 
-      var actual = _.map(values, function(value) {
-        return _.includes(value, 'sourceURL');
+      var actual = lodashStable.map(values, function(value) {
+        return lodashStable.includes(value, 'sourceURL');
       });
 
       assert.deepEqual(actual, expected);
@@ -18175,10 +18172,10 @@
       assert.expect(1);
 
       var array = ['<%= a %>', '<%- b %>', '<% print(c) %>'],
-          compiles = _.map(array, _.template),
+          compiles = lodashStable.map(array, _.template),
           data = { 'a': 'one', 'b': '`two`', 'c': 'three' };
 
-      var actual = _.map(compiles, function(compiled) {
+      var actual = lodashStable.map(compiles, function(compiled) {
         return compiled(data);
       });
 
@@ -18234,7 +18231,7 @@
     QUnit.test('should treat negative `length` as `0`', function(assert) {
       assert.expect(2);
 
-      _.each([0, -2], function(length) {
+      lodashStable.each([0, -2], function(length) {
         assert.strictEqual(_.trunc(string, { 'length': length }), '...');
       });
     });
@@ -18242,9 +18239,9 @@
     QUnit.test('should coerce `length` to an integer', function(assert) {
       assert.expect(4);
 
-      _.each(['', NaN, 4.6, '4'], function(length, index) {
+      lodashStable.each(['', NaN, 4.6, '4'], function(length, index) {
         var actual = index > 1 ? 'h...' : '...';
-        assert.strictEqual(_.trunc(string, { 'length': { 'valueOf': _.constant(length) } }), actual);
+        assert.strictEqual(_.trunc(string, { 'length': { 'valueOf': lodashStable.constant(length) } }), actual);
       });
     });
 
@@ -18252,13 +18249,13 @@
       assert.expect(2);
 
       assert.strictEqual(_.trunc(Object(string), { 'length': 4 }), 'h...');
-      assert.strictEqual(_.trunc({ 'toString': _.constant(string) }, { 'length': 5 }), 'hi...');
+      assert.strictEqual(_.trunc({ 'toString': lodashStable.constant(string) }, { 'length': 5 }), 'hi...');
     });
 
     QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) {
       assert.expect(1);
 
-      var actual = _.map([string, string, string], _.trunc),
+      var actual = lodashStable.map([string, string, string], _.trunc),
           truncated = 'hi-diddly-ho there, neighbo...';
 
       assert.deepEqual(actual, [truncated, truncated, truncated]);
@@ -18303,7 +18300,7 @@
       var done = assert.async();
 
       if (!(isRhino && isModularize)) {
-        var throttled = _.throttle(_.identity, 32),
+        var throttled = _.throttle(lodashStable.identity, 32),
             result = [throttled('a'), throttled('b')];
 
         assert.deepEqual(result, ['a', 'a']);
@@ -18337,8 +18334,8 @@
           return ++dateCount == 5 ? Infinity : +new Date;
         };
 
-        var lodash = _.runInContext(_.assign({}, root, {
-          'Date': _.assign(function() {
+        var lodash = _.runInContext(lodashStable.assign({}, root, {
+          'Date': lodashStable.assign(function() {
             return { 'getTime': getTime };
           }, {
             'now': Date.now
@@ -18387,7 +18384,7 @@
       }
     });
 
-    _.times(2, function(index) {
+    lodashStable.times(2, function(index) {
      QUnit.test('should trigger a call when invoked repeatedly' + (index ? ' and `leading` is `false`' : ''), function(assert) {
        assert.expect(1);
 
@@ -18451,10 +18448,10 @@
       assert.expect(2);
 
       if (!(isRhino && isModularize)) {
-        var withLeading = _.throttle(_.identity, 32, { 'leading': true });
+        var withLeading = _.throttle(lodashStable.identity, 32, { 'leading': true });
         assert.strictEqual(withLeading('a'), 'a');
 
-        var withoutLeading = _.throttle(_.identity, 32, { 'leading': false });
+        var withoutLeading = _.throttle(lodashStable.identity, 32, { 'leading': false });
         assert.strictEqual(withoutLeading('a'), undefined);
       }
       else {
@@ -18535,7 +18532,7 @@
 
   QUnit.module('lodash.debounce and lodash.throttle');
 
-  _.each(['debounce', 'throttle'], function(methodName) {
+  lodashStable.each(['debounce', 'throttle'], function(methodName) {
     var func = _[methodName],
         isDebounce = methodName == 'debounce';
 
@@ -18545,7 +18542,7 @@
       var pass = true;
 
       try {
-        func(_.noop, 32, 1);
+        func(noop, 32, 1);
       } catch (e) {
         pass = false;
       }
@@ -18589,7 +18586,7 @@
         };
 
         var actual = [],
-            expected = _.times(isDebounce ? 1 : 2, _.constant(object));
+            expected = lodashStable.times(isDebounce ? 1 : 2, lodashStable.constant(object));
 
         object.funced();
         if (!isDebounce) {
@@ -18613,7 +18610,7 @@
 
       if (!(isRhino && isModularize)) {
         var actual = [],
-            args = _.map(['a', 'b', 'c'], function(chr) { return [{}, chr]; }),
+            args = lodashStable.map(['a', 'b', 'c'], function(chr) { return [{}, chr]; }),
             expected = args.slice(),
             queue = args.slice();
 
@@ -18656,8 +18653,8 @@
           return ++dateCount === 4 ? +new Date(2012, 3, 23, 23, 27, 18) : +new Date;
         };
 
-        var lodash = _.runInContext(_.assign({}, root, {
-          'Date': _.assign(function() {
+        var lodash = _.runInContext(lodashStable.assign({}, root, {
+          'Date': lodashStable.assign(function() {
             return { 'getTime': getTime, 'valueOf': getTime };
           }, {
             'now': Date.now
@@ -18744,7 +18741,7 @@
     QUnit.test('should coerce non-finite `n` values to `0`', function(assert) {
       assert.expect(3);
 
-      _.each([-Infinity, NaN, Infinity], function(n) {
+      lodashStable.each([-Infinity, NaN, Infinity], function(n) {
         assert.deepEqual(_.times(n), []);
       });
     });
@@ -18772,9 +18769,9 @@
       assert.expect(1);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant([0, 1, 2]));
+          expected = lodashStable.map(values, lodashStable.constant([0, 1, 2]));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.times(3, value) : _.times(3);
       });
 
@@ -18791,9 +18788,9 @@
       assert.expect(1);
 
       var values = falsey.concat(-1, -Infinity),
-          expected = _.map(values, _.constant([]));
+          expected = lodashStable.map(values, lodashStable.constant([]));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.times(value) : _.times();
       });
 
@@ -18851,12 +18848,12 @@
       assert.expect(2);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE + 1),
+        var array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
             actual = _(array).slice(1).map(String).toArray().value();
 
-        assert.deepEqual(actual, _.map(array.slice(1), String));
+        assert.deepEqual(actual, lodashStable.map(array.slice(1), String));
 
-        var object = _.zipObject(_.times(LARGE_ARRAY_SIZE, function(index) {
+        var object = _.zipObject(lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
           return ['key' + index, index];
         }));
 
@@ -18901,7 +18898,7 @@
 
   QUnit.module('lodash.slice and lodash.toArray');
 
-  _.each(['slice', 'toArray'], function(methodName) {
+  lodashStable.each(['slice', 'toArray'], function(methodName) {
     var args = (function() { return arguments; }(1, 2, 3)),
         array = [1, 2, 3],
         func = _[methodName];
@@ -18985,7 +18982,7 @@
 
       var array = ['a', 'b', 'c'];
 
-      _.each([array, _.map(array, Object)], function(value) {
+      lodashStable.each([array, lodashStable.map(array, Object)], function(value) {
         var actual = _.toPath(value);
         assert.deepEqual(actual, array);
         assert.notStrictEqual(actual, array);
@@ -19025,7 +19022,7 @@
       function Foo() { this.b = 2; }
       Foo.prototype.c = 3;
 
-      var actual = _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
+      var actual = lodashStable.assign({ 'a': 1 }, _.toPlainObject(new Foo));
       assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 });
     });
 
@@ -19063,7 +19060,7 @@
       assert.expect(4);
 
       var accumulators = [, null, undefined],
-          expected = _.map(accumulators, _.constant(true)),
+          expected = lodashStable.map(accumulators, lodashStable.constant(true)),
           object = new Foo;
 
       var iteratee = function(result, value, key) {
@@ -19074,27 +19071,27 @@
         return index ? _.transform(object, iteratee, accumulator) : _.transform(object, iteratee);
       };
 
-      var results = _.map(accumulators, mapper);
+      var results = lodashStable.map(accumulators, mapper);
 
-      var actual = _.map(results, function(result) {
+      var actual = lodashStable.map(results, function(result) {
         return result instanceof Foo;
       });
 
       assert.deepEqual(actual, expected);
 
-      expected = _.map(accumulators, _.constant({ 'a': 1, 'b': 4, 'c': 9 }));
-      actual = _.map(results, _.clone);
+      expected = lodashStable.map(accumulators, lodashStable.constant({ 'a': 1, 'b': 4, 'c': 9 }));
+      actual = lodashStable.map(results, lodashStable.cloneDeep);
 
       assert.deepEqual(actual, expected);
 
       object = { 'a': 1, 'b': 2, 'c': 3 };
-      actual = _.map(accumulators, mapper);
+      actual = lodashStable.map(accumulators, mapper);
 
       assert.deepEqual(actual, expected);
 
       object = [1, 2, 3];
-      expected = _.map(accumulators, _.constant([1, 4, 9]));
-      actual = _.map(accumulators, mapper);
+      expected = lodashStable.map(accumulators, lodashStable.constant([1, 4, 9]));
+      actual = lodashStable.map(accumulators, mapper);
 
       assert.deepEqual(actual, expected);
     });
@@ -19103,9 +19100,9 @@
       assert.expect(4);
 
       var values = [new Foo, [1, 2, 3], { 'a': 1, 'b': 2, 'c': 3 }],
-          expected = _.map(values, _.constant([0, 1, 4, 9]));
+          expected = lodashStable.map(values, lodashStable.constant([0, 1, 4, 9]));
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return _.transform(value, function(result, value) {
           result.push(square(value));
         }, [0]);
@@ -19115,7 +19112,7 @@
 
       var object = { '_': 0, 'a': 1, 'b': 4, 'c': 9 };
       expected = [object, { '_': 0, '0': 1, '1': 4, '2': 9 }, object];
-      actual = _.map(values, function(value) {
+      actual = lodashStable.map(values, function(value) {
         return _.transform(value, function(result, value, key) {
           result[key] = square(value);
         }, { '_': 0 });
@@ -19124,14 +19121,14 @@
       assert.deepEqual(actual, expected);
 
       object = {};
-      expected = _.map(values, _.constant(object));
-      actual = _.map(values, function(value) {
-        return _.transform(value, _.noop, object);
+      expected = lodashStable.map(values, lodashStable.constant(object));
+      actual = lodashStable.map(values, function(value) {
+        return _.transform(value, noop, object);
       });
 
       assert.deepEqual(actual, expected);
 
-      actual = _.map(values, function(value) {
+      actual = lodashStable.map(values, function(value) {
         return _.transform(null, null, object);
       });
 
@@ -19159,17 +19156,17 @@
 
       var Ctors = [Boolean, Boolean, Number, Number, Number, String, String],
           values = [true, false, 0, 1, NaN, '', 'a'],
-          expected = _.map(values, _.constant({}));
+          expected = lodashStable.map(values, lodashStable.constant({}));
 
-      var results = _.map(values, function(value) {
+      var results = lodashStable.map(values, function(value) {
         return _.transform(value);
       });
 
       assert.deepEqual(results, expected);
 
-      expected = _.map(values, _.constant(false));
+      expected = lodashStable.map(values, lodashStable.constant(false));
 
-      var actual = _.map(results, function(value, index) {
+      var actual = lodashStable.map(results, function(value, index) {
         return value instanceof Ctors[index];
       });
 
@@ -19179,16 +19176,16 @@
     QUnit.test('should create an empty object when provided a falsey `object` argument', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant({}));
+      var expected = lodashStable.map(falsey, lodashStable.constant({}));
 
-      var actual = _.map(falsey, function(object, index) {
+      var actual = lodashStable.map(falsey, function(object, index) {
         return index ? _.transform(object) : _.transform();
       });
 
       assert.deepEqual(actual, expected);
     });
 
-    _.each({
+    lodashStable.each({
       'array': [1, 2, 3],
       'object': { 'a': 1, 'b': 2, 'c': 3 }
     },
@@ -19204,10 +19201,10 @@
 
         var first = args[0];
         if (key == 'array') {
-          assert.ok(first !== object && _.isArray(first));
+          assert.ok(first !== object && lodashStable.isArray(first));
           assert.deepEqual(args, [first, 1, 0, object]);
         } else {
-          assert.ok(first !== object && _.isPlainObject(first));
+          assert.ok(first !== object && lodashStable.isPlainObject(first));
           assert.deepEqual(args, [first, 1, 'a', object]);
         }
       });
@@ -19217,21 +19214,21 @@
       assert.expect(1);
 
       var objects = _.transform(_, function(result, value, key) {
-        if (_.startsWith(key, '_') && _.isObject(value) && !_.isElement(value)) {
+        if (lodashStable.startsWith(key, '_') && lodashStable.isObject(value) && !lodashStable.isElement(value)) {
           result.push(value);
         }
       }, []);
 
-      var expected = _.times(objects.length, _.constant(true));
+      var expected = lodashStable.times(objects.length, lodashStable.constant(true));
 
-      var actual = _.map(objects, function(object) {
+      var actual = lodashStable.map(objects, function(object) {
         var Ctor = object.constructor,
             result = _.transform(object);
 
         if (result === object) {
           return false;
         }
-        if (_.isTypedArray(object)) {
+        if (lodashStable.isTypedArray(object)) {
           return result instanceof Array;
         }
         return result instanceof Ctor || !(new Ctor instanceof Ctor);
@@ -19245,7 +19242,7 @@
 
   QUnit.module('trim methods');
 
-  _.each(['trim', 'trimLeft', 'trimRight'], function(methodName, index) {
+  lodashStable.each(['trim', 'trimLeft', 'trimRight'], function(methodName, index) {
     var func = _[methodName];
 
     var parts = [];
@@ -19279,7 +19276,7 @@
     QUnit.test('`_.' + methodName + '` should coerce `string` to a string', function(assert) {
       assert.expect(1);
 
-      var object = { 'toString': _.constant(whitespace + 'a b c' + whitespace) },
+      var object = { 'toString': lodashStable.constant(whitespace + 'a b c' + whitespace) },
           expected = (index == 2 ? whitespace : '') + 'a b c' + (index == 1 ? whitespace : '');
 
       assert.strictEqual(func(object), expected);
@@ -19297,7 +19294,7 @@
     QUnit.test('`_.' + methodName + '` should coerce `chars` to a string', function(assert) {
       assert.expect(1);
 
-      var object = { 'toString': _.constant('_-') },
+      var object = { 'toString': lodashStable.constant('_-') },
           string = '-_-a-b-c-_-',
           expected = (index == 2 ? '-_-' : '') + 'a-b-c' + (index == 1 ? '-_-' : '');
 
@@ -19307,7 +19304,7 @@
     QUnit.test('`_.' + methodName + '` should return an empty string for empty values and `chars`', function(assert) {
       assert.expect(6);
 
-      _.each([null, '_-'], function(chars) {
+      lodashStable.each([null, '_-'], function(chars) {
         assert.strictEqual(func(null, chars), '');
         assert.strictEqual(func(undefined, chars), '');
         assert.strictEqual(func('', chars), '');
@@ -19329,7 +19326,7 @@
 
       var string = Object(whitespace + 'a b c' + whitespace),
           trimmed = (index == 2 ? whitespace : '') + 'a b c' + (index == 1 ? whitespace : ''),
-          actual = _.map([string, string, string], func);
+          actual = lodashStable.map([string, string, string], func);
 
       assert.deepEqual(actual, [trimmed, trimmed, trimmed]);
     });
@@ -19408,7 +19405,7 @@
 
       assert.deepEqual(_.words(string), ['A', leafs, comboGlyph, 'and', rocket]);
 
-      _.times(2, function(index) {
+      lodashStable.times(2, function(index) {
         var separator = index ? RegExp(hearts) : hearts,
             options = { 'length': 4, 'separator': separator },
             actual = _.trunc(string, options);
@@ -19460,15 +19457,15 @@
     QUnit.test('should account for modifiers', function(assert) {
       assert.expect(1);
 
-      var values = _.map(emojiModifiers, function(modifier) {
+      var values = lodashStable.map(emojiModifiers, function(modifier) {
         return thumbsUp + modifier;
       });
 
-      var expected = _.map(values, function(value) {
+      var expected = lodashStable.map(values, function(value) {
         return [1, [value], [value]];
       });
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return [_.size(value), _.toArray(value), _.words(value)];
       });
 
@@ -19478,15 +19475,15 @@
     QUnit.test('should account for variation selectors with modifiers', function(assert) {
       assert.expect(1);
 
-      var values = _.map(emojiModifiers, function(modifier) {
+      var values = lodashStable.map(emojiModifiers, function(modifier) {
         return raisedHand + modifier;
       });
 
-      var expected = _.map(values, function(value) {
+      var expected = lodashStable.map(values, function(value) {
         return [1, [value], [value]];
       });
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return [_.size(value), _.toArray(value), _.words(value)];
       });
 
@@ -19496,15 +19493,15 @@
     QUnit.test('should account for combining diacritical marks', function(assert) {
       assert.expect(1);
 
-      var values = _.map(comboMarks, function(mark) {
+      var values = lodashStable.map(comboMarks, function(mark) {
         return 'o' + mark;
       });
 
-      var expected = _.map(values, function(value) {
+      var expected = lodashStable.map(values, function(value) {
         return [1, [value], [value]];
       });
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         return [_.size(value), _.toArray(value), _.words(value)];
       });
 
@@ -19586,7 +19583,7 @@
 
   QUnit.module('union methods');
 
-  _.each(['union', 'unionBy'], function(methodName) {
+  lodashStable.each(['union', 'unionBy'], function(methodName) {
     var args = (function() { return arguments; }(1, 2, 3)),
         func = _[methodName];
 
@@ -19651,7 +19648,7 @@
       assert.expect(1);
 
       var array = [[2, 1, 2], [1, 2, 1]],
-          actual = _.map(array, _.uniq);
+          actual = lodashStable.map(array, lodashStable.uniq);
 
       assert.deepEqual(actual, [[2, 1], [1, 2]]);
     });
@@ -19661,7 +19658,7 @@
 
   QUnit.module('uniq methods');
 
-  _.each(['uniq', 'uniqBy', 'sortedUniq', 'sortedUniqBy'], function(methodName) {
+  lodashStable.each(['uniq', 'uniqBy', 'sortedUniq', 'sortedUniqBy'], function(methodName) {
     var func = _[methodName],
         isSorted = /^sorted/.test(methodName);
         objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }, { 'a': 2 }, { 'a': 3 }, { 'a': 1 }];
@@ -19703,8 +19700,8 @@
           expected = [0, {}, 'a'],
           count = Math.ceil(LARGE_ARRAY_SIZE / expected.length);
 
-      _.each(expected, function(value) {
-        _.times(count, function() {
+      lodashStable.each(expected, function(value) {
+        lodashStable.times(count, function() {
           largeArray.push(value);
         });
       });
@@ -19719,8 +19716,8 @@
           expected = [false, true, null, undefined, NaN],
           count = Math.ceil(LARGE_ARRAY_SIZE / expected.length);
 
-      _.each(expected, function(value) {
-        _.times(count, function() {
+      lodashStable.each(expected, function(value) {
+        lodashStable.times(count, function() {
           largeArray.push(value);
         });
       });
@@ -19732,7 +19729,7 @@
       assert.expect(1);
 
       if (Symbol) {
-        var largeArray = _.times(LARGE_ARRAY_SIZE, function() {
+        var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function() {
           return Symbol();
         });
 
@@ -19757,12 +19754,12 @@
         var largeArray = [],
             count = Math.ceil(LARGE_ARRAY_SIZE / expected.length);
 
-        expected = _.map(expected, function(symbol) {
+        expected = lodashStable.map(expected, function(symbol) {
           return symbol || {};
         });
 
-        _.each(expected, function(value) {
-          _.times(count, function() {
+        lodashStable.each(expected, function(value) {
+          lodashStable.times(count, function() {
             largeArray.push(value);
           });
         });
@@ -19781,8 +19778,8 @@
           expected = ['2', 2, Object('2'), Object(2)],
           count = Math.ceil(LARGE_ARRAY_SIZE / expected.length);
 
-      _.each(expected, function(value) {
-        _.times(count, function() {
+      lodashStable.each(expected, function(value) {
+        lodashStable.times(count, function() {
           largeArray.push(value);
         });
       });
@@ -19795,7 +19792,7 @@
 
   QUnit.module('uniqBy methods');
 
-  _.each(['uniqBy', 'sortedUniqBy'], function(methodName) {
+  lodashStable.each(['uniqBy', 'sortedUniqBy'], function(methodName) {
     var func = _[methodName],
         isSortedUniqBy = methodName == 'sortedUniqBy',
         objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }, { 'a': 2 }, { 'a': 3 }, { 'a': 1 }];
@@ -19837,7 +19834,7 @@
 
       var arrays = [[2], [3], [1], [2], [3], [1]];
       if (isSortedUniqBy) {
-        arrays = _.sortBy(arrays, 0);
+        arrays = lodashStable.sortBy(arrays, 0);
       }
       expected = isSortedUniqBy ? [[1], [2], [3]] : arrays.slice(0, 3);
       actual = func(arrays, 0);
@@ -19845,7 +19842,7 @@
       assert.deepEqual(actual, expected);
     });
 
-    _.each({
+    lodashStable.each({
       'an array': [0, 'a'],
       'an object': { '0': 'a' },
       'a number': 0,
@@ -19869,11 +19866,11 @@
     QUnit.test('should generate unique ids', function(assert) {
       assert.expect(1);
 
-      var actual = _.times(1000, function(assert) {
+      var actual = lodashStable.times(1000, function(assert) {
         return _.uniqueId();
       });
 
-      assert.strictEqual(_.uniq(actual).length, actual.length);
+      assert.strictEqual(lodashStable.uniq(actual).length, actual.length);
     });
 
     QUnit.test('should return a string value when not providing a prefix argument', function(assert) {
@@ -19898,7 +19895,7 @@
     QUnit.test('should unset property values', function(assert) {
       assert.expect(4);
 
-      _.each(['a', ['a']], function(path) {
+      lodashStable.each(['a', ['a']], function(path) {
         var object = { 'a': 1, 'c': 2 };
         assert.strictEqual(_.unset(object, path), true);
         assert.deepEqual(object, { 'c': 2 });
@@ -19908,7 +19905,7 @@
     QUnit.test('should unset deep property values', function(assert) {
       assert.expect(4);
 
-      _.each(['a.b.c', ['a', 'b', 'c']], function(path) {
+      lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path) {
         var object = { 'a': { 'b': { 'c': null } } };
         assert.strictEqual(_.unset(object, path), true);
         assert.deepEqual(object, { 'a': { 'b': {} } });
@@ -19923,7 +19920,7 @@
         ['a', '-1.23', '["b"]', 'c', "['d']", '\ne\n', 'f', 'g']
       ];
 
-      _.each(paths, function(path) {
+      lodashStable.each(paths, function(path) {
         var object = { 'a': { '-1.23': { '["b"]': { 'c': { "['d']": { '\ne\n': { 'f': { 'g': 8 } } } } } } } };
         assert.strictEqual(_.unset(object, path), true);
         assert.notOk('g' in object.a[-1.23]['["b"]'].c["['d']"]['\ne\n'].f);
@@ -19935,7 +19932,7 @@
 
       var object = { 'a': { 'b': { 'c': null } } };
 
-      _.each(['z', 'a.z', 'a.b.z', 'a.b.c.z'], function(path) {
+      lodashStable.each(['z', 'a.z', 'a.b.z', 'a.b.c.z'], function(path) {
         assert.strictEqual(_.unset(object, path), true);
       });
 
@@ -19948,7 +19945,7 @@
       var values = [null, undefined],
           expected = [[true, true], [true, true]];
 
-      var actual = _.map(values, function(value) {
+      var actual = lodashStable.map(values, function(value) {
         try {
           return [_.unset(value, 'a.b'), _.unset(value, ['a', 'b'])];
         } catch(e) {
@@ -19965,7 +19962,7 @@
       var object = { 'a': '' },
           paths = ['constructor.prototype.a', ['constructor', 'prototype', 'a']];
 
-      _.each(paths, function(path) {
+      lodashStable.each(paths, function(path) {
         numberProto.a = 1;
 
         var actual = _.unset(0, path);
@@ -19975,7 +19972,7 @@
         delete numberProto.a;
       });
 
-      _.each(['a.replace.b', ['a', 'replace', 'b']], function(path) {
+      lodashStable.each(['a.replace.b', ['a', 'replace', 'b']], function(path) {
         stringProto.replace.b = 1;
 
         var actual = _.unset(object, path);
@@ -20035,9 +20032,9 @@
 
       var array = [[1, 3], [2, 4]],
           values = [, null, undefined],
-          expected = _.map(values, _.constant(_.unzip(array)));
+          expected = lodashStable.map(values, lodashStable.constant(_.unzip(array)));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.unzipWith(array, value) : _.unzipWith(array);
       });
 
@@ -20097,11 +20094,11 @@
     QUnit.test('should treat latin-1 supplementary letters as words', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(burredLetters, function(letter) {
+      var expected = lodashStable.map(burredLetters, function(letter) {
         return [letter];
       });
 
-      var actual = _.map(burredLetters, function(letter) {
+      var actual = lodashStable.map(burredLetters, function(letter) {
         return _.words(letter);
       });
 
@@ -20112,8 +20109,8 @@
       assert.expect(1);
 
       var operators = ['\xac', '\xb1', '\xd7', '\xf7'],
-          expected = _.map(operators, _.constant([])),
-          actual = _.map(operators, _.words);
+          expected = lodashStable.map(operators, lodashStable.constant([])),
+          actual = lodashStable.map(operators, _.words);
 
       assert.deepEqual(actual, expected);
     });
@@ -20128,8 +20125,8 @@
     QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) {
       assert.expect(1);
 
-      var strings = _.map(['a', 'b', 'c'], Object),
-          actual = _.map(strings, _.words);
+      var strings = lodashStable.map(['a', 'b', 'c'], Object),
+          actual = lodashStable.map(strings, _.words);
 
       assert.deepEqual(actual, [['a'], ['b'], ['c']]);
     });
@@ -20175,21 +20172,21 @@
 
       var args;
 
-      var wrapped = _.wrap(_.noop, function() {
+      var wrapped = _.wrap(noop, function() {
         args || (args = slice.call(arguments));
       });
 
       wrapped(1, 2, 3);
-      assert.deepEqual(args, [_.noop, 1, 2, 3]);
+      assert.deepEqual(args, [noop, 1, 2, 3]);
     });
 
     QUnit.test('should use `_.identity` when `wrapper` is nullish', function(assert) {
       assert.expect(1);
 
       var values = [, null, undefined],
-          expected = _.map(values, _.constant('a'));
+          expected = lodashStable.map(values, lodashStable.constant('a'));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         var wrapped = index ? _.wrap('a', value) : _.wrap('a');
         return wrapped('b', 'c');
       });
@@ -20213,7 +20210,7 @@
 
   QUnit.module('xor methods');
 
-  _.each(['xor', 'xorBy'], function(methodName) {
+  lodashStable.each(['xor', 'xorBy'], function(methodName) {
     var args = (function() { return arguments; }(1, 2, 3)),
         func = _[methodName];
 
@@ -20274,10 +20271,10 @@
       assert.expect(1);
 
       if (!isNpm) {
-        var array = _.range(LARGE_ARRAY_SIZE + 1),
+        var array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
             wrapped = _(array).slice(1)[methodName]([LARGE_ARRAY_SIZE, LARGE_ARRAY_SIZE + 1]);
 
-        var actual = _.map(['head', 'last'], function(methodName) {
+        var actual = lodashStable.map(['head', 'last'], function(methodName) {
           return wrapped[methodName]();
         });
 
@@ -20362,9 +20359,9 @@
     QUnit.test('should accept a falsey `array` argument', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant({}));
+      var expected = lodashStable.map(falsey, lodashStable.constant({}));
 
-      var actual = _.map(falsey, function(array, index) {
+      var actual = lodashStable.map(falsey, function(array, index) {
         try {
           return index ? _.zipObject(array) : _.zipObject();
         } catch (e) {}
@@ -20383,7 +20380,7 @@
       assert.expect(1);
 
       if (!isNpm) {
-        var array = _.times(LARGE_ARRAY_SIZE, function(index) {
+        var array = lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
           return ['key' + index, index];
         });
 
@@ -20430,9 +20427,9 @@
       var array1 = [1, 2],
           array2 = [3, 4],
           values = [, null, undefined],
-          expected = _.map(values, _.constant(_.zip(array1, array2)));
+          expected = lodashStable.map(values, lodashStable.constant(_.zip(array1, array2)));
 
-      var actual = _.map(values, function(value, index) {
+      var actual = lodashStable.map(values, function(value, index) {
         return index ? _.zipWith(array1, array2, value) : _.zipWith(array1, array2);
       });
 
@@ -20444,7 +20441,7 @@
 
   QUnit.module('lodash.unzip and lodash.zip');
 
-  _.each(['unzip', 'zip'], function(methodName, index) {
+  lodashStable.each(['unzip', 'zip'], function(methodName, index) {
     var func = _[methodName];
     func = _.bind(index ? func.apply : func.call, func, null);
 
@@ -20467,7 +20464,7 @@
       ]
     };
 
-    _.forOwn(object, function(pair, key) {
+    lodashStable.forOwn(object, function(pair, key) {
       QUnit.test('`_.' + methodName + '` should work with ' + key, function(assert) {
         assert.expect(2);
 
@@ -20497,9 +20494,9 @@
     QUnit.test('`_.' + methodName + '` should treat falsey values as empty arrays', function(assert) {
       assert.expect(1);
 
-      var expected = _.map(falsey, _.constant([]));
+      var expected = lodashStable.map(falsey, lodashStable.constant([]));
 
-      var actual = _.map(falsey, function(value) {
+      var actual = lodashStable.map(falsey, function(value) {
         return func([value, value, value]);
       });
 
@@ -20652,7 +20649,7 @@
 
   QUnit.module('lodash(...).next');
 
-  _.each([true, false], function(implict) {
+  lodashStable.each([true, false], function(implict) {
     function chain(value) {
       return implict ? _(value) : _.chain(value);
     }
@@ -20696,7 +20693,7 @@
         var hearts = '\ud83d\udc95',
             values = [[1], { 'a': 1 }, hearts];
 
-        _.each(values, function(value) {
+        lodashStable.each(values, function(value) {
           var wrapped = chain(value);
           assert.deepEqual(Array.from(wrapped), _.toArray(value));
         });
@@ -20729,7 +20726,7 @@
       assert.expect(3);
 
       if (!isNpm && Symbol && Symbol.iterator) {
-        var array = _.range(LARGE_ARRAY_SIZE),
+        var array = lodashStable.range(LARGE_ARRAY_SIZE),
             predicate = function(value) { values.push(value); return isEven(value); },
             values = [],
             wrapped = chain(array);
@@ -20887,14 +20884,14 @@
   QUnit.module('lodash(...).reverse');
 
   (function() {
-    var largeArray = _.range(LARGE_ARRAY_SIZE).concat(null),
+    var largeArray = lodashStable.range(LARGE_ARRAY_SIZE).concat(null),
         smallArray = [0, 1, 2, null];
 
     QUnit.test('should return the wrapped reversed `array`', function(assert) {
       assert.expect(6);
 
       if (!isNpm) {
-        _.times(2, function(index) {
+        lodashStable.times(2, function(index) {
           var array = (index ? largeArray : smallArray).slice(),
               clone = array.slice(),
               wrapped = _(array).reverse(),
@@ -20914,7 +20911,7 @@
       assert.expect(4);
 
       if (!isNpm) {
-        _.times(2, function(index) {
+        lodashStable.times(2, function(index) {
           var array = (index ? largeArray : smallArray).slice(),
               expected = array.slice(),
               actual = _(array).slice(1).reverse().value();
@@ -20959,18 +20956,18 @@
       assert.expect(8);
 
       if (!isNpm) {
-        _.times(2, function(index) {
+        lodashStable.times(2, function(index) {
           var clone = (index ? largeArray : smallArray).slice();
 
-          _.each(['map', 'filter'], function(methodName) {
+          lodashStable.each(['map', 'filter'], function(methodName) {
             var array = clone.slice(),
                 expected = clone.slice(1, -1).reverse(),
-                actual = _(array)[methodName](_.identity).thru(_.compact).reverse().value();
+                actual = _(array)[methodName](lodashStable.identity).thru(_.compact).reverse().value();
 
             assert.deepEqual(actual, expected);
 
             array = clone.slice();
-            actual = _(array).thru(_.compact)[methodName](_.identity).pull(1).push(3).reverse().value();
+            actual = _(array).thru(_.compact)[methodName](lodashStable.identity).pull(1).push(3).reverse().value();
 
             assert.deepEqual(actual, [3].concat(expected.slice(0, -1)));
           });
@@ -20985,7 +20982,7 @@
       assert.expect(6);
 
       if (!isNpm) {
-        _.times(2, function(index) {
+        lodashStable.times(2, function(index) {
           var array = (index ? largeArray : smallArray).slice(),
               expected = array.slice().reverse(),
               wrapped = _(array).chain().reverse().head();
@@ -21173,9 +21170,9 @@
 
       if (!isNpm) {
         var values = [, null, undefined],
-            expected = _.map(values, _.constant(''));
+            expected = lodashStable.map(values, lodashStable.constant(''));
 
-        var actual = _.map(values, function(value, index) {
+        var actual = lodashStable.map(values, function(value, index) {
           var wrapped = index ? _(value) : _();
           return String(wrapped);
         });
@@ -21261,7 +21258,7 @@
       'unshift'
     ];
 
-    _.each(funcs, function(methodName) {
+    lodashStable.each(funcs, function(methodName) {
       QUnit.test('`_(...).' + methodName + '` should return a new wrapper', function(assert) {
         assert.expect(2);
 
@@ -21298,7 +21295,7 @@
       'words'
     ];
 
-    _.each(funcs, function(methodName) {
+    lodashStable.each(funcs, function(methodName) {
       QUnit.test('`_(...).' + methodName + '` should return a new wrapped value', function(assert) {
         assert.expect(2);
 
@@ -21402,7 +21399,7 @@
       'upperFirst'
     ];
 
-    _.each(funcs, function(methodName) {
+    lodashStable.each(funcs, function(methodName) {
       QUnit.test('`_(...).' + methodName + '` should return an unwrapped value when implicitly chaining', function(assert) {
         assert.expect(1);
 
@@ -21458,10 +21455,10 @@
       assert.deepEqual(_.compact(args), [1, [3], 5], message('compact'));
       assert.deepEqual(_.drop(args, 3), [null, 5], message('drop'));
       assert.deepEqual(_.dropRight(args, 3), [1, null], message('dropRight'));
-      assert.deepEqual(_.dropRightWhile(args,_.identity), [1, null, [3], null], message('dropRightWhile'));
-      assert.deepEqual(_.dropWhile(args,_.identity), [ null, [3], null, 5], message('dropWhile'));
-      assert.deepEqual(_.findIndex(args, _.identity), 0, message('findIndex'));
-      assert.deepEqual(_.findLastIndex(args, _.identity), 4, message('findLastIndex'));
+      assert.deepEqual(_.dropRightWhile(args,lodashStable.identity), [1, null, [3], null], message('dropRightWhile'));
+      assert.deepEqual(_.dropWhile(args,lodashStable.identity), [ null, [3], null, 5], message('dropWhile'));
+      assert.deepEqual(_.findIndex(args, lodashStable.identity), 0, message('findIndex'));
+      assert.deepEqual(_.findLastIndex(args, lodashStable.identity), 4, message('findLastIndex'));
       assert.deepEqual(_.flatten(args), [1, null, 3, null, 5], message('flatten'));
       assert.deepEqual(_.head(args), 1, message('head'));
       assert.deepEqual(_.indexOf(args, 5), 4, message('indexOf'));
@@ -21476,8 +21473,8 @@
       assert.deepEqual(_.tail(args, 4), [null, [3], null, 5], message('tail'));
       assert.deepEqual(_.take(args, 2), [1, null], message('take'));
       assert.deepEqual(_.takeRight(args, 1), [5], message('takeRight'));
-      assert.deepEqual(_.takeRightWhile(args, _.identity), [5], message('takeRightWhile'));
-      assert.deepEqual(_.takeWhile(args, _.identity), [1], message('takeWhile'));
+      assert.deepEqual(_.takeRightWhile(args, lodashStable.identity), [5], message('takeRightWhile'));
+      assert.deepEqual(_.takeWhile(args, lodashStable.identity), [1], message('takeWhile'));
       assert.deepEqual(_.uniq(args), [1, null, [3], 5], message('uniq'));
       assert.deepEqual(_.without(args, null), [1, [3], 5], message('without'));
       assert.deepEqual(_.zip(args, args), [[1, 1], [null, null], [[3], [3]], [null, null], [5, 5]], message('zip'));
@@ -21537,7 +21534,7 @@
       'upperFirst'
     ];
 
-    _.each(stringMethods, function(methodName) {
+    lodashStable.each(stringMethods, function(methodName) {
       var func = _[methodName];
 
       QUnit.test('`_.' + methodName + '` should return an empty string for empty values', function(assert) {
@@ -21555,8 +21552,8 @@
   QUnit.module('lodash methods');
 
   (function() {
-    var allMethods = _.reject(_.functions(_).sort(), function(methodName) {
-      return _.startsWith(methodName, '_');
+    var allMethods = lodashStable.reject(_.functions(_).sort(), function(methodName) {
+      return lodashStable.startsWith(methodName, '_');
     });
 
     var checkFuncs = [
@@ -21639,19 +21636,19 @@
       'zip'
     ];
 
-    var acceptFalsey = _.difference(allMethods, rejectFalsey);
+    var acceptFalsey = lodashStable.difference(allMethods, rejectFalsey);
 
     QUnit.test('should accept falsey arguments', function(assert) {
       assert.expect(259);
 
-      var emptyArrays = _.map(falsey, _.constant([]));
+      var emptyArrays = lodashStable.map(falsey, lodashStable.constant([]));
 
-      _.each(acceptFalsey, function(methodName) {
+      lodashStable.each(acceptFalsey, function(methodName) {
         var expected = emptyArrays,
             func = _[methodName],
             pass = true;
 
-        var actual = _.map(falsey, function(value, index) {
+        var actual = lodashStable.map(falsey, function(value, index) {
           try {
             return index ? func(value) : func();
           } catch (e) {
@@ -21665,14 +21662,14 @@
         else if (methodName == 'pull' || methodName == 'pullAll') {
           expected = falsey;
         }
-        if (_.includes(returnArrays, methodName) && methodName != 'sample') {
+        if (lodashStable.includes(returnArrays, methodName) && methodName != 'sample') {
           assert.deepEqual(actual, expected, '_.' + methodName + ' returns an array');
         }
         assert.ok(pass, '`_.' + methodName + '` accepts falsey arguments');
       });
 
       // Skip tests for missing methods of modularized builds.
-      _.each(['chain', 'noConflict', 'runInContext'], function(methodName) {
+      lodashStable.each(['chain', 'noConflict', 'runInContext'], function(methodName) {
         if (!_[methodName]) {
           skipTest(assert);
         }
@@ -21684,7 +21681,7 @@
 
       var array = [1, 2, 3];
 
-      _.each(returnArrays, function(methodName) {
+      lodashStable.each(returnArrays, function(methodName) {
         var actual,
             func = _[methodName];
 
@@ -21698,7 +21695,7 @@
           default:
             actual = func(array);
         }
-        assert.ok(_.isArray(actual), '_.' + methodName + ' returns an array');
+        assert.ok(lodashStable.isArray(actual), '_.' + methodName + ' returns an array');
 
         var isPull = methodName == 'pull' || methodName == 'pullAll';
         assert.strictEqual(actual === array, isPull, '_.' + methodName + ' should ' + (isPull ? '' : 'not ') + 'return the provided array');
@@ -21708,17 +21705,17 @@
     QUnit.test('should throw an error for falsey arguments', function(assert) {
       assert.expect(23);
 
-      _.each(rejectFalsey, function(methodName) {
-        var expected = _.map(falsey, _.constant(true)),
+      lodashStable.each(rejectFalsey, function(methodName) {
+        var expected = lodashStable.map(falsey, lodashStable.constant(true)),
             func = _[methodName];
 
-        var actual = _.map(falsey, function(value, index) {
+        var actual = lodashStable.map(falsey, function(value, index) {
           var pass = !index && /^(?:backflow|compose|conj|disj|flow(Right)?)$/.test(methodName);
 
           try {
             index ? func(value) : func();
           } catch (e) {
-            pass = _.includes(checkFuncs, methodName)
+            pass = lodashStable.includes(checkFuncs, methodName)
               ? e.message == FUNC_ERROR_TEXT
               : !pass;
           }
@@ -21732,7 +21729,7 @@
     QUnit.test('should not set a `this` binding', function(assert) {
       assert.expect(33);
 
-      _.each(noBinding, function(methodName) {
+      lodashStable.each(noBinding, function(methodName) {
         var fn = function() { return this.a; },
             func = _[methodName],
             isNegate = methodName == 'negate',
@@ -21754,8 +21751,8 @@
       assert.expect(1);
 
       var shortNames = ['at', 'eq', 'gt', 'lt'];
-      assert.ok(_.every(_.functions(_), function(methodName) {
-        return methodName.length > 2 || _.includes(shortNames, methodName);
+      assert.ok(lodashStable.every(_.functions(_), function(methodName) {
+        return methodName.length > 2 || lodashStable.includes(shortNames, methodName);
       }));
     });
   }());