@contrast/agent 3.8.5 → 3.9.2

package/node_modules/async/index.js

@@ -3,7 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.wrapSync = exports.selectSeries = exports.selectLimit = exports.select = exports.foldr = exports.foldl = exports.inject = exports.forEachOfLimit = exports.forEachOfSeries = exports.forEachOf = exports.forEachLimit = exports.forEachSeries = exports.forEach = exports.findSeries = exports.findLimit = exports.find = exports.anySeries = exports.anyLimit = exports.any = exports.allSeries = exports.allLimit = exports.all = exports.whilst = exports.waterfall = exports.until = exports.unmemoize = exports.tryEach = exports.transform = exports.timesSeries = exports.timesLimit = exports.times = exports.timeout = exports.sortBy = exports.someSeries = exports.someLimit = exports.some = exports.setImmediate = exports.series = exports.seq = exports.retryable = exports.retry = exports.rejectSeries = exports.rejectLimit = exports.reject = exports.reflectAll = exports.reflect = exports.reduceRight = exports.reduce = exports.race = exports.queue = exports.priorityQueue = exports.parallelLimit = exports.parallel = exports.nextTick = exports.memoize = exports.mapValuesSeries = exports.mapValuesLimit = exports.mapValues = exports.mapSeries = exports.mapLimit = exports.map = exports.log = exports.groupBySeries = exports.groupByLimit = exports.groupBy = exports.forever = exports.filterSeries = exports.filterLimit = exports.filter = exports.everySeries = exports.everyLimit = exports.every = exports.ensureAsync = exports.eachSeries = exports.eachOfSeries = exports.eachOfLimit = exports.eachOf = exports.eachLimit = exports.each = exports.during = exports.doWhilst = exports.doUntil = exports.doDuring = exports.dir = exports.detectSeries = exports.detectLimit = exports.detect = exports.constant = exports.concatSeries = exports.concatLimit = exports.concat = exports.compose = exports.cargo = exports.autoInject = exports.auto = exports.asyncify = exports.applyEachSeries = exports.applyEach = exports.apply = undefined;
+exports.doDuring = exports.during = exports.wrapSync = undefined;
+exports.selectSeries = exports.selectLimit = exports.select = exports.foldr = exports.foldl = exports.inject = exports.forEachOfLimit = exports.forEachOfSeries = exports.forEachOf = exports.forEachLimit = exports.forEachSeries = exports.forEach = exports.flatMapSeries = exports.flatMapLimit = exports.flatMap = exports.findSeries = exports.findLimit = exports.find = exports.anySeries = exports.anyLimit = exports.any = exports.allSeries = exports.allLimit = exports.all = exports.whilst = exports.waterfall = exports.until = exports.unmemoize = exports.tryEach = exports.transform = exports.timesSeries = exports.timesLimit = exports.times = exports.timeout = exports.sortBy = exports.someSeries = exports.someLimit = exports.some = exports.setImmediate = exports.series = exports.seq = exports.retryable = exports.retry = exports.rejectSeries = exports.rejectLimit = exports.reject = exports.reflectAll = exports.reflect = exports.reduceRight = exports.reduce = exports.race = exports.queue = exports.priorityQueue = exports.parallelLimit = exports.parallel = exports.nextTick = exports.memoize = exports.mapValuesSeries = exports.mapValuesLimit = exports.mapValues = exports.mapSeries = exports.mapLimit = exports.map = exports.log = exports.groupBySeries = exports.groupByLimit = exports.groupBy = exports.forever = exports.filterSeries = exports.filterLimit = exports.filter = exports.everySeries = exports.everyLimit = exports.every = exports.ensureAsync = exports.eachSeries = exports.eachOfSeries = exports.eachOfLimit = exports.eachOf = exports.eachLimit = exports.each = exports.doWhilst = exports.doUntil = exports.dir = exports.detectSeries = exports.detectLimit = exports.detect = exports.constant = exports.concatSeries = exports.concatLimit = exports.concat = exports.compose = exports.cargoQueue = exports.cargo = exports.autoInject = exports.auto = exports.asyncify = exports.applyEachSeries = exports.applyEach = exports.apply = undefined;
 
 var _apply = require('./apply');
 
@@ -33,6 +34,10 @@ var _cargo = require('./cargo');
 
 var _cargo2 = _interopRequireDefault(_cargo);
 
+var _cargoQueue = require('./cargoQueue');
+
+var _cargoQueue2 = _interopRequireDefault(_cargoQueue);
+
 var _compose = require('./compose');
 
 var _compose2 = _interopRequireDefault(_compose);
@@ -69,10 +74,6 @@ var _dir = require('./dir');
 
 var _dir2 = _interopRequireDefault(_dir);
 
-var _doDuring = require('./doDuring');
-
-var _doDuring2 = _interopRequireDefault(_doDuring);
-
 var _doUntil = require('./doUntil');
 
 var _doUntil2 = _interopRequireDefault(_doUntil);
@@ -81,10 +82,6 @@ var _doWhilst = require('./doWhilst');
 
 var _doWhilst2 = _interopRequireDefault(_doWhilst);
 
-var _during = require('./during');
-
-var _during2 = _interopRequireDefault(_during);
-
 var _each = require('./each');
 
 var _each2 = _interopRequireDefault(_each);
@@ -315,6 +312,70 @@ var _whilst2 = _interopRequireDefault(_whilst);
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+/**
+ * An "async function" in the context of Async is an asynchronous function with
+ * a variable number of parameters, with the final parameter being a callback.
+ * (`function (arg1, arg2, ..., callback) {}`)
+ * The final callback is of the form `callback(err, results...)`, which must be
+ * called once the function is completed.  The callback should be called with a
+ * Error as its first argument to signal that an error occurred.
+ * Otherwise, if no error occurred, it should be called with `null` as the first
+ * argument, and any additional `result` arguments that may apply, to signal
+ * successful completion.
+ * The callback must be called exactly once, ideally on a later tick of the
+ * JavaScript event loop.
+ *
+ * This type of function is also referred to as a "Node-style async function",
+ * or a "continuation passing-style function" (CPS). Most of the methods of this
+ * library are themselves CPS/Node-style async functions, or functions that
+ * return CPS/Node-style async functions.
+ *
+ * Wherever we accept a Node-style async function, we also directly accept an
+ * [ES2017 `async` function]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function}.
+ * In this case, the `async` function will not be passed a final callback
+ * argument, and any thrown error will be used as the `err` argument of the
+ * implicit callback, and the return value will be used as the `result` value.
+ * (i.e. a `rejected` of the returned Promise becomes the `err` callback
+ * argument, and a `resolved` value becomes the `result`.)
+ *
+ * Note, due to JavaScript limitations, we can only detect native `async`
+ * functions and not transpilied implementations.
+ * Your environment must have `async`/`await` support for this to work.
+ * (e.g. Node > v7.6, or a recent version of a modern browser).
+ * If you are using `async` functions through a transpiler (e.g. Babel), you
+ * must still wrap the function with [asyncify]{@link module:Utils.asyncify},
+ * because the `async function` will be compiled to an ordinary function that
+ * returns a promise.
+ *
+ * @typedef {Function} AsyncFunction
+ * @static
+ */
+
+/**
+ * Async is a utility module which provides straight-forward, powerful functions
+ * for working with asynchronous JavaScript. Although originally designed for
+ * use with [Node.js](http://nodejs.org) and installable via
+ * `npm install --save async`, it can also be used directly in the browser.
+ * @module async
+ * @see AsyncFunction
+ */
+
+/**
+ * A collection of `async` functions for manipulating collections, such as
+ * arrays and objects.
+ * @module Collections
+ */
+
+/**
+ * A collection of `async` functions for controlling the flow through a script.
+ * @module ControlFlow
+ */
+
+/**
+ * A collection of `async` utility functions.
+ * @module Utils
+ */
+
 exports.default = {
   apply: _apply2.default,
   applyEach: _applyEach2.default,
@@ -323,6 +384,7 @@ exports.default = {
   auto: _auto2.default,
   autoInject: _autoInject2.default,
   cargo: _cargo2.default,
+  cargoQueue: _cargoQueue2.default,
   compose: _compose2.default,
   concat: _concat2.default,
   concatLimit: _concatLimit2.default,
@@ -332,10 +394,8 @@ exports.default = {
   detectLimit: _detectLimit2.default,
   detectSeries: _detectSeries2.default,
   dir: _dir2.default,
-  doDuring: _doDuring2.default,
   doUntil: _doUntil2.default,
   doWhilst: _doWhilst2.default,
-  during: _during2.default,
   each: _each2.default,
   eachLimit: _eachLimit2.default,
   eachOf: _eachOf2.default,
@@ -404,6 +464,9 @@ exports.default = {
   find: _detect2.default,
   findLimit: _detectLimit2.default,
   findSeries: _detectSeries2.default,
+  flatMap: _concat2.default,
+  flatMapLimit: _concatLimit2.default,
+  flatMapSeries: _concatSeries2.default,
   forEach: _each2.default,
   forEachSeries: _eachSeries2.default,
   forEachLimit: _eachLimit2.default,
@@ -416,71 +479,10 @@ exports.default = {
   select: _filter2.default,
   selectLimit: _filterLimit2.default,
   selectSeries: _filterSeries2.default,
-  wrapSync: _asyncify2.default
-}; /**
-    * An "async function" in the context of Async is an asynchronous function with
-    * a variable number of parameters, with the final parameter being a callback.
-    * (`function (arg1, arg2, ..., callback) {}`)
-    * The final callback is of the form `callback(err, results...)`, which must be
-    * called once the function is completed.  The callback should be called with a
-    * Error as its first argument to signal that an error occurred.
-    * Otherwise, if no error occurred, it should be called with `null` as the first
-    * argument, and any additional `result` arguments that may apply, to signal
-    * successful completion.
-    * The callback must be called exactly once, ideally on a later tick of the
-    * JavaScript event loop.
-    *
-    * This type of function is also referred to as a "Node-style async function",
-    * or a "continuation passing-style function" (CPS). Most of the methods of this
-    * library are themselves CPS/Node-style async functions, or functions that
-    * return CPS/Node-style async functions.
-    *
-    * Wherever we accept a Node-style async function, we also directly accept an
-    * [ES2017 `async` function]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function}.
-    * In this case, the `async` function will not be passed a final callback
-    * argument, and any thrown error will be used as the `err` argument of the
-    * implicit callback, and the return value will be used as the `result` value.
-    * (i.e. a `rejected` of the returned Promise becomes the `err` callback
-    * argument, and a `resolved` value becomes the `result`.)
-    *
-    * Note, due to JavaScript limitations, we can only detect native `async`
-    * functions and not transpilied implementations.
-    * Your environment must have `async`/`await` support for this to work.
-    * (e.g. Node > v7.6, or a recent version of a modern browser).
-    * If you are using `async` functions through a transpiler (e.g. Babel), you
-    * must still wrap the function with [asyncify]{@link module:Utils.asyncify},
-    * because the `async function` will be compiled to an ordinary function that
-    * returns a promise.
-    *
-    * @typedef {Function} AsyncFunction
-    * @static
-    */
-
-/**
- * Async is a utility module which provides straight-forward, powerful functions
- * for working with asynchronous JavaScript. Although originally designed for
- * use with [Node.js](http://nodejs.org) and installable via
- * `npm install --save async`, it can also be used directly in the browser.
- * @module async
- * @see AsyncFunction
- */
-
-/**
- * A collection of `async` functions for manipulating collections, such as
- * arrays and objects.
- * @module Collections
- */
-
-/**
- * A collection of `async` functions for controlling the flow through a script.
- * @module ControlFlow
- */
-
-/**
- * A collection of `async` utility functions.
- * @module Utils
- */
-
+  wrapSync: _asyncify2.default,
+  during: _whilst2.default,
+  doDuring: _doWhilst2.default
+};
 exports.apply = _apply2.default;
 exports.applyEach = _applyEach2.default;
 exports.applyEachSeries = _applyEachSeries2.default;
@@ -488,6 +490,7 @@ exports.asyncify = _asyncify2.default;
 exports.auto = _auto2.default;
 exports.autoInject = _autoInject2.default;
 exports.cargo = _cargo2.default;
+exports.cargoQueue = _cargoQueue2.default;
 exports.compose = _compose2.default;
 exports.concat = _concat2.default;
 exports.concatLimit = _concatLimit2.default;
@@ -497,10 +500,8 @@ exports.detect = _detect2.default;
 exports.detectLimit = _detectLimit2.default;
 exports.detectSeries = _detectSeries2.default;
 exports.dir = _dir2.default;
-exports.doDuring = _doDuring2.default;
 exports.doUntil = _doUntil2.default;
 exports.doWhilst = _doWhilst2.default;
-exports.during = _during2.default;
 exports.each = _each2.default;
 exports.eachLimit = _eachLimit2.default;
 exports.eachOf = _eachOf2.default;
@@ -567,6 +568,9 @@ exports.anySeries = _someSeries2.default;
 exports.find = _detect2.default;
 exports.findLimit = _detectLimit2.default;
 exports.findSeries = _detectSeries2.default;
+exports.flatMap = _concat2.default;
+exports.flatMapLimit = _concatLimit2.default;
+exports.flatMapSeries = _concatSeries2.default;
 exports.forEach = _each2.default;
 exports.forEachSeries = _eachSeries2.default;
 exports.forEachLimit = _eachLimit2.default;
@@ -579,4 +583,6 @@ exports.foldr = _reduceRight2.default;
 exports.select = _filter2.default;
 exports.selectLimit = _filterLimit2.default;
 exports.selectSeries = _filterSeries2.default;
-exports.wrapSync = _asyncify2.default;
+exports.wrapSync = _asyncify2.default;
+exports.during = _whilst2.default;
+exports.doDuring = _doWhilst2.default;

package/node_modules/async/inject.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/internal/DoublyLinkedList.js

@@ -3,86 +3,90 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = DLL;
 // Simple doubly linked list (https://en.wikipedia.org/wiki/Doubly_linked_list) implementation
 // used for queues. This implementation assumes that the node provided by the user can be modified
 // to adjust the next and last properties. We implement only the minimal functionality
 // for queue support.
-function DLL() {
-    this.head = this.tail = null;
-    this.length = 0;
-}
+class DLL {
+    constructor() {
+        this.head = this.tail = null;
+        this.length = 0;
+    }
 
-function setInitial(dll, node) {
-    dll.length = 1;
-    dll.head = dll.tail = node;
-}
+    removeLink(node) {
+        if (node.prev) node.prev.next = node.next;else this.head = node.next;
+        if (node.next) node.next.prev = node.prev;else this.tail = node.prev;
 
-DLL.prototype.removeLink = function (node) {
-    if (node.prev) node.prev.next = node.next;else this.head = node.next;
-    if (node.next) node.next.prev = node.prev;else this.tail = node.prev;
+        node.prev = node.next = null;
+        this.length -= 1;
+        return node;
+    }
 
-    node.prev = node.next = null;
-    this.length -= 1;
-    return node;
-};
+    empty() {
+        while (this.head) this.shift();
+        return this;
+    }
 
-DLL.prototype.empty = function () {
-    while (this.head) this.shift();
-    return this;
-};
+    insertAfter(node, newNode) {
+        newNode.prev = node;
+        newNode.next = node.next;
+        if (node.next) node.next.prev = newNode;else this.tail = newNode;
+        node.next = newNode;
+        this.length += 1;
+    }
 
-DLL.prototype.insertAfter = function (node, newNode) {
-    newNode.prev = node;
-    newNode.next = node.next;
-    if (node.next) node.next.prev = newNode;else this.tail = newNode;
-    node.next = newNode;
-    this.length += 1;
-};
+    insertBefore(node, newNode) {
+        newNode.prev = node.prev;
+        newNode.next = node;
+        if (node.prev) node.prev.next = newNode;else this.head = newNode;
+        node.prev = newNode;
+        this.length += 1;
+    }
 
-DLL.prototype.insertBefore = function (node, newNode) {
-    newNode.prev = node.prev;
-    newNode.next = node;
-    if (node.prev) node.prev.next = newNode;else this.head = newNode;
-    node.prev = newNode;
-    this.length += 1;
-};
+    unshift(node) {
+        if (this.head) this.insertBefore(this.head, node);else setInitial(this, node);
+    }
 
-DLL.prototype.unshift = function (node) {
-    if (this.head) this.insertBefore(this.head, node);else setInitial(this, node);
-};
+    push(node) {
+        if (this.tail) this.insertAfter(this.tail, node);else setInitial(this, node);
+    }
 
-DLL.prototype.push = function (node) {
-    if (this.tail) this.insertAfter(this.tail, node);else setInitial(this, node);
-};
+    shift() {
+        return this.head && this.removeLink(this.head);
+    }
 
-DLL.prototype.shift = function () {
-    return this.head && this.removeLink(this.head);
-};
+    pop() {
+        return this.tail && this.removeLink(this.tail);
+    }
 
-DLL.prototype.pop = function () {
-    return this.tail && this.removeLink(this.tail);
-};
+    toArray() {
+        return [...this];
+    }
 
-DLL.prototype.toArray = function () {
-    var arr = Array(this.length);
-    var curr = this.head;
-    for (var idx = 0; idx < this.length; idx++) {
-        arr[idx] = curr.data;
-        curr = curr.next;
+    *[Symbol.iterator]() {
+        var cur = this.head;
+        while (cur) {
+            yield cur.data;
+            cur = cur.next;
+        }
     }
-    return arr;
-};
 
-DLL.prototype.remove = function (testFn) {
-    var curr = this.head;
-    while (!!curr) {
-        var next = curr.next;
-        if (testFn(curr)) {
-            this.removeLink(curr);
+    remove(testFn) {
+        var curr = this.head;
+        while (curr) {
+            var { next } = curr;
+            if (testFn(curr)) {
+                this.removeLink(curr);
+            }
+            curr = next;
         }
-        curr = next;
+        return this;
     }
-    return this;
-};
+}
+
+exports.default = DLL;
+function setInitial(dll, node) {
+    dll.length = 1;
+    dll.head = dll.tail = node;
+}
 module.exports = exports["default"];

package/node_modules/async/internal/Heap.js

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+// Binary min-heap implementation used for priority queue.
+// Implementation is stable, i.e. push time is considered for equal priorities
+class Heap {
+    constructor() {
+        this.heap = [];
+        this.pushCount = Number.MIN_SAFE_INTEGER;
+    }
+
+    get length() {
+        return this.heap.length;
+    }
+
+    empty() {
+        this.heap = [];
+        return this;
+    }
+
+    percUp(index) {
+        let p;
+
+        while (index > 0 && smaller(this.heap[index], this.heap[p = parent(index)])) {
+            let t = this.heap[index];
+            this.heap[index] = this.heap[p];
+            this.heap[p] = t;
+
+            index = p;
+        }
+    }
+
+    percDown(index) {
+        let l;
+
+        while ((l = leftChi(index)) < this.heap.length) {
+            if (l + 1 < this.heap.length && smaller(this.heap[l + 1], this.heap[l])) {
+                l = l + 1;
+            }
+
+            if (smaller(this.heap[index], this.heap[l])) {
+                break;
+            }
+
+            let t = this.heap[index];
+            this.heap[index] = this.heap[l];
+            this.heap[l] = t;
+
+            index = l;
+        }
+    }
+
+    push(node) {
+        node.pushCount = ++this.pushCount;
+        this.heap.push(node);
+        this.percUp(this.heap.length - 1);
+    }
+
+    unshift(node) {
+        return this.heap.push(node);
+    }
+
+    shift() {
+        let [top] = this.heap;
+
+        this.heap[0] = this.heap[this.heap.length - 1];
+        this.heap.pop();
+        this.percDown(0);
+
+        return top;
+    }
+
+    toArray() {
+        return [...this];
+    }
+
+    *[Symbol.iterator]() {
+        for (let i = 0; i < this.heap.length; i++) {
+            yield this.heap[i].data;
+        }
+    }
+
+    remove(testFn) {
+        let j = 0;
+        for (let i = 0; i < this.heap.length; i++) {
+            if (!testFn(this.heap[i])) {
+                this.heap[j] = this.heap[i];
+                j++;
+            }
+        }
+
+        this.heap.splice(j);
+
+        for (let i = parent(this.heap.length - 1); i >= 0; i--) {
+            this.percDown(i);
+        }
+
+        return this;
+    }
+}
+
+exports.default = Heap;
+function leftChi(i) {
+    return (i << 1) + 1;
+}
+
+function parent(i) {
+    return (i + 1 >> 1) - 1;
+}
+
+function smaller(x, y) {
+    if (x.priority !== y.priority) {
+        return x.priority < y.priority;
+    } else {
+        return x.pushCount < y.pushCount;
+    }
+}
+module.exports = exports["default"];

package/node_modules/async/internal/applyEach.js

@@ -3,36 +3,27 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = applyEach;
 
-var _slice = require('./slice');
-
-var _slice2 = _interopRequireDefault(_slice);
-
-var _initialParams = require('./initialParams');
-
-var _initialParams2 = _interopRequireDefault(_initialParams);
+exports.default = function (eachfn) {
+    return function applyEach(fns, ...callArgs) {
+        const go = (0, _awaitify2.default)(function (callback) {
+            var that = this;
+            return eachfn(fns, (fn, cb) => {
+                (0, _wrapAsync2.default)(fn).apply(that, callArgs.concat(cb));
+            }, callback);
+        });
+        return go;
+    };
+};
 
 var _wrapAsync = require('./wrapAsync');
 
 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
 
+var _awaitify = require('./awaitify');
+
+var _awaitify2 = _interopRequireDefault(_awaitify);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function applyEach(eachfn) {
-    return function (fns /*, ...args*/) {
-        var args = (0, _slice2.default)(arguments, 1);
-        var go = (0, _initialParams2.default)(function (args, callback) {
-            var that = this;
-            return eachfn(fns, function (fn, cb) {
-                (0, _wrapAsync2.default)(fn).apply(that, args.concat(cb));
-            }, callback);
-        });
-        if (args.length) {
-            return go.apply(this, args);
-        } else {
-            return go;
-        }
-    };
-}
 module.exports = exports['default'];