Initial import from local backup (Documents-Playground/pakerpale)

node_modules/seq/test/readdir.js

@@ -0,0 +1,35 @@
+var assert = require('assert');
+var Seq = require('seq');
+var fs = require('fs');
+
+exports.readdir = function () {
+    var to = setTimeout(function () {
+        assert.fail('never got to the end of the chain');
+    }, 500);
+    
+    Seq()
+        .seq(fs.readdir, __dirname, Seq)
+        .seq(function (files) {
+            clearTimeout(to);
+            assert.ok(files.length >= 2);
+        })
+        .catch(assert.fail)
+    ;
+}; 
+
+exports.readdirs = function () {
+    var to = setTimeout(function () {
+        assert.fail('never got to the end of the chain');
+    }, 500);
+    
+    Seq()
+        .par(fs.readdir, __dirname, Seq)
+        .par(fs.readdir, __dirname + '/../examples', Seq)
+        .seq(function (tests, examples) {
+            clearTimeout(to);
+            assert.ok(tests.length >= 2);
+            assert.ok(examples.length >= 2);
+        })
+        .catch(assert.fail)
+    ;
+}; 

node_modules/seq/test/seq.js

@@ -0,0 +1,946 @@
+var Seq = require('seq');
+var assert = require('assert');
+
+exports.seq = function () {
+    var to = setTimeout(function () {
+        assert.fail('never got to the end of the chain');
+    }, 100);
+    
+    Seq([0])
+        .seq('pow', function (n) {
+            this(null, 1);
+        })
+        .seq(function (n) {
+            assert.eql(n, 1);
+            assert.eql(n, this.vars.pow);
+            var seq = this;
+            setTimeout(function () { seq(null, 2) }, 25);
+            assert.eql(this.stack, [n]);
+        })
+        .seq(function (n) {
+            assert.eql(n, 2);
+            assert.eql(this.stack, [n]);
+            this(null, 5, 6, 7);
+        })
+        .seq(function (x, y, z) {
+            clearTimeout(to);
+            assert.eql([x,y,z], [5,6,7]);
+        })
+    ;
+};
+
+exports.into = function () {
+    var to = setTimeout(function () {
+        assert.fail('never got to the end of the chain');
+    }, 10);
+    var calls = 0;
+    
+    Seq([3,4,5])
+        .seq(function () {
+            this.into('w')(null, 5);
+        })
+        .seq(function (w) {
+            clearTimeout(to);
+            assert.eql(w, this.vars.w);
+            assert.eql(arguments.length, 1);
+            assert.eql(w, 5);
+        })
+    ;
+};
+
+exports.catchSeq = function () {
+    var to = setTimeout(function () {
+        assert.fail('never caught the error');
+    }, 100);
+    
+    var tf = setTimeout(function () {
+        assert.fail('final action never executed');
+    }, 100);
+    
+    var calls = {};
+    Seq([1])
+        .seq(function (n) {
+            assert.eql(n, 1);
+            calls.before = true;
+            this('pow!');
+            calls.after = true;
+        })
+        .seq(function (n) {
+            calls.next = true;
+            assert.fail('should have skipped this');
+        })
+        .catch(function (err) {
+            assert.eql(err, 'pow!');
+            assert.ok(calls.before);
+            assert.ok(!calls.after);
+            assert.ok(!calls.next);
+            clearTimeout(to);
+        })
+        .do(function () {
+            //assert.ok(calls.after);
+            clearTimeout(tf);
+        })
+    ;
+};
+
+exports.par = function () {
+    var to = setTimeout(function () {
+        assert.fail('seq never fired');
+    }, 1000);
+    
+    Seq()
+        .seq(function () {
+            this(null, 'mew');
+        })
+        .par(function () {
+            var seq = this;
+            setTimeout(function () { seq(null, 'x') }, 50);
+        })
+        .par(function () {
+            var seq = this;
+            setTimeout(function () { seq(null, 'y') }, 25);
+        })
+        .par('z', function () {
+            this(null, 42);
+        })
+        .seq(function (x, y, z) {
+            clearTimeout(to);
+            assert.eql(x, 'x');
+            assert.eql(y, 'y');
+            assert.eql(z, 42);
+            assert.eql(this.args, { 0 : ['x'], 1 : ['y'], z : [42] });
+            assert.eql(this.stack, [ 'x', 'y', 42 ]);
+            assert.eql(this.vars, { z : 42 });
+        })
+    ;
+};
+
+exports.catchPar = function () {
+    var done = false, caught = false;
+    var tc = setTimeout(function () {
+        assert.fail('error not caught');
+    }, 1000);
+    
+    Seq()
+        .par('one', function () {
+            setTimeout(this.bind({}, 'rawr'), 25);
+        })
+        .par('two', function () {
+            setTimeout(this.bind({}, null, 'y'), 50);
+        })
+        .seq(function (x, y) {
+            assert.fail('seq fired with error above');
+        })
+        .catch(function (err, key) {
+            clearTimeout(tc);
+            assert.eql(err, 'rawr');
+            assert.eql(key, 'one');
+        })
+    ;
+};
+
+exports.catchParWithoutSeq = function () {
+    var done = false, caught = false;
+    var tc = setTimeout(function () {
+        assert.fail('error not caught');
+    }, 5000);
+    
+    Seq()
+        .par('one', function () {
+            setTimeout(this.bind({}, 'rawr'), 25);
+        })
+        .par('two', function () {
+            setTimeout(this.bind({}, null, 'y'), 50);
+        })
+        .catch(function (err, key) {
+            clearTimeout(tc);
+            assert.eql(err, 'rawr');
+            assert.eql(key, 'one');
+        })
+    ;    
+}
+
+exports.catchParMultipleErrors = function() {
+    var caught={};
+    var to = setTimeout(function() {
+        assert.fail('Never finished');
+    }, 1000);
+    var times = 0;
+    
+    Seq()
+        .par('one', function() {
+            setTimeout(this.bind({}, 'rawr1'), 25);
+        })
+        .par('two', function() {
+            setTimeout(this.bind({}, 'rawr2'), 50);
+        })
+        .catch(function(err,key) {
+            caught[key] = err;
+        })
+        .seq(function() {
+            clearTimeout(to);
+            times ++;
+            assert.eql(times, 1);
+            assert.eql(caught, { one:'rawr1', two:'rawr2' });
+        })
+    ;
+};
+
+exports.catchParThenSeq = function () {
+    var tc = setTimeout(function () {
+        assert.fail('error not caught');
+    }, 1000);
+    var tf = setTimeout(function () {
+        assert.fail('final seq not run');
+    }, 500);
+    var times = 0;
+    var errs = [
+        { key : 'one', msg : 'rawr' },
+        { key : 'four', msg : 'pow' },
+    ];
+    
+    Seq()
+        .par('one', function () {
+            setTimeout(this.bind({}, 'rawr'), 25);
+        })
+        .par('two', function () {
+            setTimeout(this.bind({}, null, 'y'), 50);
+        })
+        .par('three', function () {
+            setTimeout(this.bind({}, null, 'z'), 30);
+        })
+        .par('four', function () {
+            setTimeout(this.bind({}, 'pow'), 45);
+        })
+        .seq(function (x, y) {
+            assert.fail('seq fired with error above');
+        })
+        .catch(function (err, key) {
+            clearTimeout(tc);
+            var e = errs.shift();
+            assert.eql(err, e.msg);
+            assert.eql(key, e.key);
+        })
+        .seq(function () {
+            clearTimeout(tf);
+            times ++;
+            assert.eql(times, 1);
+        })
+    ;    
+}
+
+exports.forEach = function () {
+    var to = setTimeout(function () {
+        assert.fail('seq never fired after forEach');
+    }, 25);
+    
+    var count = 0;
+    Seq([1,2,3])
+        .push(4)
+        .forEach(function (x, i) {
+            assert.eql(x - 1, i);
+            count ++;
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(count, 4);
+        })
+    ;
+};
+
+exports.seqEach = function () {
+    var to = setTimeout(function () {
+        assert.fail('seqEach never finished');
+    }, 25);
+    
+    var count = 0;
+    var ii = 0;
+    Seq([1,2,3])
+        .seqEach(function (x, i) {
+            assert.eql(i, ii++);
+            assert.eql(x, [1,2,3][i]);
+            count ++;
+            this(null);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(count, 3);
+        })
+    ;
+};
+
+exports.seqEachCatch = function () {
+    var to = setTimeout(function () {
+        assert.fail('never caught the error');
+    }, 25);
+    var tf = setTimeout(function () {
+        assert.fail('never resumed afterwards');
+    }, 25);
+    
+    var meows = [];
+    
+    var values = [];
+    Seq([1,2,3,4])
+        .seqEach(function (x, i) {
+            values.push([i,x]);
+            assert.eql(x - 1, i);
+            if (i >= 2) this('meow ' + i)
+            else this(null, x * 10);
+        })
+        .seq(function (xs) {
+            assert.fail('should fail before this action');
+        })
+        .catch(function (err) {
+            clearTimeout(to);
+            meows.push(err);
+            assert.eql(err, 'meow 2');
+            assert.eql(values, [[0,1],[1,2],[2,3]]);
+        })
+        .seq(function () {
+            clearTimeout(tf);
+        })
+    ;
+};
+
+exports.parEach = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 100);
+    
+    var values = [];
+    Seq([1,2,3,4])
+        .parEach(function (x, i) {
+            values.push([i,x]);
+            setTimeout(this.bind({}, null), 20);
+        })
+        .seq(function () {
+            assert.deepEqual(this.stack, [1,2,3,4])
+            assert.deepEqual(values, [[0,1],[1,2],[2,3],[3,4]]);
+            clearTimeout(to);
+        })
+    ;
+};
+
+exports.parEachVars = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 1000);
+    var values = [];
+    
+    Seq()
+        .seq('abc', function () {
+            this(null, 'a', 'b', 'c');
+        })
+        .parEach(function (x) {
+            values.push(x);
+            setTimeout(this.bind(this, null), Math.floor(Math.random() * 50));
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(values, ['a','b','c']);
+            assert.eql(this.stack, ['a','b','c']);
+            assert.eql(this.vars.abc, 'a');
+        })
+    ;
+};
+
+exports.parEachInto = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 100);
+    
+    Seq([1,2,3,4])
+        .parEach(function (x, i) {
+            setTimeout((function () {
+                this.into('abcd'.charAt(i))(null, x);
+            }).bind(this), 20);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.deepEqual(this.stack, [1,2,3,4])
+            assert.deepEqual(this.vars, { a : 1, b : 2, c : 3, d : 4 });
+        })
+    ;
+};
+
+exports.parEachCatch = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 100);
+    
+    var values = [];
+    Seq([1,2,3,4])
+        .parEach(function (x, i) {
+            values.push([i,x]);
+            setTimeout(this.bind({}, 'zing'), 10);
+        })
+        .seq(function () {
+            assert.fail('should have errored before this point')
+        })
+        .catch(function (err) {
+            clearTimeout(to);
+            assert.eql(err, 'zing');
+            assert.deepEqual(values, [[0,1],[1,2],[2,3],[3,4]]);
+        })
+    ;
+};
+
+exports.parEachLimited = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 500);
+    
+    var running = 0;
+    var values = [];
+    Seq([1,2,3,4,5,6,7,8,9,10])
+        .parEach(3, function (x, i) {
+            running ++;
+            
+            assert.ok(running <= 3);
+            
+            values.push([i,x]);
+            setTimeout((function () {
+                running --;
+                this(null);
+            }).bind(this), 10);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(values,
+                [[0,1],[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8],[8,9],[9,10]]
+            );
+        })
+    ;
+};
+
+exports.parMap = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 500);
+    
+    var running = 0;
+    var values = [];
+    Seq([1,2,3,4,5,6,7,8,9,10])
+        .parMap(2, function (x, i) {
+            running ++;
+            
+            assert.ok(running <= 2);
+            
+            setTimeout((function () {
+                running --;
+                this(null, x * 10);
+            }).bind(this), Math.floor(Math.random() * 100));
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(this.stack, [10,20,30,40,50,60,70,80,90,100]);
+            assert.eql(this.stack, [].slice.call(arguments));
+        })
+    ;
+};
+
+exports.parMapFast = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 500);
+    
+    var values = [];
+    Seq([1,2,3,4,5,6,7,8,9,10])
+        .parMap(function (x, i) {
+            this(null, x * 10);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(this.stack, [10,20,30,40,50,60,70,80,90,100]);
+            assert.eql(this.stack, [].slice.call(arguments));
+        })
+    ;
+};
+
+exports.parMapInto = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 500);
+    
+    var values = [];
+    Seq([1,2,3,4,5,6,7,8,9,10])
+        .parMap(function (x, i) {
+            this.into(9 - i)(null, x * 10);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(this.stack, [100, 90, 80, 70, 60, 50, 40, 30, 20, 10]);
+            assert.eql(this.stack, [].slice.call(arguments));
+        })
+    ;
+};
+
+exports.seqMap = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 500);
+    
+    var running = 0;
+    var values = [];
+    Seq([1,2,3,4,5,6,7,8,9,10])
+        .seqMap(function (x, i) {
+            running ++;
+            
+            assert.eql(running, 1);
+            
+            setTimeout((function () {
+                running --;
+                this(null, x * 10);
+            }).bind(this), 10);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(this.stack, [10,20,30,40,50,60,70,80,90,100]);
+        })
+    ;
+};
+
+
+exports.seqMapInto = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 500);
+    
+    var running = 0;
+    var values = [];
+    Seq([1,2,3,4,5,6,7,8,9,10])
+        .seqMap(function (x, i) {
+            running ++;
+            
+            assert.eql(running, 1);
+            
+            setTimeout((function () {
+                running --;
+                this.into(9 - i)(null, x * 10);
+            }).bind(this), 10);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(this.stack, [100, 90, 80, 70, 60, 50, 40, 30, 20, 10]);
+        })
+    ;
+};
+
+exports.parFilter = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 500);
+    
+    var running = 0;
+    var values = [];
+    Seq([1,2,3,4,5,6,7,8,9,10])
+        .parFilter(2, function (x, i) {
+            running ++;
+            
+            assert.ok(running <= 2);
+            
+            setTimeout((function () {
+                running --;
+                this(null, x % 2 === 0);
+            }).bind(this), Math.floor(Math.random() * 100));
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(this.stack, [2,4,6,8,10]);
+            assert.eql(this.stack, [].slice.call(arguments));
+        })
+    ;
+};
+
+exports.seqFilter = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 500);
+    
+    var running = 0;
+    var values = [];
+    Seq([1,2,3,4,5,6,7,8,9,10])
+        .seqFilter(function (x, i) {
+            running ++;
+            
+            assert.eql(running, 1);
+            
+            setTimeout((function () {
+                running --;
+                this(null, x % 2 === 0);
+            }).bind(this), 10);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(this.stack, [2,4,6,8,10]);
+        })
+    ;
+};
+
+exports.parFilterInto = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 500);
+    
+    var running = 0;
+    var values = [];
+    Seq([1,2,3,4,5,6,7,8,9,10])
+        .parFilter(2, function (x, i) {
+            running ++;
+            
+            assert.ok(running <= 2);
+            
+            setTimeout((function () {
+                running --;
+                this.into(x % 3)(null, x % 2 === 0);
+            }).bind(this), Math.floor(Math.random() * 100));
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(this.stack, [ 6, 10, 4, 2, 8 ]);
+            assert.eql(this.stack, [].slice.call(arguments));
+        })
+    ;
+};
+
+exports.seqFilterInto = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 500);
+    
+    var running = 0;
+    var values = [];
+    Seq([1,2,3,4,5,6,7,8,9,10])
+        .seqFilter(function (x, i) {
+            running ++;
+            
+            assert.eql(running, 1);
+            
+            setTimeout((function () {
+                running --;
+                this.into(x % 3)(null, x % 2 === 0);
+            }).bind(this), 10);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(this.stack, [ 6, 10, 4, 2, 8 ]);
+        })
+    ;
+};
+
+exports.stack = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 100);
+    
+    Seq([4,5,6])
+        .seq(function (x, y, z) {
+            assert.eql(arguments.length, 3);
+            assert.eql([x,y,z], [4,5,6]);
+            assert.eql(this.stack, [4,5,6]);
+            this(null);
+        })
+        .set([3,4])
+        .seq(function (x, y) {
+            assert.eql(arguments.length, 2);
+            assert.eql([x,y], [3,4]);
+            assert.eql(this.stack, [3,4]);
+            this(null);
+        })
+        .empty()
+        .seq(function () {
+            assert.eql(arguments.length, 0);
+            assert.eql(this.stack, []);
+            this.next(null, ['a']);
+        })
+        .extend(['b','c'])
+        .seq(function (a, b, c) {
+            assert.eql(arguments.length, 3);
+            assert.eql([a,b,c], ['a','b','c']);
+            assert.eql(this.stack, ['a','b','c']);
+            this.pass(null);
+        })
+        .pop()
+        .push('c', 'd', 'e')
+        .seq(function (a, b, c, d, e) {
+            assert.eql(arguments.length, 5);
+            assert.eql([a,b,c,d,e], ['a','b','c','d','e']);
+            assert.eql(this.stack, ['a','b','c','d','e']);
+            this.pass(null);
+        })
+        .shift()
+        .shift()
+        .seq(function (c, d, e) {
+            assert.eql(arguments.length, 3);
+            assert.eql([c,d,e], ['c','d','e']);
+            assert.eql(this.stack, ['c','d','e']);
+            this.pass(null);
+        })
+        .set([['a',['b']],['c','d',['e']]])
+        .flatten(false) // only flatten one level
+        .seq(function (a, b, c, d, e) {
+            assert.eql(arguments.length, 5);
+            assert.eql([a,b,c,d,e], ['a',['b'],'c','d',['e']]);
+            assert.eql(this.stack,  ['a',['b'],'c','d',['e']]);
+            this.pass(null);
+        })
+        .set([['a','b'],['c','d',['e']]])
+        .flatten()
+        .seq(function (a, b, c, d, e) {
+            assert.eql(arguments.length, 5);
+            assert.eql([a,b,c,d,e], ['a','b','c','d','e']);
+            assert.eql(this.stack, ['a','b','c','d','e']);
+            this.pass(null);
+        })
+        .splice(2, 2)
+        .seq(function (a, b, e) {
+            assert.eql(arguments.length, 3);
+            assert.eql([a,b,e], ['a','b','e']);
+            assert.eql(this.stack, ['a','b','e']);
+            this.pass(null);
+        })
+        .reverse()
+        .seq(function (a, b, e){
+            assert.eql(arguments.length, 3);
+            assert.eql([a,b,e], ['e','b','a']);
+            assert.eql(this.stack, ['e','b','a']);
+            this.pass(null);
+        })
+        .map(function(ch){ return ch.toUpperCase(); })
+        .seq(function (A, B, E){
+            assert.eql(arguments.length, 3);
+            assert.eql([A,B,E], ['E','B','A']);
+            assert.eql(this.stack, ['E','B','A']);
+            this.pass(null);
+        })
+        .reduce(function(s, ch){ return s + ':' + ch; })
+        .seq(function (acc){
+            assert.eql(arguments.length, 1);
+            assert.eql(acc, 'E:B:A');
+            assert.eql(this.stack, ['E:B:A']);
+            this.pass(null);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            this(null);
+        })
+    ;
+};
+
+exports.ap = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 100);
+    
+    var cmp = [1,2,3];
+    Seq.ap([1,2,3])
+        .seqEach(function (x) {
+            assert.eql(cmp.shift(), x);
+            this(null);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(cmp, []);
+        })
+    ;
+    
+    assert.throws(function () {
+        Seq.ap({ a : 1, b : 2 });
+    });
+};
+
+exports.seqBind = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 100);
+    
+    Seq([4,5])
+        .seq(function (a, b, c, d) {
+            assert.eql(a, 2);
+            assert.eql(b, 3);
+            assert.eql(c, 4);
+            assert.eql(d, 5);
+            this(null);
+        }, 2, 3)
+        .seq(function () {
+            clearTimeout(to);
+        })
+    ;
+};
+
+exports.parBind = function () {
+    var t1 = setTimeout(function () {
+        assert.fail('1 never finished');
+    }, 500);
+    var t2 = setTimeout(function () {
+        assert.fail('2 never finished');
+    }, 500);
+    var t3 = setTimeout(function () {
+        assert.fail('3 never finished');
+    }, 500);
+    
+    Seq(['c'])
+        .par(function (a, b, c) {
+            clearTimeout(t1);
+            assert.eql(a, 'a');
+            assert.eql(b, 'b');
+            assert.eql(c, 'c');
+            this(null);
+        }, 'a', 'b')
+        .par(function (x, c) {
+            clearTimeout(t2);
+            assert.eql(x, 'x');
+            assert.eql(c, 'c');
+            this(null);
+        }, 'x')
+        .seq(function () {
+            clearTimeout(t3);
+        })
+    ;
+};
+
+exports.emptySeqEach = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 100);
+    
+    Seq()
+        .seqEach(function (x) {
+            assert.fail('no elements');
+        })
+        .seq(function () {
+            clearTimeout(to);
+        })
+    ;
+};
+
+exports.emptyForEach = function () {
+    var to = setTimeout(function () {
+        assert.fail('seq never fired');
+    }, 500);
+    
+    Seq()
+        .forEach(function () {
+            assert.fail('non-empty stack');
+        })
+        .seq(function () {
+            clearTimeout(to);
+        })
+    ;
+};
+
+exports.emptyParEach = function () {
+    var to = setTimeout(function () {
+        assert.fail('seq never fired');
+    }, 500);
+    
+    Seq()
+        .parEach(function () {
+            assert.fail('non-empty stack');
+        })
+        .seq(function () {
+            clearTimeout(to);
+        })
+    ;
+};
+
+exports.emptyParMap = function () {
+    var to = setTimeout(function () {
+        assert.fail('seq never fired');
+    }, 500);
+    
+    Seq()
+        .parMap(function () {
+            assert.fail('non-empty stack');
+        })
+        .seq(function () {
+            clearTimeout(to);
+        })
+    ;
+};
+
+exports.emptySeqMap = function () {
+    var to = setTimeout(function () {
+        assert.fail('seq never fired');
+    }, 500);
+    
+    Seq()
+        .seqMap(function () {
+            assert.fail('non-empty stack');
+        })
+        .seq(function () {
+            clearTimeout(to);
+        })
+    ;
+};
+
+exports.ok = function () {
+    var to = setTimeout(function () {
+        assert.fail('seq never fired');
+    }, 500);
+    
+    function moo1 (cb) { cb(3) }
+    function moo2 (cb) { cb(4) }
+    
+    Seq()
+        .par(function () { moo1(this.ok) })
+        .par(function () { moo2(this.ok) })
+        .seq(function (x, y) {
+            clearTimeout(to);
+            assert.eql(x, 3);
+            assert.eql(y, 4);
+        })
+    ;
+};
+
+exports.nextOk = function () {
+    var to = setTimeout(function () {
+        assert.fail('seq never fired');
+    }, 500);
+    
+    function moo1 (cb) { cb(3) }
+    function moo2 (cb) { cb(4) }
+    
+    Seq()
+        .par_(function (next) { moo1(next.ok) })
+        .par_(function (next) { moo2(next.ok) })
+        .seq_(function (next, x, y) {
+            assert.eql(x, 3);
+            assert.eql(y, 4);
+            next.ok([ 1, 2, 3 ])
+        })
+        .flatten()
+        .parMap_(function (next, x) {
+            next.ok(x * 100)
+        })
+        .seq_(function (next) {
+            clearTimeout(to);
+            assert.deepEqual(next.stack, [ 100, 200, 300 ]);
+        })
+    ;
+};
+
+exports.regressionTestForAccidentalDeepTraversalOfTheContext = function () {
+    // Create a single-item stack with a bunch of references to other objects:
+    var stack = [{}];
+    for (var i = 0 ; i < 10000 ; i += 1) {
+        stack[0][i] = stack[0];
+    }
+
+    var startTime = new Date(),
+        numCalled = 0,
+        to = setTimeout(function () {
+            assert.fail('never got to the end of the chain');
+        }, 1000);
+
+    Seq(stack)
+        .parEach(function (item) {
+            numCalled += 1;
+            this();
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(numCalled, 1);
+            assert.ok((new Date().getTime() - startTime) < 1000, 'if this test takes longer than a second, the bug must have been reintroduced');
+        });
+};

node_modules/seq/test/seq_.js

@@ -0,0 +1,149 @@
+var Seq = require('seq');
+var assert = require('assert');
+
+exports.seq_ = function () {
+    var to = setTimeout(function () {
+        assert.fail('never got to the end of the chain');
+    }, 5000);
+    
+    Seq(['xxx'])
+        .seq_('pow', function (next, x) {
+            assert.eql(next, this);
+            assert.eql(x, 'xxx');
+            next(null, 'yyy');
+        })
+        .seq(function (y) {
+            clearTimeout(to);
+            assert.eql(y, 'yyy');
+            assert.eql(this.vars.pow, 'yyy');
+        })
+    ;
+};
+
+exports.par_ = function () {
+    var to = setTimeout(function () {
+        assert.fail('never got to the end of the chain');
+    }, 5000);
+    
+    Seq()
+        .par_(function (next) {
+            assert.eql(next, this);
+            next(null, 111);
+        })
+        .par_(function (next) {
+            assert.eql(next, this);
+            next(null, 222);
+        })
+        .seq(function (x, y) {
+            clearTimeout(to);
+            assert.eql(x, 111);
+            assert.eql(y, 222);
+        })
+    ;
+};
+
+exports.forEach_ = function () {
+    var to = setTimeout(function () {
+        assert.fail('never got to the end of the chain');
+    }, 5000);
+    
+    var acc = [];
+    Seq([7,8,9])
+        .forEach_(function (next, x) {
+            assert.eql(next, this);
+            acc.push(x);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(acc, [ 7, 8, 9 ]);
+        })
+    ;
+};
+
+exports.seqEach_ = function () {
+    var to = setTimeout(function () {
+        assert.fail('never got to the end of the chain');
+    }, 5000);
+    
+    var acc = [];
+    Seq([7,8,9])
+        .seqEach_(function (next, x) {
+            assert.eql(next, this);
+            acc.push(x);
+            setTimeout(function () {
+                next(null, x);
+            }, Math.random() * 10);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(acc, [ 7, 8, 9 ]);
+            assert.eql(this.stack, [ 7, 8, 9 ]);
+        })
+    ;
+};
+
+exports.parEach_ = function () {
+    var to = setTimeout(function () {
+        assert.fail('never got to the end of the chain');
+    }, 5000);
+    
+    var acc = [];
+    Seq([7,8,9])
+        .parEach_(function (next, x) {
+            assert.eql(next, this);
+            acc.push(x);
+            setTimeout(function () {
+                next(null, x);
+            }, Math.random() * 10);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(acc, [ 7, 8, 9 ]);
+            assert.eql(this.stack, [ 7, 8, 9 ]);
+        })
+    ;
+};
+
+exports.seqMap_ = function () {
+    var to = setTimeout(function () {
+        assert.fail('never got to the end of the chain');
+    }, 5000);
+    
+    var acc = [];
+    Seq([7,8,9])
+        .seqMap_(function (next, x) {
+            assert.eql(next, this);
+            acc.push(x);
+            setTimeout(function () {
+                next(null, x * 10);
+            }, Math.random() * 10);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(acc, [ 7, 8, 9 ]);
+            assert.eql(this.stack, [ 70, 80, 90 ]);
+        })
+    ;
+};
+
+exports.parMap_ = function () {
+    var to = setTimeout(function () {
+        assert.fail('never got to the end of the chain');
+    }, 5000);
+    
+    var acc = [];
+    Seq([7,8,9])
+        .parMap_(function (next, x) {
+            assert.eql(next, this);
+            acc.push(x);
+            setTimeout(function () {
+                next(null, x * 10);
+            }, Math.random() * 10);
+        })
+        .seq(function () {
+            clearTimeout(to);
+            assert.eql(acc, [ 7, 8, 9 ]);
+            assert.eql(this.stack, [ 70, 80, 90 ]);
+        })
+    ;
+};