@contrast/agent 3.8.5 → 3.9.2

package/node_modules/async/mapValuesSeries.js

@@ -3,15 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.default = mapValuesSeries;
 
 var _mapValuesLimit = require('./mapValuesLimit');
 
 var _mapValuesLimit2 = _interopRequireDefault(_mapValuesLimit);
 
-var _doLimit = require('./internal/doLimit');
-
-var _doLimit2 = _interopRequireDefault(_doLimit);
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
@@ -32,6 +29,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * functions have finished, or an error occurs. `result` is a new object consisting
  * of each key from `obj`, with each transformed value on the right-hand side.
  * Invoked with (err, result).
+ * @returns {Promise} a promise, if no callback is passed
  */
-exports.default = (0, _doLimit2.default)(_mapValuesLimit2.default, 1);
+function mapValuesSeries(obj, iteratee, callback) {
+  return (0, _mapValuesLimit2.default)(obj, 1, iteratee, callback);
+}
 module.exports = exports['default'];

package/node_modules/async/memoize.js

@@ -5,14 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = memoize;
 
-var _identity = require('lodash/identity');
-
-var _identity2 = _interopRequireDefault(_identity);
-
-var _slice = require('./internal/slice');
-
-var _slice2 = _interopRequireDefault(_slice);
-
 var _setImmediate = require('./internal/setImmediate');
 
 var _setImmediate2 = _interopRequireDefault(_setImmediate);
@@ -27,15 +19,14 @@ var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function has(obj, key) {
-    return key in obj;
-}
-
 /**
  * Caches the results of an async function. When creating a hash to store
  * function results against, the callback is omitted from the hash and an
  * optional hash function can be used.
  *
+ * **Note: if the async function errs, the result will not be cached and
+ * subsequent calls will call the wrapped function.**
+ *
  * If no hash function is specified, the first argument is used as a hash key,
  * which may work reasonably if it is a string or a data type that converts to a
  * distinct string. Note that objects and arrays will not behave reasonably.
@@ -68,30 +59,29 @@ function has(obj, key) {
  *     // callback
  * });
  */
-function memoize(fn, hasher) {
+function memoize(fn, hasher = v => v) {
     var memo = Object.create(null);
     var queues = Object.create(null);
-    hasher = hasher || _identity2.default;
     var _fn = (0, _wrapAsync2.default)(fn);
-    var memoized = (0, _initialParams2.default)(function memoized(args, callback) {
-        var key = hasher.apply(null, args);
-        if (has(memo, key)) {
-            (0, _setImmediate2.default)(function () {
-                callback.apply(null, memo[key]);
-            });
-        } else if (has(queues, key)) {
+    var memoized = (0, _initialParams2.default)((args, callback) => {
+        var key = hasher(...args);
+        if (key in memo) {
+            (0, _setImmediate2.default)(() => callback(null, ...memo[key]));
+        } else if (key in queues) {
             queues[key].push(callback);
         } else {
             queues[key] = [callback];
-            _fn.apply(null, args.concat(function () /*args*/{
-                var args = (0, _slice2.default)(arguments);
-                memo[key] = args;
+            _fn(...args, (err, ...resultArgs) => {
+                // #1465 don't memoize if an error occurred
+                if (!err) {
+                    memo[key] = resultArgs;
+                }
                 var q = queues[key];
                 delete queues[key];
                 for (var i = 0, l = q.length; i < l; i++) {
-                    q[i].apply(null, args);
+                    q[i](err, ...resultArgs);
                 }
-            }));
+            });
         }
     });
     memoized.memo = memo;

package/node_modules/async/nextTick.js

@@ -1,4 +1,5 @@
 'use strict';
+/* istanbul ignore file */
 
 Object.defineProperty(exports, "__esModule", {
     value: true

package/node_modules/async/package.json

@@ -1,7 +1,7 @@
 {
   "name": "async",
   "description": "Higher-order functions and common patterns for asynchronous code",
-  "version": "2.6.3",
+  "version": "3.2.0",
   "main": "dist/async.js",
   "author": "Caolan McMahon",
   "homepage": "https://caolan.github.io/async/",
@@ -18,67 +18,69 @@
     "module",
     "utility"
   ],
-  "dependencies": {
-    "lodash": "^4.17.14"
-  },
+  "dependencies": {},
   "devDependencies": {
-    "babel-cli": "^6.24.0",
     "babel-core": "^6.26.3",
+    "babel-eslint": "^8.2.6",
+    "babel-minify": "^0.5.0",
     "babel-plugin-add-module-exports": "^0.2.1",
-    "babel-plugin-istanbul": "^2.0.1",
+    "babel-plugin-istanbul": "^5.1.4",
+    "babel-plugin-syntax-async-generators": "^6.13.0",
     "babel-plugin-transform-es2015-modules-commonjs": "^6.26.2",
     "babel-preset-es2015": "^6.3.13",
     "babel-preset-es2017": "^6.22.0",
+    "babel-register": "^6.26.0",
     "babelify": "^8.0.0",
     "benchmark": "^2.1.1",
     "bluebird": "^3.4.6",
-    "browserify": "^16.2.2",
-    "chai": "^4.1.2",
+    "browserify": "^16.2.3",
+    "chai": "^4.2.0",
     "cheerio": "^0.22.0",
-    "coveralls": "^3.0.1",
+    "coveralls": "^3.0.4",
     "es6-promise": "^2.3.0",
-    "eslint": "^2.13.1",
+    "eslint": "^6.0.1",
+    "eslint-plugin-prefer-arrow": "^1.1.5",
     "fs-extra": "^0.26.7",
-    "gh-pages-deploy": "^0.5.0",
-    "jsdoc": "^3.4.0",
-    "karma": "^2.0.2",
-    "karma-browserify": "^5.2.0",
+    "jsdoc": "^3.6.2",
+    "karma": "^4.1.0",
+    "karma-browserify": "^5.3.0",
+    "karma-edge-launcher": "^0.4.2",
     "karma-firefox-launcher": "^1.1.0",
+    "karma-junit-reporter": "^1.2.0",
     "karma-mocha": "^1.2.0",
     "karma-mocha-reporter": "^2.2.0",
-    "mocha": "^5.2.0",
+    "karma-safari-launcher": "^1.0.0",
+    "mocha": "^6.1.4",
+    "mocha-junit-reporter": "^1.18.0",
     "native-promise-only": "^0.8.0-a",
-    "nyc": "^11.8.0",
+    "nyc": "^14.1.1",
     "rimraf": "^2.5.0",
-    "rollup": "^0.36.3",
+    "rollup": "^0.63.4",
     "rollup-plugin-node-resolve": "^2.0.0",
     "rollup-plugin-npm": "^2.0.0",
     "rsvp": "^3.0.18",
     "semver": "^5.5.0",
-    "uglify-js": "~2.7.3",
     "yargs": "^11.0.0"
   },
   "scripts": {
     "coverage": "nyc npm run mocha-node-test -- --grep @nycinvalid --invert",
     "coveralls": "npm run coverage && nyc report --reporter=text-lcov | coveralls",
     "jsdoc": "jsdoc -c ./support/jsdoc/jsdoc.json && node support/jsdoc/jsdoc-fix-html.js",
-    "lint": "eslint lib/ mocha_test/ perf/memory.js perf/suites.js perf/benchmark.js support/build/ support/*.js karma.conf.js",
+    "lint": "eslint --fix lib/ test/ perf/memory.js perf/suites.js perf/benchmark.js support/build/ support/*.js karma.conf.js",
     "mocha-browser-test": "karma start",
-    "mocha-node-test": "mocha mocha_test/ --compilers js:babel-core/register",
+    "mocha-node-test": "mocha",
     "mocha-test": "npm run mocha-node-test && npm run mocha-browser-test",
     "test": "npm run lint && npm run mocha-node-test"
   },
   "license": "MIT",
-  "gh-pages-deploy": {
-    "staticpath": "docs"
-  },
   "nyc": {
     "exclude": [
-      "mocha_test"
+      "test"
     ]
-  }
+  },
+  "module": "dist/async.mjs"
 
-,"_resolved": "https://registry.npmjs.org/async/-/async-2.6.3.tgz"
-,"_integrity": "sha512-zflvls11DCy+dQWzTW2dzuilv8Z5X/pjfmZOWba6TNIVDm+2UDaJmXSOXlasHKfNBs8oo3M0aT50fDEWfKZjXg=="
-,"_from": "async@2.6.3"
+,"_resolved": "https://registry.npmjs.org/async/-/async-3.2.0.tgz"
+,"_integrity": "sha512-TR2mEZFVOj2pLStYxLht7TyfuRzaydfpxr3k9RpHIzMgw7A64dzsdqCxH1WJyQdoe8T10nDXd9wnEigmiuHIZw=="
+,"_from": "async@3.2.0"
 }

package/node_modules/async/parallel.js

@@ -3,15 +3,15 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = parallelLimit;
+exports.default = parallel;
 
 var _eachOf = require('./eachOf');
 
 var _eachOf2 = _interopRequireDefault(_eachOf);
 
-var _parallel = require('./internal/parallel');
+var _parallel2 = require('./internal/parallel');
 
-var _parallel2 = _interopRequireDefault(_parallel);
+var _parallel3 = _interopRequireDefault(_parallel2);
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -41,13 +41,14 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @memberOf module:ControlFlow
  * @method
  * @category Control Flow
- * @param {Array|Iterable|Object} tasks - A collection of
+ * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection of
  * [async functions]{@link AsyncFunction} to run.
  * Each async function can complete with any number of optional `result` values.
  * @param {Function} [callback] - An optional callback to run once all the
  * functions have completed successfully. This function gets a results array
  * (or object) containing all the result arguments passed to the task callbacks.
  * Invoked with (err, results).
+ * @returns {Promise} a promise, if a callback is not passed
  *
  * @example
  * async.parallel([
@@ -84,7 +85,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  *     // results is now equals to: {one: 1, two: 2}
  * });
  */
-function parallelLimit(tasks, callback) {
-  (0, _parallel2.default)(_eachOf2.default, tasks, callback);
+function parallel(tasks, callback) {
+  return (0, _parallel3.default)(_eachOf2.default, tasks, callback);
 }
 module.exports = exports['default'];

package/node_modules/async/parallelLimit.js

@@ -25,7 +25,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @method
  * @see [async.parallel]{@link module:ControlFlow.parallel}
  * @category Control Flow
- * @param {Array|Iterable|Object} tasks - A collection of
+ * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection of
  * [async functions]{@link AsyncFunction} to run.
  * Each async function can complete with any number of optional `result` values.
  * @param {number} limit - The maximum number of async operations at a time.
@@ -33,8 +33,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * functions have completed successfully. This function gets a results array
  * (or object) containing all the result arguments passed to the task callbacks.
  * Invoked with (err, results).
+ * @returns {Promise} a promise, if a callback is not passed
  */
 function parallelLimit(tasks, limit, callback) {
-  (0, _parallel2.default)((0, _eachOfLimit2.default)(limit), tasks, callback);
+  return (0, _parallel2.default)((0, _eachOfLimit2.default)(limit), tasks, callback);
 }
 module.exports = exports['default'];

package/node_modules/async/priorityQueue.js

@@ -8,42 +8,32 @@ exports.default = function (worker, concurrency) {
     // Start with a normal queue
     var q = (0, _queue2.default)(worker, concurrency);
 
+    q._tasks = new _Heap2.default();
+
     // Override push to accept second parameter representing priority
-    q.push = function (data, priority, callback) {
-        if (callback == null) callback = _noop2.default;
+    q.push = function (data, priority = 0, callback = () => {}) {
         if (typeof callback !== 'function') {
             throw new Error('task callback must be a function');
         }
         q.started = true;
-        if (!(0, _isArray2.default)(data)) {
+        if (!Array.isArray(data)) {
             data = [data];
         }
-        if (data.length === 0) {
+        if (data.length === 0 && q.idle()) {
             // call drain immediately if there are no tasks
-            return (0, _setImmediate2.default)(function () {
-                q.drain();
-            });
-        }
-
-        priority = priority || 0;
-        var nextNode = q._tasks.head;
-        while (nextNode && priority >= nextNode.priority) {
-            nextNode = nextNode.next;
+            return (0, _setImmediate2.default)(() => q.drain());
         }
 
         for (var i = 0, l = data.length; i < l; i++) {
             var item = {
                 data: data[i],
-                priority: priority,
-                callback: callback
+                priority,
+                callback
             };
 
-            if (nextNode) {
-                q._tasks.insertBefore(nextNode, item);
-            } else {
-                q._tasks.push(item);
-            }
+            q._tasks.push(item);
         }
+
         (0, _setImmediate2.default)(q.process);
     };
 
@@ -53,14 +43,6 @@ exports.default = function (worker, concurrency) {
     return q;
 };
 
-var _isArray = require('lodash/isArray');
-
-var _isArray2 = _interopRequireDefault(_isArray);
-
-var _noop = require('lodash/noop');
-
-var _noop2 = _interopRequireDefault(_noop);
-
 var _setImmediate = require('./setImmediate');
 
 var _setImmediate2 = _interopRequireDefault(_setImmediate);
@@ -69,6 +51,10 @@ var _queue = require('./queue');
 
 var _queue2 = _interopRequireDefault(_queue);
 
+var _Heap = require('./internal/Heap');
+
+var _Heap2 = _interopRequireDefault(_Heap);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 module.exports = exports['default'];

package/node_modules/async/queue.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 
 exports.default = function (worker, concurrency) {
   var _worker = (0, _wrapAsync2.default)(worker);
-  return (0, _queue2.default)(function (items, cb) {
+  return (0, _queue2.default)((items, cb) => {
     _worker(items[0], cb);
   }, concurrency, 1);
 };
@@ -25,7 +25,7 @@ module.exports = exports['default'];
 
 /**
  * A queue of tasks for the worker function to complete.
- * @typedef {Object} QueueObject
+ * @typedef {Iterable} QueueObject
  * @memberOf module:ControlFlow
  * @property {Function} length - a function returning the number of items
  * waiting to be processed. Invoke with `queue.length()`.
@@ -40,32 +40,45 @@ module.exports = exports['default'];
  * @property {number} concurrency - an integer for determining how many `worker`
  * functions should be run in parallel. This property can be changed after a
  * `queue` is created to alter the concurrency on-the-fly.
- * @property {Function} push - add a new task to the `queue`. Calls `callback`
+ * @property {number} payload - an integer that specifies how many items are
+ * passed to the worker function at a time. only applies if this is a
+ * [cargo]{@link module:ControlFlow.cargo} object
+ * @property {AsyncFunction} push - add a new task to the `queue`. Calls `callback`
  * once the `worker` has finished processing the task. Instead of a single task,
  * a `tasks` array can be submitted. The respective callback is used for every
  * task in the list. Invoke with `queue.push(task, [callback])`,
- * @property {Function} unshift - add a new task to the front of the `queue`.
+ * @property {AsyncFunction} unshift - add a new task to the front of the `queue`.
  * Invoke with `queue.unshift(task, [callback])`.
+ * @property {AsyncFunction} pushAsync - the same as `q.push`, except this returns
+ * a promise that rejects if an error occurs.
+ * @property {AsyncFunction} unshirtAsync - the same as `q.unshift`, except this returns
+ * a promise that rejects if an error occurs.
  * @property {Function} remove - remove items from the queue that match a test
  * function.  The test function will be passed an object with a `data` property,
  * and a `priority` property, if this is a
  * [priorityQueue]{@link module:ControlFlow.priorityQueue} object.
  * Invoked with `queue.remove(testFn)`, where `testFn` is of the form
  * `function ({data, priority}) {}` and returns a Boolean.
- * @property {Function} saturated - a callback that is called when the number of
- * running workers hits the `concurrency` limit, and further tasks will be
- * queued.
- * @property {Function} unsaturated - a callback that is called when the number
- * of running workers is less than the `concurrency` & `buffer` limits, and
- * further tasks will not be queued.
+ * @property {Function} saturated - a function that sets a callback that is
+ * called when the number of running workers hits the `concurrency` limit, and
+ * further tasks will be queued.  If the callback is omitted, `q.saturated()`
+ * returns a promise for the next occurrence.
+ * @property {Function} unsaturated - a function that sets a callback that is
+ * called when the number of running workers is less than the `concurrency` &
+ * `buffer` limits, and further tasks will not be queued. If the callback is
+ * omitted, `q.unsaturated()` returns a promise for the next occurrence.
  * @property {number} buffer - A minimum threshold buffer in order to say that
  * the `queue` is `unsaturated`.
- * @property {Function} empty - a callback that is called when the last item
- * from the `queue` is given to a `worker`.
- * @property {Function} drain - a callback that is called when the last item
- * from the `queue` has returned from the `worker`.
- * @property {Function} error - a callback that is called when a task errors.
- * Has the signature `function(error, task)`.
+ * @property {Function} empty - a function that sets a callback that is called
+ * when the last item from the `queue` is given to a `worker`. If the callback
+ * is omitted, `q.empty()` returns a promise for the next occurrence.
+ * @property {Function} drain - a function that sets a callback that is called
+ * when the last item from the `queue` has returned from the `worker`. If the
+ * callback is omitted, `q.drain()` returns a promise for the next occurrence.
+ * @property {Function} error - a function that sets a callback that is called
+ * when a task errors. Has the signature `function(error, task)`. If the
+ * callback is omitted, `error()` returns a promise that rejects on the next
+ * error.
  * @property {boolean} paused - a boolean for determining whether the queue is
  * in a paused state.
  * @property {Function} pause - a function that pauses the processing of tasks
@@ -75,6 +88,24 @@ module.exports = exports['default'];
  * @property {Function} kill - a function that removes the `drain` callback and
  * empties remaining tasks from the queue forcing it to go idle. No more tasks
  * should be pushed to the queue after calling this function. Invoke with `queue.kill()`.
+ *
+ * @example
+ * const q = aync.queue(worker, 2)
+ * q.push(item1)
+ * q.push(item2)
+ * q.push(item3)
+ * // queues are iterable, spread into an array to inspect
+ * const items = [...q] // [item1, item2, item3]
+ * // or use for of
+ * for (let item of q) {
+ *     console.log(item)
+ * }
+ *
+ * q.drain(() => {
+ *     console.log('all done')
+ * })
+ * // or
+ * await q.drain()
  */
 
 /**
@@ -94,7 +125,7 @@ module.exports = exports['default'];
  * @param {number} [concurrency=1] - An `integer` for determining how many
  * `worker` functions should be run in parallel.  If omitted, the concurrency
  * defaults to `1`.  If the concurrency is `0`, an error is thrown.
- * @returns {module:ControlFlow.QueueObject} A queue object to manage the tasks. Callbacks can
+ * @returns {module:ControlFlow.QueueObject} A queue object to manage the tasks. Callbacks can be
  * attached as certain properties to listen for specific events during the
  * lifecycle of the queue.
  * @example
@@ -106,17 +137,23 @@ module.exports = exports['default'];
  * }, 2);
  *
  * // assign a callback
- * q.drain = function() {
+ * q.drain(function() {
  *     console.log('all items have been processed');
- * };
+ * });
+ * // or await the end
+ * await q.drain()
+ *
+ * // assign an error callback
+ * q.error(function(err, task) {
+ *     console.error('task experienced an error');
+ * });
  *
  * // add some items to the queue
  * q.push({name: 'foo'}, function(err) {
  *     console.log('finished processing foo');
  * });
- * q.push({name: 'bar'}, function (err) {
- *     console.log('finished processing bar');
- * });
+ * // callback is optional
+ * q.push({name: 'bar'});
  *
  * // add some items to the queue (batch-wise)
  * q.push([{name: 'baz'},{name: 'bay'},{name: 'bax'}], function(err) {

package/node_modules/async/race.js

@@ -3,15 +3,6 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = race;
-
-var _isArray = require('lodash/isArray');
-
-var _isArray2 = _interopRequireDefault(_isArray);
-
-var _noop = require('lodash/noop');
-
-var _noop2 = _interopRequireDefault(_noop);
 
 var _once = require('./internal/once');
 
@@ -21,6 +12,10 @@ var _wrapAsync = require('./internal/wrapAsync');
 
 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
 
+var _awaitify = require('./internal/awaitify');
+
+var _awaitify2 = _interopRequireDefault(_awaitify);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
@@ -60,11 +55,13 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * });
  */
 function race(tasks, callback) {
-    callback = (0, _once2.default)(callback || _noop2.default);
-    if (!(0, _isArray2.default)(tasks)) return callback(new TypeError('First argument to race must be an array of functions'));
+    callback = (0, _once2.default)(callback);
+    if (!Array.isArray(tasks)) return callback(new TypeError('First argument to race must be an array of functions'));
     if (!tasks.length) return callback();
     for (var i = 0, l = tasks.length; i < l; i++) {
         (0, _wrapAsync2.default)(tasks[i])(callback);
     }
 }
+
+exports.default = (0, _awaitify2.default)(race, 2);
 module.exports = exports['default'];

package/node_modules/async/reduce.js

@@ -3,16 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = reduce;
 
 var _eachOfSeries = require('./eachOfSeries');
 
 var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);
 
-var _noop = require('lodash/noop');
-
-var _noop2 = _interopRequireDefault(_noop);
-
 var _once = require('./internal/once');
 
 var _once2 = _interopRequireDefault(_once);
@@ -21,6 +16,10 @@ var _wrapAsync = require('./internal/wrapAsync');
 
 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
 
+var _awaitify = require('./internal/awaitify');
+
+var _awaitify2 = _interopRequireDefault(_awaitify);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
@@ -41,7 +40,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @alias inject
  * @alias foldl
  * @category Collection
- * @param {Array|Iterable|Object} coll - A collection to iterate over.
+ * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
  * @param {*} memo - The initial state of the reduction.
  * @param {AsyncFunction} iteratee - A function applied to each item in the
  * array to produce the next step in the reduction.
@@ -52,6 +51,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Result is the reduced value. Invoked with
  * (err, result).
+ * @returns {Promise} a promise, if no callback is passed
  * @example
  *
  * async.reduce([1,2,3], 0, function(memo, item, callback) {
@@ -64,15 +64,14 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * });
  */
 function reduce(coll, memo, iteratee, callback) {
-    callback = (0, _once2.default)(callback || _noop2.default);
+    callback = (0, _once2.default)(callback);
     var _iteratee = (0, _wrapAsync2.default)(iteratee);
-    (0, _eachOfSeries2.default)(coll, function (x, i, callback) {
-        _iteratee(memo, x, function (err, v) {
+    return (0, _eachOfSeries2.default)(coll, (x, i, iterCb) => {
+        _iteratee(memo, x, (err, v) => {
             memo = v;
-            callback(err);
+            iterCb(err);
         });
-    }, function (err) {
-        callback(err, memo);
-    });
+    }, err => callback(err, memo));
 }
+exports.default = (0, _awaitify2.default)(reduce, 4);
 module.exports = exports['default'];

package/node_modules/async/reduceRight.js

@@ -9,10 +9,6 @@ var _reduce = require('./reduce');
 
 var _reduce2 = _interopRequireDefault(_reduce);
 
-var _slice = require('./internal/slice');
-
-var _slice2 = _interopRequireDefault(_slice);
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
@@ -36,9 +32,10 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Result is the reduced value. Invoked with
  * (err, result).
+ * @returns {Promise} a promise, if no callback is passed
  */
 function reduceRight(array, memo, iteratee, callback) {
-  var reversed = (0, _slice2.default)(array).reverse();
-  (0, _reduce2.default)(reversed, memo, iteratee, callback);
+  var reversed = [...array].reverse();
+  return (0, _reduce2.default)(reversed, memo, iteratee, callback);
 }
 module.exports = exports['default'];