🐛 Update: Added support for the 'find' command in settings.local.json. Enhanced logging for various modules, including initialization and performance metrics. Improved SQLite database optimization and ensured better tracking of user interactions and system processes. 📚

network-visualization/node_modules/event-stream/test/connect.asynct.js

@@ -0,0 +1,86 @@
+var es = require('../')
+  , it = require('it-is').style('colour')
+  , d = require('ubelt')
+
+function makeExamplePipe() {
+
+  return es.connect(
+    es.map(function (data, callback) {
+      callback(null, data * 2)
+    }),
+    es.map(function (data, callback) {
+      d.delay(callback)(null, data)    
+    }),
+    es.map(function (data, callback) {
+      callback(null, data + 2)
+    }))
+}
+
+exports['simple pipe'] = function (test) {
+
+  var pipe = makeExamplePipe()
+
+  pipe.on('data', function (data) {
+    it(data).equal(18)
+    test.done()
+  })
+  
+  pipe.write(8)
+
+}
+
+exports['read array then map'] = function (test) {
+
+  var readThis = d.map(3, 6, 100, d.id) //array of multiples of 3 < 100
+    , first = es.readArray(readThis)
+    , read = []
+    , pipe =
+  es.connect(
+    first,
+    es.map(function (data, callback) {
+      callback(null, {data: data})      
+    }),
+    es.map(function (data, callback) {
+      callback(null, {data: data})
+    }),
+    es.writeArray(function (err, array) {
+      it(array).deepEqual(d.map(readThis, function (data) {
+        return {data: {data: data}}
+      }))
+      test.done()  
+    })
+  )
+}
+
+exports ['connect returns a stream'] = function (test) {
+
+  var rw = 
+    es.connect(
+      es.map(function (data, callback) {
+        callback(null, data * 2)      
+      }),
+      es.map(function (data, callback) {
+        callback(null, data * 5)      
+      })
+    )
+
+  it(rw).has({readable: true, writable: true})
+
+  var array = [190, 24, 6, 7, 40, 57, 4, 6]
+    , _array = []
+    , c = 
+  es.connect(
+    es.readArray(array),
+    rw,
+    es.log('after rw:'),
+    es.writeArray(function (err, _array) {
+      it(_array).deepEqual(array.map(function (e) { return e * 10 }))
+      test.done()
+    })
+    )
+  
+}
+
+
+require('./helper')(module)
+

network-visualization/node_modules/event-stream/test/helper/index.js

@@ -0,0 +1,12 @@
+var tape = require('tape')
+
+module.exports = function (m) {
+  if(m.parent) return
+  for(var name in m.exports) {
+    tape(name, function (t) {
+      console.log('start', name)
+      t.done = t.end
+      m.exports[name](t)
+    })
+  }
+}

network-visualization/node_modules/event-stream/test/merge.asynct.js

@@ -0,0 +1,29 @@
+var es = require('../')
+  , it = require('it-is').style('colour')
+  , d = require('ubelt')
+
+exports.merge = function (t) {
+  var odd = d.map(1, 3, 100, d.id) //array of multiples of 3 < 100
+  var even = d.map(2, 4, 100, d.id) //array of multiples of 3 < 100
+
+  var r1 = es.readArray(even)
+  var r2 = es.readArray(odd)
+  var endCount = 0
+
+  var writer = es.writeArray(function (err, array){
+    if(err) throw err //unpossible
+    it(array.sort()).deepEqual(even.concat(odd).sort())
+    if (++endCount === 2) t.done()
+  })
+
+  var writer2 = es.writeArray(function (err, array){
+    if(err) throw err //unpossible
+    it(array.sort()).deepEqual(even.concat(odd).sort())
+    if (++endCount === 2) t.done()
+  })
+
+  es.merge(r1, r2).pipe(writer)
+  es.merge([r1, r2]).pipe(writer2)
+
+}
+require('./helper')(module)

network-visualization/node_modules/event-stream/test/parse.asynct.js

@@ -0,0 +1,32 @@
+var es = require('../')
+  , it = require('it-is').style('colour')
+
+exports ['es.parse() writes parsing errors with console.error'] = function (test) {
+  var parseStream = es.parse()
+  var oldConsoleError = console.error
+  console.error = function () {
+    console.error = oldConsoleError
+    it(arguments.length > 0).ok()
+    test.done()
+  }
+
+  // bare word is not valid JSON
+  parseStream.write('A')
+}
+
+exports ['es.parse({error: true(thy)}) emits error events from parsing'] = function (test) {
+  var parseStream = es.parse({error: 1})
+  var expectedError
+  try {
+    JSON.parse('A')
+  } catch(e) {
+    expectedError = e
+  }
+
+  parseStream.on('error', function (e) {
+    it(e).deepEqual(expectedError)
+    process.nextTick(function () {
+      test.done()
+    })
+  }).write('A')
+}

network-visualization/node_modules/event-stream/test/pause.asynct.js

@@ -0,0 +1,39 @@
+
+var es  = require('../')
+  , it  = require('it-is')
+  , d   = require('ubelt')
+ 
+exports ['gate buffers when shut'] = function (test) {
+
+  var hundy = d.map(1,100, d.id)
+    , gate = es.pause()
+    , ten = 10
+  es.connect(
+    es.readArray(hundy),
+    es.log('after readArray'),
+    gate,
+    //es.log('after gate'),
+    es.map(function (num, next) {
+      //stick a map in here to check that gate never emits when open
+      it(gate.paused).equal(false)
+      console.log('data', num)
+      if(!--ten) {
+        console.log('PAUSE')
+        gate.pause()//.resume()
+        d.delay(gate.resume.bind(gate), 10)()
+        ten = 10
+      }
+        
+      next(null, num)
+    }),
+    es.writeArray(function (err, array) { //just realized that I should remove the error param. errors will be emitted
+      console.log('eonuhoenuoecbulc')
+      it(array).deepEqual(hundy)
+      test.done()
+    })
+  )
+
+  gate.resume()
+
+}
+require('./helper')(module)

network-visualization/node_modules/event-stream/test/pipeline.asynct.js

@@ -0,0 +1,52 @@
+var es = require('..')
+
+exports['do not duplicate errors'] = function (test) {
+
+  var errors = 0;
+  var pipe = es.pipeline(
+    es.through(function(data) {
+      return this.emit('data', data);
+    }),
+    es.through(function(data) {
+      return this.emit('error', new Error(data));
+    })
+  )
+
+  pipe.on('error', function(err) {
+    errors++
+    console.log('error count', errors)
+      process.nextTick(function () {
+        return test.done();
+      })
+  })
+
+  return pipe.write('meh');
+
+}
+
+exports['3 pipe do not duplicate errors'] = function (test) {
+
+  var errors = 0;
+  var pipe = es.pipeline(
+    es.through(function(data) {
+      return this.emit('data', data);
+    }),
+    es.through(function(data) {
+      return this.emit('error', new Error(data));
+    }),
+    es.through()
+  )
+
+  pipe.on('error', function(err) {
+    errors++
+    console.log('error count', errors)
+      process.nextTick(function () {
+        return test.done();
+      })
+  })
+
+  return pipe.write('meh');
+
+}
+
+require('./helper')(module)

network-visualization/node_modules/event-stream/test/readArray.asynct.js

@@ -0,0 +1,89 @@
+
+var es = require('../')
+  , it = require('it-is').style('colour')
+  , d = require('ubelt')
+
+function readStream(stream, pauseAt, done) {
+  if(!done) done = pauseAt, pauseAt = -1
+  var array = [] 
+  stream.on('data', function (data) {
+    array.push(data)
+    if(!--pauseAt )
+      stream.pause(), done(null, array)
+  })
+  stream.on('error', done)
+  stream.on('end', function (data) {
+    done(null, array)
+  })
+
+}
+
+exports ['read an array'] = function (test) {
+
+  var readThis = d.map(3, 6, 100, d.id) //array of multiples of 3 < 100
+
+  var reader = es.readArray(readThis)
+
+  var writer = es.writeArray(function (err, array){
+    if(err) throw err //unpossible
+    it(array).deepEqual(readThis)
+    test.done()     
+  })
+
+  reader.pipe(writer)
+}
+
+exports ['read an array and pause it.'] = function (test) {
+
+  var readThis = d.map(3, 6, 100, d.id) //array of multiples of 3 < 100
+
+  var reader = es.readArray(readThis)
+  
+  readStream(reader, 10, function (err, data) {
+    if(err) throw err
+    it(data).deepEqual([3, 6, 9, 12, 15, 18, 21, 24, 27, 30])
+    readStream(reader, 10, function (err, data) {
+      it(data).deepEqual([33, 36, 39, 42, 45, 48, 51, 54, 57, 60])
+      test.done() 
+    })
+    reader.resume()
+  })
+
+}
+
+exports ['reader is readable, but not writeable'] = function (test) {
+  var reader = es.readArray([1])
+  it(reader).has({
+    readable: true,
+    writable: false
+  })
+
+  test.done()
+}
+
+
+exports ['read one item per tick'] = function (test) {
+  var readThis = d.map(3, 6, 100, d.id) //array of multiples of 3 < 100
+  var drains = 0
+  var reader = es.readArray(readThis)
+  var tickMapper = es.map(function (data,callback) {
+    process.nextTick(function () {
+      callback(null, data)
+    })
+    //since tickMapper is returning false
+    //pipe should pause the writer until a drain occurs
+    return false
+  })
+  reader.pipe(tickMapper)
+  readStream(tickMapper, function (err, array) {
+    it(array).deepEqual(readThis)
+    it(array.length).deepEqual(readThis.length)
+    it(drains).equal(readThis.length)
+    test.done()
+  })
+  tickMapper.on('drain', function () {
+    drains ++
+  })
+
+}
+require('./helper')(module)

network-visualization/node_modules/event-stream/test/readable.asynct.js

@@ -0,0 +1,197 @@
+
+var es = require('../')
+  , it = require('it-is').style('colour')
+  , u = require('ubelt')
+
+exports ['read an array'] = function (test) {
+
+
+  console.log('readable')
+  return test.end()
+  var readThis = u.map(3, 6, 100, u.id) //array of multiples of 3 < 100
+
+  console.log('readable')
+
+  var reader = 
+    es.readable(function (i, callback) {
+      if(i >= readThis.length)
+        return this.emit('end')
+      console.log('readable')
+      callback(null, readThis[i])
+    })
+
+  var writer = es.writeArray(function (err, array){
+    if(err) throw err
+    it(array).deepEqual(readThis)
+    test.done()
+  })
+
+  reader.pipe(writer)
+}
+
+exports ['read an array - async'] = function (test) {
+
+  var readThis = u.map(3, 6, 100, u.id) //array of multiples of 3 < 100
+
+  var reader = 
+    es.readable(function (i, callback) {
+      if(i >= readThis.length)
+        return this.emit('end')
+      u.delay(callback)(null, readThis[i])
+    })
+
+  var writer = es.writeArray(function (err, array){
+    if(err) throw err
+    it(array).deepEqual(readThis)
+    test.done()
+  })
+
+  reader.pipe(writer)
+}
+
+
+exports ['emit data then call next() also works'] = function (test) {
+
+  var readThis = u.map(3, 6, 100, u.id) //array of multiples of 3 < 100
+
+  var reader = 
+    es.readable(function (i, next) {
+      if(i >= readThis.length)
+        return this.emit('end')
+      this.emit('data', readThis[i])
+      next()
+    })
+
+  var writer = es.writeArray(function (err, array){
+    if(err) throw err
+    it(array).deepEqual(readThis)
+    test.done()     
+  })
+
+  reader.pipe(writer)
+}
+
+
+exports ['callback emits error, then stops'] = function (test) {
+
+  var err = new Error('INTENSIONAL ERROR')
+    , called = 0
+
+  var reader = 
+    es.readable(function (i, callback) {
+      if(called++)
+        return
+      callback(err)
+    })
+
+  reader.on('error', function (_err){
+    it(_err).deepEqual(err)
+    u.delay(function() {
+      it(called).equal(1)
+      test.done()
+    }, 50)()
+  })
+}
+
+exports['readable does not call read concurrently'] = function (test) {
+
+  var current = 0
+  var source = es.readable(function(count, cb){
+    current ++
+    if(count > 100)
+      return this.emit('end')
+    u.delay(function(){
+      current --
+      it(current).equal(0)      
+      cb(null, {ok: true, n: count});
+    })();
+  });
+
+  var destination = es.map(function(data, cb){
+    //console.info(data); 
+    cb();
+  });
+
+  var all = es.connect(source, destination);
+
+  destination.on('end', test.done)
+}
+
+exports ['does not raise a warning: Recursive process.nextTick detected'] = function (test) {
+    var readThisDelayed;
+
+    u.delay(function () {
+        readThisDelayed = [1, 3, 5];
+    })();
+
+    es.readable(function (count, callback) {
+
+        if (readThisDelayed) {
+            var that = this;
+            readThisDelayed.forEach(function (item) {
+                that.emit('data', item);
+            });
+
+            this.emit('end');
+            test.done();
+        }
+
+        callback();
+    });
+};
+
+//
+// emitting multiple errors is not supported by stream.
+//
+// I do not think that this is a good idea, at least, there should be an option to pipe to 
+// continue on error. it makes alot ef sense, if you are using Stream like I am, to be able to emit multiple errors.
+// an error might not necessarily mean the end of the stream. it depends on the error, at least.
+//
+// I will start a thread on the mailing list. I'd rather that than use a custom `pipe` implementation.
+// 
+// basically, I want to be able use pipe to transform objects, and if one object is invalid, 
+// the next might still be good, so I should get to choose if it's gonna stop.
+// re-enstate this test when this issue progresses.
+//
+// hmm. I could add this to es.connect by deregistering the error listener, 
+// but I would rather it be an option in core.
+
+/*
+exports ['emit multiple errors, with 2nd parameter (continueOnError)'] = function (test) {
+
+  var readThis = d.map(1, 100, d.id)
+    , errors = 0
+  var reader = 
+    es.readable(function (i, callback) {
+      console.log(i, readThis.length)
+      if(i >= readThis.length)
+        return this.emit('end')
+      if(!(readThis[i] % 7))
+        return callback(readThis[i])
+      callback(null, readThis[i])
+    }, true)
+
+  var writer = es.writeArray(function (err, array) {
+    if(err) throw err
+    it(array).every(function (u){
+      it(u % 7).notEqual(0)      
+    }).property('length', 80)
+    it(errors).equal(14)
+    test.done()     
+  })
+
+  reader.on('error', function (u) {
+    errors ++
+    console.log(u)
+    if('number' !== typeof u)
+      throw u
+
+    it(u % 7).equal(0)
+
+  })
+
+  reader.pipe(writer)
+}
+*/
+
+require('./helper')(module)

network-visualization/node_modules/event-stream/test/replace.asynct.js

@@ -0,0 +1,76 @@
+var es = require('../')
+  , it = require('it-is').style('colour')
+  , d = require('ubelt')
+  , spec = require('stream-spec')
+
+var next = process.nextTick
+
+var fizzbuzz = '12F4BF78FB11F1314FB1617F19BF2223FB26F2829FB3132F34BF3738FB41F4344FB4647F49BF5253FB56F5859FB6162F64BF6768FB71F7374FB7677F79BF8283FB86F8889FB9192F94BF9798FB'
+  , fizz7buzz = '12F4BFseven8FB11F1314FB161sevenF19BF2223FB26F2829FB3132F34BF3seven38FB41F4344FB464sevenF49BF5253FB56F5859FB6162F64BF6seven68FBseven1Fseven3seven4FBseven6sevensevenFseven9BF8283FB86F8889FB9192F94BF9seven98FB'
+  , fizzbuzzwhitespce = '  12F4BF78FB11F1314FB1617F19BF2223FB26F2829FB3132F34BF3738FB41F4344FB4647F49BF5253FB56F5859FB6162F64BF6768FB71F7374FB7677F79BF8283FB86F8889FB9192F94BF9798FB  '
+
+exports ['fizz buzz'] = function (test) {
+
+  var readThis = d.map(1, 100, function (i) {
+    return (
+     ! (i % 3 || i % 5) ? "FB" :
+      !(i % 3) ? "F" :
+      !(i % 5) ? "B" :
+      ''+i
+    )
+  }) //array of multiples of 3 < 100
+
+  var reader = es.readArray(readThis)
+  var join = es.wait(function (err, string){
+    it(string).equal(fizzbuzz)
+    test.done()
+  })
+  reader.pipe(join)
+
+}
+
+
+exports ['fizz buzz replace'] = function (test) {
+  var split = es.split(/(1)/)
+  var replace = es.replace('7', 'seven')
+//  var x = spec(replace).through()
+  split
+    .pipe(replace)
+    .pipe(es.join(function (err, string) {
+      it(string).equal(fizz7buzz)
+    }))
+
+    replace.on('close', function () {
+//      x.validate()
+      test.done()
+    })
+
+  split.write(fizzbuzz)
+  split.end()
+
+}
+
+
+exports ['fizz buzz replace whitespace using regexp'] = function (test) {
+  var split = es.split(/(1)/)
+  var replaceLeading = es.replace(/^[\s]*/, '')
+  var replaceTrailing = es.replace(/[\s]*$/, '')
+//  var x = spec(replace).through()
+  split
+    .pipe(replaceLeading)
+    .pipe(replaceTrailing)
+    .pipe(es.join(function (err, string) {
+      it(string).equal(fizzbuzz)
+    }))
+
+    replaceTrailing.on('close', function () {
+//      x.validate()
+      test.done()
+    })
+
+  split.write(fizzbuzz)
+  split.end()
+
+}
+
+require('./helper')(module)

network-visualization/node_modules/event-stream/test/simple-map.asynct.js

@@ -0,0 +1,343 @@
+'use strict';
+
+var es = require('../')
+  , it = require('it-is')
+  , u = require('ubelt')
+  , spec = require('stream-spec')
+  , Stream = require('stream')
+  , from = require('from')
+  , through = require('through')
+
+//REFACTOR THIS TEST TO USE es.readArray and es.writeArray
+
+function writeArray(array, stream) {
+
+  array.forEach( function (j) {
+    stream.write(j)
+  })
+  stream.end()
+
+}
+
+function readStream(stream, done) {
+
+  var array = [] 
+  stream.on('data', function (data) {
+    array.push(data)
+  })
+  stream.on('error', done)
+  stream.on('end', function (data) {
+    done(null, array)
+  })
+
+} 
+
+//call sink on each write,
+//and complete when finished.
+
+function pauseStream (prob, delay) { 
+  var pauseIf = (
+      'number' == typeof prob 
+    ? function () {
+        return Math.random() < prob
+      } 
+    : 'function' == typeof prob 
+    ? prob
+    : 0.1
+  )
+  var delayer = ( 
+      !delay 
+    ? process.nextTick
+    : 'number' == typeof delay 
+    ? function (next) { setTimeout(next, delay) }
+    : delay
+  )   
+
+  return es.through(function (data) {    
+    if(!this.paused && pauseIf()) {
+      console.log('PAUSE STREAM PAUSING')
+      this.pause()
+      var self = this
+      delayer(function () {
+        console.log('PAUSE STREAM RESUMING')
+        self.resume()
+      })
+    }
+    console.log("emit ('data', " + data + ')')
+    this.emit('data', data) 
+  })
+}
+
+exports ['simple map'] = function (test) {
+
+  var input = u.map(1, 1000, function () {
+    return Math.random() 
+  })
+  var expected = input.map(function (v) {
+    return v * 2
+  })
+
+  var pause = pauseStream(0.1)
+  var fs = from(input)
+  var ts = es.writeArray(function (err, ar) {
+    it(ar).deepEqual(expected)
+    test.done()
+  })
+  var map = es.through(function (data) {
+    this.emit('data', data * 2)
+  }) 
+
+  spec(map).through().validateOnExit()
+  spec(pause).through().validateOnExit()
+
+  fs.pipe(map).pipe(pause).pipe(ts)
+}
+
+exports ['simple map applied to a stream'] = function (test) {
+
+  var input = [1,2,3,7,5,3,1,9,0,2,4,6]
+  //create event stream from
+
+  var doubler = es.map(function (data, cb) {
+    cb(null, data * 2)
+  })
+
+  spec(doubler).through().validateOnExit()
+
+  //a map is only a middle man, so it is both readable and writable
+  
+  it(doubler).has({
+    readable: true,
+    writable: true,   
+  })
+
+  readStream(doubler, function (err, output) {
+    it(output).deepEqual(input.map(function (j) {
+      return j * 2
+    }))
+//    process.nextTick(x.validate)
+    test.done()
+  })
+  
+  writeArray(input, doubler)
+  
+}
+
+exports['pipe two maps together'] = function (test) {
+
+  var input = [1,2,3,7,5,3,1,9,0,2,4,6]
+  //create event stream from
+  function dd (data, cb) {
+    cb(null, data * 2)
+  }
+  var doubler1 = es.map(dd), doubler2 = es.map(dd)
+
+  doubler1.pipe(doubler2)
+  
+  spec(doubler1).through().validateOnExit()
+  spec(doubler2).through().validateOnExit()
+
+  readStream(doubler2, function (err, output) {
+    it(output).deepEqual(input.map(function (j) {
+      return j * 4
+    }))
+    test.done()
+  })
+  
+  writeArray(input, doubler1)
+
+}
+
+//next:
+//
+// test pause, resume and drian.
+//
+
+// then make a pipe joiner:
+//
+// plumber (evStr1, evStr2, evStr3, evStr4, evStr5)
+//
+// will return a single stream that write goes to the first 
+
+exports ['map will not call end until the callback'] = function (test) {
+
+  var ticker = es.map(function (data, cb) {
+    process.nextTick(function () {
+      cb(null, data * 2)
+    })
+  })
+
+  spec(ticker).through().validateOnExit()
+
+  ticker.write('x')
+  ticker.end() 
+
+  ticker.on('end', function () {
+    test.done()
+  })
+}
+
+
+exports ['emit error thrown'] = function (test) {
+
+  var err = new Error('INTENSIONAL ERROR')
+    , mapper = 
+  es.map(function () {
+    throw err
+  })
+
+  mapper.on('error', function (_err) {
+    it(_err).equal(err)  
+    test.done()
+  })
+
+//  onExit(spec(mapper).basic().validate)
+//need spec that says stream may error.
+
+  mapper.write('hello')
+
+}
+
+exports ['emit error calledback'] = function (test) {
+
+  var err = new Error('INTENSIONAL ERROR')
+    , mapper = 
+  es.map(function (data, callback) {
+    callback(err)
+  })
+
+  mapper.on('error', function (_err) {
+    it(_err).equal(err)  
+    test.done()
+  })
+
+  mapper.write('hello')
+
+}
+
+exports ['do not emit drain if not paused'] = function (test) {
+
+  var map = es.map(function (data, callback) {
+    u.delay(callback)(null, 1)
+    return true
+  })
+  
+  spec(map).through().pausable().validateOnExit()
+
+  map.on('drain', function () {
+    it(false).ok('should not emit drain unless the stream is paused')
+  })
+
+  it(map.write('hello')).equal(true)
+  it(map.write('hello')).equal(true)
+  it(map.write('hello')).equal(true)
+  setTimeout(function () {map.end()},10)
+  map.on('end', test.done)
+}
+
+exports ['emits drain if paused, when all '] = function (test) {
+  var active = 0
+  var drained = false
+  var map = es.map(function (data, callback) {
+    active ++
+    u.delay(function () {
+      active --
+      callback(null, 1)
+    })()
+    console.log('WRITE', false)
+    return false
+  })
+
+  spec(map).through().validateOnExit()
+
+  map.on('drain', function () {
+    drained = true
+    it(active).equal(0, 'should emit drain when all maps are done')
+  })
+
+  it(map.write('hello')).equal(false)
+  it(map.write('hello')).equal(false)
+  it(map.write('hello')).equal(false)
+
+  process.nextTick(function () {map.end()},10)
+
+  map.on('end', function () {
+    console.log('end')
+    it(drained).ok('shoud have emitted drain before end')
+    test.done() 
+  })
+
+}
+
+exports ['map applied to a stream with filtering'] = function (test) {
+
+  var input = [1,2,3,7,5,3,1,9,0,2,4,6]
+
+  var doubler = es.map(function (data, callback) {
+    if (data % 2)
+      callback(null, data * 2)
+    else
+      callback()
+  })
+  
+  readStream(doubler, function (err, output) {
+    it(output).deepEqual(input.filter(function (j) {
+      return j % 2
+    }).map(function (j) {
+      return j * 2
+    }))
+    test.done()
+  })
+  
+  spec(doubler).through().validateOnExit()
+
+  writeArray(input, doubler)
+  
+}
+
+exports ['simple mapSync applied to a stream'] = function (test) {
+
+  var input = [1,2,3,7,5,3,1,9,0,2,4,6]
+
+  var doubler = es.mapSync(function (data) {
+    return data * 2
+  })
+  
+  readStream(doubler, function (err, output) {
+    it(output).deepEqual(input.map(function (j) {
+      return j * 2
+    }))
+    test.done()
+  })
+  
+  spec(doubler).through().validateOnExit()
+
+  writeArray(input, doubler)
+  
+}
+
+exports ['mapSync applied to a stream with filtering'] = function (test) {
+
+  var input = [1,2,3,7,5,3,1,9,0,2,4,6]
+
+  var doubler = es.mapSync(function (data) {
+    if (data % 2)
+      return data * 2
+  })
+  
+  readStream(doubler, function (err, output) {
+    it(output).deepEqual(input.filter(function (j) {
+      return j % 2
+    }).map(function (j) {
+      return j * 2
+    }))
+    test.done()
+  })
+  
+  spec(doubler).through().validateOnExit()
+
+  writeArray(input, doubler)
+  
+}
+
+require('./helper')(module)

network-visualization/node_modules/event-stream/test/spec.asynct.js

@@ -0,0 +1,86 @@
+/*
+  assert that data is called many times
+  assert that end is called eventually
+
+  assert that when stream enters pause state,
+  on drain is emitted eventually.
+*/
+
+var es = require('..')
+var it = require('it-is').style('colour')
+var spec = require('stream-spec')
+
+exports['simple stream'] = function (test) {
+
+  var stream = es.through()
+  var x = spec(stream).basic().pausable()
+
+  stream.write(1)
+  stream.write(1)
+  stream.pause()
+  stream.write(1)
+  stream.resume()
+  stream.write(1)
+  stream.end(2) //this will call write()
+
+  process.nextTick(function (){
+    x.validate()
+    test.done()
+  }) 
+}
+
+exports['throw on write when !writable'] = function (test) {
+
+  var stream = es.through()
+  var x = spec(stream).basic().pausable()
+
+  stream.write(1)
+  stream.write(1)
+  stream.end(2) //this will call write()
+  stream.write(1) //this will be throwing..., but the spec will catch it.
+
+  process.nextTick(function () {
+    x.validate()
+    test.done()
+  })
+  
+}
+
+exports['end fast'] = function (test) {
+
+  var stream = es.through()
+  var x = spec(stream).basic().pausable()
+
+  stream.end() //this will call write()
+
+  process.nextTick(function () {
+    x.validate()
+    test.done()
+  })
+  
+}
+
+
+/*
+  okay, that was easy enough, whats next?
+
+  say, after you call paused(), write should return false
+  until resume is called.
+
+  simple way to implement this:
+    write must return !paused
+  after pause() paused = true
+  after resume() paused = false
+
+  on resume, if !paused drain is emitted again.
+  after drain, !paused
+
+  there are lots of subtle ordering bugs in streams.
+
+  example, set !paused before emitting drain.
+
+  the stream api is stateful. 
+*/
+
+
+require('./helper')(module)

network-visualization/node_modules/event-stream/test/split.asynct.js

@@ -0,0 +1,47 @@
+var es = require('../')
+  , it = require('it-is').style('colour')
+  , d = require('ubelt')
+  , join = require('path').join
+  , fs = require('fs')
+  , Stream = require('stream').Stream
+  , spec = require('stream-spec')
+
+exports ['es.split() works like String#split'] = function (test) {
+  var readme = join(__filename)
+    , expected = fs.readFileSync(readme, 'utf-8').split('\n')
+    , cs = es.split()
+    , actual = []
+    , ended = false
+    , x = spec(cs).through()
+
+  var a = new Stream ()
+  
+  a.write = function (l) {
+    actual.push(l.trim())
+  }
+  a.end = function () {
+
+      ended = true
+      expected.forEach(function (v,k) {
+        //String.split will append an empty string ''
+        //if the string ends in a split pattern.
+        //es.split doesn't which was breaking this test.
+        //clearly, appending the empty string is correct.
+        //tests are passing though. which is the current job.
+        if(v)
+          it(actual[k]).like(v)
+      })
+      //give the stream time to close
+      process.nextTick(function () {
+        test.done()
+        x.validate()
+      })
+  }
+  a.writable = true
+  
+  fs.createReadStream(readme, {flags: 'r'}).pipe(cs)
+  cs.pipe(a) 
+  
+}
+
+require('./helper')(module)

network-visualization/node_modules/event-stream/test/stringify.js

@@ -0,0 +1,15 @@
+
+
+
+var es = require('../')
+
+exports['handle buffer'] = function (t) {
+
+
+  es.stringify().on('data', function (d) {
+    t.equal(d.trim(), JSON.stringify('HELLO'))
+    t.end()
+  }).write(new Buffer('HELLO'))
+
+}
+require('./helper')(module)

network-visualization/node_modules/event-stream/test/writeArray.asynct.js

@@ -0,0 +1,31 @@
+
+var es = require('../')
+  , it = require('it-is').style('colour')
+  , d = require('ubelt')
+
+exports ['write an array'] = function (test) {
+
+  var readThis = d.map(3, 6, 100, d.id) //array of multiples of 3 < 100
+
+  var writer = es.writeArray(function (err, array){
+    if(err) throw err //unpossible
+    it(array).deepEqual(readThis)
+    test.done()     
+  })
+  
+  d.each(readThis, writer.write.bind(writer))
+  writer.end()
+
+}
+
+
+exports ['writer is writable, but not readable'] = function (test) {
+  var reader = es.writeArray(function () {})
+  it(reader).has({
+    readable: false,
+    writable: true
+  })
+
+  test.done()
+}
+require('./helper')(module)