@contrast/agent 4.16.0 → 4.17.0

package/node_modules/async/internal/reject.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = reject;
 
-var _filter = require('./filter');
+var _filter = require('./filter.js');
 
 var _filter2 = _interopRequireDefault(_filter);
 
-var _wrapAsync = require('./wrapAsync');
+var _wrapAsync = require('./wrapAsync.js');
 
 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
 

package/node_modules/async/internal/setImmediate.js

@@ -1,11 +1,13 @@
 'use strict';
-/* istanbul ignore file */
 
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
 exports.fallback = fallback;
 exports.wrap = wrap;
+/* istanbul ignore file */
+
+var hasQueueMicrotask = exports.hasQueueMicrotask = typeof queueMicrotask === 'function' && queueMicrotask;
 var hasSetImmediate = exports.hasSetImmediate = typeof setImmediate === 'function' && setImmediate;
 var hasNextTick = exports.hasNextTick = typeof process === 'object' && typeof process.nextTick === 'function';
 
@@ -19,7 +21,9 @@ function wrap(defer) {
 
 var _defer;
 
-if (hasSetImmediate) {
+if (hasQueueMicrotask) {
+    _defer = queueMicrotask;
+} else if (hasSetImmediate) {
     _defer = setImmediate;
 } else if (hasNextTick) {
     _defer = process.nextTick;

package/node_modules/async/internal/wrapAsync.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.isAsyncIterable = exports.isAsyncGenerator = exports.isAsync = undefined;
 
-var _asyncify = require('../asyncify');
+var _asyncify = require('../asyncify.js');
 
 var _asyncify2 = _interopRequireDefault(_asyncify);
 

package/node_modules/async/log.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 
-var _consoleFunc = require('./internal/consoleFunc');
+var _consoleFunc = require('./internal/consoleFunc.js');
 
 var _consoleFunc2 = _interopRequireDefault(_consoleFunc);
 

package/node_modules/async/map.js

@@ -4,15 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 
-var _map2 = require('./internal/map');
+var _map2 = require('./internal/map.js');
 
 var _map3 = _interopRequireDefault(_map2);
 
-var _eachOf = require('./eachOf');
+var _eachOf = require('./eachOf.js');
 
 var _eachOf2 = _interopRequireDefault(_eachOf);
 
-var _awaitify = require('./internal/awaitify');
+var _awaitify = require('./internal/awaitify.js');
 
 var _awaitify2 = _interopRequireDefault(_awaitify);
 
@@ -21,7 +21,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 /**
  * Produces a new collection of values by mapping each value in `coll` through
  * the `iteratee` function. The `iteratee` is called with an item from `coll`
- * and a callback for when it has finished processing. Each of these callback
+ * and a callback for when it has finished processing. Each of these callbacks
  * takes 2 arguments: an `error`, and the transformed item from `coll`. If
  * `iteratee` passes an error to its callback, the main `callback` (for the
  * `map` function) is immediately called with the error.
@@ -51,9 +51,89 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @returns {Promise} a promise, if no callback is passed
  * @example
  *
- * async.map(['file1','file2','file3'], fs.stat, function(err, results) {
- *     // results is now an array of stats for each file
+ * // file1.txt is a file that is 1000 bytes in size
+ * // file2.txt is a file that is 2000 bytes in size
+ * // file3.txt is a file that is 3000 bytes in size
+ * // file4.txt does not exist
+ *
+ * const fileList = ['file1.txt','file2.txt','file3.txt'];
+ * const withMissingFileList = ['file1.txt','file2.txt','file4.txt'];
+ *
+ * // asynchronous function that returns the file size in bytes
+ * function getFileSizeInBytes(file, callback) {
+ *     fs.stat(file, function(err, stat) {
+ *         if (err) {
+ *             return callback(err);
+ *         }
+ *         callback(null, stat.size);
+ *     });
+ * }
+ *
+ * // Using callbacks
+ * async.map(fileList, getFileSizeInBytes, function(err, results) {
+ *     if (err) {
+ *         console.log(err);
+ *     } else {
+ *         console.log(results);
+ *         // results is now an array of the file size in bytes for each file, e.g.
+ *         // [ 1000, 2000, 3000]
+ *     }
+ * });
+ *
+ * // Error Handling
+ * async.map(withMissingFileList, getFileSizeInBytes, function(err, results) {
+ *     if (err) {
+ *         console.log(err);
+ *         // [ Error: ENOENT: no such file or directory ]
+ *     } else {
+ *         console.log(results);
+ *     }
+ * });
+ *
+ * // Using Promises
+ * async.map(fileList, getFileSizeInBytes)
+ * .then( results => {
+ *     console.log(results);
+ *     // results is now an array of the file size in bytes for each file, e.g.
+ *     // [ 1000, 2000, 3000]
+ * }).catch( err => {
+ *     console.log(err);
+ * });
+ *
+ * // Error Handling
+ * async.map(withMissingFileList, getFileSizeInBytes)
+ * .then( results => {
+ *     console.log(results);
+ * }).catch( err => {
+ *     console.log(err);
+ *     // [ Error: ENOENT: no such file or directory ]
  * });
+ *
+ * // Using async/await
+ * async () => {
+ *     try {
+ *         let results = await async.map(fileList, getFileSizeInBytes);
+ *         console.log(results);
+ *         // results is now an array of the file size in bytes for each file, e.g.
+ *         // [ 1000, 2000, 3000]
+ *     }
+ *     catch (err) {
+ *         console.log(err);
+ *     }
+ * }
+ *
+ * // Error Handling
+ * async () => {
+ *     try {
+ *         let results = await async.map(withMissingFileList, getFileSizeInBytes);
+ *         console.log(results);
+ *     }
+ *     catch (err) {
+ *         console.log(err);
+ *         // [ Error: ENOENT: no such file or directory ]
+ *     }
+ * }
+ *
  */
 function map(coll, iteratee, callback) {
   return (0, _map3.default)(_eachOf2.default, coll, iteratee, callback);

package/node_modules/async/mapLimit.js

@@ -4,15 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 
-var _map2 = require('./internal/map');
+var _map2 = require('./internal/map.js');
 
 var _map3 = _interopRequireDefault(_map2);
 
-var _eachOfLimit = require('./internal/eachOfLimit');
+var _eachOfLimit = require('./internal/eachOfLimit.js');
 
 var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
 
-var _awaitify = require('./internal/awaitify');
+var _awaitify = require('./internal/awaitify.js');
 
 var _awaitify2 = _interopRequireDefault(_awaitify);
 

package/node_modules/async/mapSeries.js

@@ -4,15 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 
-var _map2 = require('./internal/map');
+var _map2 = require('./internal/map.js');
 
 var _map3 = _interopRequireDefault(_map2);
 
-var _eachOfSeries = require('./eachOfSeries');
+var _eachOfSeries = require('./eachOfSeries.js');
 
 var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);
 
-var _awaitify = require('./internal/awaitify');
+var _awaitify = require('./internal/awaitify.js');
 
 var _awaitify2 = _interopRequireDefault(_awaitify);
 

package/node_modules/async/mapValues.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = mapValues;
 
-var _mapValuesLimit = require('./mapValuesLimit');
+var _mapValuesLimit = require('./mapValuesLimit.js');
 
 var _mapValuesLimit2 = _interopRequireDefault(_mapValuesLimit);
 
@@ -41,20 +41,110 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @returns {Promise} a promise, if no callback is passed
  * @example
  *
- * async.mapValues({
- *     f1: 'file1',
- *     f2: 'file2',
- *     f3: 'file3'
- * }, function (file, key, callback) {
- *   fs.stat(file, callback);
- * }, function(err, result) {
- *     // result is now a map of stats for each file, e.g.
+ * // file1.txt is a file that is 1000 bytes in size
+ * // file2.txt is a file that is 2000 bytes in size
+ * // file3.txt is a file that is 3000 bytes in size
+ * // file4.txt does not exist
+ *
+ * const fileMap = {
+ *     f1: 'file1.txt',
+ *     f2: 'file2.txt',
+ *     f3: 'file3.txt'
+ * };
+ *
+ * const withMissingFileMap = {
+ *     f1: 'file1.txt',
+ *     f2: 'file2.txt',
+ *     f3: 'file4.txt'
+ * };
+ *
+ * // asynchronous function that returns the file size in bytes
+ * function getFileSizeInBytes(file, key, callback) {
+ *     fs.stat(file, function(err, stat) {
+ *         if (err) {
+ *             return callback(err);
+ *         }
+ *         callback(null, stat.size);
+ *     });
+ * }
+ *
+ * // Using callbacks
+ * async.mapValues(fileMap, getFileSizeInBytes, function(err, result) {
+ *     if (err) {
+ *         console.log(err);
+ *     } else {
+ *         console.log(result);
+ *         // result is now a map of file size in bytes for each file, e.g.
+ *         // {
+ *         //     f1: 1000,
+ *         //     f2: 2000,
+ *         //     f3: 3000
+ *         // }
+ *     }
+ * });
+ *
+ * // Error handling
+ * async.mapValues(withMissingFileMap, getFileSizeInBytes, function(err, result) {
+ *     if (err) {
+ *         console.log(err);
+ *         // [ Error: ENOENT: no such file or directory ]
+ *     } else {
+ *         console.log(result);
+ *     }
+ * });
+ *
+ * // Using Promises
+ * async.mapValues(fileMap, getFileSizeInBytes)
+ * .then( result => {
+ *     console.log(result);
+ *     // result is now a map of file size in bytes for each file, e.g.
  *     // {
- *     //     f1: [stats for file1],
- *     //     f2: [stats for file2],
- *     //     f3: [stats for file3]
+ *     //     f1: 1000,
+ *     //     f2: 2000,
+ *     //     f3: 3000
  *     // }
+ * }).catch (err => {
+ *     console.log(err);
+ * });
+ *
+ * // Error Handling
+ * async.mapValues(withMissingFileMap, getFileSizeInBytes)
+ * .then( result => {
+ *     console.log(result);
+ * }).catch (err => {
+ *     console.log(err);
+ *     // [ Error: ENOENT: no such file or directory ]
  * });
+ *
+ * // Using async/await
+ * async () => {
+ *     try {
+ *         let result = await async.mapValues(fileMap, getFileSizeInBytes);
+ *         console.log(result);
+ *         // result is now a map of file size in bytes for each file, e.g.
+ *         // {
+ *         //     f1: 1000,
+ *         //     f2: 2000,
+ *         //     f3: 3000
+ *         // }
+ *     }
+ *     catch (err) {
+ *         console.log(err);
+ *     }
+ * }
+ *
+ * // Error Handling
+ * async () => {
+ *     try {
+ *         let result = await async.mapValues(withMissingFileMap, getFileSizeInBytes);
+ *         console.log(result);
+ *     }
+ *     catch (err) {
+ *         console.log(err);
+ *         // [ Error: ENOENT: no such file or directory ]
+ *     }
+ * }
+ *
  */
 function mapValues(obj, iteratee, callback) {
   return (0, _mapValuesLimit2.default)(obj, Infinity, iteratee, callback);

package/node_modules/async/mapValuesLimit.js

@@ -4,19 +4,19 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 
-var _eachOfLimit = require('./internal/eachOfLimit');
+var _eachOfLimit = require('./internal/eachOfLimit.js');
 
 var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
 
-var _awaitify = require('./internal/awaitify');
+var _awaitify = require('./internal/awaitify.js');
 
 var _awaitify2 = _interopRequireDefault(_awaitify);
 
-var _once = require('./internal/once');
+var _once = require('./internal/once.js');
 
 var _once2 = _interopRequireDefault(_once);
 
-var _wrapAsync = require('./internal/wrapAsync');
+var _wrapAsync = require('./internal/wrapAsync.js');
 
 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
 

package/node_modules/async/mapValuesSeries.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = mapValuesSeries;
 
-var _mapValuesLimit = require('./mapValuesLimit');
+var _mapValuesLimit = require('./mapValuesLimit.js');
 
 var _mapValuesLimit2 = _interopRequireDefault(_mapValuesLimit);
 

package/node_modules/async/memoize.js

@@ -5,15 +5,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = memoize;
 
-var _setImmediate = require('./internal/setImmediate');
+var _setImmediate = require('./internal/setImmediate.js');
 
 var _setImmediate2 = _interopRequireDefault(_setImmediate);
 
-var _initialParams = require('./internal/initialParams');
+var _initialParams = require('./internal/initialParams.js');
 
 var _initialParams2 = _interopRequireDefault(_initialParams);
 
-var _wrapAsync = require('./internal/wrapAsync');
+var _wrapAsync = require('./internal/wrapAsync.js');
 
 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
 

package/node_modules/async/nextTick.js

@@ -1,11 +1,10 @@
 'use strict';
-/* istanbul ignore file */
 
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
 
-var _setImmediate = require('./internal/setImmediate');
+var _setImmediate = require('./internal/setImmediate.js');
 
 /**
  * Calls `callback` on a later loop around the event loop. In Node.js this just
@@ -38,7 +37,8 @@ var _setImmediate = require('./internal/setImmediate');
  *     // a, b, and c equal 1, 2, and 3
  * }, 1, 2, 3);
  */
-var _defer;
+var _defer; /* istanbul ignore file */
+
 
 if (_setImmediate.hasNextTick) {
     _defer = process.nextTick;

package/node_modules/async/package.json

@@ -1,7 +1,7 @@
 {
   "name": "async",
   "description": "Higher-order functions and common patterns for asynchronous code",
-  "version": "3.2.0",
+  "version": "3.2.3",
   "main": "dist/async.js",
   "author": "Caolan McMahon",
   "homepage": "https://caolan.github.io/async/",
@@ -18,7 +18,6 @@
     "module",
     "utility"
   ],
-  "dependencies": {},
   "devDependencies": {
     "babel-core": "^6.26.3",
     "babel-eslint": "^8.2.6",
@@ -54,7 +53,6 @@
     "mocha-junit-reporter": "^1.18.0",
     "native-promise-only": "^0.8.0-a",
     "nyc": "^14.1.1",
-    "rimraf": "^2.5.0",
     "rollup": "^0.63.4",
     "rollup-plugin-node-resolve": "^2.0.0",
     "rollup-plugin-npm": "^2.0.0",
@@ -80,7 +78,7 @@
   },
   "module": "dist/async.mjs"
 
-,"_resolved": "https://registry.npmjs.org/async/-/async-3.2.0.tgz"
-,"_integrity": "sha512-TR2mEZFVOj2pLStYxLht7TyfuRzaydfpxr3k9RpHIzMgw7A64dzsdqCxH1WJyQdoe8T10nDXd9wnEigmiuHIZw=="
-,"_from": "async@3.2.0"
+,"_resolved": "https://registry.npmjs.org/async/-/async-3.2.3.tgz"
+,"_integrity": "sha512-spZRyzKL5l5BZQrr/6m/SqFdBN0q3OCI0f9rjfBzCMBIP4p75P620rR3gTmaksNOhmzgdxcaxdNfMy6anrbM0g=="
+,"_from": "async@3.2.3"
 }

package/node_modules/async/parallel.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = parallel;
 
-var _eachOf = require('./eachOf');
+var _eachOf = require('./eachOf.js');
 
 var _eachOf2 = _interopRequireDefault(_eachOf);
 
-var _parallel2 = require('./internal/parallel');
+var _parallel2 = require('./internal/parallel.js');
 
 var _parallel3 = _interopRequireDefault(_parallel2);
 
@@ -51,6 +51,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @returns {Promise} a promise, if a callback is not passed
  *
  * @example
+ *
+ * //Using Callbacks
  * async.parallel([
  *     function(callback) {
  *         setTimeout(function() {
@@ -62,10 +64,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  *             callback(null, 'two');
  *         }, 100);
  *     }
- * ],
- * // optional callback
- * function(err, results) {
- *     // the results array will equal ['one','two'] even though
+ * ], function(err, results) {
+ *     console.log(results);
+ *     // results is equal to ['one','two'] even though
  *     // the second function had a shorter timeout.
  * });
  *
@@ -82,8 +83,96 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  *         }, 100);
  *     }
  * }, function(err, results) {
- *     // results is now equals to: {one: 1, two: 2}
+ *     console.log(results);
+ *     // results is equal to: { one: 1, two: 2 }
  * });
+ *
+ * //Using Promises
+ * async.parallel([
+ *     function(callback) {
+ *         setTimeout(function() {
+ *             callback(null, 'one');
+ *         }, 200);
+ *     },
+ *     function(callback) {
+ *         setTimeout(function() {
+ *             callback(null, 'two');
+ *         }, 100);
+ *     }
+ * ]).then(results => {
+ *     console.log(results);
+ *     // results is equal to ['one','two'] even though
+ *     // the second function had a shorter timeout.
+ * }).catch(err => {
+ *     console.log(err);
+ * });
+ *
+ * // an example using an object instead of an array
+ * async.parallel({
+ *     one: function(callback) {
+ *         setTimeout(function() {
+ *             callback(null, 1);
+ *         }, 200);
+ *     },
+ *     two: function(callback) {
+ *         setTimeout(function() {
+ *             callback(null, 2);
+ *         }, 100);
+ *     }
+ * }).then(results => {
+ *     console.log(results);
+ *     // results is equal to: { one: 1, two: 2 }
+ * }).catch(err => {
+ *     console.log(err);
+ * });
+ *
+ * //Using async/await
+ * async () => {
+ *     try {
+ *         let results = await async.parallel([
+ *             function(callback) {
+ *                 setTimeout(function() {
+ *                     callback(null, 'one');
+ *                 }, 200);
+ *             },
+ *             function(callback) {
+ *                 setTimeout(function() {
+ *                     callback(null, 'two');
+ *                 }, 100);
+ *             }
+ *         ]);
+ *         console.log(results);
+ *         // results is equal to ['one','two'] even though
+ *         // the second function had a shorter timeout.
+ *     }
+ *     catch (err) {
+ *         console.log(err);
+ *     }
+ * }
+ *
+ * // an example using an object instead of an array
+ * async () => {
+ *     try {
+ *         let results = await async.parallel({
+ *             one: function(callback) {
+ *                 setTimeout(function() {
+ *                     callback(null, 1);
+ *                 }, 200);
+ *             },
+ *            two: function(callback) {
+ *                 setTimeout(function() {
+ *                     callback(null, 2);
+ *                 }, 100);
+ *            }
+ *         });
+ *         console.log(results);
+ *         // results is equal to: { one: 1, two: 2 }
+ *     }
+ *     catch (err) {
+ *         console.log(err);
+ *     }
+ * }
+ *
  */
 function parallel(tasks, callback) {
   return (0, _parallel3.default)(_eachOf2.default, tasks, callback);

package/node_modules/async/parallelLimit.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = parallelLimit;
 
-var _eachOfLimit = require('./internal/eachOfLimit');
+var _eachOfLimit = require('./internal/eachOfLimit.js');
 
 var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
 
-var _parallel = require('./internal/parallel');
+var _parallel = require('./internal/parallel.js');
 
 var _parallel2 = _interopRequireDefault(_parallel);
 

package/node_modules/async/priorityQueue.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = function (worker, concurrency) {
     // Start with a normal queue
     var q = (0, _queue2.default)(worker, concurrency);
+    var processingScheduled = false;
 
     q._tasks = new _Heap2.default();
 
@@ -34,7 +35,13 @@ exports.default = function (worker, concurrency) {
             q._tasks.push(item);
         }
 
-        (0, _setImmediate2.default)(q.process);
+        if (!processingScheduled) {
+            processingScheduled = true;
+            (0, _setImmediate2.default)(() => {
+                processingScheduled = false;
+                q.process();
+            });
+        }
     };
 
     // Remove unshift function
@@ -43,15 +50,15 @@ exports.default = function (worker, concurrency) {
     return q;
 };
 
-var _setImmediate = require('./setImmediate');
+var _setImmediate = require('./setImmediate.js');
 
 var _setImmediate2 = _interopRequireDefault(_setImmediate);
 
-var _queue = require('./queue');
+var _queue = require('./queue.js');
 
 var _queue2 = _interopRequireDefault(_queue);
 
-var _Heap = require('./internal/Heap');
+var _Heap = require('./internal/Heap.js');
 
 var _Heap2 = _interopRequireDefault(_Heap);