From 23b4d6fd80c9df4b29ec7f8d9bb0aea789acf5cc Mon Sep 17 00:00:00 2001
From: Graeme Yeates <yeatesgraeme@gmail.com>
Date: Sun, 19 Jul 2015 22:11:12 -0400
Subject: update minified build

---
 dist/async.js      | 1216 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 dist/async.min.map |    1 +
 2 files changed, 1217 insertions(+)
 create mode 100644 dist/async.js
 create mode 100644 dist/async.min.map

(limited to 'dist')

diff --git a/dist/async.js b/dist/async.js
new file mode 100644
index 0000000..f3cfb80
--- /dev/null
+++ b/dist/async.js
@@ -0,0 +1,1216 @@
+/*!
+ * async
+ * https://github.com/caolan/async
+ *
+ * Copyright 2010-2014 Caolan McMahon
+ * Released under the MIT license
+ */
+(function () {
+
+    var async = {};
+    function noop() {}
+    function identity(v) {
+        return v;
+    }
+    function toBool(v) {
+        return !!v;
+    }
+    function notId(v) {
+        return !v;
+    }
+
+    // global on the server, window in the browser
+    var previous_async;
+
+    // Establish the root object, `window` (`self`) in the browser, `global`
+    // on the server, or `this` in some virtual machines. We use `self`
+    // instead of `window` for `WebWorker` support.
+    var root = typeof self === 'object' && self.self === self && self ||
+            typeof global === 'object' && global.global === global && global ||
+            this;
+
+    if (root != null) {
+        previous_async = root.async;
+    }
+
+    async.noConflict = function () {
+        root.async = previous_async;
+        return async;
+    };
+
+    function only_once(fn) {
+        return function() {
+            if (fn === null) throw new Error("Callback was already called.");
+            fn.apply(this, arguments);
+            fn = null;
+        };
+    }
+
+    function _once(fn) {
+        return function() {
+            if (fn === null) return;
+            fn.apply(this, arguments);
+            fn = null;
+        };
+    }
+
+    //// cross-browser compatiblity functions ////
+
+    var _toString = Object.prototype.toString;
+
+    var _isArray = Array.isArray || function (obj) {
+        return _toString.call(obj) === '[object Array]';
+    };
+
+    function _isArrayLike(arr) {
+        return _isArray(arr) || (
+            // has a positive integer length property
+            typeof arr.length === "number" &&
+            arr.length >= 0 &&
+            arr.length % 1 === 0
+        );
+    }
+
+    function _each(coll, iterator) {
+        return _isArrayLike(coll) ?
+            _arrayEach(coll, iterator) :
+            _forEachOf(coll, iterator);
+    }
+
+    function _arrayEach(arr, iterator) {
+        var index = -1,
+            length = arr.length;
+
+        while (++index < length) {
+            iterator(arr[index], index, arr);
+        }
+    }
+
+    function _map(arr, iterator) {
+        var index = -1,
+            length = arr.length,
+            result = Array(length);
+
+        while (++index < length) {
+            result[index] = iterator(arr[index], index, arr);
+        }
+        return result;
+    }
+
+    function _range(count) {
+        return _map(Array(count), function (v, i) { return i; });
+    }
+
+    function _reduce(arr, iterator, memo) {
+        _arrayEach(arr, function (x, i, a) {
+            memo = iterator(memo, x, i, a);
+        });
+        return memo;
+    }
+
+    function _forEachOf(object, iterator) {
+        _arrayEach(_keys(object), function (key) {
+            iterator(object[key], key);
+        });
+    }
+
+    function _indexOf(arr, item) {
+        for (var i = 0; i < arr.length; i++) {
+            if (arr[i] === item) return i;
+        }
+        return -1;
+    }
+
+    var _keys = Object.keys || function (obj) {
+        var keys = [];
+        for (var k in obj) {
+            if (obj.hasOwnProperty(k)) {
+                keys.push(k);
+            }
+        }
+        return keys;
+    };
+
+    function _keyIterator(coll) {
+        var i = -1;
+        var len;
+        var keys;
+        if (_isArrayLike(coll)) {
+            len = coll.length;
+            return function next() {
+                i++;
+                return i < len ? i : null;
+            };
+        } else {
+            keys = _keys(coll);
+            len = keys.length;
+            return function next() {
+                i++;
+                return i < len ? keys[i] : null;
+            };
+        }
+    }
+
+    // Similar to ES6's rest param (http://ariya.ofilabs.com/2013/03/es6-and-rest-parameter.html)
+    // This accumulates the arguments passed into an array, after a given index.
+    // From underscore.js (https://github.com/jashkenas/underscore/pull/2140).
+    function _restParam(func, startIndex) {
+        startIndex = startIndex == null ? func.length - 1 : +startIndex;
+        return function() {
+            var length = Math.max(arguments.length - startIndex, 0);
+            var rest = Array(length);
+            for (var index = 0; index < length; index++) {
+                rest[index] = arguments[index + startIndex];
+            }
+            switch (startIndex) {
+                case 0: return func.call(this, rest);
+                case 1: return func.call(this, arguments[0], rest);
+                case 2: return func.call(this, arguments[0], arguments[1], rest);
+            }
+            // Currently unused but handle cases outside of the switch statement:
+            // var args = Array(startIndex + 1);
+            // for (index = 0; index < startIndex; index++) {
+            //     args[index] = arguments[index];
+            // }
+            // args[startIndex] = rest;
+            // return func.apply(this, args);
+        };
+    }
+
+    function _withoutIndex(iterator) {
+        return function (value, index, callback) {
+            return iterator(value, callback);
+        };
+    }
+
+    //// exported async module functions ////
+
+    //// nextTick implementation with browser-compatible fallback ////
+
+    // capture the global reference to guard against fakeTimer mocks
+    var _setImmediate = typeof setImmediate === 'function' && setImmediate;
+
+    var _delay = _setImmediate ? function(fn) {
+        // not a direct alias for IE10 compatibility
+        _setImmediate(fn);
+    } : function(fn) {
+        setTimeout(fn, 0);
+    };
+
+    if (typeof process === 'object' && typeof process.nextTick === 'function') {
+        async.nextTick = process.nextTick;
+    } else {
+        async.nextTick = _delay;
+    }
+    async.setImmediate = _setImmediate ? _delay : async.nextTick;
+
+
+    async.forEach =
+    async.each = function (arr, iterator, callback) {
+        return async.eachOf(arr, _withoutIndex(iterator), callback);
+    };
+
+    async.forEachSeries =
+    async.eachSeries = function (arr, iterator, callback) {
+        return async.eachOfSeries(arr, _withoutIndex(iterator), callback);
+    };
+
+
+    async.forEachLimit =
+    async.eachLimit = function (arr, limit, iterator, callback) {
+        return _eachOfLimit(limit)(arr, _withoutIndex(iterator), callback);
+    };
+
+    async.forEachOf =
+    async.eachOf = function (object, iterator, callback) {
+        callback = _once(callback || noop);
+        object = object || [];
+        var size = _isArrayLike(object) ? object.length : _keys(object).length;
+        var completed = 0;
+        if (!size) {
+            return callback(null);
+        }
+        _each(object, function (value, key) {
+            iterator(object[key], key, only_once(done));
+        });
+        function done(err) {
+            if (err) {
+                callback(err);
+            }
+            else {
+                completed += 1;
+                if (completed >= size) {
+                    callback(null);
+                }
+            }
+        }
+    };
+
+    async.forEachOfSeries =
+    async.eachOfSeries = function (obj, iterator, callback) {
+        callback = _once(callback || noop);
+        obj = obj || [];
+        var nextKey = _keyIterator(obj);
+        var key = nextKey();
+        function iterate() {
+            var sync = true;
+            if (key === null) {
+                return callback(null);
+            }
+            iterator(obj[key], key, only_once(function (err) {
+                if (err) {
+                    callback(err);
+                }
+                else {
+                    key = nextKey();
+                    if (key === null) {
+                        return callback(null);
+                    } else {
+                        if (sync) {
+                            async.nextTick(iterate);
+                        } else {
+                            iterate();
+                        }
+                    }
+                }
+            }));
+            sync = false;
+        }
+        iterate();
+    };
+
+
+
+    async.forEachOfLimit =
+    async.eachOfLimit = function (obj, limit, iterator, callback) {
+        _eachOfLimit(limit)(obj, iterator, callback);
+    };
+
+    function _eachOfLimit(limit) {
+
+        return function (obj, iterator, callback) {
+            callback = _once(callback || noop);
+            obj = obj || [];
+            var nextKey = _keyIterator(obj);
+            if (limit <= 0) {
+                return callback(null);
+            }
+            var done = false;
+            var running = 0;
+            var errored = false;
+
+            (function replenish () {
+                if (done && running <= 0) {
+                    return callback(null);
+                }
+
+                while (running < limit && !errored) {
+                    var key = nextKey();
+                    if (key === null) {
+                        done = true;
+                        if (running <= 0) {
+                            callback(null);
+                        }
+                        return;
+                    }
+                    running += 1;
+                    iterator(obj[key], key, only_once(function (err) {
+                        running -= 1;
+                        if (err) {
+                            callback(err);
+                            errored = true;
+                        }
+                        else {
+                            replenish();
+                        }
+                    }));
+                }
+            })();
+        };
+    }
+
+
+    function doParallel(fn) {
+        return function (obj, iterator, callback) {
+            return fn(async.eachOf, obj, iterator, callback);
+        };
+    }
+    function doParallelLimit(fn) {
+        return function (obj, limit, iterator, callback) {
+            return fn(_eachOfLimit(limit), obj, iterator, callback);
+        };
+    }
+    function doSeries(fn) {
+        return function (obj, iterator, callback) {
+            return fn(async.eachOfSeries, obj, iterator, callback);
+        };
+    }
+
+    function _asyncMap(eachfn, arr, iterator, callback) {
+        callback = _once(callback || noop);
+        var results = [];
+        eachfn(arr, function (value, index, callback) {
+            iterator(value, function (err, v) {
+                results[index] = v;
+                callback(err);
+            });
+        }, function (err) {
+            callback(err, results);
+        });
+    }
+
+    async.map = doParallel(_asyncMap);
+    async.mapSeries = doSeries(_asyncMap);
+    async.mapLimit = doParallelLimit(_asyncMap);
+
+    // reduce only has a series version, as doing reduce in parallel won't
+    // work in many situations.
+    async.inject =
+    async.foldl =
+    async.reduce = function (arr, memo, iterator, callback) {
+        async.eachOfSeries(arr, function (x, i, callback) {
+            iterator(memo, x, function (err, v) {
+                memo = v;
+                callback(err);
+            });
+        }, function (err) {
+            callback(err || null, memo);
+        });
+    };
+
+    async.foldr =
+    async.reduceRight = function (arr, memo, iterator, callback) {
+        var reversed = _map(arr, identity).reverse();
+        async.reduce(reversed, memo, iterator, callback);
+    };
+
+    function _filter(eachfn, arr, iterator, callback) {
+        var results = [];
+        eachfn(arr, function (x, index, callback) {
+            iterator(x, function (v) {
+                if (v) {
+                    results.push({index: index, value: x});
+                }
+                callback();
+            });
+        }, function () {
+            callback(_map(results.sort(function (a, b) {
+                return a.index - b.index;
+            }), function (x) {
+                return x.value;
+            }));
+        });
+    }
+
+    async.select =
+    async.filter = doParallel(_filter);
+
+    async.selectLimit =
+    async.filterLimit = doParallelLimit(_filter);
+
+    async.selectSeries =
+    async.filterSeries = doSeries(_filter);
+
+    function _reject(eachfn, arr, iterator, callback) {
+        _filter(eachfn, arr, function(value, cb) {
+            iterator(value, function(v) {
+                cb(!v);
+            });
+        }, callback);
+    }
+    async.reject = doParallel(_reject);
+    async.rejectLimit = doParallelLimit(_reject);
+    async.rejectSeries = doSeries(_reject);
+
+    function _createTester(eachfn, check, getResult) {
+        return function(arr, limit, iterator, cb) {
+            function done() {
+                if (cb) cb(getResult(false, void 0));
+            }
+            function iteratee(x, _, callback) {
+                if (!cb) return callback();
+                iterator(x, function (v) {
+                    if (cb && check(v)) {
+                        cb(getResult(true, x));
+                        cb = iterator = false;
+                    }
+                    callback();
+                });
+            }
+            if (arguments.length > 3) {
+                eachfn(arr, limit, iteratee, done);
+            } else {
+                cb = iterator;
+                iterator = limit;
+                eachfn(arr, iteratee, done);
+            }
+        };
+    }
+
+    async.any =
+    async.some = _createTester(async.eachOf, toBool, identity);
+
+    async.someLimit = _createTester(async.eachOfLimit, toBool, identity);
+
+    async.all =
+    async.every = _createTester(async.eachOf, notId, notId);
+
+    async.everyLimit = _createTester(async.eachOfLimit, notId, notId);
+
+    function _findGetResult(v, x) {
+        return x;
+    }
+    async.detect = _createTester(async.eachOf, identity, _findGetResult);
+    async.detectSeries = _createTester(async.eachOfSeries, identity, _findGetResult);
+
+    async.sortBy = function (arr, iterator, callback) {
+        async.map(arr, function (x, callback) {
+            iterator(x, function (err, criteria) {
+                if (err) {
+                    callback(err);
+                }
+                else {
+                    callback(null, {value: x, criteria: criteria});
+                }
+            });
+        }, function (err, results) {
+            if (err) {
+                return callback(err);
+            }
+            else {
+                callback(null, _map(results.sort(comparator), function (x) {
+                    return x.value;
+                }));
+            }
+
+        });
+
+        function comparator(left, right) {
+            var a = left.criteria, b = right.criteria;
+            return a < b ? -1 : a > b ? 1 : 0;
+        }
+    };
+
+    async.auto = function (tasks, callback) {
+        callback = _once(callback || noop);
+        var keys = _keys(tasks);
+        var remainingTasks = keys.length;
+        if (!remainingTasks) {
+            return callback(null);
+        }
+
+        var results = {};
+
+        var listeners = [];
+        function addListener(fn) {
+            listeners.unshift(fn);
+        }
+        function removeListener(fn) {
+            var idx = _indexOf(listeners, fn);
+            if (idx >= 0) listeners.splice(idx, 1);
+        }
+        function taskComplete() {
+            remainingTasks--;
+            _arrayEach(listeners.slice(0), function (fn) {
+                fn();
+            });
+        }
+
+        addListener(function () {
+            if (!remainingTasks) {
+                callback(null, results);
+            }
+        });
+
+        _arrayEach(keys, function (k) {
+            var task = _isArray(tasks[k]) ? tasks[k]: [tasks[k]];
+            var taskCallback = _restParam(function(err, args) {
+                if (args.length <= 1) {
+                    args = args[0];
+                }
+                if (err) {
+                    var safeResults = {};
+                    _forEachOf(results, function(val, rkey) {
+                        safeResults[rkey] = val;
+                    });
+                    safeResults[k] = args;
+                    callback(err, safeResults);
+                }
+                else {
+                    results[k] = args;
+                    async.setImmediate(taskComplete);
+                }
+            });
+            var requires = task.slice(0, task.length - 1);
+            // prevent dead-locks
+            var len = requires.length;
+            var dep;
+            while (len--) {
+                if (!(dep = tasks[requires[len]])) {
+                    throw new Error('Has inexistant dependency');
+                }
+                if (_isArray(dep) && _indexOf(dep, k) >= 0) {
+                    throw new Error('Has cyclic dependencies');
+                }
+            }
+            function ready() {
+                return _reduce(requires, function (a, x) {
+                    return (a && results.hasOwnProperty(x));
+                }, true) && !results.hasOwnProperty(k);
+            }
+            if (ready()) {
+                task[task.length - 1](taskCallback, results);
+            }
+            else {
+                addListener(listener);
+            }
+            function listener() {
+                if (ready()) {
+                    removeListener(listener);
+                    task[task.length - 1](taskCallback, results);
+                }
+            }
+        });
+    };
+
+
+
+    async.retry = function(times, task, callback) {
+        var DEFAULT_TIMES = 5;
+        var DEFAULT_INTERVAL = 0;
+
+        var attempts = [];
+
+        var opts = {
+            times: DEFAULT_TIMES,
+            interval: DEFAULT_INTERVAL
+        };
+
+        function parseTimes(acc, t){
+            if(typeof t === 'number'){
+                acc.times = parseInt(t, 10) || DEFAULT_TIMES;
+            } else if(typeof t === 'object'){
+                acc.times = parseInt(t.times, 10) || DEFAULT_TIMES;
+                acc.interval = parseInt(t.interval, 10) || DEFAULT_INTERVAL;
+            } else {
+                throw new Error('Unsupported argument type for \'times\': ' + typeof(t));
+            }
+        }
+
+        var length = arguments.length;
+        if (length < 1 || length > 3) {
+            throw new Error('Invalid arguments - must be either (task), (task, callback), (times, task) or (times, task, callback)');
+        } else if (length <= 2 && typeof times === 'function') {
+            callback = task;
+            task = times;
+        }
+        if (typeof times !== 'function') {
+            parseTimes(opts, times);
+        }
+        opts.callback = callback;
+        opts.task = task;
+
+        function wrappedTask(wrappedCallback, wrappedResults) {
+            function retryAttempt(task, finalAttempt) {
+                return function(seriesCallback) {
+                    task(function(err, result){
+                        seriesCallback(!err || finalAttempt, {err: err, result: result});
+                    }, wrappedResults);
+                };
+            }
+
+            function retryInterval(interval){
+                return function(seriesCallback){
+                    setTimeout(function(){
+                        seriesCallback(null);
+                    }, interval);
+                };
+            }
+
+            while (opts.times) {
+
+                var finalAttempt = !(opts.times-=1);
+                attempts.push(retryAttempt(opts.task, finalAttempt));
+                if(!finalAttempt && opts.interval > 0){
+                    attempts.push(retryInterval(opts.interval));
+                }
+            }
+
+            async.series(attempts, function(done, data){
+                data = data[data.length - 1];
+                (wrappedCallback || opts.callback)(data.err, data.result);
+            });
+        }
+
+        // If a callback is passed, run this as a controll flow
+        return opts.callback ? wrappedTask() : wrappedTask;
+    };
+
+    async.waterfall = function (tasks, callback) {
+        callback = _once(callback || noop);
+        if (!_isArray(tasks)) {
+            var err = new Error('First argument to waterfall must be an array of functions');
+            return callback(err);
+        }
+        if (!tasks.length) {
+            return callback();
+        }
+        function wrapIterator(iterator) {
+            return _restParam(function (err, args) {
+                if (err) {
+                    callback.apply(null, [err].concat(args));
+                }
+                else {
+                    var next = iterator.next();
+                    if (next) {
+                        args.push(wrapIterator(next));
+                    }
+                    else {
+                        args.push(callback);
+                    }
+                    ensureAsync(iterator).apply(null, args);
+                }
+            });
+        }
+        wrapIterator(async.iterator(tasks))();
+    };
+
+    function _parallel(eachfn, tasks, callback) {
+        callback = callback || noop;
+        var results = _isArrayLike(tasks) ? [] : {};
+
+        eachfn(tasks, function (task, key, callback) {
+            task(_restParam(function (err, args) {
+                if (args.length <= 1) {
+                    args = args[0];
+                }
+                results[key] = args;
+                callback(err);
+            }));
+        }, function (err) {
+            callback(err, results);
+        });
+    }
+
+    async.parallel = function (tasks, callback) {
+        _parallel(async.eachOf, tasks, callback);
+    };
+
+    async.parallelLimit = function(tasks, limit, callback) {
+        _parallel(_eachOfLimit(limit), tasks, callback);
+    };
+
+    async.series = function(tasks, callback) {
+        _parallel(async.eachOfSeries, tasks, callback);
+    };
+
+    async.iterator = function (tasks) {
+        function makeCallback(index) {
+            function fn() {
+                if (tasks.length) {
+                    tasks[index].apply(null, arguments);
+                }
+                return fn.next();
+            }
+            fn.next = function () {
+                return (index < tasks.length - 1) ? makeCallback(index + 1): null;
+            };
+            return fn;
+        }
+        return makeCallback(0);
+    };
+
+    async.apply = _restParam(function (fn, args) {
+        return _restParam(function (callArgs) {
+            return fn.apply(
+                null, args.concat(callArgs)
+            );
+        });
+    });
+
+    function _concat(eachfn, arr, fn, callback) {
+        var result = [];
+        eachfn(arr, function (x, index, cb) {
+            fn(x, function (err, y) {
+                result = result.concat(y || []);
+                cb(err);
+            });
+        }, function (err) {
+            callback(err, result);
+        });
+    }
+    async.concat = doParallel(_concat);
+    async.concatSeries = doSeries(_concat);
+
+    async.whilst = function (test, iterator, callback) {
+        callback = callback || noop;
+        if (test()) {
+            var next = _restParam(function(err, args) {
+                if (err) {
+                    callback(err);
+                } else if (test.apply(this, args)) {
+                    iterator(next);
+                } else {
+                    callback(null);
+                }
+            });
+            iterator(next);
+        } else {
+            callback(null);
+        }
+    };
+
+    async.doWhilst = function (iterator, test, callback) {
+        var calls = 0;
+        return async.whilst(function() {
+            return ++calls <= 1 || test.apply(this, arguments);
+        }, iterator, callback);
+    };
+
+    async.until = function (test, iterator, callback) {
+        return async.whilst(function() {
+            return !test.apply(this, arguments);
+        }, iterator, callback);
+    };
+
+    async.doUntil = function (iterator, test, callback) {
+        return async.doWhilst(iterator, function() {
+            return !test.apply(this, arguments);
+        }, callback);
+    };
+
+    async.during = function (test, iterator, callback) {
+        callback = callback || noop;
+
+        var next = _restParam(function(err, args) {
+            if (err) {
+                callback(err);
+            } else {
+                args.push(check);
+                test.apply(this, args);
+            }
+        });
+
+        var check = function(err, truth) {
+            if (err) {
+                callback(err);
+            } else if (truth) {
+                iterator(next);
+            } else {
+                callback(null);
+            }
+        };
+
+        test(check);
+    };
+
+    async.doDuring = function (iterator, test, callback) {
+        var calls = 0;
+        async.during(function(next) {
+            if (calls++ < 1) {
+                next(null, true);
+            } else {
+                test.apply(this, arguments);
+            }
+        }, iterator, callback);
+    };
+
+    function _queue(worker, concurrency, payload) {
+        if (concurrency == null) {
+            concurrency = 1;
+        }
+        else if(concurrency === 0) {
+            throw new Error('Concurrency must not be zero');
+        }
+        function _insert(q, data, pos, callback) {
+            if (callback != null && typeof callback !== "function") {
+                throw new Error("task callback must be a function");
+            }
+            q.started = true;
+            if (!_isArray(data)) {
+                data = [data];
+            }
+            if(data.length === 0 && q.idle()) {
+                // call drain immediately if there are no tasks
+                return async.setImmediate(function() {
+                    q.drain();
+                });
+            }
+            _arrayEach(data, function(task) {
+                var item = {
+                    data: task,
+                    callback: callback || noop
+                };
+
+                if (pos) {
+                    q.tasks.unshift(item);
+                } else {
+                    q.tasks.push(item);
+                }
+
+                if (q.tasks.length === q.concurrency) {
+                    q.saturated();
+                }
+            });
+            async.setImmediate(q.process);
+        }
+        function _next(q, tasks) {
+            return function(){
+                workers -= 1;
+                var args = arguments;
+                _arrayEach(tasks, function (task) {
+                    task.callback.apply(task, args);
+                });
+                if (q.tasks.length + workers === 0) {
+                    q.drain();
+                }
+                q.process();
+            };
+        }
+
+        var workers = 0;
+        var q = {
+            tasks: [],
+            concurrency: concurrency,
+            payload: payload,
+            saturated: noop,
+            empty: noop,
+            drain: noop,
+            started: false,
+            paused: false,
+            push: function (data, callback) {
+                _insert(q, data, false, callback);
+            },
+            kill: function () {
+                q.drain = noop;
+                q.tasks = [];
+            },
+            unshift: function (data, callback) {
+                _insert(q, data, true, callback);
+            },
+            process: function () {
+                if (!q.paused && workers < q.concurrency && q.tasks.length) {
+                    while(workers < q.concurrency && q.tasks.length){
+                        var tasks = q.payload ?
+                            q.tasks.splice(0, q.payload) :
+                            q.tasks.splice(0, q.tasks.length);
+
+                        var data = _map(tasks, function (task) {
+                            return task.data;
+                        });
+
+                        if (q.tasks.length === 0) {
+                            q.empty();
+                        }
+                        workers += 1;
+                        var cb = only_once(_next(q, tasks));
+                        worker(data, cb);
+                    }
+                }
+            },
+            length: function () {
+                return q.tasks.length;
+            },
+            running: function () {
+                return workers;
+            },
+            idle: function() {
+                return q.tasks.length + workers === 0;
+            },
+            pause: function () {
+                q.paused = true;
+            },
+            resume: function () {
+                if (q.paused === false) { return; }
+                q.paused = false;
+                var resumeCount = Math.min(q.concurrency, q.tasks.length);
+                // Need to call q.process once per concurrent
+                // worker to preserve full concurrency after pause
+                for (var w = 1; w <= resumeCount; w++) {
+                    async.setImmediate(q.process);
+                }
+            }
+        };
+        return q;
+    }
+
+    async.queue = function (worker, concurrency) {
+        var q = _queue(function (items, cb) {
+            worker(items[0], cb);
+        }, concurrency, 1);
+
+        return q;
+    };
+
+    async.priorityQueue = function (worker, concurrency) {
+
+        function _compareTasks(a, b){
+            return a.priority - b.priority;
+        }
+
+        function _binarySearch(sequence, item, compare) {
+            var beg = -1,
+                end = sequence.length - 1;
+            while (beg < end) {
+                var mid = beg + ((end - beg + 1) >>> 1);
+                if (compare(item, sequence[mid]) >= 0) {
+                    beg = mid;
+                } else {
+                    end = mid - 1;
+                }
+            }
+            return beg;
+        }
+
+        function _insert(q, data, priority, callback) {
+            if (callback != null && typeof callback !== "function") {
+                throw new Error("task callback must be a function");
+            }
+            q.started = true;
+            if (!_isArray(data)) {
+                data = [data];
+            }
+            if(data.length === 0) {
+                // call drain immediately if there are no tasks
+                return async.setImmediate(function() {
+                    q.drain();
+                });
+            }
+            _arrayEach(data, function(task) {
+                var item = {
+                    data: task,
+                    priority: priority,
+                    callback: typeof callback === 'function' ? callback : noop
+                };
+
+                q.tasks.splice(_binarySearch(q.tasks, item, _compareTasks) + 1, 0, item);
+
+                if (q.tasks.length === q.concurrency) {
+                    q.saturated();
+                }
+                async.setImmediate(q.process);
+            });
+        }
+
+        // Start with a normal queue
+        var q = async.queue(worker, concurrency);
+
+        // Override push to accept second parameter representing priority
+        q.push = function (data, priority, callback) {
+            _insert(q, data, priority, callback);
+        };
+
+        // Remove unshift function
+        delete q.unshift;
+
+        return q;
+    };
+
+    async.cargo = function (worker, payload) {
+        return _queue(worker, 1, payload);
+    };
+
+    function _console_fn(name) {
+        return _restParam(function (fn, args) {
+            fn.apply(null, args.concat([_restParam(function (err, args) {
+                if (typeof console !== 'undefined') {
+                    if (err) {
+                        if (console.error) {
+                            console.error(err);
+                        }
+                    }
+                    else if (console[name]) {
+                        _arrayEach(args, function (x) {
+                            console[name](x);
+                        });
+                    }
+                }
+            })]));
+        });
+    }
+    async.log = _console_fn('log');
+    async.dir = _console_fn('dir');
+    /*async.info = _console_fn('info');
+    async.warn = _console_fn('warn');
+    async.error = _console_fn('error');*/
+
+    async.memoize = function (fn, hasher) {
+        var memo = {};
+        var queues = {};
+        hasher = hasher || identity;
+        var memoized = _restParam(function memoized(args) {
+            var callback = args.pop();
+            var key = hasher.apply(null, args);
+            if (key in memo) {
+                async.nextTick(function () {
+                    callback.apply(null, memo[key]);
+                });
+            }
+            else if (key in queues) {
+                queues[key].push(callback);
+            }
+            else {
+                queues[key] = [callback];
+                fn.apply(null, args.concat([_restParam(function (args) {
+                    memo[key] = args;
+                    var q = queues[key];
+                    delete queues[key];
+                    for (var i = 0, l = q.length; i < l; i++) {
+                        q[i].apply(null, args);
+                    }
+                })]));
+            }
+        });
+        memoized.memo = memo;
+        memoized.unmemoized = fn;
+        return memoized;
+    };
+
+    async.unmemoize = function (fn) {
+        return function () {
+            return (fn.unmemoized || fn).apply(null, arguments);
+        };
+    };
+
+    function _times(mapper) {
+        return function (count, iterator, callback) {
+            mapper(_range(count), iterator, callback);
+        };
+    }
+
+    async.times = _times(async.map);
+    async.timesSeries = _times(async.mapSeries);
+    async.timesLimit = function (count, limit, iterator, callback) {
+        return async.mapLimit(_range(count), limit, iterator, callback);
+    };
+
+    async.seq = function (/* functions... */) {
+        var fns = arguments;
+        return _restParam(function (args) {
+            var that = this;
+
+            var callback = args[args.length - 1];
+            if (typeof callback == 'function') {
+                args.pop();
+            } else {
+                callback = noop;
+            }
+
+            async.reduce(fns, args, function (newargs, fn, cb) {
+                fn.apply(that, newargs.concat([_restParam(function (err, nextargs) {
+                    cb(err, nextargs);
+                })]));
+            },
+            function (err, results) {
+                callback.apply(that, [err].concat(results));
+            });
+        });
+    };
+
+    async.compose = function (/* functions... */) {
+        return async.seq.apply(null, Array.prototype.reverse.call(arguments));
+    };
+
+
+    function _applyEach(eachfn) {
+        return _restParam(function(fns, args) {
+            var go = _restParam(function(args) {
+                var that = this;
+                var callback = args.pop();
+                return eachfn(fns, function (fn, _, cb) {
+                    fn.apply(that, args.concat([cb]));
+                },
+                callback);
+            });
+            if (args.length) {
+                return go.apply(this, args);
+            }
+            else {
+                return go;
+            }
+        });
+    }
+
+    async.applyEach = _applyEach(async.eachOf);
+    async.applyEachSeries = _applyEach(async.eachOfSeries);
+
+
+    async.forever = function (fn, callback) {
+        var done = only_once(callback || noop);
+        var task = ensureAsync(fn);
+        function next(err) {
+            if (err) {
+                return done(err);
+            }
+            task(next);
+        }
+        next();
+    };
+
+    function ensureAsync(fn) {
+        return _restParam(function (args) {
+            var callback = args.pop();
+            args.push(function () {
+                var innerArgs = arguments;
+                if (sync) {
+                    async.setImmediate(function () {
+                        callback.apply(null, innerArgs);
+                    });
+                } else {
+                    callback.apply(null, innerArgs);
+                }
+            });
+            var sync = true;
+            fn.apply(this, args);
+            sync = false;
+        });
+    }
+
+    async.ensureAsync = ensureAsync;
+
+    async.constant = _restParam(function(values) {
+        var args = [null].concat(values);
+        return function (callback) {
+            return callback.apply(this, args);
+        };
+    });
+
+    async.wrapSync =
+    async.asyncify = function asyncify(func) {
+        return _restParam(function (args) {
+            var callback = args.pop();
+            var result;
+            try {
+                result = func.apply(this, args);
+            } catch (e) {
+                return callback(e);
+            }
+            // if result is Promise object
+            if (typeof result !== 'undefined' && typeof result.then === "function") {
+                result.then(function(value) {
+                    callback(null, value);
+                }).catch(function(err) {
+                    callback(err.message ? err : new Error(err));
+                });
+            } else {
+                callback(null, result);
+            }
+        });
+    };
+
+    // Node.js
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = async;
+    }
+    // AMD / RequireJS
+    else if (typeof define !== 'undefined' && define.amd) {
+        define([], function () {
+            return async;
+        });
+    }
+    // included directly via <script> tag
+    else {
+        root.async = async;
+    }
+
+}());
diff --git a/dist/async.min.map b/dist/async.min.map
new file mode 100644
index 0000000..3eba3cb
--- /dev/null
+++ b/dist/async.min.map
@@ -0,0 +1 @@
+{"version":3,"file":"async.min.js","sources":["async.js"],"names":["noop","identity","v","toBool","notId","only_once","fn","Error","apply","this","arguments","_once","_isArrayLike","arr","_isArray","length","_each","coll","iterator","_arrayEach","_forEachOf","index","_map","result","Array","_range","count","i","_reduce","memo","x","a","object","_keys","key","_indexOf","item","_keyIterator","len","keys","_restParam","func","startIndex","Math","max","rest","call","_withoutIndex","value","callback","_eachOfLimit","limit","obj","nextKey","done","running","errored","replenish","err","doParallel","async","eachOf","doParallelLimit","doSeries","eachOfSeries","_asyncMap","eachfn","results","_filter","push","sort","b","_reject","cb","_createTester","check","getResult","iteratee","_","_findGetResult","_parallel","tasks","task","args","_concat","y","concat","_queue","worker","concurrency","payload","_insert","q","data","pos","started","idle","setImmediate","drain","unshift","saturated","process","_next","workers","empty","paused","kill","splice","pause","resume","resumeCount","min","w","_console_fn","name","console","error","_times","mapper","_applyEach","fns","go","that","pop","ensureAsync","innerArgs","sync","previous_async","root","self","global","noConflict","_toString","Object","prototype","toString","isArray","k","hasOwnProperty","_setImmediate","_delay","setTimeout","nextTick","forEach","each","forEachSeries","eachSeries","forEachLimit","eachLimit","forEachOf","completed","size","forEachOfSeries","iterate","forEachOfLimit","eachOfLimit","map","mapSeries","mapLimit","inject","foldl","reduce","foldr","reduceRight","reversed","reverse","select","filter","selectLimit","filterLimit","selectSeries","filterSeries","reject","rejectLimit","rejectSeries","any","some","someLimit","all","every","everyLimit","detect","detectSeries","sortBy","comparator","left","right","criteria","auto","addListener","listeners","removeListener","idx","taskComplete","remainingTasks","slice","ready","requires","listener","taskCallback","dep","safeResults","val","rkey","retry","times","parseTimes","acc","t","parseInt","DEFAULT_TIMES","interval","DEFAULT_INTERVAL","wrappedTask","wrappedCallback","wrappedResults","retryAttempt","finalAttempt","seriesCallback","retryInterval","opts","attempts","series","waterfall","wrapIterator","next","parallel","parallelLimit","makeCallback","callArgs","concatSeries","whilst","test","doWhilst","calls","until","doUntil","during","truth","doDuring","queue","items","priorityQueue","_compareTasks","priority","_binarySearch","sequence","compare","beg","end","mid","cargo","log","dir","memoize","hasher","queues","memoized","l","unmemoized","unmemoize","timesSeries","timesLimit","seq","newargs","nextargs","compose","applyEach","applyEachSeries","forever","constant","values","wrapSync","asyncify","e","then","message","module","exports","define","amd"],"mappings":"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"}
\ No newline at end of file
-- 
cgit v1.2.1