Separate android and nodejs

--Subproject commit cc12bd6bf562dd7938b8e9b63f2dd40057afc541

-../ejs/bin/cli.js
\ No newline at end of file

-../jake/bin/cli.js
\ No newline at end of file

-../mime/cli.js
\ No newline at end of file

-../sshpk/bin/sshpk-conv
\ No newline at end of file

-../sshpk/bin/sshpk-sign
\ No newline at end of file

-../sshpk/bin/sshpk-verify
\ No newline at end of file

-../uuid/bin/uuid
\ No newline at end of file

-../xml-js/bin/cli.js
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = mapValuesSeries;
-
-var _mapValuesLimit = require('./mapValuesLimit.js');
-
-var _mapValuesLimit2 = _interopRequireDefault(_mapValuesLimit);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`mapValues`]{@link module:Collections.mapValues} but runs only a single async operation at a time.
- *
- * @name mapValuesSeries
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.mapValues]{@link module:Collections.mapValues}
- * @category Collection
- * @param {Object} obj - A collection to iterate over.
- * @param {AsyncFunction} iteratee - A function to apply to each value and key
- * in `coll`.
- * The iteratee should complete with the transformed value as its result.
- * Invoked with (value, key, callback).
- * @param {Function} [callback] - A callback which is called when all `iteratee`
- * 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
- */
-function mapValuesSeries(obj, iteratee, callback) {
-  return (0, _mapValuesLimit2.default)(obj, 1, iteratee, callback);
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _setImmediate = require('./internal/setImmediate.js');
-
-/**
- * Calls `callback` on a later loop around the event loop. In Node.js this just
- * calls `process.nextTick`.  In the browser it will use `setImmediate` if
- * available, otherwise `setTimeout(callback, 0)`, which means other higher
- * priority events may precede the execution of `callback`.
- *
- * This is used internally for browser-compatibility purposes.
- *
- * @name nextTick
- * @static
- * @memberOf module:Utils
- * @method
- * @see [async.setImmediate]{@link module:Utils.setImmediate}
- * @category Util
- * @param {Function} callback - The function to call on a later loop around
- * the event loop. Invoked with (args...).
- * @param {...*} args... - any number of additional arguments to pass to the
- * callback on the next tick.
- * @example
- *
- * var call_order = [];
- * async.nextTick(function() {
- *     call_order.push('two');
- *     // call_order now equals ['one','two']
- * });
- * call_order.push('one');
- *
- * async.setImmediate(function (a, b, c) {
- *     // a, b, and c equal 1, 2, and 3
- * }, 1, 2, 3);
- */
-var _defer; /* istanbul ignore file */
-
-
-if (_setImmediate.hasNextTick) {
-    _defer = process.nextTick;
-} else if (_setImmediate.hasSetImmediate) {
-    _defer = setImmediate;
-} else {
-    _defer = _setImmediate.fallback;
-}
-
-exports.default = (0, _setImmediate.wrap)(_defer);
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = parallelLimit;
-
-var _eachOfLimit = require('./internal/eachOfLimit.js');
-
-var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
-
-var _parallel = require('./internal/parallel.js');
-
-var _parallel2 = _interopRequireDefault(_parallel);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`parallel`]{@link module:ControlFlow.parallel} but runs a maximum of `limit` async operations at a
- * time.
- *
- * @name parallelLimit
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.parallel]{@link module:ControlFlow.parallel}
- * @category Control Flow
- * @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.
- * @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
- */
-function parallelLimit(tasks, limit, callback) {
-  return (0, _parallel2.default)((0, _eachOfLimit2.default)(limit), tasks, callback);
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _once = require('./internal/once.js');
-
-var _once2 = _interopRequireDefault(_once);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Runs the `tasks` array of functions in parallel, without waiting until the
- * previous function has completed. Once any of the `tasks` complete or pass an
- * error to its callback, the main `callback` is immediately called. It's
- * equivalent to `Promise.race()`.
- *
- * @name race
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @category Control Flow
- * @param {Array} tasks - An array containing [async functions]{@link AsyncFunction}
- * to run. Each function can complete with an optional `result` value.
- * @param {Function} callback - A callback to run once any of the functions have
- * completed. This function gets an error or result from the first function that
- * completed. Invoked with (err, result).
- * @returns undefined
- * @example
- *
- * async.race([
- *     function(callback) {
- *         setTimeout(function() {
- *             callback(null, 'one');
- *         }, 200);
- *     },
- *     function(callback) {
- *         setTimeout(function() {
- *             callback(null, 'two');
- *         }, 100);
- *     }
- * ],
- * // main callback
- * function(err, result) {
- *     // the result will be equal to 'two' as it finishes earlier
- * });
- */
-function race(tasks, callback) {
-    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'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = reduceRight;
-
-var _reduce = require('./reduce.js');
-
-var _reduce2 = _interopRequireDefault(_reduce);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Same as [`reduce`]{@link module:Collections.reduce}, only operates on `array` in reverse order.
- *
- * @name reduceRight
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.reduce]{@link module:Collections.reduce}
- * @alias foldr
- * @category Collection
- * @param {Array} array - 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.
- * The `iteratee` should complete with the next state of the reduction.
- * If the iteratee completes with an error, the reduction is stopped and the
- * main `callback` is immediately called with the error.
- * Invoked with (memo, item, callback).
- * @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 = [...array].reverse();
-  return (0, _reduce2.default)(reversed, memo, iteratee, callback);
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = reflect;
-
-var _initialParams = require('./internal/initialParams.js');
-
-var _initialParams2 = _interopRequireDefault(_initialParams);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Wraps the async function in another function that always completes with a
- * result object, even when it errors.
- *
- * The result object has either the property `error` or `value`.
- *
- * @name reflect
- * @static
- * @memberOf module:Utils
- * @method
- * @category Util
- * @param {AsyncFunction} fn - The async function you want to wrap
- * @returns {Function} - A function that always passes null to it's callback as
- * the error. The second argument to the callback will be an `object` with
- * either an `error` or a `value` property.
- * @example
- *
- * async.parallel([
- *     async.reflect(function(callback) {
- *         // do some stuff ...
- *         callback(null, 'one');
- *     }),
- *     async.reflect(function(callback) {
- *         // do some more stuff but error ...
- *         callback('bad stuff happened');
- *     }),
- *     async.reflect(function(callback) {
- *         // do some more stuff ...
- *         callback(null, 'two');
- *     })
- * ],
- * // optional callback
- * function(err, results) {
- *     // values
- *     // results[0].value = 'one'
- *     // results[1].error = 'bad stuff happened'
- *     // results[2].value = 'two'
- * });
- */
-function reflect(fn) {
-    var _fn = (0, _wrapAsync2.default)(fn);
-    return (0, _initialParams2.default)(function reflectOn(args, reflectCallback) {
-        args.push((error, ...cbArgs) => {
-            let retVal = {};
-            if (error) {
-                retVal.error = error;
-            }
-            if (cbArgs.length > 0) {
-                var value = cbArgs;
-                if (cbArgs.length <= 1) {
-                    [value] = cbArgs;
-                }
-                retVal.value = value;
-            }
-            reflectCallback(null, retVal);
-        });
-
-        return _fn.apply(this, args);
-    });
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = reflectAll;
-
-var _reflect = require('./reflect.js');
-
-var _reflect2 = _interopRequireDefault(_reflect);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * A helper function that wraps an array or an object of functions with `reflect`.
- *
- * @name reflectAll
- * @static
- * @memberOf module:Utils
- * @method
- * @see [async.reflect]{@link module:Utils.reflect}
- * @category Util
- * @param {Array|Object|Iterable} tasks - The collection of
- * [async functions]{@link AsyncFunction} to wrap in `async.reflect`.
- * @returns {Array} Returns an array of async functions, each wrapped in
- * `async.reflect`
- * @example
- *
- * let tasks = [
- *     function(callback) {
- *         setTimeout(function() {
- *             callback(null, 'one');
- *         }, 200);
- *     },
- *     function(callback) {
- *         // do some more stuff but error ...
- *         callback(new Error('bad stuff happened'));
- *     },
- *     function(callback) {
- *         setTimeout(function() {
- *             callback(null, 'two');
- *         }, 100);
- *     }
- * ];
- *
- * async.parallel(async.reflectAll(tasks),
- * // optional callback
- * function(err, results) {
- *     // values
- *     // results[0].value = 'one'
- *     // results[1].error = Error('bad stuff happened')
- *     // results[2].value = 'two'
- * });
- *
- * // an example using an object instead of an array
- * let tasks = {
- *     one: function(callback) {
- *         setTimeout(function() {
- *             callback(null, 'one');
- *         }, 200);
- *     },
- *     two: function(callback) {
- *         callback('two');
- *     },
- *     three: function(callback) {
- *         setTimeout(function() {
- *             callback(null, 'three');
- *         }, 100);
- *     }
- * };
- *
- * async.parallel(async.reflectAll(tasks),
- * // optional callback
- * function(err, results) {
- *     // values
- *     // results.one.value = 'one'
- *     // results.two.error = 'two'
- *     // results.three.value = 'three'
- * });
- */
-function reflectAll(tasks) {
-    var results;
-    if (Array.isArray(tasks)) {
-        results = tasks.map(_reflect2.default);
-    } else {
-        results = {};
-        Object.keys(tasks).forEach(key => {
-            results[key] = _reflect2.default.call(this, tasks[key]);
-        });
-    }
-    return results;
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _reject2 = require('./internal/reject.js');
-
-var _reject3 = _interopRequireDefault(_reject2);
-
-var _eachOfLimit = require('./internal/eachOfLimit.js');
-
-var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`reject`]{@link module:Collections.reject} but runs a maximum of `limit` async operations at a
- * time.
- *
- * @name rejectLimit
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.reject]{@link module:Collections.reject}
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {number} limit - The maximum number of async operations at a time.
- * @param {Function} iteratee - An async truth test to apply to each item in
- * `coll`.
- * The should complete with a boolean value as its `result`.
- * Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called after all the
- * `iteratee` functions have finished. Invoked with (err, results).
- * @returns {Promise} a promise, if no callback is passed
- */
-function rejectLimit(coll, limit, iteratee, callback) {
-  return (0, _reject3.default)((0, _eachOfLimit2.default)(limit), coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(rejectLimit, 4);
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _reject2 = require('./internal/reject.js');
-
-var _reject3 = _interopRequireDefault(_reject2);
-
-var _eachOfSeries = require('./eachOfSeries.js');
-
-var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`reject`]{@link module:Collections.reject} but runs only a single async operation at a time.
- *
- * @name rejectSeries
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.reject]{@link module:Collections.reject}
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {Function} iteratee - An async truth test to apply to each item in
- * `coll`.
- * The should complete with a boolean value as its `result`.
- * Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called after all the
- * `iteratee` functions have finished. Invoked with (err, results).
- * @returns {Promise} a promise, if no callback is passed
- */
-function rejectSeries(coll, iteratee, callback) {
-  return (0, _reject3.default)(_eachOfSeries2.default, coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(rejectSeries, 3);
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = retryable;
-
-var _retry = require('./retry.js');
-
-var _retry2 = _interopRequireDefault(_retry);
-
-var _initialParams = require('./internal/initialParams.js');
-
-var _initialParams2 = _interopRequireDefault(_initialParams);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _promiseCallback = require('./internal/promiseCallback.js');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * A close relative of [`retry`]{@link module:ControlFlow.retry}.  This method
- * wraps a task and makes it retryable, rather than immediately calling it
- * with retries.
- *
- * @name retryable
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.retry]{@link module:ControlFlow.retry}
- * @category Control Flow
- * @param {Object|number} [opts = {times: 5, interval: 0}| 5] - optional
- * options, exactly the same as from `retry`, except for a `opts.arity` that
- * is the arity of the `task` function, defaulting to `task.length`
- * @param {AsyncFunction} task - the asynchronous function to wrap.
- * This function will be passed any arguments passed to the returned wrapper.
- * Invoked with (...args, callback).
- * @returns {AsyncFunction} The wrapped function, which when invoked, will
- * retry on an error, based on the parameters specified in `opts`.
- * This function will accept the same parameters as `task`.
- * @example
- *
- * async.auto({
- *     dep1: async.retryable(3, getFromFlakyService),
- *     process: ["dep1", async.retryable(3, function (results, cb) {
- *         maybeProcessData(results.dep1, cb);
- *     })]
- * }, callback);
- */
-function retryable(opts, task) {
-    if (!task) {
-        task = opts;
-        opts = null;
-    }
-    let arity = opts && opts.arity || task.length;
-    if ((0, _wrapAsync.isAsync)(task)) {
-        arity += 1;
-    }
-    var _task = (0, _wrapAsync2.default)(task);
-    return (0, _initialParams2.default)((args, callback) => {
-        if (args.length < arity - 1 || callback == null) {
-            args.push(callback);
-            callback = (0, _promiseCallback.promiseCallback)();
-        }
-        function taskFn(cb) {
-            _task(...args, cb);
-        }
-
-        if (opts) (0, _retry2.default)(opts, taskFn, callback);else (0, _retry2.default)(taskFn, callback);
-
-        return callback[_promiseCallback.PROMISE_SYMBOL];
-    });
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _filter2 = require('./internal/filter.js');
-
-var _filter3 = _interopRequireDefault(_filter2);
-
-var _eachOf = require('./eachOf.js');
-
-var _eachOf2 = _interopRequireDefault(_eachOf);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Returns a new array of all the values in `coll` which pass an async truth
- * test. This operation is performed in parallel, but the results array will be
- * in the same order as the original.
- *
- * @name filter
- * @static
- * @memberOf module:Collections
- * @method
- * @alias select
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {Function} iteratee - A truth test to apply to each item in `coll`.
- * The `iteratee` is passed a `callback(err, truthValue)`, which must be called
- * with a boolean argument once it has completed. Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called after all the
- * `iteratee` functions have finished. Invoked with (err, results).
- * @returns {Promise} a promise, if no callback provided
- * @example
- *
- * // dir1 is a directory that contains file1.txt, file2.txt
- * // dir2 is a directory that contains file3.txt, file4.txt
- * // dir3 is a directory that contains file5.txt
- *
- * const files = ['dir1/file1.txt','dir2/file3.txt','dir3/file6.txt'];
- *
- * // asynchronous function that checks if a file exists
- * function fileExists(file, callback) {
- *    fs.access(file, fs.constants.F_OK, (err) => {
- *        callback(null, !err);
- *    });
- * }
- *
- * // Using callbacks
- * async.filter(files, fileExists, function(err, results) {
- *    if(err) {
- *        console.log(err);
- *    } else {
- *        console.log(results);
- *        // [ 'dir1/file1.txt', 'dir2/file3.txt' ]
- *        // results is now an array of the existing files
- *    }
- * });
- *
- * // Using Promises
- * async.filter(files, fileExists)
- * .then(results => {
- *     console.log(results);
- *     // [ 'dir1/file1.txt', 'dir2/file3.txt' ]
- *     // results is now an array of the existing files
- * }).catch(err => {
- *     console.log(err);
- * });
- *
- * // Using async/await
- * async () => {
- *     try {
- *         let results = await async.filter(files, fileExists);
- *         console.log(results);
- *         // [ 'dir1/file1.txt', 'dir2/file3.txt' ]
- *         // results is now an array of the existing files
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- */
-function filter(coll, iteratee, callback) {
-  return (0, _filter3.default)(_eachOf2.default, coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(filter, 3);
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _filter2 = require('./internal/filter.js');
-
-var _filter3 = _interopRequireDefault(_filter2);
-
-var _eachOfLimit = require('./internal/eachOfLimit.js');
-
-var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`filter`]{@link module:Collections.filter} but runs a maximum of `limit` async operations at a
- * time.
- *
- * @name filterLimit
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.filter]{@link module:Collections.filter}
- * @alias selectLimit
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {number} limit - The maximum number of async operations at a time.
- * @param {Function} iteratee - A truth test to apply to each item in `coll`.
- * The `iteratee` is passed a `callback(err, truthValue)`, which must be called
- * with a boolean argument once it has completed. Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called after all the
- * `iteratee` functions have finished. Invoked with (err, results).
- * @returns {Promise} a promise, if no callback provided
- */
-function filterLimit(coll, limit, iteratee, callback) {
-  return (0, _filter3.default)((0, _eachOfLimit2.default)(limit), coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(filterLimit, 4);
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _filter2 = require('./internal/filter.js');
-
-var _filter3 = _interopRequireDefault(_filter2);
-
-var _eachOfSeries = require('./eachOfSeries.js');
-
-var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`filter`]{@link module:Collections.filter} but runs only a single async operation at a time.
- *
- * @name filterSeries
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.filter]{@link module:Collections.filter}
- * @alias selectSeries
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {Function} iteratee - A truth test to apply to each item in `coll`.
- * The `iteratee` is passed a `callback(err, truthValue)`, which must be called
- * with a boolean argument once it has completed. Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called after all the
- * `iteratee` functions have finished. Invoked with (err, results)
- * @returns {Promise} a promise, if no callback provided
- */
-function filterSeries(coll, iteratee, callback) {
-  return (0, _filter3.default)(_eachOfSeries2.default, coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(filterSeries, 3);
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = seq;
-
-var _reduce = require('./reduce.js');
-
-var _reduce2 = _interopRequireDefault(_reduce);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _promiseCallback = require('./internal/promiseCallback.js');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Version of the compose function that is more natural to read. Each function
- * consumes the return value of the previous function. It is the equivalent of
- * [compose]{@link module:ControlFlow.compose} with the arguments reversed.
- *
- * Each function is executed with the `this` binding of the composed function.
- *
- * @name seq
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.compose]{@link module:ControlFlow.compose}
- * @category Control Flow
- * @param {...AsyncFunction} functions - the asynchronous functions to compose
- * @returns {Function} a function that composes the `functions` in order
- * @example
- *
- * // Requires lodash (or underscore), express3 and dresende's orm2.
- * // Part of an app, that fetches cats of the logged user.
- * // This example uses `seq` function to avoid overnesting and error
- * // handling clutter.
- * app.get('/cats', function(request, response) {
- *     var User = request.models.User;
- *     async.seq(
- *         User.get.bind(User),  // 'User.get' has signature (id, callback(err, data))
- *         function(user, fn) {
- *             user.getCats(fn);      // 'getCats' has signature (callback(err, data))
- *         }
- *     )(req.session.user_id, function (err, cats) {
- *         if (err) {
- *             console.error(err);
- *             response.json({ status: 'error', message: err.message });
- *         } else {
- *             response.json({ status: 'ok', message: 'Cats found', data: cats });
- *         }
- *     });
- * });
- */
-function seq(...functions) {
-    var _functions = functions.map(_wrapAsync2.default);
-    return function (...args) {
-        var that = this;
-
-        var cb = args[args.length - 1];
-        if (typeof cb == 'function') {
-            args.pop();
-        } else {
-            cb = (0, _promiseCallback.promiseCallback)();
-        }
-
-        (0, _reduce2.default)(_functions, args, (newargs, fn, iterCb) => {
-            fn.apply(that, newargs.concat((err, ...nextargs) => {
-                iterCb(err, nextargs);
-            }));
-        }, (err, results) => cb(err, ...results));
-
-        return cb[_promiseCallback.PROMISE_SYMBOL];
-    };
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _setImmediate = require('./internal/setImmediate.js');
-
-var _setImmediate2 = _interopRequireDefault(_setImmediate);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Calls `callback` on a later loop around the event loop. In Node.js this just
- * calls `setImmediate`.  In the browser it will use `setImmediate` if
- * available, otherwise `setTimeout(callback, 0)`, which means other higher
- * priority events may precede the execution of `callback`.
- *
- * This is used internally for browser-compatibility purposes.
- *
- * @name setImmediate
- * @static
- * @memberOf module:Utils
- * @method
- * @see [async.nextTick]{@link module:Utils.nextTick}
- * @category Util
- * @param {Function} callback - The function to call on a later loop around
- * the event loop. Invoked with (args...).
- * @param {...*} args... - any number of additional arguments to pass to the
- * callback on the next tick.
- * @example
- *
- * var call_order = [];
- * async.nextTick(function() {
- *     call_order.push('two');
- *     // call_order now equals ['one','two']
- * });
- * call_order.push('one');
- *
- * async.setImmediate(function (a, b, c) {
- *     // a, b, and c equal 1, 2, and 3
- * }, 1, 2, 3);
- */
-exports.default = _setImmediate2.default;
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _createTester = require('./internal/createTester.js');
-
-var _createTester2 = _interopRequireDefault(_createTester);
-
-var _eachOf = require('./eachOf.js');
-
-var _eachOf2 = _interopRequireDefault(_eachOf);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Returns `true` if at least one element in the `coll` satisfies an async test.
- * If any iteratee call returns `true`, the main `callback` is immediately
- * called.
- *
- * @name some
- * @static
- * @memberOf module:Collections
- * @method
- * @alias any
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {AsyncFunction} iteratee - An async truth test to apply to each item
- * in the collections in parallel.
- * The iteratee should complete with a boolean `result` value.
- * Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called as soon as any
- * iteratee returns `true`, or after all the iteratee functions have finished.
- * Result will be either `true` or `false` depending on the values of the async
- * tests. Invoked with (err, result).
- * @returns {Promise} a promise, if no callback provided
- * @example
- *
- * // dir1 is a directory that contains file1.txt, file2.txt
- * // dir2 is a directory that contains file3.txt, file4.txt
- * // dir3 is a directory that contains file5.txt
- * // dir4 does not exist
- *
- * // asynchronous function that checks if a file exists
- * function fileExists(file, callback) {
- *    fs.access(file, fs.constants.F_OK, (err) => {
- *        callback(null, !err);
- *    });
- * }
- *
- * // Using callbacks
- * async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists,
- *    function(err, result) {
- *        console.log(result);
- *        // true
- *        // result is true since some file in the list exists
- *    }
- *);
- *
- * async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists,
- *    function(err, result) {
- *        console.log(result);
- *        // false
- *        // result is false since none of the files exists
- *    }
- *);
- *
- * // Using Promises
- * async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists)
- * .then( result => {
- *     console.log(result);
- *     // true
- *     // result is true since some file in the list exists
- * }).catch( err => {
- *     console.log(err);
- * });
- *
- * async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists)
- * .then( result => {
- *     console.log(result);
- *     // false
- *     // result is false since none of the files exists
- * }).catch( err => {
- *     console.log(err);
- * });
- *
- * // Using async/await
- * async () => {
- *     try {
- *         let result = await async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists);
- *         console.log(result);
- *         // true
- *         // result is true since some file in the list exists
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- * async () => {
- *     try {
- *         let result = await async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists);
- *         console.log(result);
- *         // false
- *         // result is false since none of the files exists
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- */
-function some(coll, iteratee, callback) {
-  return (0, _createTester2.default)(Boolean, res => res)(_eachOf2.default, coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(some, 3);
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _createTester = require('./internal/createTester.js');
-
-var _createTester2 = _interopRequireDefault(_createTester);
-
-var _eachOfLimit = require('./internal/eachOfLimit.js');
-
-var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`some`]{@link module:Collections.some} but runs a maximum of `limit` async operations at a time.
- *
- * @name someLimit
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.some]{@link module:Collections.some}
- * @alias anyLimit
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {number} limit - The maximum number of async operations at a time.
- * @param {AsyncFunction} iteratee - An async truth test to apply to each item
- * in the collections in parallel.
- * The iteratee should complete with a boolean `result` value.
- * Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called as soon as any
- * iteratee returns `true`, or after all the iteratee functions have finished.
- * Result will be either `true` or `false` depending on the values of the async
- * tests. Invoked with (err, result).
- * @returns {Promise} a promise, if no callback provided
- */
-function someLimit(coll, limit, iteratee, callback) {
-  return (0, _createTester2.default)(Boolean, res => res)((0, _eachOfLimit2.default)(limit), coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(someLimit, 4);
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _createTester = require('./internal/createTester.js');
-
-var _createTester2 = _interopRequireDefault(_createTester);
-
-var _eachOfSeries = require('./eachOfSeries.js');
-
-var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`some`]{@link module:Collections.some} but runs only a single async operation at a time.
- *
- * @name someSeries
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.some]{@link module:Collections.some}
- * @alias anySeries
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {AsyncFunction} iteratee - An async truth test to apply to each item
- * in the collections in series.
- * The iteratee should complete with a boolean `result` value.
- * Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called as soon as any
- * iteratee returns `true`, or after all the iteratee functions have finished.
- * Result will be either `true` or `false` depending on the values of the async
- * tests. Invoked with (err, result).
- * @returns {Promise} a promise, if no callback provided
- */
-function someSeries(coll, iteratee, callback) {
-  return (0, _createTester2.default)(Boolean, res => res)(_eachOfSeries2.default, coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(someSeries, 3);
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _map = require('./map.js');
-
-var _map2 = _interopRequireDefault(_map);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Sorts a list by the results of running each `coll` value through an async
- * `iteratee`.
- *
- * @name sortBy
- * @static
- * @memberOf module:Collections
- * @method
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {AsyncFunction} iteratee - An async function to apply to each item in
- * `coll`.
- * The iteratee should complete with a value to use as the sort criteria as
- * its `result`.
- * Invoked with (item, callback).
- * @param {Function} callback - A callback which is called after all the
- * `iteratee` functions have finished, or an error occurs. Results is the items
- * from the original `coll` sorted by the values returned by the `iteratee`
- * calls. Invoked with (err, results).
- * @returns {Promise} a promise, if no callback passed
- * @example
- *
- * // bigfile.txt is a file that is 251100 bytes in size
- * // mediumfile.txt is a file that is 11000 bytes in size
- * // smallfile.txt is a file that is 121 bytes in size
- *
- * // 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.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], getFileSizeInBytes,
- *     function(err, results) {
- *         if (err) {
- *             console.log(err);
- *         } else {
- *             console.log(results);
- *             // results is now the original array of files sorted by
- *             // file size (ascending by default), e.g.
- *             // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']
- *         }
- *     }
- * );
- *
- * // By modifying the callback parameter the
- * // sorting order can be influenced:
- *
- * // ascending order
- * async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], function(file, callback) {
- *     getFileSizeInBytes(file, function(getFileSizeErr, fileSize) {
- *         if (getFileSizeErr) return callback(getFileSizeErr);
- *         callback(null, fileSize);
- *     });
- * }, function(err, results) {
- *         if (err) {
- *             console.log(err);
- *         } else {
- *             console.log(results);
- *             // results is now the original array of files sorted by
- *             // file size (ascending by default), e.g.
- *             // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']
- *         }
- *     }
- * );
- *
- * // descending order
- * async.sortBy(['bigfile.txt','mediumfile.txt','smallfile.txt'], function(file, callback) {
- *     getFileSizeInBytes(file, function(getFileSizeErr, fileSize) {
- *         if (getFileSizeErr) {
- *             return callback(getFileSizeErr);
- *         }
- *         callback(null, fileSize * -1);
- *     });
- * }, function(err, results) {
- *         if (err) {
- *             console.log(err);
- *         } else {
- *             console.log(results);
- *             // results is now the original array of files sorted by
- *             // file size (ascending by default), e.g.
- *             // [ 'bigfile.txt', 'mediumfile.txt', 'smallfile.txt']
- *         }
- *     }
- * );
- *
- * // Error handling
- * async.sortBy(['mediumfile.txt','smallfile.txt','missingfile.txt'], getFileSizeInBytes,
- *     function(err, results) {
- *         if (err) {
- *             console.log(err);
- *             // [ Error: ENOENT: no such file or directory ]
- *         } else {
- *             console.log(results);
- *         }
- *     }
- * );
- *
- * // Using Promises
- * async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], getFileSizeInBytes)
- * .then( results => {
- *     console.log(results);
- *     // results is now the original array of files sorted by
- *     // file size (ascending by default), e.g.
- *     // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']
- * }).catch( err => {
- *     console.log(err);
- * });
- *
- * // Error handling
- * async.sortBy(['mediumfile.txt','smallfile.txt','missingfile.txt'], 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.sortBy(['bigfile.txt','mediumfile.txt','smallfile.txt'], getFileSizeInBytes);
- *         console.log(results);
- *         // results is now the original array of files sorted by
- *         // file size (ascending by default), e.g.
- *         // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * })();
- *
- * // Error handling
- * async () => {
- *     try {
- *         let results = await async.sortBy(['missingfile.txt','mediumfile.txt','smallfile.txt'], getFileSizeInBytes);
- *         console.log(results);
- *     }
- *     catch (err) {
- *         console.log(err);
- *         // [ Error: ENOENT: no such file or directory ]
- *     }
- * }
- *
- */
-function sortBy(coll, iteratee, callback) {
-    var _iteratee = (0, _wrapAsync2.default)(iteratee);
-    return (0, _map2.default)(coll, (x, iterCb) => {
-        _iteratee(x, (err, criteria) => {
-            if (err) return iterCb(err);
-            iterCb(err, { value: x, criteria });
-        });
-    }, (err, results) => {
-        if (err) return callback(err);
-        callback(null, results.sort(comparator).map(v => v.value));
-    });
-
-    function comparator(left, right) {
-        var a = left.criteria,
-            b = right.criteria;
-        return a < b ? -1 : a > b ? 1 : 0;
-    }
-}
-exports.default = (0, _awaitify2.default)(sortBy, 3);
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = timeout;
-
-var _initialParams = require('./internal/initialParams.js');
-
-var _initialParams2 = _interopRequireDefault(_initialParams);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Sets a time limit on an asynchronous function. If the function does not call
- * its callback within the specified milliseconds, it will be called with a
- * timeout error. The code property for the error object will be `'ETIMEDOUT'`.
- *
- * @name timeout
- * @static
- * @memberOf module:Utils
- * @method
- * @category Util
- * @param {AsyncFunction} asyncFn - The async function to limit in time.
- * @param {number} milliseconds - The specified time limit.
- * @param {*} [info] - Any variable you want attached (`string`, `object`, etc)
- * to timeout Error for more information..
- * @returns {AsyncFunction} Returns a wrapped function that can be used with any
- * of the control flow functions.
- * Invoke this function with the same parameters as you would `asyncFunc`.
- * @example
- *
- * function myFunction(foo, callback) {
- *     doAsyncTask(foo, function(err, data) {
- *         // handle errors
- *         if (err) return callback(err);
- *
- *         // do some stuff ...
- *
- *         // return processed data
- *         return callback(null, data);
- *     });
- * }
- *
- * var wrapped = async.timeout(myFunction, 1000);
- *
- * // call `wrapped` as you would `myFunction`
- * wrapped({ bar: 'bar' }, function(err, data) {
- *     // if `myFunction` takes < 1000 ms to execute, `err`
- *     // and `data` will have their expected values
- *
- *     // else `err` will be an Error with the code 'ETIMEDOUT'
- * });
- */
-function timeout(asyncFn, milliseconds, info) {
-    var fn = (0, _wrapAsync2.default)(asyncFn);
-
-    return (0, _initialParams2.default)((args, callback) => {
-        var timedOut = false;
-        var timer;
-
-        function timeoutCallback() {
-            var name = asyncFn.name || 'anonymous';
-            var error = new Error('Callback function "' + name + '" timed out.');
-            error.code = 'ETIMEDOUT';
-            if (info) {
-                error.info = info;
-            }
-            timedOut = true;
-            callback(error);
-        }
-
-        args.push((...cbArgs) => {
-            if (!timedOut) {
-                callback(...cbArgs);
-                clearTimeout(timer);
-            }
-        });
-
-        // setup timer and call original function
-        timer = setTimeout(timeoutCallback, milliseconds);
-        fn(...args);
-    });
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = times;
-
-var _timesLimit = require('./timesLimit.js');
-
-var _timesLimit2 = _interopRequireDefault(_timesLimit);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Calls the `iteratee` function `n` times, and accumulates results in the same
- * manner you would use with [map]{@link module:Collections.map}.
- *
- * @name times
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.map]{@link module:Collections.map}
- * @category Control Flow
- * @param {number} n - The number of times to run the function.
- * @param {AsyncFunction} iteratee - The async function to call `n` times.
- * Invoked with the iteration index and a callback: (n, next).
- * @param {Function} callback - see {@link module:Collections.map}.
- * @returns {Promise} a promise, if no callback is provided
- * @example
- *
- * // Pretend this is some complicated async factory
- * var createUser = function(id, callback) {
- *     callback(null, {
- *         id: 'user' + id
- *     });
- * };
- *
- * // generate 5 users
- * async.times(5, function(n, next) {
- *     createUser(n, function(err, user) {
- *         next(err, user);
- *     });
- * }, function(err, users) {
- *     // we should now have 5 users
- * });
- */
-function times(n, iteratee, callback) {
-  return (0, _timesLimit2.default)(n, Infinity, iteratee, callback);
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = timesLimit;
-
-var _mapLimit = require('./mapLimit.js');
-
-var _mapLimit2 = _interopRequireDefault(_mapLimit);
-
-var _range = require('./internal/range.js');
-
-var _range2 = _interopRequireDefault(_range);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [times]{@link module:ControlFlow.times} but runs a maximum of `limit` async operations at a
- * time.
- *
- * @name timesLimit
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.times]{@link module:ControlFlow.times}
- * @category Control Flow
- * @param {number} count - The number of times to run the function.
- * @param {number} limit - The maximum number of async operations at a time.
- * @param {AsyncFunction} iteratee - The async function to call `n` times.
- * Invoked with the iteration index and a callback: (n, next).
- * @param {Function} callback - see [async.map]{@link module:Collections.map}.
- * @returns {Promise} a promise, if no callback is provided
- */
-function timesLimit(count, limit, iteratee, callback) {
-  var _iteratee = (0, _wrapAsync2.default)(iteratee);
-  return (0, _mapLimit2.default)((0, _range2.default)(count), limit, _iteratee, callback);
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = timesSeries;
-
-var _timesLimit = require('./timesLimit.js');
-
-var _timesLimit2 = _interopRequireDefault(_timesLimit);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [times]{@link module:ControlFlow.times} but runs only a single async operation at a time.
- *
- * @name timesSeries
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.times]{@link module:ControlFlow.times}
- * @category Control Flow
- * @param {number} n - The number of times to run the function.
- * @param {AsyncFunction} iteratee - The async function to call `n` times.
- * Invoked with the iteration index and a callback: (n, next).
- * @param {Function} callback - see {@link module:Collections.map}.
- * @returns {Promise} a promise, if no callback is provided
- */
-function timesSeries(n, iteratee, callback) {
-  return (0, _timesLimit2.default)(n, 1, iteratee, callback);
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = transform;
-
-var _eachOf = require('./eachOf.js');
-
-var _eachOf2 = _interopRequireDefault(_eachOf);
-
-var _once = require('./internal/once.js');
-
-var _once2 = _interopRequireDefault(_once);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _promiseCallback = require('./internal/promiseCallback.js');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * A relative of `reduce`.  Takes an Object or Array, and iterates over each
- * element in parallel, each step potentially mutating an `accumulator` value.
- * The type of the accumulator defaults to the type of collection passed in.
- *
- * @name transform
- * @static
- * @memberOf module:Collections
- * @method
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {*} [accumulator] - The initial state of the transform.  If omitted,
- * it will default to an empty Object or Array, depending on the type of `coll`
- * @param {AsyncFunction} iteratee - A function applied to each item in the
- * collection that potentially modifies the accumulator.
- * Invoked with (accumulator, item, key, callback).
- * @param {Function} [callback] - A callback which is called after all the
- * `iteratee` functions have finished. Result is the transformed accumulator.
- * Invoked with (err, result).
- * @returns {Promise} a promise, if no callback provided
- * @example
- *
- * // 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
- *
- * // helper function that returns human-readable size format from bytes
- * function formatBytes(bytes, decimals = 2) {
- *   // implementation not included for brevity
- *   return humanReadbleFilesize;
- * }
- *
- * const fileList = ['file1.txt','file2.txt','file3.txt'];
- *
- * // asynchronous function that returns the file size, transformed to human-readable format
- * // e.g. 1024 bytes = 1KB, 1234 bytes = 1.21 KB, 1048576 bytes = 1MB, etc.
- * function transformFileSize(acc, value, key, callback) {
- *     fs.stat(value, function(err, stat) {
- *         if (err) {
- *             return callback(err);
- *         }
- *         acc[key] = formatBytes(stat.size);
- *         callback(null);
- *     });
- * }
- *
- * // Using callbacks
- * async.transform(fileList, transformFileSize, function(err, result) {
- *     if(err) {
- *         console.log(err);
- *     } else {
- *         console.log(result);
- *         // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]
- *     }
- * });
- *
- * // Using Promises
- * async.transform(fileList, transformFileSize)
- * .then(result => {
- *     console.log(result);
- *     // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]
- * }).catch(err => {
- *     console.log(err);
- * });
- *
- * // Using async/await
- * (async () => {
- *     try {
- *         let result = await async.transform(fileList, transformFileSize);
- *         console.log(result);
- *         // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * })();
- *
- * @example
- *
- * // 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
- *
- * // helper function that returns human-readable size format from bytes
- * function formatBytes(bytes, decimals = 2) {
- *   // implementation not included for brevity
- *   return humanReadbleFilesize;
- * }
- *
- * const fileMap = { f1: 'file1.txt', f2: 'file2.txt', f3: 'file3.txt' };
- *
- * // asynchronous function that returns the file size, transformed to human-readable format
- * // e.g. 1024 bytes = 1KB, 1234 bytes = 1.21 KB, 1048576 bytes = 1MB, etc.
- * function transformFileSize(acc, value, key, callback) {
- *     fs.stat(value, function(err, stat) {
- *         if (err) {
- *             return callback(err);
- *         }
- *         acc[key] = formatBytes(stat.size);
- *         callback(null);
- *     });
- * }
- *
- * // Using callbacks
- * async.transform(fileMap, transformFileSize, function(err, result) {
- *     if(err) {
- *         console.log(err);
- *     } else {
- *         console.log(result);
- *         // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }
- *     }
- * });
- *
- * // Using Promises
- * async.transform(fileMap, transformFileSize)
- * .then(result => {
- *     console.log(result);
- *     // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }
- * }).catch(err => {
- *     console.log(err);
- * });
- *
- * // Using async/await
- * async () => {
- *     try {
- *         let result = await async.transform(fileMap, transformFileSize);
- *         console.log(result);
- *         // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- */
-function transform(coll, accumulator, iteratee, callback) {
-    if (arguments.length <= 3 && typeof accumulator === 'function') {
-        callback = iteratee;
-        iteratee = accumulator;
-        accumulator = Array.isArray(coll) ? [] : {};
-    }
-    callback = (0, _once2.default)(callback || (0, _promiseCallback.promiseCallback)());
-    var _iteratee = (0, _wrapAsync2.default)(iteratee);
-
-    (0, _eachOf2.default)(coll, (v, k, cb) => {
-        _iteratee(accumulator, v, k, cb);
-    }, err => callback(err, accumulator));
-    return callback[_promiseCallback.PROMISE_SYMBOL];
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _eachSeries = require('./eachSeries.js');
-
-var _eachSeries2 = _interopRequireDefault(_eachSeries);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * It runs each task in series but stops whenever any of the functions were
- * successful. If one of the tasks were successful, the `callback` will be
- * passed the result of the successful task. If all tasks fail, the callback
- * will be passed the error and result (if any) of the final attempt.
- *
- * @name tryEach
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @category Control Flow
- * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection containing functions to
- * run, each function is passed a `callback(err, result)` it must call on
- * completion with an error `err` (which can be `null`) and an optional `result`
- * value.
- * @param {Function} [callback] - An optional callback which is called when one
- * of the tasks has succeeded, or all have failed. It receives the `err` and
- * `result` arguments of the last attempt at completing the `task`. Invoked with
- * (err, results).
- * @returns {Promise} a promise, if no callback is passed
- * @example
- * async.tryEach([
- *     function getDataFromFirstWebsite(callback) {
- *         // Try getting the data from the first website
- *         callback(err, data);
- *     },
- *     function getDataFromSecondWebsite(callback) {
- *         // First website failed,
- *         // Try getting the data from the backup website
- *         callback(err, data);
- *     }
- * ],
- * // optional callback
- * function(err, results) {
- *     Now do something with the data.
- * });
- *
- */
-function tryEach(tasks, callback) {
-    var error = null;
-    var result;
-    return (0, _eachSeries2.default)(tasks, (task, taskCb) => {
-        (0, _wrapAsync2.default)(task)((err, ...args) => {
-            if (err === false) return taskCb(err);
-
-            if (args.length < 2) {
-                [result] = args;
-            } else {
-                result = args;
-            }
-            error = err;
-            taskCb(err ? null : {});
-        });
-    }, () => callback(error, result));
-}
-
-exports.default = (0, _awaitify2.default)(tryEach);
-module.exports = exports['default'];
\ No newline at end of file

-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = unmemoize;
-/**
- * Undoes a [memoize]{@link module:Utils.memoize}d function, reverting it to the original,
- * unmemoized form. Handy for testing.
- *
- * @name unmemoize
- * @static
- * @memberOf module:Utils
- * @method
- * @see [async.memoize]{@link module:Utils.memoize}
- * @category Util
- * @param {AsyncFunction} fn - the memoized function
- * @returns {AsyncFunction} a function that calls the original unmemoized function
- */
-function unmemoize(fn) {
-    return (...args) => {
-        return (fn.unmemoized || fn)(...args);
-    };
-}
-module.exports = exports["default"];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = until;
-
-var _whilst = require('./whilst.js');
-
-var _whilst2 = _interopRequireDefault(_whilst);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Repeatedly call `iteratee` until `test` returns `true`. Calls `callback` when
- * stopped, or an error occurs. `callback` will be passed an error and any
- * arguments passed to the final `iteratee`'s callback.
- *
- * The inverse of [whilst]{@link module:ControlFlow.whilst}.
- *
- * @name until
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.whilst]{@link module:ControlFlow.whilst}
- * @category Control Flow
- * @param {AsyncFunction} test - asynchronous truth test to perform before each
- * execution of `iteratee`. Invoked with (callback).
- * @param {AsyncFunction} iteratee - An async function which is called each time
- * `test` fails. Invoked with (callback).
- * @param {Function} [callback] - A callback which is called after the test
- * function has passed and repeated execution of `iteratee` has stopped. `callback`
- * will be passed an error and any arguments passed to the final `iteratee`'s
- * callback. Invoked with (err, [results]);
- * @returns {Promise} a promise, if a callback is not passed
- *
- * @example
- * const results = []
- * let finished = false
- * async.until(function test(cb) {
- *     cb(null, finished)
- * }, function iter(next) {
- *     fetchPage(url, (err, body) => {
- *         if (err) return next(err)
- *         results = results.concat(body.objects)
- *         finished = !!body.next
- *         next(err)
- *     })
- * }, function done (err) {
- *     // all pages have been fetched
- * })
- */
-function until(test, iteratee, callback) {
-  const _test = (0, _wrapAsync2.default)(test);
-  return (0, _whilst2.default)(cb => _test((err, truth) => cb(err, !truth)), iteratee, callback);
-}
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _once = require('./internal/once.js');
-
-var _once2 = _interopRequireDefault(_once);
-
-var _onlyOnce = require('./internal/onlyOnce.js');
-
-var _onlyOnce2 = _interopRequireDefault(_onlyOnce);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Runs the `tasks` array of functions in series, each passing their results to
- * the next in the array. However, if any of the `tasks` pass an error to their
- * own callback, the next function is not executed, and the main `callback` is
- * immediately called with the error.
- *
- * @name waterfall
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @category Control Flow
- * @param {Array} tasks - An array of [async functions]{@link AsyncFunction}
- * to run.
- * Each function should complete with any number of `result` values.
- * The `result` values will be passed as arguments, in order, to the next task.
- * @param {Function} [callback] - An optional callback to run once all the
- * functions have completed. This will be passed the results of the last task's
- * callback. Invoked with (err, [results]).
- * @returns undefined
- * @example
- *
- * async.waterfall([
- *     function(callback) {
- *         callback(null, 'one', 'two');
- *     },
- *     function(arg1, arg2, callback) {
- *         // arg1 now equals 'one' and arg2 now equals 'two'
- *         callback(null, 'three');
- *     },
- *     function(arg1, callback) {
- *         // arg1 now equals 'three'
- *         callback(null, 'done');
- *     }
- * ], function (err, result) {
- *     // result now equals 'done'
- * });
- *
- * // Or, with named functions:
- * async.waterfall([
- *     myFirstFunction,
- *     mySecondFunction,
- *     myLastFunction,
- * ], function (err, result) {
- *     // result now equals 'done'
- * });
- * function myFirstFunction(callback) {
- *     callback(null, 'one', 'two');
- * }
- * function mySecondFunction(arg1, arg2, callback) {
- *     // arg1 now equals 'one' and arg2 now equals 'two'
- *     callback(null, 'three');
- * }
- * function myLastFunction(arg1, callback) {
- *     // arg1 now equals 'three'
- *     callback(null, 'done');
- * }
- */
-function waterfall(tasks, callback) {
-    callback = (0, _once2.default)(callback);
-    if (!Array.isArray(tasks)) return callback(new Error('First argument to waterfall must be an array of functions'));
-    if (!tasks.length) return callback();
-    var taskIndex = 0;
-
-    function nextTask(args) {
-        var task = (0, _wrapAsync2.default)(tasks[taskIndex++]);
-        task(...args, (0, _onlyOnce2.default)(next));
-    }
-
-    function next(err, ...args) {
-        if (err === false) return;
-        if (err || taskIndex === tasks.length) {
-            return callback(err, ...args);
-        }
-        nextTask(args);
-    }
-
-    nextTask([]);
-}
-
-exports.default = (0, _awaitify2.default)(waterfall);
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _onlyOnce = require('./internal/onlyOnce.js');
-
-var _onlyOnce2 = _interopRequireDefault(_onlyOnce);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Repeatedly call `iteratee`, while `test` returns `true`. Calls `callback` when
- * stopped, or an error occurs.
- *
- * @name whilst
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @category Control Flow
- * @param {AsyncFunction} test - asynchronous truth test to perform before each
- * execution of `iteratee`. Invoked with ().
- * @param {AsyncFunction} iteratee - An async function which is called each time
- * `test` passes. Invoked with (callback).
- * @param {Function} [callback] - A callback which is called after the test
- * function has failed and repeated execution of `iteratee` has stopped. `callback`
- * will be passed an error and any arguments passed to the final `iteratee`'s
- * callback. Invoked with (err, [results]);
- * @returns {Promise} a promise, if no callback is passed
- * @example
- *
- * var count = 0;
- * async.whilst(
- *     function test(cb) { cb(null, count < 5); },
- *     function iter(callback) {
- *         count++;
- *         setTimeout(function() {
- *             callback(null, count);
- *         }, 1000);
- *     },
- *     function (err, n) {
- *         // 5 seconds have passed, n = 5
- *     }
- * );
- */
-function whilst(test, iteratee, callback) {
-    callback = (0, _onlyOnce2.default)(callback);
-    var _fn = (0, _wrapAsync2.default)(iteratee);
-    var _test = (0, _wrapAsync2.default)(test);
-    var results = [];
-
-    function next(err, ...rest) {
-        if (err) return callback(err);
-        results = rest;
-        if (err === false) return;
-        _test(check);
-    }
-
-    function check(err, truth) {
-        if (err) return callback(err);
-        if (err === false) return;
-        if (!truth) return callback(null, ...results);
-        _fn(next);
-    }
-
-    return _test(check);
-}
-exports.default = (0, _awaitify2.default)(whilst, 3);
-module.exports = exports['default'];
\ No newline at end of file

-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = asyncify;
-
-var _initialParams = require('./internal/initialParams.js');
-
-var _initialParams2 = _interopRequireDefault(_initialParams);
-
-var _setImmediate = require('./internal/setImmediate.js');
-
-var _setImmediate2 = _interopRequireDefault(_setImmediate);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Take a sync function and make it async, passing its return value to a
- * callback. This is useful for plugging sync functions into a waterfall,
- * series, or other async functions. Any arguments passed to the generated
- * function will be passed to the wrapped function (except for the final
- * callback argument). Errors thrown will be passed to the callback.
- *
- * If the function passed to `asyncify` returns a Promise, that promises's
- * resolved/rejected state will be used to call the callback, rather than simply
- * the synchronous return value.
- *
- * This also means you can asyncify ES2017 `async` functions.
- *
- * @name asyncify
- * @static
- * @memberOf module:Utils
- * @method
- * @alias wrapSync
- * @category Util
- * @param {Function} func - The synchronous function, or Promise-returning
- * function to convert to an {@link AsyncFunction}.
- * @returns {AsyncFunction} An asynchronous wrapper of the `func`. To be
- * invoked with `(args..., callback)`.
- * @example
- *
- * // passing a regular synchronous function
- * async.waterfall([
- *     async.apply(fs.readFile, filename, "utf8"),
- *     async.asyncify(JSON.parse),
- *     function (data, next) {
- *         // data is the result of parsing the text.
- *         // If there was a parsing error, it would have been caught.
- *     }
- * ], callback);
- *
- * // passing a function returning a promise
- * async.waterfall([
- *     async.apply(fs.readFile, filename, "utf8"),
- *     async.asyncify(function (contents) {
- *         return db.model.create(contents);
- *     }),
- *     function (model, next) {
- *         // `model` is the instantiated model object.
- *         // If there was an error, this function would be skipped.
- *     }
- * ], callback);
- *
- * // es2017 example, though `asyncify` is not needed if your JS environment
- * // supports async functions out of the box
- * var q = async.queue(async.asyncify(async function(file) {
- *     var intermediateStep = await processFile(file);
- *     return await somePromise(intermediateStep)
- * }));
- *
- * q.push(files);
- */
-function asyncify(func) {
-    if ((0, _wrapAsync.isAsync)(func)) {
-        return function (...args /*, callback*/) {
-            const callback = args.pop();
-            const promise = func.apply(this, args);
-            return handlePromise(promise, callback);
-        };
-    }
-
-    return (0, _initialParams2.default)(function (args, callback) {
-        var result;
-        try {
-            result = func.apply(this, args);
-        } catch (e) {
-            return callback(e);
-        }
-        // if result is Promise object
-        if (result && typeof result.then === 'function') {
-            return handlePromise(result, callback);
-        } else {
-            callback(null, result);
-        }
-    });
-}
-
-function handlePromise(promise, callback) {
-    return promise.then(value => {
-        invokeCallback(callback, null, value);
-    }, err => {
-        invokeCallback(callback, err && err.message ? err : new Error(err));
-    });
-}
-
-function invokeCallback(callback, error, value) {
-    try {
-        callback(error, value);
-    } catch (err) {
-        (0, _setImmediate2.default)(e => {
-            throw e;
-        }, err);
-    }
-}
-module.exports = exports['default'];
\ No newline at end of file

-The MIT License (MIT)
-
-Copyright (c) 2016 Alex Indigo
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

-# asynckit [![NPM Module](https://img.shields.io/npm/v/asynckit.svg?style=flat)](https://www.npmjs.com/package/asynckit)
-
-Minimal async jobs utility library, with streams support.
-
-[![PhantomJS Build](https://img.shields.io/travis/alexindigo/asynckit/v0.4.0.svg?label=browser&style=flat)](https://travis-ci.org/alexindigo/asynckit)
-[![Linux Build](https://img.shields.io/travis/alexindigo/asynckit/v0.4.0.svg?label=linux:0.12-6.x&style=flat)](https://travis-ci.org/alexindigo/asynckit)
-[![Windows Build](https://img.shields.io/appveyor/ci/alexindigo/asynckit/v0.4.0.svg?label=windows:0.12-6.x&style=flat)](https://ci.appveyor.com/project/alexindigo/asynckit)
-
-[![Coverage Status](https://img.shields.io/coveralls/alexindigo/asynckit/v0.4.0.svg?label=code+coverage&style=flat)](https://coveralls.io/github/alexindigo/asynckit?branch=master)
-[![Dependency Status](https://img.shields.io/david/alexindigo/asynckit/v0.4.0.svg?style=flat)](https://david-dm.org/alexindigo/asynckit)
-[![bitHound Overall Score](https://www.bithound.io/github/alexindigo/asynckit/badges/score.svg)](https://www.bithound.io/github/alexindigo/asynckit)
-
-<!-- [![Readme](https://img.shields.io/badge/readme-tested-brightgreen.svg?style=flat)](https://www.npmjs.com/package/reamde) -->
-
-AsyncKit provides harness for `parallel` and `serial` iterators over list of items represented by arrays or objects.
-Optionally it accepts abort function (should be synchronously return by iterator for each item), and terminates left over jobs upon an error event. For specific iteration order built-in (`ascending` and `descending`) and custom sort helpers also supported, via `asynckit.serialOrdered` method.
-
-It ensures async operations to keep behavior more stable and prevent `Maximum call stack size exceeded` errors, from sync iterators.
-
-| compression        |     size |
-| :----------------- | -------: |
-| asynckit.js        | 12.34 kB |
-| asynckit.min.js    |  4.11 kB |
-| asynckit.min.js.gz |  1.47 kB |
-
-
-## Install
-
-```sh
-$ npm install --save asynckit
-```
-
-## Examples
-
-### Parallel Jobs
-
-Runs iterator over provided array in parallel. Stores output in the `result` array,
-on the matching positions. In unlikely event of an error from one of the jobs,
-will terminate rest of the active jobs (if abort function is provided)
-and return error along with salvaged data to the main callback function.
-
-#### Input Array
-
-```javascript
-var parallel = require('asynckit').parallel
-  , assert   = require('assert')
-  ;
-
-var source         = [ 1, 1, 4, 16, 64, 32, 8, 2 ]
-  , expectedResult = [ 2, 2, 8, 32, 128, 64, 16, 4 ]
-  , expectedTarget = [ 1, 1, 2, 4, 8, 16, 32, 64 ]
-  , target         = []
-  ;
-
-parallel(source, asyncJob, function(err, result)
-{
-  assert.deepEqual(result, expectedResult);
-  assert.deepEqual(target, expectedTarget);
-});
-
-// async job accepts one element from the array
-// and a callback function
-function asyncJob(item, cb)
-{
-  // different delays (in ms) per item
-  var delay = item * 25;
-
-  // pretend different jobs take different time to finish
-  // and not in consequential order
-  var timeoutId = setTimeout(function() {
-    target.push(item);
-    cb(null, item * 2);
-  }, delay);
-
-  // allow to cancel "leftover" jobs upon error
-  // return function, invoking of which will abort this job
-  return clearTimeout.bind(null, timeoutId);
-}
-```
-
-More examples could be found in [test/test-parallel-array.js](test/test-parallel-array.js).
-
-#### Input Object
-
-Also it supports named jobs, listed via object.
-
-```javascript
-var parallel = require('asynckit/parallel')
-  , assert   = require('assert')
-  ;
-
-var source         = { first: 1, one: 1, four: 4, sixteen: 16, sixtyFour: 64, thirtyTwo: 32, eight: 8, two: 2 }
-  , expectedResult = { first: 2, one: 2, four: 8, sixteen: 32, sixtyFour: 128, thirtyTwo: 64, eight: 16, two: 4 }
-  , expectedTarget = [ 1, 1, 2, 4, 8, 16, 32, 64 ]
-  , expectedKeys   = [ 'first', 'one', 'two', 'four', 'eight', 'sixteen', 'thirtyTwo', 'sixtyFour' ]
-  , target         = []
-  , keys           = []
-  ;
-
-parallel(source, asyncJob, function(err, result)
-{
-  assert.deepEqual(result, expectedResult);
-  assert.deepEqual(target, expectedTarget);
-  assert.deepEqual(keys, expectedKeys);
-});
-
-// supports full value, key, callback (shortcut) interface
-function asyncJob(item, key, cb)
-{
-  // different delays (in ms) per item
-  var delay = item * 25;
-
-  // pretend different jobs take different time to finish
-  // and not in consequential order
-  var timeoutId = setTimeout(function() {
-    keys.push(key);
-    target.push(item);
-    cb(null, item * 2);
-  }, delay);
-
-  // allow to cancel "leftover" jobs upon error
-  // return function, invoking of which will abort this job
-  return clearTimeout.bind(null, timeoutId);
-}
-```
-
-More examples could be found in [test/test-parallel-object.js](test/test-parallel-object.js).
-
-### Serial Jobs
-
-Runs iterator over provided array sequentially. Stores output in the `result` array,
-on the matching positions. In unlikely event of an error from one of the jobs,
-will not proceed to the rest of the items in the list
-and return error along with salvaged data to the main callback function.
-
-#### Input Array
-
-```javascript
-var serial = require('asynckit/serial')
-  , assert = require('assert')
-  ;
-
-var source         = [ 1, 1, 4, 16, 64, 32, 8, 2 ]
-  , expectedResult = [ 2, 2, 8, 32, 128, 64, 16, 4 ]
-  , expectedTarget = [ 0, 1, 2, 3, 4, 5, 6, 7 ]
-  , target         = []
-  ;
-
-serial(source, asyncJob, function(err, result)
-{
-  assert.deepEqual(result, expectedResult);
-  assert.deepEqual(target, expectedTarget);
-});
-
-// extended interface (item, key, callback)
-// also supported for arrays
-function asyncJob(item, key, cb)
-{
-  target.push(key);
-
-  // it will be automatically made async
-  // even it iterator "returns" in the same event loop
-  cb(null, item * 2);
-}
-```
-
-More examples could be found in [test/test-serial-array.js](test/test-serial-array.js).
-
-#### Input Object
-
-Also it supports named jobs, listed via object.
-
-```javascript
-var serial = require('asynckit').serial
-  , assert = require('assert')
-  ;
-
-var source         = [ 1, 1, 4, 16, 64, 32, 8, 2 ]
-  , expectedResult = [ 2, 2, 8, 32, 128, 64, 16, 4 ]
-  , expectedTarget = [ 0, 1, 2, 3, 4, 5, 6, 7 ]
-  , target         = []
-  ;
-
-var source         = { first: 1, one: 1, four: 4, sixteen: 16, sixtyFour: 64, thirtyTwo: 32, eight: 8, two: 2 }
-  , expectedResult = { first: 2, one: 2, four: 8, sixteen: 32, sixtyFour: 128, thirtyTwo: 64, eight: 16, two: 4 }
-  , expectedTarget = [ 1, 1, 4, 16, 64, 32, 8, 2 ]
-  , target         = []
-  ;
-
-
-serial(source, asyncJob, function(err, result)
-{
-  assert.deepEqual(result, expectedResult);
-  assert.deepEqual(target, expectedTarget);
-});
-
-// shortcut interface (item, callback)
-// works for object as well as for the arrays
-function asyncJob(item, cb)
-{
-  target.push(item);
-
-  // it will be automatically made async
-  // even it iterator "returns" in the same event loop
-  cb(null, item * 2);
-}
-```
-
-More examples could be found in [test/test-serial-object.js](test/test-serial-object.js).
-
-_Note: Since _object_ is an _unordered_ collection of properties,
-it may produce unexpected results with sequential iterations.
-Whenever order of the jobs' execution is important please use `serialOrdered` method._
-
-### Ordered Serial Iterations
-
-TBD
-
-For example [compare-property](compare-property) package.
-
-### Streaming interface
-
-TBD
-
-## Want to Know More?
-
-More examples can be found in [test folder](test/).
-
-Or open an [issue](https://github.com/alexindigo/asynckit/issues) with questions and/or suggestions.
-
-## License
-
-AsyncKit is licensed under the MIT license.

-/* eslint no-console: "off" */
-
-var asynckit = require('./')
-  , async    = require('async')
-  , assert   = require('assert')
-  , expected = 0
-  ;
-
-var Benchmark = require('benchmark');
-var suite = new Benchmark.Suite;
-
-var source = [];
-for (var z = 1; z < 100; z++)
-{
-  source.push(z);
-  expected += z;
-}
-
-suite
-// add tests
-
-.add('async.map', function(deferred)
-{
-  var total = 0;
-
-  async.map(source,
-  function(i, cb)
-  {
-    setImmediate(function()
-    {
-      total += i;
-      cb(null, total);
-    });
-  },
-  function(err, result)
-  {
-    assert.ifError(err);
-    assert.equal(result[result.length - 1], expected);
-    deferred.resolve();
-  });
-}, {'defer': true})
-
-
-.add('asynckit.parallel', function(deferred)
-{
-  var total = 0;
-
-  asynckit.parallel(source,
-  function(i, cb)
-  {
-    setImmediate(function()
-    {
-      total += i;
-      cb(null, total);
-    });
-  },
-  function(err, result)
-  {
-    assert.ifError(err);
-    assert.equal(result[result.length - 1], expected);
-    deferred.resolve();
-  });
-}, {'defer': true})
-
-
-// add listeners
-.on('cycle', function(ev)
-{
-  console.log(String(ev.target));
-})
-.on('complete', function()
-{
-  console.log('Fastest is ' + this.filter('fastest').map('name'));
-})
-// run async
-.run({ 'async': true });

-// API
-module.exports = abort;
-
-/**
- * Aborts leftover active jobs
- *
- * @param {object} state - current state object
- */
-function abort(state)
-{
-  Object.keys(state.jobs).forEach(clean.bind(state));
-
-  // reset leftover jobs
-  state.jobs = {};
-}
-
-/**
- * Cleans up leftover job by invoking abort function for the provided job id
- *
- * @this  state
- * @param {string|number} key - job id to abort
- */
-function clean(key)
-{
-  if (typeof this.jobs[key] == 'function')
-  {
-    this.jobs[key]();
-  }
-}

-var defer = require('./defer.js');
-
-// API
-module.exports = async;
-
-/**
- * Runs provided callback asynchronously
- * even if callback itself is not
- *
- * @param   {function} callback - callback to invoke
- * @returns {function} - augmented callback
- */
-function async(callback)
-{
-  var isAsync = false;
-
-  // check if async happened
-  defer(function() { isAsync = true; });
-
-  return function async_callback(err, result)
-  {
-    if (isAsync)
-    {
-      callback(err, result);
-    }
-    else
-    {
-      defer(function nextTick_callback()
-      {
-        callback(err, result);
-      });
-    }
-  };
-}

-var async = require('./async.js')
-  , abort = require('./abort.js')
-  ;
-
-// API
-module.exports = iterate;
-
-/**
- * Iterates over each job object
- *
- * @param {array|object} list - array or object (named list) to iterate over
- * @param {function} iterator - iterator to run
- * @param {object} state - current job status
- * @param {function} callback - invoked when all elements processed
- */
-function iterate(list, iterator, state, callback)
-{
-  // store current index
-  var key = state['keyedList'] ? state['keyedList'][state.index] : state.index;
-
-  state.jobs[key] = runJob(iterator, key, list[key], function(error, output)
-  {
-    // don't repeat yourself
-    // skip secondary callbacks
-    if (!(key in state.jobs))
-    {
-      return;
-    }
-
-    // clean up jobs
-    delete state.jobs[key];
-
-    if (error)
-    {
-      // don't process rest of the results
-      // stop still active jobs
-      // and reset the list
-      abort(state);
-    }
-    else
-    {
-      state.results[key] = output;
-    }
-
-    // return salvaged results
-    callback(error, state.results);
-  });
-}
-
-/**
- * Runs iterator over provided job element
- *
- * @param   {function} iterator - iterator to invoke
- * @param   {string|number} key - key/index of the element in the list of jobs
- * @param   {mixed} item - job description
- * @param   {function} callback - invoked after iterator is done with the job
- * @returns {function|mixed} - job abort function or something else
- */
-function runJob(iterator, key, item, callback)
-{
-  var aborter;
-
-  // allow shortcut if iterator expects only two arguments
-  if (iterator.length == 2)
-  {
-    aborter = iterator(item, async(callback));
-  }
-  // otherwise go with full three arguments
-  else
-  {
-    aborter = iterator(item, key, async(callback));
-  }
-
-  return aborter;
-}

-var streamify = require('./streamify.js')
-  , defer     = require('./defer.js')
-  ;
-
-// API
-module.exports = ReadableAsyncKit;
-
-/**
- * Base constructor for all streams
- * used to hold properties/methods
- */
-function ReadableAsyncKit()
-{
-  ReadableAsyncKit.super_.apply(this, arguments);
-
-  // list of active jobs
-  this.jobs = {};
-
-  // add stream methods
-  this.destroy = destroy;
-  this._start  = _start;
-  this._read   = _read;
-}
-
-/**
- * Destroys readable stream,
- * by aborting outstanding jobs
- *
- * @returns {void}
- */
-function destroy()
-{
-  if (this.destroyed)
-  {
-    return;
-  }
-
-  this.destroyed = true;
-
-  if (typeof this.terminator == 'function')
-  {
-    this.terminator();
-  }
-}
-
-/**
- * Starts provided jobs in async manner
- *
- * @private
- */
-function _start()
-{
-  // first argument – runner function
-  var runner = arguments[0]
-    // take away first argument
-    , args   = Array.prototype.slice.call(arguments, 1)
-      // second argument - input data
-    , input  = args[0]
-      // last argument - result callback
-    , endCb  = streamify.callback.call(this, args[args.length - 1])
-    ;
-
-  args[args.length - 1] = endCb;
-  // third argument - iterator
-  args[1] = streamify.iterator.call(this, args[1]);
-
-  // allow time for proper setup
-  defer(function()
-  {
-    if (!this.destroyed)
-    {
-      this.terminator = runner.apply(null, args);
-    }
-    else
-    {
-      endCb(null, Array.isArray(input) ? [] : {});
-    }
-  }.bind(this));
-}
-
-
-/**
- * Implement _read to comply with Readable streams
- * Doesn't really make sense for flowing object mode
- *
- * @private
- */
-function _read()
-{
-
-}

-var parallel = require('../parallel.js');
-
-// API
-module.exports = ReadableParallel;
-
-/**
- * Streaming wrapper to `asynckit.parallel`
- *
- * @param   {array|object} list - array or object (named list) to iterate over
- * @param   {function} iterator - iterator to run
- * @param   {function} callback - invoked when all elements processed
- * @returns {stream.Readable#}
- */
-function ReadableParallel(list, iterator, callback)
-{
-  if (!(this instanceof ReadableParallel))
-  {
-    return new ReadableParallel(list, iterator, callback);
-  }
-
-  // turn on object mode
-  ReadableParallel.super_.call(this, {objectMode: true});
-
-  this._start(parallel, list, iterator, callback);
-}

-var serial = require('../serial.js');
-
-// API
-module.exports = ReadableSerial;
-
-/**
- * Streaming wrapper to `asynckit.serial`
- *
- * @param   {array|object} list - array or object (named list) to iterate over
- * @param   {function} iterator - iterator to run
- * @param   {function} callback - invoked when all elements processed
- * @returns {stream.Readable#}
- */
-function ReadableSerial(list, iterator, callback)
-{
-  if (!(this instanceof ReadableSerial))
-  {
-    return new ReadableSerial(list, iterator, callback);
-  }
-
-  // turn on object mode
-  ReadableSerial.super_.call(this, {objectMode: true});
-
-  this._start(serial, list, iterator, callback);
-}

-var serialOrdered = require('../serialOrdered.js');
-
-// API
-module.exports = ReadableSerialOrdered;
-// expose sort helpers
-module.exports.ascending  = serialOrdered.ascending;
-module.exports.descending = serialOrdered.descending;
-
-/**
- * Streaming wrapper to `asynckit.serialOrdered`
- *
- * @param   {array|object} list - array or object (named list) to iterate over
- * @param   {function} iterator - iterator to run
- * @param   {function} sortMethod - custom sort function
- * @param   {function} callback - invoked when all elements processed
- * @returns {stream.Readable#}
- */
-function ReadableSerialOrdered(list, iterator, sortMethod, callback)
-{
-  if (!(this instanceof ReadableSerialOrdered))
-  {
-    return new ReadableSerialOrdered(list, iterator, sortMethod, callback);
-  }
-
-  // turn on object mode
-  ReadableSerialOrdered.super_.call(this, {objectMode: true});
-
-  this._start(serialOrdered, list, iterator, sortMethod, callback);
-}

-// API
-module.exports = state;
-
-/**
- * Creates initial state object
- * for iteration over list
- *
- * @param   {array|object} list - list to iterate over
- * @param   {function|null} sortMethod - function to use for keys sort,
- *                                     or `null` to keep them as is
- * @returns {object} - initial state object
- */
-function state(list, sortMethod)
-{
-  var isNamedList = !Array.isArray(list)
-    , initState =
-    {
-      index    : 0,
-      keyedList: isNamedList || sortMethod ? Object.keys(list) : null,
-      jobs     : {},
-      results  : isNamedList ? {} : [],
-      size     : isNamedList ? Object.keys(list).length : list.length
-    }
-    ;
-
-  if (sortMethod)
-  {
-    // sort array keys based on it's values
-    // sort object's keys just on own merit
-    initState.keyedList.sort(isNamedList ? sortMethod : function(a, b)
-    {
-      return sortMethod(list[a], list[b]);
-    });
-  }
-
-  return initState;
-}

-var async = require('./async.js');
-
-// API
-module.exports = {
-  iterator: wrapIterator,
-  callback: wrapCallback
-};
-
-/**
- * Wraps iterators with long signature
- *
- * @this    ReadableAsyncKit#
- * @param   {function} iterator - function to wrap
- * @returns {function} - wrapped function
- */
-function wrapIterator(iterator)
-{
-  var stream = this;
-
-  return function(item, key, cb)
-  {
-    var aborter
-      , wrappedCb = async(wrapIteratorCallback.call(stream, cb, key))
-      ;
-
-    stream.jobs[key] = wrappedCb;
-
-    // it's either shortcut (item, cb)
-    if (iterator.length == 2)
-    {
-      aborter = iterator(item, wrappedCb);
-    }
-    // or long format (item, key, cb)
-    else
-    {
-      aborter = iterator(item, key, wrappedCb);
-    }
-
-    return aborter;
-  };
-}
-
-/**
- * Wraps provided callback function
- * allowing to execute snitch function before
- * real callback
- *
- * @this    ReadableAsyncKit#
- * @param   {function} callback - function to wrap
- * @returns {function} - wrapped function
- */
-function wrapCallback(callback)
-{
-  var stream = this;
-
-  var wrapped = function(error, result)
-  {
-    return finisher.call(stream, error, result, callback);
-  };
-
-  return wrapped;
-}
-
-/**
- * Wraps provided iterator callback function
- * makes sure snitch only called once,
- * but passes secondary calls to the original callback
- *
- * @this    ReadableAsyncKit#
- * @param   {function} callback - callback to wrap
- * @param   {number|string} key - iteration key
- * @returns {function} wrapped callback
- */
-function wrapIteratorCallback(callback, key)
-{
-  var stream = this;
-
-  return function(error, output)
-  {
-    // don't repeat yourself
-    if (!(key in stream.jobs))
-    {
-      callback(error, output);
-      return;
-    }
-
-    // clean up jobs
-    delete stream.jobs[key];
-
-    return streamer.call(stream, error, {key: key, value: output}, callback);
-  };
-}
-
-/**
- * Stream wrapper for iterator callback
- *
- * @this  ReadableAsyncKit#
- * @param {mixed} error - error response
- * @param {mixed} output - iterator output
- * @param {function} callback - callback that expects iterator results
- */
-function streamer(error, output, callback)
-{
-  if (error && !this.error)
-  {
-    this.error = error;
-    this.pause();
-    this.emit('error', error);
-    // send back value only, as expected
-    callback(error, output && output.value);
-    return;
-  }
-
-  // stream stuff
-  this.push(output);
-
-  // back to original track
-  // send back value only, as expected
-  callback(error, output && output.value);
-}
-
-/**
- * Stream wrapper for finishing callback
- *
- * @this  ReadableAsyncKit#
- * @param {mixed} error - error response
- * @param {mixed} output - iterator output
- * @param {function} callback - callback that expects final results
- */
-function finisher(error, output, callback)
-{
-  // signal end of the stream
-  // only for successfully finished streams
-  if (!error)
-  {
-    this.push(null);
-  }
-
-  // back to original track
-  callback(error, output);
-}

-var abort = require('./abort.js')
-  , async = require('./async.js')
-  ;
-
-// API
-module.exports = terminator;
-
-/**
- * Terminates jobs in the attached state context
- *
- * @this  AsyncKitState#
- * @param {function} callback - final callback to invoke after termination
- */
-function terminator(callback)
-{
-  if (!Object.keys(this.jobs).length)
-  {
-    return;
-  }
-
-  // fast forward iteration index
-  this.index = this.size;
-
-  // abort jobs
-  abort(this);
-
-  // send back results we have so far
-  async(callback)(null, this.results);
-}

-{
-  "name": "asynckit",
-  "version": "0.4.0",
-  "description": "Minimal async jobs utility library, with streams support",
-  "main": "index.js",
-  "scripts": {
-    "clean": "rimraf coverage",
-    "lint": "eslint *.js lib/*.js test/*.js",
-    "test": "istanbul cover --reporter=json tape -- 'test/test-*.js' | tap-spec",
-    "win-test": "tape test/test-*.js",
-    "browser": "browserify -t browserify-istanbul test/lib/browserify_adjustment.js test/test-*.js | obake --coverage | tap-spec",
-    "report": "istanbul report",
-    "size": "browserify index.js | size-table asynckit",
-    "debug": "tape test/test-*.js"
-  },
-  "pre-commit": [
-    "clean",
-    "lint",
-    "test",
-    "browser",
-    "report",
-    "size"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/alexindigo/asynckit.git"
-  },
-  "keywords": [
-    "async",
-    "jobs",
-    "parallel",
-    "serial",
-    "iterator",
-    "array",
-    "object",
-    "stream",
-    "destroy",
-    "terminate",
-    "abort"
-  ],
-  "author": "Alex Indigo <iam@alexindigo.com>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/alexindigo/asynckit/issues"
-  },
-  "homepage": "https://github.com/alexindigo/asynckit#readme",
-  "devDependencies": {
-    "browserify": "^13.0.0",
-    "browserify-istanbul": "^2.0.0",
-    "coveralls": "^2.11.9",
-    "eslint": "^2.9.0",
-    "istanbul": "^0.4.3",
-    "obake": "^0.1.2",
-    "phantomjs-prebuilt": "^2.1.7",
-    "pre-commit": "^1.1.3",
-    "reamde": "^1.1.0",
-    "rimraf": "^2.5.2",
-    "size-table": "^0.2.0",
-    "tap-spec": "^4.1.1",
-    "tape": "^4.5.1"
-  },
-  "dependencies": {}
-}

-var iterate    = require('./lib/iterate.js')
-  , initState  = require('./lib/state.js')
-  , terminator = require('./lib/terminator.js')
-  ;
-
-// Public API
-module.exports = parallel;
-
-/**
- * Runs iterator over provided array elements in parallel
- *
- * @param   {array|object} list - array or object (named list) to iterate over
- * @param   {function} iterator - iterator to run
- * @param   {function} callback - invoked when all elements processed
- * @returns {function} - jobs terminator
- */
-function parallel(list, iterator, callback)
-{
-  var state = initState(list);
-
-  while (state.index < (state['keyedList'] || list).length)
-  {
-    iterate(list, iterator, state, function(error, result)
-    {
-      if (error)
-      {
-        callback(error, result);
-        return;
-      }
-
-      // looks like it's the last one
-      if (Object.keys(state.jobs).length === 0)
-      {
-        callback(null, state.results);
-        return;
-      }
-    });
-
-    state.index++;
-  }
-
-  return terminator.bind(state, callback);
-}

-var serialOrdered = require('./serialOrdered.js');
-
-// Public API
-module.exports = serial;
-
-/**
- * Runs iterator over provided array elements in series
- *
- * @param   {array|object} list - array or object (named list) to iterate over
- * @param   {function} iterator - iterator to run
- * @param   {function} callback - invoked when all elements processed
- * @returns {function} - jobs terminator
- */
-function serial(list, iterator, callback)
-{
-  return serialOrdered(list, iterator, null, callback);
-}

-var iterate    = require('./lib/iterate.js')
-  , initState  = require('./lib/state.js')
-  , terminator = require('./lib/terminator.js')
-  ;
-
-// Public API
-module.exports = serialOrdered;
-// sorting helpers
-module.exports.ascending  = ascending;
-module.exports.descending = descending;
-
-/**
- * Runs iterator over provided sorted array elements in series
- *
- * @param   {array|object} list - array or object (named list) to iterate over
- * @param   {function} iterator - iterator to run
- * @param   {function} sortMethod - custom sort function
- * @param   {function} callback - invoked when all elements processed
- * @returns {function} - jobs terminator
- */
-function serialOrdered(list, iterator, sortMethod, callback)
-{
-  var state = initState(list, sortMethod);
-
-  iterate(list, iterator, state, function iteratorHandler(error, result)
-  {
-    if (error)
-    {
-      callback(error, result);
-      return;
-    }
-
-    state.index++;
-
-    // are we there yet?
-    if (state.index < (state['keyedList'] || list).length)
-    {
-      iterate(list, iterator, state, iteratorHandler);
-      return;
-    }
-
-    // done here
-    callback(null, state.results);
-  });
-
-  return terminator.bind(state, callback);
-}
-
-/*
- * -- Sort methods
- */
-
-/**
- * sort helper to sort array elements in ascending order
- *
- * @param   {mixed} a - an item to compare
- * @param   {mixed} b - an item to compare
- * @returns {number} - comparison result
- */
-function ascending(a, b)
-{
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-
-/**
- * sort helper to sort array elements in descending order
- *
- * @param   {mixed} a - an item to compare
- * @param   {mixed} b - an item to compare
- * @returns {number} - comparison result
- */
-function descending(a, b)
-{
-  return -1 * ascending(a, b);
-}

-var inherits              = require('util').inherits
-  , Readable              = require('stream').Readable
-  , ReadableAsyncKit      = require('./lib/readable_asynckit.js')
-  , ReadableParallel      = require('./lib/readable_parallel.js')
-  , ReadableSerial        = require('./lib/readable_serial.js')
-  , ReadableSerialOrdered = require('./lib/readable_serial_ordered.js')
-  ;
-
-// API
-module.exports =
-{
-  parallel      : ReadableParallel,
-  serial        : ReadableSerial,
-  serialOrdered : ReadableSerialOrdered, 
-};
-
-inherits(ReadableAsyncKit, Readable);
-
-inherits(ReadableParallel, ReadableAsyncKit);
-inherits(ReadableSerial, ReadableAsyncKit);
-inherits(ReadableSerialOrdered, ReadableAsyncKit);

-
-/*!
- *  Copyright 2010 LearnBoost <dev@learnboost.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Module dependencies.
- */
-
-var crypto = require('crypto')
-  , parse = require('url').parse
-  ;
-
-/**
- * Valid keys.
- */
-
-var keys = 
-  [ 'acl'
-  , 'location'
-  , 'logging'
-  , 'notification'
-  , 'partNumber'
-  , 'policy'
-  , 'requestPayment'
-  , 'torrent'
-  , 'uploadId'
-  , 'uploads'
-  , 'versionId'
-  , 'versioning'
-  , 'versions'
-  , 'website'
-  ]
-
-/**
- * Return an "Authorization" header value with the given `options`
- * in the form of "AWS <key>:<signature>"
- *
- * @param {Object} options
- * @return {String}
- * @api private
- */
-
-function authorization (options) {
-  return 'AWS ' + options.key + ':' + sign(options)
-}
-
-module.exports = authorization
-module.exports.authorization = authorization
-
-/**
- * Simple HMAC-SHA1 Wrapper
- *
- * @param {Object} options
- * @return {String}
- * @api private
- */ 
-
-function hmacSha1 (options) {
-  return crypto.createHmac('sha1', options.secret).update(options.message).digest('base64')
-}
-
-module.exports.hmacSha1 = hmacSha1
-
-/**
- * Create a base64 sha1 HMAC for `options`. 
- * 
- * @param {Object} options
- * @return {String}
- * @api private
- */
-
-function sign (options) {
-  options.message = stringToSign(options)
-  return hmacSha1(options)
-}
-module.exports.sign = sign
-
-/**
- * Create a base64 sha1 HMAC for `options`. 
- *
- * Specifically to be used with S3 presigned URLs
- * 
- * @param {Object} options
- * @return {String}
- * @api private
- */
-
-function signQuery (options) {
-  options.message = queryStringToSign(options)
-  return hmacSha1(options)
-}
-module.exports.signQuery= signQuery
-
-/**
- * Return a string for sign() with the given `options`.
- *
- * Spec:
- * 
- *    <verb>\n
- *    <md5>\n
- *    <content-type>\n
- *    <date>\n
- *    [headers\n]
- *    <resource>
- *
- * @param {Object} options
- * @return {String}
- * @api private
- */
-
-function stringToSign (options) {
-  var headers = options.amazonHeaders || ''
-  if (headers) headers += '\n'
-  var r = 
-    [ options.verb
-    , options.md5
-    , options.contentType
-    , options.date ? options.date.toUTCString() : ''
-    , headers + options.resource
-    ]
-  return r.join('\n')
-}
-module.exports.stringToSign = stringToSign
-
-/**
- * Return a string for sign() with the given `options`, but is meant exclusively
- * for S3 presigned URLs
- *
- * Spec:
- * 
- *    <date>\n
- *    <resource>
- *
- * @param {Object} options
- * @return {String}
- * @api private
- */
-
-function queryStringToSign (options){
-  return 'GET\n\n\n' + options.date + '\n' + options.resource
-}
-module.exports.queryStringToSign = queryStringToSign
-
-/**
- * Perform the following:
- *
- *  - ignore non-amazon headers
- *  - lowercase fields
- *  - sort lexicographically
- *  - trim whitespace between ":"
- *  - join with newline
- *
- * @param {Object} headers
- * @return {String}
- * @api private
- */
-
-function canonicalizeHeaders (headers) {
-  var buf = []
-    , fields = Object.keys(headers)
-    ;
-  for (var i = 0, len = fields.length; i < len; ++i) {
-    var field = fields[i]
-      , val = headers[field]
-      , field = field.toLowerCase()
-      ;
-    if (0 !== field.indexOf('x-amz')) continue
-    buf.push(field + ':' + val)
-  }
-  return buf.sort().join('\n')
-}
-module.exports.canonicalizeHeaders = canonicalizeHeaders
-
-/**
- * Perform the following:
- *
- *  - ignore non sub-resources
- *  - sort lexicographically
- *
- * @param {String} resource
- * @return {String}
- * @api private
- */
-
-function canonicalizeResource (resource) {
-  var url = parse(resource, true)
-    , path = url.pathname
-    , buf = []
-    ;
-
-  Object.keys(url.query).forEach(function(key){
-    if (!~keys.indexOf(key)) return
-    var val = '' == url.query[key] ? '' : '=' + encodeURIComponent(url.query[key])
-    buf.push(key + val)
-  })
-
-  return path + (buf.length ? '?' + buf.sort().join('&') : '')
-}
-module.exports.canonicalizeResource = canonicalizeResource

-{
-  "author": "Mikeal Rogers <mikeal.rogers@gmail.com> (http://www.futurealoof.com)",
-  "name": "aws-sign2",
-  "description": "AWS signing. Originally pulled from LearnBoost/knox, maintained as vendor in request, now a standalone module.",
-  "version": "0.7.0",
-  "repository": {
-    "url": "https://github.com/mikeal/aws-sign"
-  },
-  "license": "Apache-2.0",
-  "main": "index.js",
-  "dependencies": {},
-  "devDependencies": {},
-  "optionalDependencies": {},
-  "engines": {
-    "node": "*"
-  }
-}

-# These are supported funding model platforms
-
-github: mhart

-language: node_js
-node_js:
-  - "0.10"
-  - "0.12"
-  - "4"
-  - "6"
-  - "8"
-  - "10"
-  - "12"

-Copyright 2013 Michael Hart (michael.hart.au@gmail.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

-aws4
-----
-
-[![Build Status](https://api.travis-ci.org/mhart/aws4.png?branch=master)](https://travis-ci.org/github/mhart/aws4)
-
-A small utility to sign vanilla Node.js http(s) request options using Amazon's
-[AWS Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).
-
-If you want to sign and send AWS requests in a modern browser, or an environment like [Cloudflare Workers](https://developers.cloudflare.com/workers/), then check out [aws4fetch](https://github.com/mhart/aws4fetch) – otherwise you can also bundle this library for use [in older browsers](./browser).
-
-The only AWS service that *doesn't* support v4 as of 2020-05-22 is
-[SimpleDB](https://docs.aws.amazon.com/AmazonSimpleDB/latest/DeveloperGuide/SDB_API.html)
-(it only supports [AWS Signature Version 2](https://github.com/mhart/aws2)).
-
-It also provides defaults for a number of core AWS headers and
-request parameters, making it very easy to query AWS services, or
-build out a fully-featured AWS library.
-
-Example
--------
-
-```javascript
-var https = require('https')
-var aws4  = require('aws4')
-
-// to illustrate usage, we'll create a utility function to request and pipe to stdout
-function request(opts) { https.request(opts, function(res) { res.pipe(process.stdout) }).end(opts.body || '') }
-
-// aws4 will sign an options object as you'd pass to http.request, with an AWS service and region
-var opts = { host: 'my-bucket.s3.us-west-1.amazonaws.com', path: '/my-object', service: 's3', region: 'us-west-1' }
-
-// aws4.sign() will sign and modify these options, ready to pass to http.request
-aws4.sign(opts, { accessKeyId: '', secretAccessKey: '' })
-
-// or it can get credentials from process.env.AWS_ACCESS_KEY_ID, etc
-aws4.sign(opts)
-
-// for most AWS services, aws4 can figure out the service and region if you pass a host
-opts = { host: 'my-bucket.s3.us-west-1.amazonaws.com', path: '/my-object' }
-
-// usually it will add/modify request headers, but you can also sign the query:
-opts = { host: 'my-bucket.s3.amazonaws.com', path: '/?X-Amz-Expires=12345', signQuery: true }
-
-// and for services with simple hosts, aws4 can infer the host from service and region:
-opts = { service: 'sqs', region: 'us-east-1', path: '/?Action=ListQueues' }
-
-// and if you're using us-east-1, it's the default:
-opts = { service: 'sqs', path: '/?Action=ListQueues' }
-
-aws4.sign(opts)
-console.log(opts)
-/*
-{
-  host: 'sqs.us-east-1.amazonaws.com',
-  path: '/?Action=ListQueues',
-  headers: {
-    Host: 'sqs.us-east-1.amazonaws.com',
-    'X-Amz-Date': '20121226T061030Z',
-    Authorization: 'AWS4-HMAC-SHA256 Credential=ABCDEF/20121226/us-east-1/sqs/aws4_request, ...'
-  }
-}
-*/
-
-// we can now use this to query AWS
-request(opts)
-/*
-<?xml version="1.0"?>
-<ListQueuesResponse xmlns="https://queue.amazonaws.com/doc/2012-11-05/">
-...
-*/
-
-// aws4 can infer the HTTP method if a body is passed in
-// method will be POST and Content-Type: 'application/x-www-form-urlencoded; charset=utf-8'
-request(aws4.sign({ service: 'iam', body: 'Action=ListGroups&Version=2010-05-08' }))
-/*
-<ListGroupsResponse xmlns="https://iam.amazonaws.com/doc/2010-05-08/">
-...
-*/
-
-// you can specify any custom option or header as per usual
-request(aws4.sign({
-  service: 'dynamodb',
-  region: 'ap-southeast-2',
-  method: 'POST',
-  path: '/',
-  headers: {
-    'Content-Type': 'application/x-amz-json-1.0',
-    'X-Amz-Target': 'DynamoDB_20120810.ListTables'
-  },
-  body: '{}'
-}))
-/*
-{"TableNames":[]}
-...
-*/
-
-// The raw RequestSigner can be used to generate CodeCommit Git passwords
-var signer = new aws4.RequestSigner({
-  service: 'codecommit',
-  host: 'git-codecommit.us-east-1.amazonaws.com',
-  method: 'GIT',
-  path: '/v1/repos/MyAwesomeRepo',
-})
-var password = signer.getDateTime() + 'Z' + signer.signature()
-
-// see example.js for examples with other services
-```
-
-API
----
-
-### aws4.sign(requestOptions, [credentials])
-
-Calculates and populates any necessary AWS headers and/or request
-options on `requestOptions`. Returns `requestOptions` as a convenience for chaining.
-
-`requestOptions` is an object holding the same options that the Node.js
-[http.request](https://nodejs.org/docs/latest/api/http.html#http_http_request_options_callback)
-function takes.
-
-The following properties of `requestOptions` are used in the signing or
-populated if they don't already exist:
-
-- `hostname` or `host` (will try to be determined from `service` and `region` if not given)
-- `method` (will use `'GET'` if not given or `'POST'` if there is a `body`)
-- `path` (will use `'/'` if not given)
-- `body` (will use `''` if not given)
-- `service` (will try to be calculated from `hostname` or `host` if not given)
-- `region` (will try to be calculated from `hostname` or `host` or use `'us-east-1'` if not given)
-- `signQuery` (to sign the query instead of adding an `Authorization` header, defaults to false)
-- `headers['Host']` (will use `hostname` or `host` or be calculated if not given)
-- `headers['Content-Type']` (will use `'application/x-www-form-urlencoded; charset=utf-8'`
-  if not given and there is a `body`)
-- `headers['Date']` (used to calculate the signature date if given, otherwise `new Date` is used)
-
-Your AWS credentials (which can be found in your
-[AWS console](https://portal.aws.amazon.com/gp/aws/securityCredentials))
-can be specified in one of two ways:
-
-- As the second argument, like this:
-
-```javascript
-aws4.sign(requestOptions, {
-  secretAccessKey: "<your-secret-access-key>",
-  accessKeyId: "<your-access-key-id>",
-  sessionToken: "<your-session-token>"
-})
-```
-
-- From `process.env`, such as this:
-
-```
-export AWS_ACCESS_KEY_ID="<your-access-key-id>"
-export AWS_SECRET_ACCESS_KEY="<your-secret-access-key>"
-export AWS_SESSION_TOKEN="<your-session-token>"
-```
-
-(will also use `AWS_ACCESS_KEY` and `AWS_SECRET_KEY` if available)
-
-The `sessionToken` property and `AWS_SESSION_TOKEN` environment variable are optional for signing
-with [IAM STS temporary credentials](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html).
-
-Installation
-------------
-
-With [npm](https://www.npmjs.com/) do:
-
-```
-npm install aws4
-```
-
-Can also be used [in the browser](./browser).
-
-Thanks
-------
-
-Thanks to [@jed](https://github.com/jed) for his
-[dynamo-client](https://github.com/jed/dynamo-client) lib where I first
-committed and subsequently extracted this code.
-
-Also thanks to the
-[official Node.js AWS SDK](https://github.com/aws/aws-sdk-js) for giving
-me a start on implementing the v4 signature.

-module.exports = function(size) {
-  return new LruCache(size)
-}
-
-function LruCache(size) {
-  this.capacity = size | 0
-  this.map = Object.create(null)
-  this.list = new DoublyLinkedList()
-}
-
-LruCache.prototype.get = function(key) {
-  var node = this.map[key]
-  if (node == null) return undefined
-  this.used(node)
-  return node.val
-}
-
-LruCache.prototype.set = function(key, val) {
-  var node = this.map[key]
-  if (node != null) {
-    node.val = val
-  } else {
-    if (!this.capacity) this.prune()
-    if (!this.capacity) return false
-    node = new DoublyLinkedNode(key, val)
-    this.map[key] = node
-    this.capacity--
-  }
-  this.used(node)
-  return true
-}
-
-LruCache.prototype.used = function(node) {
-  this.list.moveToFront(node)
-}
-
-LruCache.prototype.prune = function() {
-  var node = this.list.pop()
-  if (node != null) {
-    delete this.map[node.key]
-    this.capacity++
-  }
-}
-
-
-function DoublyLinkedList() {
-  this.firstNode = null
-  this.lastNode = null
-}
-
-DoublyLinkedList.prototype.moveToFront = function(node) {
-  if (this.firstNode == node) return
-
-  this.remove(node)
-
-  if (this.firstNode == null) {
-    this.firstNode = node
-    this.lastNode = node
-    node.prev = null
-    node.next = null
-  } else {
-    node.prev = null
-    node.next = this.firstNode
-    node.next.prev = node
-    this.firstNode = node
-  }
-}
-
-DoublyLinkedList.prototype.pop = function() {
-  var lastNode = this.lastNode
-  if (lastNode != null) {
-    this.remove(lastNode)
-  }
-  return lastNode
-}
-
-DoublyLinkedList.prototype.remove = function(node) {
-  if (this.firstNode == node) {
-    this.firstNode = node.next
-  } else if (node.prev != null) {
-    node.prev.next = node.next
-  }
-  if (this.lastNode == node) {
-    this.lastNode = node.prev
-  } else if (node.next != null) {
-    node.next.prev = node.prev
-  }
-}
-
-
-function DoublyLinkedNode(key, val) {
-  this.key = key
-  this.val = val
-  this.prev = null
-  this.next = null
-}

-{
-  "name": "aws4",
-  "version": "1.11.0",
-  "description": "Signs and prepares requests using AWS Signature Version 4",
-  "author": "Michael Hart <michael.hart.au@gmail.com> (https://github.com/mhart)",
-  "license": "MIT",
-  "repository": "github:mhart/aws4",
-  "main": "aws4.js",
-  "scripts": {
-    "test": "mocha ./test/fast.js -R list",
-    "integration": "node ./test/slow.js"
-  },
-  "devDependencies": {
-    "mocha": "^2.5.3",
-    "should": "^8.4.0"
-  }
-}

-tidelift: "npm/balanced-match"
-patreon: juliangruber

-(MIT)
-
-Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

-# balanced-match
-
-Match balanced string pairs, like `{` and `}` or `<b>` and `</b>`. Supports regular expressions as well!
-
-[![build status](https://secure.travis-ci.org/juliangruber/balanced-match.svg)](http://travis-ci.org/juliangruber/balanced-match)
-[![downloads](https://img.shields.io/npm/dm/balanced-match.svg)](https://www.npmjs.org/package/balanced-match)
-
-[![testling badge](https://ci.testling.com/juliangruber/balanced-match.png)](https://ci.testling.com/juliangruber/balanced-match)
-
-## Example
-
-Get the first matching pair of braces:
-
-```js
-var balanced = require('balanced-match');
-
-console.log(balanced('{', '}', 'pre{in{nested}}post'));
-console.log(balanced('{', '}', 'pre{first}between{second}post'));
-console.log(balanced(/\s+\{\s+/, /\s+\}\s+/, 'pre  {   in{nest}   }  post'));
-```
-
-The matches are:
-
-```bash
-$ node example.js
-{ start: 3, end: 14, pre: 'pre', body: 'in{nested}', post: 'post' }
-{ start: 3,
-  end: 9,
-  pre: 'pre',
-  body: 'first',
-  post: 'between{second}post' }
-{ start: 3, end: 17, pre: 'pre', body: 'in{nest}', post: 'post' }
-```
-
-## API
-
-### var m = balanced(a, b, str)
-
-For the first non-nested matching pair of `a` and `b` in `str`, return an
-object with those keys:
-
-* **start** the index of the first match of `a`
-* **end** the index of the matching `b`
-* **pre** the preamble, `a` and `b` not included
-* **body** the match, `a` and `b` not included
-* **post** the postscript, `a` and `b` not included
-
-If there's no match, `undefined` will be returned.
-
-If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `['{', 'a', '']` and `{a}}` will match `['', 'a', '}']`.
-
-### var r = balanced.range(a, b, str)
-
-For the first non-nested matching pair of `a` and `b` in `str`, return an
-array with indexes: `[ <a index>, <b index> ]`.
-
-If there's no match, `undefined` will be returned.
-
-If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `[ 1, 3 ]` and `{a}}` will match `[0, 2]`.
-
-## Installation
-
-With [npm](https://npmjs.org) do:
-
-```bash
-npm install balanced-match
-```
-
-## Security contact information
-
-To report a security vulnerability, please use the
-[Tidelift security contact](https://tidelift.com/security).
-Tidelift will coordinate the fix and disclosure.
-
-## License
-
-(MIT)
-
-Copyright (c) 2013 Julian Gruber &lt;julian@juliangruber.com&gt;
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

-'use strict';
-module.exports = balanced;
-function balanced(a, b, str) {
-  if (a instanceof RegExp) a = maybeMatch(a, str);
-  if (b instanceof RegExp) b = maybeMatch(b, str);
-
-  var r = range(a, b, str);
-
-  return r && {
-    start: r[0],
-    end: r[1],
-    pre: str.slice(0, r[0]),
-    body: str.slice(r[0] + a.length, r[1]),
-    post: str.slice(r[1] + b.length)
-  };
-}
-
-function maybeMatch(reg, str) {
-  var m = str.match(reg);
-  return m ? m[0] : null;
-}
-
-balanced.range = range;
-function range(a, b, str) {
-  var begs, beg, left, right, result;
-  var ai = str.indexOf(a);
-  var bi = str.indexOf(b, ai + 1);
-  var i = ai;
-
-  if (ai >= 0 && bi > 0) {
-    if(a===b) {
-      return [ai, bi];
-    }
-    begs = [];
-    left = str.length;
-
-    while (i >= 0 && !result) {
-      if (i == ai) {
-        begs.push(i);
-        ai = str.indexOf(a, i + 1);
-      } else if (begs.length == 1) {
-        result = [ begs.pop(), bi ];
-      } else {
-        beg = begs.pop();
-        if (beg < left) {
-          left = beg;
-          right = bi;
-        }
-
-        bi = str.indexOf(b, i + 1);
-      }
-
-      i = ai < bi && ai >= 0 ? ai : bi;
-    }
-
-    if (begs.length) {
-      result = [ left, right ];
-    }
-  }
-
-  return result;
-}

-{
-  "name": "balanced-match",
-  "description": "Match balanced character pairs, like \"{\" and \"}\"",
-  "version": "1.0.2",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/juliangruber/balanced-match.git"
-  },
-  "homepage": "https://github.com/juliangruber/balanced-match",
-  "main": "index.js",
-  "scripts": {
-    "test": "tape test/test.js",
-    "bench": "matcha test/bench.js"
-  },
-  "devDependencies": {
-    "matcha": "^0.7.0",
-    "tape": "^4.6.0"
-  },
-  "keywords": [
-    "match",
-    "regexp",
-    "test",
-    "balanced",
-    "parse"
-  ],
-  "author": {
-    "name": "Julian Gruber",
-    "email": "mail@juliangruber.com",
-    "url": "http://juliangruber.com"
-  },
-  "license": "MIT",
-  "testling": {
-    "files": "test/*.js",
-    "browsers": [
-      "ie/8..latest",
-      "firefox/20..latest",
-      "firefox/nightly",
-      "chrome/25..latest",
-      "chrome/canary",
-      "opera/12..latest",
-      "opera/next",
-      "safari/5.1..latest",
-      "ipad/6.0..latest",
-      "iphone/6.0..latest",
-      "android-browser/4.2..latest"
-    ]
-  }
-}

-# Contributing
-
-This repository uses [cr.joyent.us](https://cr.joyent.us) (Gerrit) for new
-changes. Anyone can submit changes. To get started, see the [cr.joyent.us user
-guide](https://github.com/joyent/joyent-gerrit/blob/master/docs/user/README.md).
-This repo does not use GitHub pull requests.
-
-See the [Joyent Engineering
-Guidelines](https://github.com/joyent/eng/blob/master/docs/index.md) for general
-best practices expected in this repository.
-
-If you're changing something non-trivial or user-facing, you may want to submit
-an issue first.

-The Blowfish portions are under the following license:
-
-Blowfish block cipher for OpenBSD
-Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
-All rights reserved.
-
-Implementation advice by David Mazieres <dm@lcs.mit.edu>.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-3. The name of the author may not be used to endorse or promote products
-   derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-
-The bcrypt_pbkdf portions are under the following license:
-
-Copyright (c) 2013 Ted Unangst <tedu@openbsd.org>
-
-Permission to use, copy, modify, and distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-
-
-Performance improvements (Javascript-specific):
-
-Copyright 2016, Joyent Inc
-Author: Alex Wilson <alex.wilson@joyent.com>
-
-Permission to use, copy, modify, and distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

-Port of the OpenBSD `bcrypt_pbkdf` function to pure Javascript. `npm`-ified
-version of [Devi Mandiri's port](https://github.com/devi/tmp/blob/master/js/bcrypt_pbkdf.js),
-with some minor performance improvements. The code is copied verbatim (and
-un-styled) from Devi's work.
-
-This product includes software developed by Niels Provos.
-
-## API
-
-### `bcrypt_pbkdf.pbkdf(pass, passlen, salt, saltlen, key, keylen, rounds)`
-
-Derive a cryptographic key of arbitrary length from a given password and salt,
-using the OpenBSD `bcrypt_pbkdf` function. This is a combination of Blowfish and
-SHA-512.
-
-See [this article](http://www.tedunangst.com/flak/post/bcrypt-pbkdf) for
-further information.
-
-Parameters:
-
- * `pass`, a Uint8Array of length `passlen`
- * `passlen`, an integer Number
- * `salt`, a Uint8Array of length `saltlen`
- * `saltlen`, an integer Number
- * `key`, a Uint8Array of length `keylen`, will be filled with output
- * `keylen`, an integer Number
- * `rounds`, an integer Number, number of rounds of the PBKDF to run
-
-### `bcrypt_pbkdf.hash(sha2pass, sha2salt, out)`
-
-Calculate a Blowfish hash, given SHA2-512 output of a password and salt. Used as
-part of the inner round function in the PBKDF.
-
-Parameters:
-
- * `sha2pass`, a Uint8Array of length 64
- * `sha2salt`, a Uint8Array of length 64
- * `out`, a Uint8Array of length 32, will be filled with output
-
-## License
-
-This source form is a 1:1 port from the OpenBSD `blowfish.c` and `bcrypt_pbkdf.c`.
-As a result, it retains the original copyright and license. The two files are
-under slightly different (but compatible) licenses, and are here combined in
-one file. For each of the full license texts see `LICENSE`.

-(The MIT License)
-
-Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
-Copyright (c) 2014-2015 Douglas Christopher Wilson <doug@somethingdoug.com>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-# Security Policies and Procedures
-
-## Reporting a Bug
-
-The Express team and community take all security bugs seriously. Thank you
-for improving the security of Express. We appreciate your efforts and
-responsible disclosure and will make every effort to acknowledge your
-contributions.
-
-Report security bugs by emailing the current owner(s) of `body-parser`. This
-information can be found in the npm registry using the command
-`npm owner ls body-parser`.
-If unsure or unable to get the information from the above, open an issue
-in the [project issue tracker](https://github.com/expressjs/body-parser/issues)
-asking for the current contact information.
-
-To ensure the timely response to your report, please ensure that the entirety
-of the report is contained within the email body and not solely behind a web
-link or an attachment.
-
-At least one owner will acknowledge your email within 48 hours, and will send a
-more detailed response within 48 hours indicating the next steps in handling
-your report. After the initial reply to your report, the owners will
-endeavor to keep you informed of the progress towards a fix and full
-announcement, and may ask for additional information or guidance.

-/*!
- * body-parser
- * Copyright(c) 2014-2015 Douglas Christopher Wilson
- * MIT Licensed
- */
-
-'use strict'
-
-/**
- * Module dependencies.
- * @private
- */
-
-var deprecate = require('depd')('body-parser')
-
-/**
- * Cache of loaded parsers.
- * @private
- */
-
-var parsers = Object.create(null)
-
-/**
- * @typedef Parsers
- * @type {function}
- * @property {function} json
- * @property {function} raw
- * @property {function} text
- * @property {function} urlencoded
- */
-
-/**
- * Module exports.
- * @type {Parsers}
- */
-
-exports = module.exports = deprecate.function(bodyParser,
-  'bodyParser: use individual json/urlencoded middlewares')
-
-/**
- * JSON parser.
- * @public
- */
-
-Object.defineProperty(exports, 'json', {
-  configurable: true,
-  enumerable: true,
-  get: createParserGetter('json')
-})
-
-/**
- * Raw parser.
- * @public
- */
-
-Object.defineProperty(exports, 'raw', {
-  configurable: true,
-  enumerable: true,
-  get: createParserGetter('raw')
-})
-
-/**
- * Text parser.
- * @public
- */
-
-Object.defineProperty(exports, 'text', {
-  configurable: true,
-  enumerable: true,
-  get: createParserGetter('text')
-})
-
-/**
- * URL-encoded parser.
- * @public
- */
-
-Object.defineProperty(exports, 'urlencoded', {
-  configurable: true,
-  enumerable: true,
-  get: createParserGetter('urlencoded')
-})
-
-/**
- * Create a middleware to parse json and urlencoded bodies.
- *
- * @param {object} [options]
- * @return {function}
- * @deprecated
- * @public
- */
-
-function bodyParser (options) {
-  var opts = {}
-
-  // exclude type option
-  if (options) {
-    for (var prop in options) {
-      if (prop !== 'type') {
-        opts[prop] = options[prop]
-      }
-    }
-  }
-
-  var _urlencoded = exports.urlencoded(opts)
-  var _json = exports.json(opts)
-
-  return function bodyParser (req, res, next) {
-    _json(req, res, function (err) {
-      if (err) return next(err)
-      _urlencoded(req, res, next)
-    })
-  }
-}
-
-/**
- * Create a getter for loading a parser.
- * @private
- */
-
-function createParserGetter (name) {
-  return function get () {
-    return loadParser(name)
-  }
-}
-
-/**
- * Load a parser module.
- * @private
- */
-
-function loadParser (parserName) {
-  var parser = parsers[parserName]
-
-  if (parser !== undefined) {
-    return parser
-  }
-
-  // this uses a switch for static require analysis
-  switch (parserName) {
-    case 'json':
-      parser = require('./lib/types/json')
-      break
-    case 'raw':
-      parser = require('./lib/types/raw')
-      break
-    case 'text':
-      parser = require('./lib/types/text')
-      break
-    case 'urlencoded':
-      parser = require('./lib/types/urlencoded')
-      break
-  }
-
-  // store to prevent invoking require()
-  return (parsers[parserName] = parser)
-}

-/*!
- * body-parser
- * Copyright(c) 2014-2015 Douglas Christopher Wilson
- * MIT Licensed
- */
-
-'use strict'
-
-/**
- * Module dependencies.
- * @private
- */
-
-var createError = require('http-errors')
-var destroy = require('destroy')
-var getBody = require('raw-body')
-var iconv = require('iconv-lite')
-var onFinished = require('on-finished')
-var unpipe = require('unpipe')
-var zlib = require('zlib')
-
-/**
- * Module exports.
- */
-
-module.exports = read
-
-/**
- * Read a request into a buffer and parse.
- *
- * @param {object} req
- * @param {object} res
- * @param {function} next
- * @param {function} parse
- * @param {function} debug
- * @param {object} options
- * @private
- */
-
-function read (req, res, next, parse, debug, options) {
-  var length
-  var opts = options
-  var stream
-
-  // flag as parsed
-  req._body = true
-
-  // read options
-  var encoding = opts.encoding !== null
-    ? opts.encoding
-    : null
-  var verify = opts.verify
-
-  try {
-    // get the content stream
-    stream = contentstream(req, debug, opts.inflate)
-    length = stream.length
-    stream.length = undefined
-  } catch (err) {
-    return next(err)
-  }
-
-  // set raw-body options
-  opts.length = length
-  opts.encoding = verify
-    ? null
-    : encoding
-
-  // assert charset is supported
-  if (opts.encoding === null && encoding !== null && !iconv.encodingExists(encoding)) {
-    return next(createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
-      charset: encoding.toLowerCase(),
-      type: 'charset.unsupported'
-    }))
-  }
-
-  // read body
-  debug('read body')
-  getBody(stream, opts, function (error, body) {
-    if (error) {
-      var _error
-
-      if (error.type === 'encoding.unsupported') {
-        // echo back charset
-        _error = createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
-          charset: encoding.toLowerCase(),
-          type: 'charset.unsupported'
-        })
-      } else {
-        // set status code on error
-        _error = createError(400, error)
-      }
-
-      // unpipe from stream and destroy
-      if (stream !== req) {
-        unpipe(req)
-        destroy(stream, true)
-      }
-
-      // read off entire request
-      dump(req, function onfinished () {
-        next(createError(400, _error))
-      })
-      return
-    }
-
-    // verify
-    if (verify) {
-      try {
-        debug('verify body')
-        verify(req, res, body, encoding)
-      } catch (err) {
-        next(createError(403, err, {
-          body: body,
-          type: err.type || 'entity.verify.failed'
-        }))
-        return
-      }
-    }
-
-    // parse
-    var str = body
-    try {
-      debug('parse body')
-      str = typeof body !== 'string' && encoding !== null
-        ? iconv.decode(body, encoding)
-        : body
-      req.body = parse(str)
-    } catch (err) {
-      next(createError(400, err, {
-        body: str,
-        type: err.type || 'entity.parse.failed'
-      }))
-      return
-    }
-
-    next()
-  })
-}
-
-/**
- * Get the content stream of the request.
- *
- * @param {object} req
- * @param {function} debug
- * @param {boolean} [inflate=true]
- * @return {object}
- * @api private
- */
-
-function contentstream (req, debug, inflate) {
-  var encoding = (req.headers['content-encoding'] || 'identity').toLowerCase()
-  var length = req.headers['content-length']
-  var stream
-
-  debug('content-encoding "%s"', encoding)
-
-  if (inflate === false && encoding !== 'identity') {
-    throw createError(415, 'content encoding unsupported', {
-      encoding: encoding,
-      type: 'encoding.unsupported'
-    })
-  }
-
-  switch (encoding) {
-    case 'deflate':
-      stream = zlib.createInflate()
-      debug('inflate body')
-      req.pipe(stream)
-      break
-    case 'gzip':
-      stream = zlib.createGunzip()
-      debug('gunzip body')
-      req.pipe(stream)
-      break
-    case 'identity':
-      stream = req
-      stream.length = length
-      break
-    default:
-      throw createError(415, 'unsupported content encoding "' + encoding + '"', {
-        encoding: encoding,
-        type: 'encoding.unsupported'
-      })
-  }
-
-  return stream
-}
-
-/**
- * Dump the contents of a request.
- *
- * @param {object} req
- * @param {function} callback
- * @api private
- */
-
-function dump (req, callback) {
-  if (onFinished.isFinished(req)) {
-    callback(null)
-  } else {
-    onFinished(req, callback)
-    req.resume()
-  }
-}

-/*!
- * body-parser
- * Copyright(c) 2014 Jonathan Ong
- * Copyright(c) 2014-2015 Douglas Christopher Wilson
- * MIT Licensed
- */
-
-'use strict'
-
-/**
- * Module dependencies.
- * @private
- */
-
-var bytes = require('bytes')
-var contentType = require('content-type')
-var createError = require('http-errors')
-var debug = require('debug')('body-parser:json')
-var read = require('../read')
-var typeis = require('type-is')
-
-/**
- * Module exports.
- */
-
-module.exports = json
-
-/**
- * RegExp to match the first non-space in a string.
- *
- * Allowed whitespace is defined in RFC 7159:
- *
- *    ws = *(
- *            %x20 /              ; Space
- *            %x09 /              ; Horizontal tab
- *            %x0A /              ; Line feed or New line
- *            %x0D )              ; Carriage return
- */
-
-var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d])/ // eslint-disable-line no-control-regex
-
-/**
- * Create a middleware to parse JSON bodies.
- *
- * @param {object} [options]
- * @return {function}
- * @public
- */
-
-function json (options) {
-  var opts = options || {}
-
-  var limit = typeof opts.limit !== 'number'
-    ? bytes.parse(opts.limit || '100kb')
-    : opts.limit
-  var inflate = opts.inflate !== false
-  var reviver = opts.reviver
-  var strict = opts.strict !== false
-  var type = opts.type || 'application/json'
-  var verify = opts.verify || false
-
-  if (verify !== false && typeof verify !== 'function') {
-    throw new TypeError('option verify must be function')
-  }
-
-  // create the appropriate type checking function
-  var shouldParse = typeof type !== 'function'
-    ? typeChecker(type)
-    : type
-
-  function parse (body) {
-    if (body.length === 0) {
-      // special-case empty json body, as it's a common client-side mistake
-      // TODO: maybe make this configurable or part of "strict" option
-      return {}
-    }
-
-    if (strict) {
-      var first = firstchar(body)
-
-      if (first !== '{' && first !== '[') {
-        debug('strict violation')
-        throw createStrictSyntaxError(body, first)
-      }
-    }
-
-    try {
-      debug('parse json')
-      return JSON.parse(body, reviver)
-    } catch (e) {
-      throw normalizeJsonSyntaxError(e, {
-        message: e.message,
-        stack: e.stack
-      })
-    }
-  }
-
-  return function jsonParser (req, res, next) {
-    if (req._body) {
-      debug('body already parsed')
-      next()
-      return
-    }
-
-    req.body = req.body || {}
-
-    // skip requests without bodies
-    if (!typeis.hasBody(req)) {
-      debug('skip empty body')
-      next()
-      return
-    }
-
-    debug('content-type %j', req.headers['content-type'])
-
-    // determine if request should be parsed
-    if (!shouldParse(req)) {
-      debug('skip parsing')
-      next()
-      return
-    }
-
-    // assert charset per RFC 7159 sec 8.1
-    var charset = getCharset(req) || 'utf-8'
-    if (charset.slice(0, 4) !== 'utf-') {
-      debug('invalid charset')
-      next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', {
-        charset: charset,
-        type: 'charset.unsupported'
-      }))
-      return
-    }
-
-    // read
-    read(req, res, next, parse, debug, {
-      encoding: charset,
-      inflate: inflate,
-      limit: limit,
-      verify: verify
-    })
-  }
-}
-
-/**
- * Create strict violation syntax error matching native error.
- *
- * @param {string} str
- * @param {string} char
- * @return {Error}
- * @private
- */
-
-function createStrictSyntaxError (str, char) {
-  var index = str.indexOf(char)
-  var partial = index !== -1
-    ? str.substring(0, index) + '#'
-    : ''
-
-  try {
-    JSON.parse(partial); /* istanbul ignore next */ throw new SyntaxError('strict violation')
-  } catch (e) {
-    return normalizeJsonSyntaxError(e, {
-      message: e.message.replace('#', char),
-      stack: e.stack
-    })
-  }
-}
-
-/**
- * Get the first non-whitespace character in a string.
- *
- * @param {string} str
- * @return {function}
- * @private
- */
-
-function firstchar (str) {
-  var match = FIRST_CHAR_REGEXP.exec(str)
-
-  return match
-    ? match[1]
-    : undefined
-}
-
-/**
- * Get the charset of a request.
- *
- * @param {object} req
- * @api private
- */
-
-function getCharset (req) {
-  try {
-    return (contentType.parse(req).parameters.charset || '').toLowerCase()
-  } catch (e) {
-    return undefined
-  }
-}
-
-/**
- * Normalize a SyntaxError for JSON.parse.
- *
- * @param {SyntaxError} error
- * @param {object} obj
- * @return {SyntaxError}
- */
-
-function normalizeJsonSyntaxError (error, obj) {
-  var keys = Object.getOwnPropertyNames(error)
-
-  for (var i = 0; i < keys.length; i++) {
-    var key = keys[i]
-    if (key !== 'stack' && key !== 'message') {
-      delete error[key]
-    }
-  }
-
-  // replace stack before message for Node.js 0.10 and below
-  error.stack = obj.stack.replace(error.message, obj.message)
-  error.message = obj.message
-
-  return error
-}
-
-/**
- * Get the simple type checker.
- *
- * @param {string} type
- * @return {function}
- */
-
-function typeChecker (type) {
-  return function checkType (req) {
-    return Boolean(typeis(req, type))
-  }
-}