incubator-callback-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ste...@apache.org
Subject [3/14] updated package.json
Date Tue, 11 Sep 2012 22:59:40 GMT
http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/async/lib/async.js
----------------------------------------------------------------------
diff --git a/node_modules/async/lib/async.js b/node_modules/async/lib/async.js
deleted file mode 100644
index c862008..0000000
--- a/node_modules/async/lib/async.js
+++ /dev/null
@@ -1,690 +0,0 @@
-/*global setTimeout: false, console: false */
-(function () {
-
-    var async = {};
-
-    // global on the server, window in the browser
-    var root = this,
-        previous_async = root.async;
-
-    if (typeof module !== 'undefined' && module.exports) {
-        module.exports = async;
-    }
-    else {
-        root.async = async;
-    }
-
-    async.noConflict = function () {
-        root.async = previous_async;
-        return async;
-    };
-
-    //// cross-browser compatiblity functions ////
-
-    var _forEach = function (arr, iterator) {
-        if (arr.forEach) {
-            return arr.forEach(iterator);
-        }
-        for (var i = 0; i < arr.length; i += 1) {
-            iterator(arr[i], i, arr);
-        }
-    };
-
-    var _map = function (arr, iterator) {
-        if (arr.map) {
-            return arr.map(iterator);
-        }
-        var results = [];
-        _forEach(arr, function (x, i, a) {
-            results.push(iterator(x, i, a));
-        });
-        return results;
-    };
-
-    var _reduce = function (arr, iterator, memo) {
-        if (arr.reduce) {
-            return arr.reduce(iterator, memo);
-        }
-        _forEach(arr, function (x, i, a) {
-            memo = iterator(memo, x, i, a);
-        });
-        return memo;
-    };
-
-    var _keys = function (obj) {
-        if (Object.keys) {
-            return Object.keys(obj);
-        }
-        var keys = [];
-        for (var k in obj) {
-            if (obj.hasOwnProperty(k)) {
-                keys.push(k);
-            }
-        }
-        return keys;
-    };
-
-    var _indexOf = function (arr, item) {
-        if (arr.indexOf) {
-            return arr.indexOf(item);
-        }
-        for (var i = 0; i < arr.length; i += 1) {
-            if (arr[i] === item) {
-                return i;
-            }
-        }
-        return -1;
-    };
-
-    //// exported async module functions ////
-
-    //// nextTick implementation with browser-compatible fallback ////
-    if (typeof process === 'undefined' || !(process.nextTick)) {
-        async.nextTick = function (fn) {
-            setTimeout(fn, 0);
-        };
-    }
-    else {
-        async.nextTick = process.nextTick;
-    }
-
-    async.forEach = function (arr, iterator, callback) {
-        if (!arr.length) {
-            return callback();
-        }
-        var completed = 0;
-        _forEach(arr, function (x) {
-            iterator(x, function (err) {
-                if (err) {
-                    callback(err);
-                    callback = function () {};
-                }
-                else {
-                    completed += 1;
-                    if (completed === arr.length) {
-                        callback();
-                    }
-                }
-            });
-        });
-    };
-
-    async.forEachSeries = function (arr, iterator, callback) {
-        if (!arr.length) {
-            return callback();
-        }
-        var completed = 0;
-        var iterate = function () {
-            iterator(arr[completed], function (err) {
-                if (err) {
-                    callback(err);
-                    callback = function () {};
-                }
-                else {
-                    completed += 1;
-                    if (completed === arr.length) {
-                        callback();
-                    }
-                    else {
-                        iterate();
-                    }
-                }
-            });
-        };
-        iterate();
-    };
-    
-    async.forEachLimit = function (arr, limit, iterator, callback) {
-        if (!arr.length || limit <= 0) {
-            return callback(); 
-        }
-        var completed = 0;
-        var started = 0;
-        var running = 0;
-        
-        (function replenish () {
-          if (completed === arr.length) {
-              return callback();
-          }
-          
-          while (running < limit && started < arr.length) {
-            iterator(arr[started], function (err) {
-              if (err) {
-                  callback(err);
-                  callback = function () {};
-              }
-              else {
-                  completed += 1;
-                  running -= 1;
-                  if (completed === arr.length) {
-                      callback();
-                  }
-                  else {
-                      replenish();
-                  }
-              }
-            });
-            started += 1;
-            running += 1;
-          }
-        })();
-    };
-
-
-    var doParallel = function (fn) {
-        return function () {
-            var args = Array.prototype.slice.call(arguments);
-            return fn.apply(null, [async.forEach].concat(args));
-        };
-    };
-    var doSeries = function (fn) {
-        return function () {
-            var args = Array.prototype.slice.call(arguments);
-            return fn.apply(null, [async.forEachSeries].concat(args));
-        };
-    };
-
-
-    var _asyncMap = function (eachfn, arr, iterator, callback) {
-        var results = [];
-        arr = _map(arr, function (x, i) {
-            return {index: i, value: x};
-        });
-        eachfn(arr, function (x, callback) {
-            iterator(x.value, function (err, v) {
-                results[x.index] = v;
-                callback(err);
-            });
-        }, function (err) {
-            callback(err, results);
-        });
-    };
-    async.map = doParallel(_asyncMap);
-    async.mapSeries = doSeries(_asyncMap);
-
-
-    // reduce only has a series version, as doing reduce in parallel won't
-    // work in many situations.
-    async.reduce = function (arr, memo, iterator, callback) {
-        async.forEachSeries(arr, function (x, callback) {
-            iterator(memo, x, function (err, v) {
-                memo = v;
-                callback(err);
-            });
-        }, function (err) {
-            callback(err, memo);
-        });
-    };
-    // inject alias
-    async.inject = async.reduce;
-    // foldl alias
-    async.foldl = async.reduce;
-
-    async.reduceRight = function (arr, memo, iterator, callback) {
-        var reversed = _map(arr, function (x) {
-            return x;
-        }).reverse();
-        async.reduce(reversed, memo, iterator, callback);
-    };
-    // foldr alias
-    async.foldr = async.reduceRight;
-
-    var _filter = function (eachfn, arr, iterator, callback) {
-        var results = [];
-        arr = _map(arr, function (x, i) {
-            return {index: i, value: x};
-        });
-        eachfn(arr, function (x, callback) {
-            iterator(x.value, function (v) {
-                if (v) {
-                    results.push(x);
-                }
-                callback();
-            });
-        }, function (err) {
-            callback(_map(results.sort(function (a, b) {
-                return a.index - b.index;
-            }), function (x) {
-                return x.value;
-            }));
-        });
-    };
-    async.filter = doParallel(_filter);
-    async.filterSeries = doSeries(_filter);
-    // select alias
-    async.select = async.filter;
-    async.selectSeries = async.filterSeries;
-
-    var _reject = function (eachfn, arr, iterator, callback) {
-        var results = [];
-        arr = _map(arr, function (x, i) {
-            return {index: i, value: x};
-        });
-        eachfn(arr, function (x, callback) {
-            iterator(x.value, function (v) {
-                if (!v) {
-                    results.push(x);
-                }
-                callback();
-            });
-        }, function (err) {
-            callback(_map(results.sort(function (a, b) {
-                return a.index - b.index;
-            }), function (x) {
-                return x.value;
-            }));
-        });
-    };
-    async.reject = doParallel(_reject);
-    async.rejectSeries = doSeries(_reject);
-
-    var _detect = function (eachfn, arr, iterator, main_callback) {
-        eachfn(arr, function (x, callback) {
-            iterator(x, function (result) {
-                if (result) {
-                    main_callback(x);
-                    main_callback = function () {};
-                }
-                else {
-                    callback();
-                }
-            });
-        }, function (err) {
-            main_callback();
-        });
-    };
-    async.detect = doParallel(_detect);
-    async.detectSeries = doSeries(_detect);
-
-    async.some = function (arr, iterator, main_callback) {
-        async.forEach(arr, function (x, callback) {
-            iterator(x, function (v) {
-                if (v) {
-                    main_callback(true);
-                    main_callback = function () {};
-                }
-                callback();
-            });
-        }, function (err) {
-            main_callback(false);
-        });
-    };
-    // any alias
-    async.any = async.some;
-
-    async.every = function (arr, iterator, main_callback) {
-        async.forEach(arr, function (x, callback) {
-            iterator(x, function (v) {
-                if (!v) {
-                    main_callback(false);
-                    main_callback = function () {};
-                }
-                callback();
-            });
-        }, function (err) {
-            main_callback(true);
-        });
-    };
-    // all alias
-    async.all = async.every;
-
-    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 {
-                var fn = function (left, right) {
-                    var a = left.criteria, b = right.criteria;
-                    return a < b ? -1 : a > b ? 1 : 0;
-                };
-                callback(null, _map(results.sort(fn), function (x) {
-                    return x.value;
-                }));
-            }
-        });
-    };
-
-    async.auto = function (tasks, callback) {
-        callback = callback || function () {};
-        var keys = _keys(tasks);
-        if (!keys.length) {
-            return callback(null);
-        }
-
-        var results = {};
-
-        var listeners = [];
-        var addListener = function (fn) {
-            listeners.unshift(fn);
-        };
-        var removeListener = function (fn) {
-            for (var i = 0; i < listeners.length; i += 1) {
-                if (listeners[i] === fn) {
-                    listeners.splice(i, 1);
-                    return;
-                }
-            }
-        };
-        var taskComplete = function () {
-            _forEach(listeners, function (fn) {
-                fn();
-            });
-        };
-
-        addListener(function () {
-            if (_keys(results).length === keys.length) {
-                callback(null, results);
-            }
-        });
-
-        _forEach(keys, function (k) {
-            var task = (tasks[k] instanceof Function) ? [tasks[k]]: tasks[k];
-            var taskCallback = function (err) {
-                if (err) {
-                    callback(err);
-                    // stop subsequent errors hitting callback multiple times
-                    callback = function () {};
-                }
-                else {
-                    var args = Array.prototype.slice.call(arguments, 1);
-                    if (args.length <= 1) {
-                        args = args[0];
-                    }
-                    results[k] = args;
-                    taskComplete();
-                }
-            };
-            var requires = task.slice(0, Math.abs(task.length - 1)) || [];
-            var ready = function () {
-                return _reduce(requires, function (a, x) {
-                    return (a && results.hasOwnProperty(x));
-                }, true);
-            };
-            if (ready()) {
-                task[task.length - 1](taskCallback, results);
-            }
-            else {
-                var listener = function () {
-                    if (ready()) {
-                        removeListener(listener);
-                        task[task.length - 1](taskCallback, results);
-                    }
-                };
-                addListener(listener);
-            }
-        });
-    };
-
-    async.waterfall = function (tasks, callback) {
-        if (!tasks.length) {
-            return callback();
-        }
-        callback = callback || function () {};
-        var wrapIterator = function (iterator) {
-            return function (err) {
-                if (err) {
-                    callback(err);
-                    callback = function () {};
-                }
-                else {
-                    var args = Array.prototype.slice.call(arguments, 1);
-                    var next = iterator.next();
-                    if (next) {
-                        args.push(wrapIterator(next));
-                    }
-                    else {
-                        args.push(callback);
-                    }
-                    async.nextTick(function () {
-                        iterator.apply(null, args);
-                    });
-                }
-            };
-        };
-        wrapIterator(async.iterator(tasks))();
-    };
-
-    async.parallel = function (tasks, callback) {
-        callback = callback || function () {};
-        if (tasks.constructor === Array) {
-            async.map(tasks, function (fn, callback) {
-                if (fn) {
-                    fn(function (err) {
-                        var args = Array.prototype.slice.call(arguments, 1);
-                        if (args.length <= 1) {
-                            args = args[0];
-                        }
-                        callback.call(null, err, args);
-                    });
-                }
-            }, callback);
-        }
-        else {
-            var results = {};
-            async.forEach(_keys(tasks), function (k, callback) {
-                tasks[k](function (err) {
-                    var args = Array.prototype.slice.call(arguments, 1);
-                    if (args.length <= 1) {
-                        args = args[0];
-                    }
-                    results[k] = args;
-                    callback(err);
-                });
-            }, function (err) {
-                callback(err, results);
-            });
-        }
-    };
-
-    async.series = function (tasks, callback) {
-        callback = callback || function () {};
-        if (tasks.constructor === Array) {
-            async.mapSeries(tasks, function (fn, callback) {
-                if (fn) {
-                    fn(function (err) {
-                        var args = Array.prototype.slice.call(arguments, 1);
-                        if (args.length <= 1) {
-                            args = args[0];
-                        }
-                        callback.call(null, err, args);
-                    });
-                }
-            }, callback);
-        }
-        else {
-            var results = {};
-            async.forEachSeries(_keys(tasks), function (k, callback) {
-                tasks[k](function (err) {
-                    var args = Array.prototype.slice.call(arguments, 1);
-                    if (args.length <= 1) {
-                        args = args[0];
-                    }
-                    results[k] = args;
-                    callback(err);
-                });
-            }, function (err) {
-                callback(err, results);
-            });
-        }
-    };
-
-    async.iterator = function (tasks) {
-        var makeCallback = function (index) {
-            var fn = function () {
-                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 = function (fn) {
-        var args = Array.prototype.slice.call(arguments, 1);
-        return function () {
-            return fn.apply(
-                null, args.concat(Array.prototype.slice.call(arguments))
-            );
-        };
-    };
-
-    var _concat = function (eachfn, arr, fn, callback) {
-        var r = [];
-        eachfn(arr, function (x, cb) {
-            fn(x, function (err, y) {
-                r = r.concat(y || []);
-                cb(err);
-            });
-        }, function (err) {
-            callback(err, r);
-        });
-    };
-    async.concat = doParallel(_concat);
-    async.concatSeries = doSeries(_concat);
-
-    async.whilst = function (test, iterator, callback) {
-        if (test()) {
-            iterator(function (err) {
-                if (err) {
-                    return callback(err);
-                }
-                async.whilst(test, iterator, callback);
-            });
-        }
-        else {
-            callback();
-        }
-    };
-
-    async.until = function (test, iterator, callback) {
-        if (!test()) {
-            iterator(function (err) {
-                if (err) {
-                    return callback(err);
-                }
-                async.until(test, iterator, callback);
-            });
-        }
-        else {
-            callback();
-        }
-    };
-
-    async.queue = function (worker, concurrency) {
-        var workers = 0;
-        var q = {
-            tasks: [],
-            concurrency: concurrency,
-            saturated: null,
-            empty: null,
-            drain: null,
-            push: function (data, callback) {
-                q.tasks.push({data: data, callback: callback});
-                if(q.saturated && q.tasks.length == concurrency) q.saturated();
-                async.nextTick(q.process);
-            },
-            process: function () {
-                if (workers < q.concurrency && q.tasks.length) {
-                    var task = q.tasks.shift();
-                    if(q.empty && q.tasks.length == 0) q.empty();
-                    workers += 1;
-                    worker(task.data, function () {
-                        workers -= 1;
-                        if (task.callback) {
-                            task.callback.apply(task, arguments);
-                        }
-                        if(q.drain && q.tasks.length + workers == 0) q.drain();
-                        q.process();
-                    });
-                }
-            },
-            length: function () {
-                return q.tasks.length;
-            },
-            running: function () {
-                return workers;
-            }
-        };
-        return q;
-    };
-
-    var _console_fn = function (name) {
-        return function (fn) {
-            var args = Array.prototype.slice.call(arguments, 1);
-            fn.apply(null, args.concat([function (err) {
-                var args = Array.prototype.slice.call(arguments, 1);
-                if (typeof console !== 'undefined') {
-                    if (err) {
-                        if (console.error) {
-                            console.error(err);
-                        }
-                    }
-                    else if (console[name]) {
-                        _forEach(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 || function (x) {
-            return x;
-        };
-        var memoized = function () {
-            var args = Array.prototype.slice.call(arguments);
-            var callback = args.pop();
-            var key = hasher.apply(null, args);
-            if (key in memo) {
-                callback.apply(null, memo[key]);
-            }
-            else if (key in queues) {
-                queues[key].push(callback);
-            }
-            else {
-                queues[key] = [callback];
-                fn.apply(null, args.concat([function () {
-                    memo[key] = arguments;
-                    var q = queues[key];
-                    delete queues[key];
-                    for (var i = 0, l = q.length; i < l; i++) {
-                      q[i].apply(null, arguments);
-                    }
-                }]));
-            }
-        };
-        memoized.unmemoized = fn;
-        return memoized;
-    };
-
-    async.unmemoize = function (fn) {
-      return function () {
-        return (fn.unmemoized || fn).apply(null, arguments);
-      }
-    };
-
-}());

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/async/nodelint.cfg
----------------------------------------------------------------------
diff --git a/node_modules/async/nodelint.cfg b/node_modules/async/nodelint.cfg
deleted file mode 100644
index 457a967..0000000
--- a/node_modules/async/nodelint.cfg
+++ /dev/null
@@ -1,4 +0,0 @@
-var options = {
-    indent: 4,
-    onevar: false
-};

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/async/package.json
----------------------------------------------------------------------
diff --git a/node_modules/async/package.json b/node_modules/async/package.json
deleted file mode 100644
index 6198943..0000000
--- a/node_modules/async/package.json
+++ /dev/null
@@ -1,16 +0,0 @@
-{ "name": "async"
-, "description": "Higher-order functions and common patterns for asynchronous code"
-, "main": "./index"
-, "author": "Caolan McMahon"
-, "version": "0.1.15"
-, "repository" :
-  { "type" : "git"
-  , "url" : "http://github.com/caolan/async.git"
-  }
-, "bugs" : { "url" : "http://github.com/caolan/async/issues" }
-, "licenses" :
-  [ { "type" : "MIT"
-    , "url" : "http://github.com/caolan/async/raw/master/LICENSE"
-    }
-  ]
-}

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/async/test/test-async.js
----------------------------------------------------------------------
diff --git a/node_modules/async/test/test-async.js b/node_modules/async/test/test-async.js
deleted file mode 100644
index d3eeddc..0000000
--- a/node_modules/async/test/test-async.js
+++ /dev/null
@@ -1,1577 +0,0 @@
-var async = require('../lib/async');
-
-
-exports['auto'] = function(test){
-    var callOrder = [];
-    var testdata = [{test: 'test'}];
-    async.auto({
-        task1: ['task2', function(callback){
-            setTimeout(function(){
-                callOrder.push('task1');
-                callback();
-            }, 25);
-        }],
-        task2: function(callback){
-            setTimeout(function(){
-                callOrder.push('task2');
-                callback();
-            }, 50);
-        },
-        task3: ['task2', function(callback){
-            callOrder.push('task3');
-            callback();
-        }],
-        task4: ['task1', 'task2', function(callback){
-            callOrder.push('task4');
-            callback();
-        }]
-    },
-    function(err){
-        test.same(callOrder, ['task2','task3','task1','task4']);
-        test.done();
-    });
-};
-
-exports['auto results'] = function(test){
-    var callOrder = [];
-    async.auto({
-      task1: ['task2', function(callback, results){
-          test.same(results.task2, 'task2');
-          setTimeout(function(){
-              callOrder.push('task1');
-              callback(null, 'task1a', 'task1b');
-          }, 25);
-      }],
-      task2: function(callback){
-          setTimeout(function(){
-              callOrder.push('task2');
-              callback(null, 'task2');
-          }, 50);
-      },
-      task3: ['task2', function(callback, results){
-          test.same(results.task2, 'task2');
-          callOrder.push('task3');
-          callback(null);
-      }],
-      task4: ['task1', 'task2', function(callback, results){
-          test.same(results.task1, ['task1a','task1b']);
-          test.same(results.task2, 'task2');
-          callOrder.push('task4');
-          callback(null, 'task4');
-      }]
-    },
-    function(err, results){
-        test.same(callOrder, ['task2','task3','task1','task4']);
-        test.same(results, {task1: ['task1a','task1b'], task2: 'task2', task3: undefined, task4: 'task4'});
-        test.done();
-    });
-};
-
-
-exports['auto empty object'] = function(test){
-    async.auto({}, function(err){
-        test.done();
-    });
-};
-
-exports['auto error'] = function(test){
-    test.expect(1);
-    async.auto({
-        task1: function(callback){
-            callback('testerror');
-        },
-        task2: ['task1', function(callback){
-            test.ok(false, 'task2 should not be called');
-            callback();
-        }],
-        task3: function(callback){
-            callback('testerror2');
-        }
-    },
-    function(err){
-        test.equals(err, 'testerror');
-    });
-    setTimeout(test.done, 100);
-};
-
-exports['auto no callback'] = function(test){
-    async.auto({
-        task1: function(callback){callback();},
-        task2: ['task1', function(callback){callback(); test.done();}]
-    });
-};
-
-exports['waterfall'] = function(test){
-    test.expect(6);
-    var call_order = [];
-    async.waterfall([
-        function(callback){
-            call_order.push('fn1');
-            setTimeout(function(){callback(null, 'one', 'two');}, 0);
-        },
-        function(arg1, arg2, callback){
-            call_order.push('fn2');
-            test.equals(arg1, 'one');
-            test.equals(arg2, 'two');
-            setTimeout(function(){callback(null, arg1, arg2, 'three');}, 25);
-        },
-        function(arg1, arg2, arg3, callback){
-            call_order.push('fn3');
-            test.equals(arg1, 'one');
-            test.equals(arg2, 'two');
-            test.equals(arg3, 'three');
-            callback(null, 'four');
-        },
-        function(arg4, callback){
-            call_order.push('fn4');
-            test.same(call_order, ['fn1','fn2','fn3','fn4']);
-            callback(null, 'test');
-        }
-    ], function(err){
-        test.done();
-    });
-};
-
-exports['waterfall empty array'] = function(test){
-    async.waterfall([], function(err){
-        test.done();
-    });
-};
-
-exports['waterfall no callback'] = function(test){
-    async.waterfall([
-        function(callback){callback();},
-        function(callback){callback(); test.done();}
-    ]);
-};
-
-exports['waterfall async'] = function(test){
-    var call_order = [];
-    async.waterfall([
-        function(callback){
-            call_order.push(1);
-            callback();
-            call_order.push(2);
-        },
-        function(callback){
-            call_order.push(3);
-            callback();
-        },
-        function(){
-            test.same(call_order, [1,2,3]);
-            test.done();
-        }
-    ]);
-};
-
-exports['waterfall error'] = function(test){
-    test.expect(1);
-    async.waterfall([
-        function(callback){
-            callback('error');
-        },
-        function(callback){
-            test.ok(false, 'next function should not be called');
-            callback();
-        }
-    ], function(err){
-        test.equals(err, 'error');
-    });
-    setTimeout(test.done, 50);
-};
-
-exports['waterfall multiple callback calls'] = function(test){
-    var call_order = [];
-    var arr = [
-        function(callback){
-            call_order.push(1);
-            // call the callback twice. this should call function 2 twice
-            callback(null, 'one', 'two');
-            callback(null, 'one', 'two');
-        },
-        function(arg1, arg2, callback){
-            call_order.push(2);
-            callback(null, arg1, arg2, 'three');
-        },
-        function(arg1, arg2, arg3, callback){
-            call_order.push(3);
-            callback(null, 'four');
-        },
-        function(arg4){
-            call_order.push(4);
-            arr[3] = function(){
-                call_order.push(4);
-                test.same(call_order, [1,2,2,3,3,4,4]);
-                test.done();
-            };
-        }
-    ];
-    async.waterfall(arr);
-};
-
-
-exports['parallel'] = function(test){
-    var call_order = [];
-    async.parallel([
-        function(callback){
-            setTimeout(function(){
-                call_order.push(1);
-                callback(null, 1);
-            }, 50);
-        },
-        function(callback){
-            setTimeout(function(){
-                call_order.push(2);
-                callback(null, 2);
-            }, 100);
-        },
-        function(callback){
-            setTimeout(function(){
-                call_order.push(3);
-                callback(null, 3,3);
-            }, 25);
-        }
-    ],
-    function(err, results){
-        test.equals(err, null);
-        test.same(call_order, [3,1,2]);
-        test.same(results, [1,2,[3,3]]);
-        test.done();
-    });
-};
-
-exports['parallel empty array'] = function(test){
-    async.parallel([], function(err, results){
-        test.equals(err, null);
-        test.same(results, []);
-        test.done();
-    });
-};
-
-exports['parallel error'] = function(test){
-    async.parallel([
-        function(callback){
-            callback('error', 1);
-        },
-        function(callback){
-            callback('error2', 2);
-        }
-    ],
-    function(err, results){
-        test.equals(err, 'error');
-    });
-    setTimeout(test.done, 100);
-};
-
-exports['parallel no callback'] = function(test){
-    async.parallel([
-        function(callback){callback();},
-        function(callback){callback(); test.done();},
-    ]);
-};
-
-exports['parallel object'] = function(test){
-    var call_order = [];
-    async.parallel({
-        one: function(callback){
-            setTimeout(function(){
-                call_order.push(1);
-                callback(null, 1);
-            }, 25);
-        },
-        two: function(callback){
-            setTimeout(function(){
-                call_order.push(2);
-                callback(null, 2);
-            }, 50);
-        },
-        three: function(callback){
-            setTimeout(function(){
-                call_order.push(3);
-                callback(null, 3,3);
-            }, 15);
-        }
-    },
-    function(err, results){
-        test.equals(err, null);
-        test.same(call_order, [3,1,2]);
-        test.same(results, {
-            one: 1,
-            two: 2,
-            three: [3,3]
-        });
-        test.done();
-    });
-};
-
-exports['series'] = function(test){
-    var call_order = [];
-    async.series([
-        function(callback){
-            setTimeout(function(){
-                call_order.push(1);
-                callback(null, 1);
-            }, 25);
-        },
-        function(callback){
-            setTimeout(function(){
-                call_order.push(2);
-                callback(null, 2);
-            }, 50);
-        },
-        function(callback){
-            setTimeout(function(){
-                call_order.push(3);
-                callback(null, 3,3);
-            }, 15);
-        }
-    ],
-    function(err, results){
-        test.equals(err, null);
-        test.same(results, [1,2,[3,3]]);
-        test.same(call_order, [1,2,3]);
-        test.done();
-    });
-};
-
-exports['series empty array'] = function(test){
-    async.series([], function(err, results){
-        test.equals(err, null);
-        test.same(results, []);
-        test.done();
-    });
-};
-
-exports['series error'] = function(test){
-    test.expect(1);
-    async.series([
-        function(callback){
-            callback('error', 1);
-        },
-        function(callback){
-            test.ok(false, 'should not be called');
-            callback('error2', 2);
-        }
-    ],
-    function(err, results){
-        test.equals(err, 'error');
-    });
-    setTimeout(test.done, 100);
-};
-
-exports['series no callback'] = function(test){
-    async.series([
-        function(callback){callback();},
-        function(callback){callback(); test.done();},
-    ]);
-};
-
-exports['series object'] = function(test){
-    var call_order = [];
-    async.series({
-        one: function(callback){
-            setTimeout(function(){
-                call_order.push(1);
-                callback(null, 1);
-            }, 25);
-        },
-        two: function(callback){
-            setTimeout(function(){
-                call_order.push(2);
-                callback(null, 2);
-            }, 50);
-        },
-        three: function(callback){
-            setTimeout(function(){
-                call_order.push(3);
-                callback(null, 3,3);
-            }, 15);
-        }
-    },
-    function(err, results){
-        test.equals(err, null);
-        test.same(results, {
-            one: 1,
-            two: 2,
-            three: [3,3]
-        });
-        test.same(call_order, [1,2,3]);
-        test.done();
-    });
-};
-
-exports['iterator'] = function(test){
-    var call_order = [];
-    var iterator = async.iterator([
-        function(){call_order.push(1);},
-        function(arg1){
-            test.equals(arg1, 'arg1');
-            call_order.push(2);
-        },
-        function(arg1, arg2){
-            test.equals(arg1, 'arg1');
-            test.equals(arg2, 'arg2');
-            call_order.push(3);
-        }
-    ]);
-    iterator();
-    test.same(call_order, [1]);
-    var iterator2 = iterator();
-    test.same(call_order, [1,1]);
-    var iterator3 = iterator2('arg1');
-    test.same(call_order, [1,1,2]);
-    var iterator4 = iterator3('arg1', 'arg2');
-    test.same(call_order, [1,1,2,3]);
-    test.equals(iterator4, undefined);
-    test.done();
-};
-
-exports['iterator empty array'] = function(test){
-    var iterator = async.iterator([]);
-    test.equals(iterator(), undefined);
-    test.equals(iterator.next(), undefined);
-    test.done();
-};
-
-exports['iterator.next'] = function(test){
-    var call_order = [];
-    var iterator = async.iterator([
-        function(){call_order.push(1);},
-        function(arg1){
-            test.equals(arg1, 'arg1');
-            call_order.push(2);
-        },
-        function(arg1, arg2){
-            test.equals(arg1, 'arg1');
-            test.equals(arg2, 'arg2');
-            call_order.push(3);
-        }
-    ]);
-    var fn = iterator.next();
-    var iterator2 = fn('arg1');
-    test.same(call_order, [2]);
-    iterator2('arg1','arg2');
-    test.same(call_order, [2,3]);
-    test.equals(iterator2.next(), undefined);
-    test.done();
-};
-
-exports['forEach'] = function(test){
-    var args = [];
-    async.forEach([1,3,2], function(x, callback){
-        setTimeout(function(){
-            args.push(x);
-            callback();
-        }, x*25);
-    }, function(err){
-        test.same(args, [1,2,3]);
-        test.done();
-    });
-};
-
-exports['forEach empty array'] = function(test){
-    test.expect(1);
-    async.forEach([], function(x, callback){
-        test.ok(false, 'iterator should not be called');
-        callback();
-    }, function(err){
-        test.ok(true, 'should call callback');
-    });
-    setTimeout(test.done, 25);
-};
-
-exports['forEach error'] = function(test){
-    test.expect(1);
-    async.forEach([1,2,3], function(x, callback){
-        callback('error');
-    }, function(err){
-        test.equals(err, 'error');
-    });
-    setTimeout(test.done, 50);
-};
-
-exports['forEachSeries'] = function(test){
-    var args = [];
-    async.forEachSeries([1,3,2], function(x, callback){
-        setTimeout(function(){
-            args.push(x);
-            callback();
-        }, x*25);
-    }, function(err){
-        test.same(args, [1,3,2]);
-        test.done();
-    });
-};
-
-exports['forEachSeries empty array'] = function(test){
-    test.expect(1);
-    async.forEachSeries([], function(x, callback){
-        test.ok(false, 'iterator should not be called');
-        callback();
-    }, function(err){
-        test.ok(true, 'should call callback');
-    });
-    setTimeout(test.done, 25);
-};
-
-exports['forEachSeries error'] = function(test){
-    test.expect(2);
-    var call_order = [];
-    async.forEachSeries([1,2,3], function(x, callback){
-        call_order.push(x);
-        callback('error');
-    }, function(err){
-        test.same(call_order, [1]);
-        test.equals(err, 'error');
-    });
-    setTimeout(test.done, 50);
-};
-
-exports['forEachLimit'] = function(test){
-    var args = [];
-    var arr = [0,1,2,3,4,5,6,7,8,9];
-    async.forEachLimit(arr, 2, function(x,callback){
-        setTimeout(function(){
-            args.push(x);
-            callback();
-        }, x*5);
-    }, function(err){
-        test.same(args, arr);
-        test.done();
-    });
-};
-
-exports['forEachLimit empty array'] = function(test){
-    test.expect(1);
-    async.forEachLimit([], 2, function(x, callback){
-        test.ok(false, 'iterator should not be called');
-        callback();
-    }, function(err){
-        test.ok(true, 'should call callback');
-    });
-    setTimeout(test.done, 25);
-};
-
-exports['forEachLimit limit exceeds size'] = function(test){
-    var args = [];
-    var arr = [0,1,2,3,4,5,6,7,8,9];
-    async.forEachLimit(arr, 20, function(x,callback){
-        setTimeout(function(){
-            args.push(x);
-            callback();
-        }, x*5);
-    }, function(err){
-        test.same(args, arr);
-        test.done();
-    });
-};
-
-exports['forEachLimit limit equal size'] = function(test){
-    var args = [];
-    var arr = [0,1,2,3,4,5,6,7,8,9];
-    async.forEachLimit(arr, 10, function(x,callback){
-        setTimeout(function(){
-            args.push(x);
-            callback();
-        }, x*5);
-    }, function(err){
-        test.same(args, arr);
-        test.done();
-    });
-};
-
-exports['forEachLimit zero limit'] = function(test){
-    test.expect(1);
-    async.forEachLimit([0,1,2,3,4,5], 0, function(x, callback){
-        test.ok(false, 'iterator should not be called');
-        callback();
-    }, function(err){
-        test.ok(true, 'should call callback');
-    });
-    setTimeout(test.done, 25);
-};
-
-exports['forEachLimit error'] = function(test){
-    test.expect(2);
-    var arr = [0,1,2,3,4,5,6,7,8,9];
-    var call_order = [];
-    
-    async.forEachLimit(arr, 3, function(x, callback){
-        call_order.push(x);
-        if (x === 2) {
-            callback('error');
-        }
-    }, function(err){
-        test.same(call_order, [0,1,2]);
-        test.equals(err, 'error');
-    });
-    setTimeout(test.done, 25);
-};
-
-exports['map'] = function(test){
-    var call_order = [];
-    async.map([1,3,2], function(x, callback){
-        setTimeout(function(){
-            call_order.push(x);
-            callback(null, x*2);
-        }, x*25);
-    }, function(err, results){
-        test.same(call_order, [1,2,3]);
-        test.same(results, [2,6,4]);
-        test.done();
-    });
-};
-
-exports['map original untouched'] = function(test){
-    var a = [1,2,3];
-    async.map(a, function(x, callback){
-        callback(null, x*2);
-    }, function(err, results){
-        test.same(results, [2,4,6]);
-        test.same(a, [1,2,3]);
-        test.done();
-    });
-};
-
-exports['map error'] = function(test){
-    test.expect(1);
-    async.map([1,2,3], function(x, callback){
-        callback('error');
-    }, function(err, results){
-        test.equals(err, 'error');
-    });
-    setTimeout(test.done, 50);
-};
-
-exports['mapSeries'] = function(test){
-    var call_order = [];
-    async.mapSeries([1,3,2], function(x, callback){
-        setTimeout(function(){
-            call_order.push(x);
-            callback(null, x*2);
-        }, x*25);
-    }, function(err, results){
-        test.same(call_order, [1,3,2]);
-        test.same(results, [2,6,4]);
-        test.done();
-    });
-};
-
-exports['mapSeries error'] = function(test){
-    test.expect(1);
-    async.mapSeries([1,2,3], function(x, callback){
-        callback('error');
-    }, function(err, results){
-        test.equals(err, 'error');
-    });
-    setTimeout(test.done, 50);
-};
-
-exports['reduce'] = function(test){
-    var call_order = [];
-    async.reduce([1,2,3], 0, function(a, x, callback){
-        call_order.push(x);
-        callback(null, a + x);
-    }, function(err, result){
-        test.equals(result, 6);
-        test.same(call_order, [1,2,3]);
-        test.done();
-    });
-};
-
-exports['reduce async with non-reference memo'] = function(test){
-    async.reduce([1,3,2], 0, function(a, x, callback){
-        setTimeout(function(){callback(null, a + x)}, Math.random()*100);
-    }, function(err, result){
-        test.equals(result, 6);
-        test.done();
-    });
-};
-
-exports['reduce error'] = function(test){
-    test.expect(1);
-    async.reduce([1,2,3], 0, function(a, x, callback){
-        callback('error');
-    }, function(err, result){
-        test.equals(err, 'error');
-    });
-    setTimeout(test.done, 50);
-};
-
-exports['inject alias'] = function(test){
-    test.equals(async.inject, async.reduce);
-    test.done();
-};
-
-exports['foldl alias'] = function(test){
-    test.equals(async.foldl, async.reduce);
-    test.done();
-};
-
-exports['reduceRight'] = function(test){
-    var call_order = [];
-    var a = [1,2,3];
-    async.reduceRight(a, 0, function(a, x, callback){
-        call_order.push(x);
-        callback(null, a + x);
-    }, function(err, result){
-        test.equals(result, 6);
-        test.same(call_order, [3,2,1]);
-        test.same(a, [1,2,3]);
-        test.done();
-    });
-};
-
-exports['foldr alias'] = function(test){
-    test.equals(async.foldr, async.reduceRight);
-    test.done();
-};
-
-exports['filter'] = function(test){
-    async.filter([3,1,2], function(x, callback){
-        setTimeout(function(){callback(x % 2);}, x*25);
-    }, function(results){
-        test.same(results, [3,1]);
-        test.done();
-    });
-};
-
-exports['filter original untouched'] = function(test){
-    var a = [3,1,2];
-    async.filter(a, function(x, callback){
-        callback(x % 2);
-    }, function(results){
-        test.same(results, [3,1]);
-        test.same(a, [3,1,2]);
-        test.done();
-    });
-};
-
-exports['filterSeries'] = function(test){
-    async.filterSeries([3,1,2], function(x, callback){
-        setTimeout(function(){callback(x % 2);}, x*25);
-    }, function(results){
-        test.same(results, [3,1]);
-        test.done();
-    });
-};
-
-exports['select alias'] = function(test){
-    test.equals(async.select, async.filter);
-    test.done();
-};
-
-exports['selectSeries alias'] = function(test){
-    test.equals(async.selectSeries, async.filterSeries);
-    test.done();
-};
-
-exports['reject'] = function(test){
-    async.reject([3,1,2], function(x, callback){
-        setTimeout(function(){callback(x % 2);}, x*25);
-    }, function(results){
-        test.same(results, [2]);
-        test.done();
-    });
-};
-
-exports['reject original untouched'] = function(test){
-    var a = [3,1,2];
-    async.reject(a, function(x, callback){
-        callback(x % 2);
-    }, function(results){
-        test.same(results, [2]);
-        test.same(a, [3,1,2]);
-        test.done();
-    });
-};
-
-exports['rejectSeries'] = function(test){
-    async.rejectSeries([3,1,2], function(x, callback){
-        setTimeout(function(){callback(x % 2);}, x*25);
-    }, function(results){
-        test.same(results, [2]);
-        test.done();
-    });
-};
-
-exports['some true'] = function(test){
-    async.some([3,1,2], function(x, callback){
-        setTimeout(function(){callback(x === 1);}, 0);
-    }, function(result){
-        test.equals(result, true);
-        test.done();
-    });
-};
-
-exports['some false'] = function(test){
-    async.some([3,1,2], function(x, callback){
-        setTimeout(function(){callback(x === 10);}, 0);
-    }, function(result){
-        test.equals(result, false);
-        test.done();
-    });
-};
-
-exports['some early return'] = function(test){
-    var call_order = [];
-    async.some([1,2,3], function(x, callback){
-        setTimeout(function(){
-            call_order.push(x);
-            callback(x === 1);
-        }, x*25);
-    }, function(result){
-        call_order.push('callback');
-    });
-    setTimeout(function(){
-        test.same(call_order, [1,'callback',2,3]);
-        test.done();
-    }, 100);
-};
-
-exports['any alias'] = function(test){
-    test.equals(async.any, async.some);
-    test.done();
-};
-
-exports['every true'] = function(test){
-    async.every([1,2,3], function(x, callback){
-        setTimeout(function(){callback(true);}, 0);
-    }, function(result){
-        test.equals(result, true);
-        test.done();
-    });
-};
-
-exports['every false'] = function(test){
-    async.every([1,2,3], function(x, callback){
-        setTimeout(function(){callback(x % 2);}, 0);
-    }, function(result){
-        test.equals(result, false);
-        test.done();
-    });
-};
-
-exports['every early return'] = function(test){
-    var call_order = [];
-    async.every([1,2,3], function(x, callback){
-        setTimeout(function(){
-            call_order.push(x);
-            callback(x === 1);
-        }, x*25);
-    }, function(result){
-        call_order.push('callback');
-    });
-    setTimeout(function(){
-        test.same(call_order, [1,2,'callback',3]);
-        test.done();
-    }, 100);
-};
-
-exports['all alias'] = function(test){
-    test.equals(async.all, async.every);
-    test.done();
-};
-
-exports['detect'] = function(test){
-    var call_order = [];
-    async.detect([3,2,1], function(x, callback){
-        setTimeout(function(){
-            call_order.push(x);
-            callback(x == 2);
-        }, x*25);
-    }, function(result){
-        call_order.push('callback');
-        test.equals(result, 2);
-    });
-    setTimeout(function(){
-        test.same(call_order, [1,2,'callback',3]);
-        test.done();
-    }, 100);
-};
-
-exports['detect - mulitple matches'] = function(test){
-    var call_order = [];
-    async.detect([3,2,2,1,2], function(x, callback){
-        setTimeout(function(){
-            call_order.push(x);
-            callback(x == 2);
-        }, x*25);
-    }, function(result){
-        call_order.push('callback');
-        test.equals(result, 2);
-    });
-    setTimeout(function(){
-        test.same(call_order, [1,2,'callback',2,2,3]);
-        test.done();
-    }, 100);
-};
-
-exports['detectSeries'] = function(test){
-    var call_order = [];
-    async.detectSeries([3,2,1], function(x, callback){
-        setTimeout(function(){
-            call_order.push(x);
-            callback(x == 2);
-        }, x*25);
-    }, function(result){
-        call_order.push('callback');
-        test.equals(result, 2);
-    });
-    setTimeout(function(){
-        test.same(call_order, [3,2,'callback']);
-        test.done();
-    }, 200);
-};
-
-exports['detectSeries - multiple matches'] = function(test){
-    var call_order = [];
-    async.detectSeries([3,2,2,1,2], function(x, callback){
-        setTimeout(function(){
-            call_order.push(x);
-            callback(x == 2);
-        }, x*25);
-    }, function(result){
-        call_order.push('callback');
-        test.equals(result, 2);
-    });
-    setTimeout(function(){
-        test.same(call_order, [3,2,'callback']);
-        test.done();
-    }, 200);
-};
-
-exports['sortBy'] = function(test){
-    async.sortBy([{a:1},{a:15},{a:6}], function(x, callback){
-        setTimeout(function(){callback(null, x.a);}, 0);
-    }, function(err, result){
-        test.same(result, [{a:1},{a:6},{a:15}]);
-        test.done();
-    });
-};
-
-exports['apply'] = function(test){
-    test.expect(6);
-    var fn = function(){
-        test.same(Array.prototype.slice.call(arguments), [1,2,3,4])
-    };
-    async.apply(fn, 1, 2, 3, 4)();
-    async.apply(fn, 1, 2, 3)(4);
-    async.apply(fn, 1, 2)(3, 4);
-    async.apply(fn, 1)(2, 3, 4);
-    async.apply(fn)(1, 2, 3, 4);
-    test.equals(
-        async.apply(function(name){return 'hello ' + name}, 'world')(),
-        'hello world'
-    );
-    test.done();
-};
-
-
-// generates tests for console functions such as async.log
-var console_fn_tests = function(name){
-
-    if (typeof console !== 'undefined') {
-        exports[name] = function(test){
-            test.expect(5);
-            var fn = function(arg1, callback){
-                test.equals(arg1, 'one');
-                setTimeout(function(){callback(null, 'test');}, 0);
-            };
-            var fn_err = function(arg1, callback){
-                test.equals(arg1, 'one');
-                setTimeout(function(){callback('error');}, 0);
-            };
-            var _console_fn = console[name];
-            var _error = console.error;
-            console[name] = function(val){
-                test.equals(val, 'test');
-                test.equals(arguments.length, 1);
-                console.error = function(val){
-                    test.equals(val, 'error');
-                    console[name] = _console_fn;
-                    console.error = _error;
-                    test.done();
-                };
-                async[name](fn_err, 'one');
-            };
-            async[name](fn, 'one');
-        };
-
-        exports[name + ' with multiple result params'] = function(test){
-            var fn = function(callback){callback(null,'one','two','three');};
-            var _console_fn = console[name];
-            var called_with = [];
-            console[name] = function(x){
-                called_with.push(x);
-            };
-            async[name](fn);
-            test.same(called_with, ['one','two','three']);
-            console[name] = _console_fn;
-            test.done();
-        };
-    }
-
-    // browser-only test
-    exports[name + ' without console.' + name] = function(test){
-        if (typeof window !== 'undefined') {
-            var _console = window.console;
-            window.console = undefined;
-            var fn = function(callback){callback(null, 'val');};
-            var fn_err = function(callback){callback('error');};
-            async[name](fn);
-            async[name](fn_err);
-            window.console = _console;
-        }
-        test.done();
-    };
-
-};
-
-console_fn_tests('log');
-console_fn_tests('dir');
-/*console_fn_tests('info');
-console_fn_tests('warn');
-console_fn_tests('error');*/
-
-exports['nextTick'] = function(test){
-    var call_order = [];
-    async.nextTick(function(){call_order.push('two');});
-    call_order.push('one');
-    setTimeout(function(){
-        test.same(call_order, ['one','two']);
-        test.done();
-    }, 50);
-};
-
-exports['nextTick in the browser'] = function(test){
-    if (typeof process !== 'undefined') {
-        // skip this test in node
-        return test.done();
-    }
-    test.expect(1);
-
-    var call_order = [];
-    async.nextTick(function(){call_order.push('two');});
-
-    call_order.push('one');
-    setTimeout(function(){
-        if (typeof process !== 'undefined') {
-            process.nextTick = _nextTick;
-        }
-        test.same(call_order, ['one','two']);
-    }, 50);
-    setTimeout(test.done, 100);
-};
-
-exports['noConflict - node only'] = function(test){
-    if (typeof process !== 'undefined') {
-        // node only test
-        test.expect(3);
-        var fs = require('fs');
-        var filename = __dirname + '/../lib/async.js';
-        fs.readFile(filename, function(err, content){
-            if(err) return test.done();
-            var Script = process.binding('evals').Script;
-
-            var s = new Script(content, filename);
-            var s2 = new Script(
-                content + 'this.async2 = this.async.noConflict();',
-                filename
-            );
-
-            var sandbox1 = {async: 'oldvalue'};
-            s.runInNewContext(sandbox1);
-            test.ok(sandbox1.async);
-
-            var sandbox2 = {async: 'oldvalue'};
-            s2.runInNewContext(sandbox2);
-            test.equals(sandbox2.async, 'oldvalue');
-            test.ok(sandbox2.async2);
-
-            test.done();
-        });
-    }
-    else test.done();
-};
-
-exports['concat'] = function(test){
-    var call_order = [];
-    var iterator = function (x, cb) {
-        setTimeout(function(){
-            call_order.push(x);
-            var r = [];
-            while (x > 0) {
-                r.push(x);
-                x--;
-            }
-            cb(null, r);
-        }, x*25);
-    };
-    async.concat([1,3,2], iterator, function(err, results){
-        test.same(results, [1,2,1,3,2,1]);
-        test.same(call_order, [1,2,3]);
-        test.ok(!err);
-        test.done();
-    });
-};
-
-exports['concat error'] = function(test){
-    var iterator = function (x, cb) {
-        cb(new Error('test error'));
-    };
-    async.concat([1,2,3], iterator, function(err, results){
-        test.ok(err);
-        test.done();
-    });
-};
-
-exports['concatSeries'] = function(test){
-    var call_order = [];
-    var iterator = function (x, cb) {
-        setTimeout(function(){
-            call_order.push(x);
-            var r = [];
-            while (x > 0) {
-                r.push(x);
-                x--;
-            }
-            cb(null, r);
-        }, x*25);
-    };
-    async.concatSeries([1,3,2], iterator, function(err, results){
-        test.same(results, [1,3,2,1,2,1]);
-        test.same(call_order, [1,3,2]);
-        test.ok(!err);
-        test.done();
-    });
-};
-
-exports['until'] = function (test) {
-    var call_order = [];
-
-    var count = 0;
-    async.until(
-        function () {
-            call_order.push(['test', count]);
-            return (count == 5);
-        },
-        function (cb) {
-            call_order.push(['iterator', count]);
-            count++;
-            cb();
-        },
-        function (err) {
-            test.same(call_order, [
-                ['test', 0],
-                ['iterator', 0], ['test', 1],
-                ['iterator', 1], ['test', 2],
-                ['iterator', 2], ['test', 3],
-                ['iterator', 3], ['test', 4],
-                ['iterator', 4], ['test', 5],
-            ]);
-            test.equals(count, 5);
-            test.done();
-        }
-    );
-};
-
-exports['whilst'] = function (test) {
-    var call_order = [];
-
-    var count = 0;
-    async.whilst(
-        function () {
-            call_order.push(['test', count]);
-            return (count < 5);
-        },
-        function (cb) {
-            call_order.push(['iterator', count]);
-            count++;
-            cb();
-        },
-        function (err) {
-            test.same(call_order, [
-                ['test', 0],
-                ['iterator', 0], ['test', 1],
-                ['iterator', 1], ['test', 2],
-                ['iterator', 2], ['test', 3],
-                ['iterator', 3], ['test', 4],
-                ['iterator', 4], ['test', 5],
-            ]);
-            test.equals(count, 5);
-            test.done();
-        }
-    );
-};
-
-exports['queue'] = function (test) {
-    var call_order = [],
-        delays = [40,20,60,20];
-
-    // worker1: --1-4
-    // worker2: -2---3
-    // order of completion: 2,1,4,3
-
-    var q = async.queue(function (task, callback) {
-        setTimeout(function () {
-            call_order.push('process ' + task);
-            callback('error', 'arg');
-        }, delays.splice(0,1)[0]);
-    }, 2);
-
-    q.push(1, function (err, arg) {
-        test.equal(err, 'error');
-        test.equal(arg, 'arg');
-        test.equal(q.length(), 1);
-        call_order.push('callback ' + 1);
-    });
-    q.push(2, function (err, arg) {
-        test.equal(err, 'error');
-        test.equal(arg, 'arg');
-        test.equal(q.length(), 2);
-        call_order.push('callback ' + 2);
-    });
-    q.push(3, function (err, arg) {
-        test.equal(err, 'error');
-        test.equal(arg, 'arg');
-        test.equal(q.length(), 0);
-        call_order.push('callback ' + 3);
-    });
-    q.push(4, function (err, arg) {
-        test.equal(err, 'error');
-        test.equal(arg, 'arg');
-        test.equal(q.length(), 0);
-        call_order.push('callback ' + 4);
-    });
-    test.equal(q.length(), 4);
-    test.equal(q.concurrency, 2);
-
-    setTimeout(function () {
-        test.same(call_order, [
-            'process 2', 'callback 2',
-            'process 1', 'callback 1',
-            'process 4', 'callback 4',
-            'process 3', 'callback 3'
-        ]);
-        test.equal(q.concurrency, 2);
-        test.equal(q.length(), 0);
-        test.done();
-    }, 200);
-};
-
-exports['queue changing concurrency'] = function (test) {
-    var call_order = [],
-        delays = [40,20,60,20];
-
-    // worker1: --1-2---3-4
-    // order of completion: 1,2,3,4
-
-    var q = async.queue(function (task, callback) {
-        setTimeout(function () {
-            call_order.push('process ' + task);
-            callback('error', 'arg');
-        }, delays.splice(0,1)[0]);
-    }, 2);
-
-    q.push(1, function (err, arg) {
-        test.equal(err, 'error');
-        test.equal(arg, 'arg');
-        test.equal(q.length(), 3);
-        call_order.push('callback ' + 1);
-    });
-    q.push(2, function (err, arg) {
-        test.equal(err, 'error');
-        test.equal(arg, 'arg');
-        test.equal(q.length(), 2);
-        call_order.push('callback ' + 2);
-    });
-    q.push(3, function (err, arg) {
-        test.equal(err, 'error');
-        test.equal(arg, 'arg');
-        test.equal(q.length(), 1);
-        call_order.push('callback ' + 3);
-    });
-    q.push(4, function (err, arg) {
-        test.equal(err, 'error');
-        test.equal(arg, 'arg');
-        test.equal(q.length(), 0);
-        call_order.push('callback ' + 4);
-    });
-    test.equal(q.length(), 4);
-    test.equal(q.concurrency, 2);
-    q.concurrency = 1;
-
-    setTimeout(function () {
-        test.same(call_order, [
-            'process 1', 'callback 1',
-            'process 2', 'callback 2',
-            'process 3', 'callback 3',
-            'process 4', 'callback 4'
-        ]);
-        test.equal(q.concurrency, 1);
-        test.equal(q.length(), 0);
-        test.done();
-    }, 250);
-};
-
-exports['queue push without callback'] = function (test) {
-    var call_order = [],
-        delays = [40,20,60,20];
-
-    // worker1: --1-4
-    // worker2: -2---3
-    // order of completion: 2,1,4,3
-
-    var q = async.queue(function (task, callback) {
-        setTimeout(function () {
-            call_order.push('process ' + task);
-            callback('error', 'arg');
-        }, delays.splice(0,1)[0]);
-    }, 2);
-
-    q.push(1);
-    q.push(2);
-    q.push(3);
-    q.push(4);
-
-    setTimeout(function () {
-        test.same(call_order, [
-            'process 2',
-            'process 1',
-            'process 4',
-            'process 3'
-        ]);
-        test.done();
-    }, 200);
-};
-
-exports['memoize'] = function (test) {
-    test.expect(4);
-    var call_order = [];
-
-    var fn = function (arg1, arg2, callback) {
-        call_order.push(['fn', arg1, arg2]);
-        callback(null, arg1 + arg2);
-    };
-
-    var fn2 = async.memoize(fn);
-    fn2(1, 2, function (err, result) {
-        test.equal(result, 3);
-    });
-    fn2(1, 2, function (err, result) {
-        test.equal(result, 3);
-    });
-    fn2(2, 2, function (err, result) {
-        test.equal(result, 4);
-    });
-
-    test.same(call_order, [['fn',1,2], ['fn',2,2]]);
-    test.done();
-};
-
-exports['unmemoize'] = function(test) {
-    test.expect(4);
-    var call_order = [];
-
-    var fn = function (arg1, arg2, callback) {
-        call_order.push(['fn', arg1, arg2]);
-        callback(null, arg1 + arg2);
-    };
-
-    var fn2 = async.memoize(fn);
-    var fn3 = async.unmemoize(fn2);
-    fn3(1, 2, function (err, result) {
-        test.equal(result, 3);
-    });
-    fn3(1, 2, function (err, result) {
-        test.equal(result, 3);
-    });
-    fn3(2, 2, function (err, result) {
-        test.equal(result, 4);
-    });
-
-    test.same(call_order, [['fn',1,2], ['fn',1,2], ['fn',2,2]]);
-
-    test.done();
-}
-
-exports['unmemoize a not memoized function'] = function(test) {
-    test.expect(1);
-
-    var fn = function (arg1, arg2, callback) {
-        callback(null, arg1 + arg2);
-    };
-
-    var fn2 = async.unmemoize(fn);
-    fn2(1, 2, function(err, result) {
-        test.equal(result, 3);
-    });
-
-    test.done();
-}
-
-exports['memoize error'] = function (test) {
-    test.expect(1);
-    var testerr = new Error('test');
-    var fn = function (arg1, arg2, callback) {
-        callback(testerr, arg1 + arg2);
-    };
-    async.memoize(fn)(1, 2, function (err, result) {
-        test.equal(err, testerr);
-    });
-    test.done();
-};
-
-exports['memoize multiple calls'] = function (test) {
-    test.expect(3);
-    var fn = function (arg1, arg2, callback) {
-        test.ok(true);
-        setTimeout(function(){
-            callback(null, arg1, arg2);
-        }, 10);
-    };
-    var fn2 = async.memoize(fn);
-    fn2(1, 2, function(err, result) {
-        test.equal(result, 1, 2);
-    });
-    fn2(1, 2, function(err, result) {
-        test.equal(result, 1, 2);
-        test.done();
-    });
-};
-
-exports['memoize custom hash function'] = function (test) {
-    test.expect(2);
-    var testerr = new Error('test');
-
-    var fn = function (arg1, arg2, callback) {
-        callback(testerr, arg1 + arg2);
-    };
-    var fn2 = async.memoize(fn, function () {
-        return 'custom hash';
-    });
-    fn2(1, 2, function (err, result) {
-        test.equal(result, 3);
-    });
-    fn2(2, 2, function (err, result) {
-        test.equal(result, 3);
-    });
-    test.done();
-};
-
-// Issue 10 on github: https://github.com/caolan/async/issues#issue/10
-exports['falsy return values in series'] = function (test) {
-    function taskFalse(callback) {
-        async.nextTick(function() {
-            callback(null, false);
-        });
-    };
-    function taskUndefined(callback) {
-        async.nextTick(function() {
-            callback(null, undefined);
-        });
-    };
-    function taskEmpty(callback) {
-        async.nextTick(function() {
-            callback(null);
-        });
-    };
-    function taskNull(callback) {
-        async.nextTick(function() {
-            callback(null, null);
-        });
-    };
-    async.series(
-        [taskFalse, taskUndefined, taskEmpty, taskNull],
-        function(err, results) {
-            test.equal(results.length, 4);
-            test.strictEqual(results[0], false);
-            test.strictEqual(results[1], undefined);
-            test.strictEqual(results[2], undefined);
-            test.strictEqual(results[3], null);
-            test.done();
-        }
-    );
-};
-
-// Issue 10 on github: https://github.com/caolan/async/issues#issue/10
-exports['falsy return values in parallel'] = function (test) {
-    function taskFalse(callback) {
-        async.nextTick(function() {
-            callback(null, false);
-        });
-    };
-    function taskUndefined(callback) {
-        async.nextTick(function() {
-            callback(null, undefined);
-        });
-    };
-    function taskEmpty(callback) {
-        async.nextTick(function() {
-            callback(null);
-        });
-    };
-    function taskNull(callback) {
-        async.nextTick(function() {
-            callback(null, null);
-        });
-    };
-    async.parallel(
-        [taskFalse, taskUndefined, taskEmpty, taskNull],
-        function(err, results) {
-            test.equal(results.length, 4);
-            test.strictEqual(results[0], false);
-            test.strictEqual(results[1], undefined);
-            test.strictEqual(results[2], undefined);
-            test.strictEqual(results[3], null);
-            test.done();
-        }
-    );
-};
-
-exports['queue events'] = function(test) {
-    var calls = [];
-    var q = async.queue(function(task, cb) {
-        // nop
-        calls.push('process ' + task);
-        cb();
-    }, 3);
-
-    q.saturated = function() {
-        test.ok(q.length() == 3, 'queue should be saturated now');
-        calls.push('saturated');
-    };
-    q.empty = function() {
-        test.ok(q.length() == 0, 'queue should be empty now');
-        calls.push('empty');
-    };
-    q.drain = function() {
-        test.ok(
-            q.length() == 0 && q.running() == 0,
-            'queue should be empty now and no more workers should be running'
-        );
-        calls.push('drain');
-        test.same(calls, [
-            'saturated',
-            'process foo',
-            'foo cb',
-            'process bar',
-            'bar cb',
-            'process zoo',
-            'zoo cb',
-            'process poo',
-            'poo cb',
-            'empty',
-            'process moo',
-            'moo cb',
-            'drain',
-        ]);
-        test.done();
-    };
-    q.push('foo', function () {calls.push('foo cb');});
-    q.push('bar', function () {calls.push('bar cb');});
-    q.push('zoo', function () {calls.push('zoo cb');});
-    q.push('poo', function () {calls.push('poo cb');});
-    q.push('moo', function () {calls.push('moo cb');});
-};

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/async/test/test.html
----------------------------------------------------------------------
diff --git a/node_modules/async/test/test.html b/node_modules/async/test/test.html
deleted file mode 100644
index 2450e2d..0000000
--- a/node_modules/async/test/test.html
+++ /dev/null
@@ -1,24 +0,0 @@
-<html>
-  <head>
-    <title>Async.js Test Suite</title>
-    <!--
-      async must be included after nodeunit because nodeunit already uses
-      the async lib internally and will overwrite the version we want to test
-    -->
-    <script src="../deps/nodeunit.js"></script>
-    <script src="../lib/async.js"></script>
-    <link rel="stylesheet" href="../deps/nodeunit.css" type="text/css" media="screen" />
-    <script>
-      var _async = this.async;
-      this.require = function () { return _async; };
-      this.exports = {};
-    </script>
-    <script src="test-async.js"></script>
-  </head>
-  <body>
-    <h1 id="nodeunit-header">Async.js Test Suite</h1>
-    <script>
-      nodeunit.run({'test-async': exports});
-    </script>
-  </body>
-</html>

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/coffee-script/.npmignore
----------------------------------------------------------------------
diff --git a/node_modules/coffee-script/.npmignore b/node_modules/coffee-script/.npmignore
deleted file mode 100644
index 21e430d..0000000
--- a/node_modules/coffee-script/.npmignore
+++ /dev/null
@@ -1,11 +0,0 @@
-*.coffee
-*.html
-.DS_Store
-.git*
-Cakefile
-documentation/
-examples/
-extras/coffee-script.js
-raw/
-src/
-test/

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/coffee-script/LICENSE
----------------------------------------------------------------------
diff --git a/node_modules/coffee-script/LICENSE b/node_modules/coffee-script/LICENSE
deleted file mode 100644
index 8cb3cfd..0000000
--- a/node_modules/coffee-script/LICENSE
+++ /dev/null
@@ -1,22 +0,0 @@
-Copyright (c) 2011 Jeremy Ashkenas
-
-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.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/coffee-script/README
----------------------------------------------------------------------
diff --git a/node_modules/coffee-script/README b/node_modules/coffee-script/README
deleted file mode 100644
index 69ee6f4..0000000
--- a/node_modules/coffee-script/README
+++ /dev/null
@@ -1,51 +0,0 @@
-
-            {
-         }   }   {
-        {   {  }  }
-         }   }{  {
-        {  }{  }  }                    _____       __  __
-       ( }{ }{  { )                   / ____|     / _|/ _|
-     .- { { }  { }} -.               | |     ___ | |_| |_ ___  ___
-    (  ( } { } { } }  )              | |    / _ \|  _|  _/ _ \/ _ \
-    |`-..________ ..-'|              | |___| (_) | | | ||  __/  __/
-    |                 |               \_____\___/|_| |_| \___|\___|
-    |                 ;--.
-    |                (__  \            _____           _       _
-    |                 | )  )          / ____|         (_)     | |
-    |                 |/  /          | (___   ___ _ __ _ _ __ | |_
-    |                 (  /            \___ \ / __| '__| | '_ \| __|
-    |                 |/              ____) | (__| |  | | |_) | |_
-    |                 |              |_____/ \___|_|  |_| .__/ \__|
-     `-.._________..-'                                  | |
-                                                        |_|
-
-
-  CoffeeScript is a little language that compiles into JavaScript.
-
-  Install Node.js, and then the CoffeeScript compiler:
-  sudo bin/cake install
-
-  Or, if you have the Node Package Manager installed:
-  npm install -g coffee-script
-  (Leave off the -g if you don't wish to install globally.)
-
-  Execute a script:
-  coffee /path/to/script.coffee
-
-  Compile a script:
-  coffee -c /path/to/script.coffee
-
-  For documentation, usage, and examples, see:
-  http://coffeescript.org/
-
-  To suggest a feature, report a bug, or general discussion:
-  http://github.com/jashkenas/coffee-script/issues/
-
-  If you'd like to chat, drop by #coffeescript on Freenode IRC,
-  or on webchat.freenode.net.
-
-  The source repository:
-  git://github.com/jashkenas/coffee-script.git
-
-  All contributors are listed here:
-  http://github.com/jashkenas/coffee-script/contributors

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/coffee-script/Rakefile
----------------------------------------------------------------------
diff --git a/node_modules/coffee-script/Rakefile b/node_modules/coffee-script/Rakefile
deleted file mode 100644
index dfb85da..0000000
--- a/node_modules/coffee-script/Rakefile
+++ /dev/null
@@ -1,78 +0,0 @@
-require 'rubygems'
-require 'erb'
-require 'fileutils'
-require 'rake/testtask'
-require 'json'
-
-desc "Build the documentation page"
-task :doc do
-  source = 'documentation/index.html.erb'
-  child = fork { exec "bin/coffee -bcw -o documentation/js documentation/coffee/*.coffee" }
-  at_exit { Process.kill("INT", child) }
-  Signal.trap("INT") { exit }
-  loop do
-    mtime = File.stat(source).mtime
-    if !@mtime || mtime > @mtime
-      rendered = ERB.new(File.read(source)).result(binding)
-      File.open('index.html', 'w+') {|f| f.write(rendered) }
-    end
-    @mtime = mtime
-    sleep 1
-  end
-end
-
-desc "Build coffee-script-source gem"
-task :gem do
-  require 'rubygems'
-  require 'rubygems/package'
-
-  gemspec = Gem::Specification.new do |s|
-    s.name      = 'coffee-script-source'
-    s.version   = JSON.parse(File.read('package.json'))["version"]
-    s.date      = Time.now.strftime("%Y-%m-%d")
-
-    s.homepage    = "http://jashkenas.github.com/coffee-script/"
-    s.summary     = "The CoffeeScript Compiler"
-    s.description = <<-EOS
-      CoffeeScript is a little language that compiles into JavaScript.
-      Underneath all of those embarrassing braces and semicolons,
-      JavaScript has always had a gorgeous object model at its heart.
-      CoffeeScript is an attempt to expose the good parts of JavaScript
-      in a simple way.
-    EOS
-
-    s.files = [
-      'lib/coffee_script/coffee-script.js',
-      'lib/coffee_script/source.rb'
-    ]
-
-    s.authors           = ['Jeremy Ashkenas']
-    s.email             = 'jashkenas@gmail.com'
-    s.rubyforge_project = 'coffee-script-source'
-  end
-
-  file = File.open("coffee-script-source.gem", "w")
-  Gem::Package.open(file, 'w') do |pkg|
-    pkg.metadata = gemspec.to_yaml
-
-    path = "lib/coffee_script/source.rb"
-    contents = <<-ERUBY
-module CoffeeScript
-  module Source
-    def self.bundled_path
-      File.expand_path("../coffee-script.js", __FILE__)
-    end
-  end
-end
-    ERUBY
-    pkg.add_file_simple(path, 0644, contents.size) do |tar_io|
-      tar_io.write(contents)
-    end
-
-    contents = File.read("extras/coffee-script.js")
-    path = "lib/coffee_script/coffee-script.js"
-    pkg.add_file_simple(path, 0644, contents.size) do |tar_io|
-      tar_io.write(contents)
-    end
-  end
-end

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/coffee-script/bin/cake
----------------------------------------------------------------------
diff --git a/node_modules/coffee-script/bin/cake b/node_modules/coffee-script/bin/cake
deleted file mode 100755
index 5965f4e..0000000
--- a/node_modules/coffee-script/bin/cake
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-
-var path = require('path');
-var fs   = require('fs');
-var lib  = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
-
-require(lib + '/coffee-script/cake').run();

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/coffee-script/bin/coffee
----------------------------------------------------------------------
diff --git a/node_modules/coffee-script/bin/coffee b/node_modules/coffee-script/bin/coffee
deleted file mode 100755
index 3d1d71c..0000000
--- a/node_modules/coffee-script/bin/coffee
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-
-var path = require('path');
-var fs   = require('fs');
-var lib  = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
-
-require(lib + '/coffee-script/command').run();

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/coffee-script/extras/jsl.conf
----------------------------------------------------------------------
diff --git a/node_modules/coffee-script/extras/jsl.conf b/node_modules/coffee-script/extras/jsl.conf
deleted file mode 100644
index 1190da5..0000000
--- a/node_modules/coffee-script/extras/jsl.conf
+++ /dev/null
@@ -1,44 +0,0 @@
-# JavaScriptLint configuration file for CoffeeScript.
-
-+no_return_value              # function {0} does not always return a value
-+duplicate_formal             # duplicate formal argument {0}
--equal_as_assign              # test for equality (==) mistyped as assignment (=)?{0}
-+var_hides_arg                # variable {0} hides argument
-+redeclared_var               # redeclaration of {0} {1}
--anon_no_return_value         # anonymous function does not always return a value
-+missing_semicolon            # missing semicolon
-+meaningless_block            # meaningless block; curly braces have no impact
--comma_separated_stmts        # multiple statements separated by commas (use semicolons?)
-+unreachable_code             # unreachable code
-+missing_break                # missing break statement
--missing_break_for_last_case  # missing break statement for last case in switch
--comparison_type_conv         # comparisons against null, 0, true, false, or an empty string allowing implicit type conversion (use === or !==)
--inc_dec_within_stmt          # increment (++) and decrement (--) operators used as part of greater statement
--useless_void                 # use of the void type may be unnecessary (void is always undefined)
-+multiple_plus_minus          # unknown order of operations for successive plus (e.g. x+++y) or minus (e.g. x---y) signs
-+use_of_label                 # use of label
--block_without_braces         # block statement without curly braces
-+leading_decimal_point        # leading decimal point may indicate a number or an object member
-+trailing_decimal_point       # trailing decimal point may indicate a number or an object member
-+octal_number                 # leading zeros make an octal number
-+nested_comment               # nested comment
-+misplaced_regex              # regular expressions should be preceded by a left parenthesis, assignment, colon, or comma
-+ambiguous_newline            # unexpected end of line; it is ambiguous whether these lines are part of the same statement
-+empty_statement              # empty statement or extra semicolon
--missing_option_explicit      # the "option explicit" control comment is missing
-+partial_option_explicit      # the "option explicit" control comment, if used, must be in the first script tag
-+dup_option_explicit          # duplicate "option explicit" control comment
-+useless_assign               # useless assignment
-+ambiguous_nested_stmt        # block statements containing block statements should use curly braces to resolve ambiguity
-+ambiguous_else_stmt          # the else statement could be matched with one of multiple if statements (use curly braces to indicate intent)
--missing_default_case         # missing default case in switch statement
-+duplicate_case_in_switch     # duplicate case in switch statements
-+default_not_at_end           # the default case is not at the end of the switch statement
-+legacy_cc_not_understood     # couldn't understand control comment using /*@keyword@*/ syntax
-+jsl_cc_not_understood        # couldn't understand control comment using /*jsl:keyword*/ syntax
-+useless_comparison           # useless comparison; comparing identical expressions
-+with_statement               # with statement hides undeclared variables; use temporary variable instead
-+trailing_comma_in_array      # extra comma is not recommended in array initializers
-+assign_to_function_call      # assignment to a function call
-+parseint_missing_radix       # parseInt missing radix parameter
-+lambda_assign_requires_semicolon

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/coffee-script/lib/coffee-script/browser.js
----------------------------------------------------------------------
diff --git a/node_modules/coffee-script/lib/coffee-script/browser.js b/node_modules/coffee-script/lib/coffee-script/browser.js
deleted file mode 100644
index ec2e479..0000000
--- a/node_modules/coffee-script/lib/coffee-script/browser.js
+++ /dev/null
@@ -1,74 +0,0 @@
-(function() {
-  var CoffeeScript, runScripts;
-
-  CoffeeScript = require('./coffee-script');
-
-  CoffeeScript.require = require;
-
-  CoffeeScript.eval = function(code, options) {
-    return eval(CoffeeScript.compile(code, options));
-  };
-
-  CoffeeScript.run = function(code, options) {
-    if (options == null) options = {};
-    options.bare = true;
-    return Function(CoffeeScript.compile(code, options))();
-  };
-
-  if (typeof window === "undefined" || window === null) return;
-
-  CoffeeScript.load = function(url, callback) {
-    var xhr;
-    xhr = new (window.ActiveXObject || XMLHttpRequest)('Microsoft.XMLHTTP');
-    xhr.open('GET', url, true);
-    if ('overrideMimeType' in xhr) xhr.overrideMimeType('text/plain');
-    xhr.onreadystatechange = function() {
-      var _ref;
-      if (xhr.readyState === 4) {
-        if ((_ref = xhr.status) === 0 || _ref === 200) {
-          CoffeeScript.run(xhr.responseText);
-        } else {
-          throw new Error("Could not load " + url);
-        }
-        if (callback) return callback();
-      }
-    };
-    return xhr.send(null);
-  };
-
-  runScripts = function() {
-    var coffees, execute, index, length, s, scripts;
-    scripts = document.getElementsByTagName('script');
-    coffees = (function() {
-      var _i, _len, _results;
-      _results = [];
-      for (_i = 0, _len = scripts.length; _i < _len; _i++) {
-        s = scripts[_i];
-        if (s.type === 'text/coffeescript') _results.push(s);
-      }
-      return _results;
-    })();
-    index = 0;
-    length = coffees.length;
-    (execute = function() {
-      var script;
-      script = coffees[index++];
-      if ((script != null ? script.type : void 0) === 'text/coffeescript') {
-        if (script.src) {
-          return CoffeeScript.load(script.src, execute);
-        } else {
-          CoffeeScript.run(script.innerHTML);
-          return execute();
-        }
-      }
-    })();
-    return null;
-  };
-
-  if (window.addEventListener) {
-    addEventListener('DOMContentLoaded', runScripts, false);
-  } else {
-    attachEvent('onload', runScripts);
-  }
-
-}).call(this);

http://git-wip-us.apache.org/repos/asf/incubator-cordova-coho/blob/1d113e44/node_modules/coffee-script/lib/coffee-script/cake.js
----------------------------------------------------------------------
diff --git a/node_modules/coffee-script/lib/coffee-script/cake.js b/node_modules/coffee-script/lib/coffee-script/cake.js
deleted file mode 100644
index 986d5cc..0000000
--- a/node_modules/coffee-script/lib/coffee-script/cake.js
+++ /dev/null
@@ -1,99 +0,0 @@
-(function() {
-  var CoffeeScript, cakefileDirectory, fatalError, fs, helpers, missingTask, oparse, options, optparse, path, printTasks, switches, tasks;
-
-  fs = require('fs');
-
-  path = require('path');
-
-  helpers = require('./helpers');
-
-  optparse = require('./optparse');
-
-  CoffeeScript = require('./coffee-script');
-
-  tasks = {};
-
-  options = {};
-
-  switches = [];
-
-  oparse = null;
-
-  helpers.extend(global, {
-    task: function(name, description, action) {
-      var _ref;
-      if (!action) {
-        _ref = [description, action], action = _ref[0], description = _ref[1];
-      }
-      return tasks[name] = {
-        name: name,
-        description: description,
-        action: action
-      };
-    },
-    option: function(letter, flag, description) {
-      return switches.push([letter, flag, description]);
-    },
-    invoke: function(name) {
-      if (!tasks[name]) missingTask(name);
-      return tasks[name].action(options);
-    }
-  });
-
-  exports.run = function() {
-    var arg, args, _i, _len, _ref, _results;
-    global.__originalDirname = fs.realpathSync('.');
-    process.chdir(cakefileDirectory(__originalDirname));
-    args = process.argv.slice(2);
-    CoffeeScript.run(fs.readFileSync('Cakefile').toString(), {
-      filename: 'Cakefile'
-    });
-    oparse = new optparse.OptionParser(switches);
-    if (!args.length) return printTasks();
-    try {
-      options = oparse.parse(args);
-    } catch (e) {
-      return fatalError("" + e);
-    }
-    _ref = options.arguments;
-    _results = [];
-    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-      arg = _ref[_i];
-      _results.push(invoke(arg));
-    }
-    return _results;
-  };
-
-  printTasks = function() {
-    var cakefilePath, desc, name, spaces, task;
-    cakefilePath = path.join(path.relative(__originalDirname, process.cwd()), 'Cakefile');
-    console.log("" + cakefilePath + " defines the following tasks:\n");
-    for (name in tasks) {
-      task = tasks[name];
-      spaces = 20 - name.length;
-      spaces = spaces > 0 ? Array(spaces + 1).join(' ') : '';
-      desc = task.description ? "# " + task.description : '';
-      console.log("cake " + name + spaces + " " + desc);
-    }
-    if (switches.length) return console.log(oparse.help());
-  };
-
-  fatalError = function(message) {
-    console.error(message + '\n');
-    console.log('To see a list of all tasks/options, run "cake"');
-    return process.exit(1);
-  };
-
-  missingTask = function(task) {
-    return fatalError("No such task: " + task);
-  };
-
-  cakefileDirectory = function(dir) {
-    var parent;
-    if (path.existsSync(path.join(dir, 'Cakefile'))) return dir;
-    parent = path.normalize(path.join(dir, '..'));
-    if (parent !== dir) return cakefileDirectory(parent);
-    throw new Error("Cakefile not found in " + (process.cwd()));
-  };
-
-}).call(this);


Mime
View raw message