Index: frontend/node_modules/bfj/test/integration.js
===================================================================
--- frontend/node_modules/bfj/test/integration.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/integration.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,431 @@
+'use strict'
+
+const assert = require('chai').assert
+const axios = require('axios')
+const fs = require('fs')
+const path = require('path')
+const Promise = require('bluebird')
+const stream = require('stream')
+
+const modulePath = '../src'
+
+suite('integration:', () => {
+  let log
+
+  setup(() => {
+    log = {}
+  })
+
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns object', () => {
+    assert.isObject(require(modulePath))
+  })
+
+  suite('require:', () => {
+    let bfj
+
+    setup(() => {
+      bfj = require(modulePath)
+    })
+
+    test('walk function is exported', () => {
+      assert.isFunction(bfj.walk)
+    })
+
+    test('walk expects one argument', () => {
+      assert.lengthOf(bfj.walk, 1)
+    })
+
+    test('match function is exported', () => {
+      assert.isFunction(bfj.match)
+    })
+
+    test('match expects two arguments', () => {
+      assert.lengthOf(bfj.match, 2)
+    })
+
+    test('parse function is exported', () => {
+      assert.isFunction(bfj.parse)
+    })
+
+    test('parse expects one argument', () => {
+      assert.lengthOf(bfj.parse, 1)
+    })
+
+    test('read function is exported', () => {
+      assert.isFunction(bfj.read)
+    })
+
+    test('read expects two arguments', () => {
+      assert.lengthOf(bfj.read, 2)
+    })
+
+    test('eventify function is exported', () => {
+      assert.isFunction(bfj.eventify)
+    })
+
+    test('eventify expects one argument', () => {
+      assert.lengthOf(bfj.eventify, 1)
+    })
+
+    test('streamify function is exported', () => {
+      assert.isFunction(bfj.streamify)
+    })
+
+    test('streamify expects one argument', () => {
+      assert.lengthOf(bfj.streamify, 1)
+    })
+
+    test('stringify function is exported', () => {
+      assert.isFunction(bfj.stringify)
+    })
+
+    test('stringify expects two arguments', () => {
+      assert.lengthOf(bfj.stringify, 2)
+    })
+
+    test('write function is exported', () => {
+      assert.isFunction(bfj.write)
+    })
+
+    test('write expects two arguments', () => {
+      assert.lengthOf(bfj.write, 3)
+    })
+
+    test('events are exported', () => {
+      assert.deepEqual(bfj.events, require('../src/events'))
+    })
+
+    suite('read object:', () => {
+      let failed, file, result, error
+
+      setup(() => {
+        failed = false
+        file = path.join(__dirname, 'data.json')
+        fs.writeFileSync(file, JSON.stringify({
+          foo: [ 'b', 'a', 'r' ],
+          baz: null,
+          qux: 3.14159265359e42
+        }, null, '\t'))
+        return bfj.read(file)
+          .then(res => {
+            result = res
+          })
+          .catch(err => {
+            failed = true
+            error = err
+          })
+      })
+
+      teardown(() => {
+        fs.unlinkSync(file)
+      })
+
+      test('result was correct', () => {
+        assert.isFalse(failed)
+        assert.isUndefined(error)
+        assert.isObject(result)
+        assert.lengthOf(Object.keys(result), 3)
+        assert.isArray(result.foo)
+        assert.lengthOf(result.foo, 3)
+        assert.strictEqual(result.foo[0], 'b')
+        assert.strictEqual(result.foo[1], 'a')
+        assert.strictEqual(result.foo[2], 'r')
+        assert.isNull(result.baz)
+        assert.strictEqual(result.qux, 3.14159265359e42)
+      })
+    })
+
+    suite('read value:', () => {
+      let failed, file, result, error
+
+      setup(() => {
+        failed = false
+        file = path.join(__dirname, 'data.json')
+        fs.writeFileSync(file, '"foo"')
+        return bfj.read(file)
+          .then(res => {
+            result = res
+          })
+          .catch(err => {
+            failed = true
+            error = err
+          })
+      })
+
+      teardown(() => {
+        fs.unlinkSync(file)
+      })
+
+      test('result was correct', () => {
+        assert.isFalse(failed)
+        assert.isUndefined(error)
+        assert.strictEqual(result, 'foo')
+      })
+    })
+
+    suite('read error:', () => {
+      let failed, file, result, error
+
+      setup(() => {
+        failed = false
+        file = path.join(__dirname, 'data.json')
+        fs.writeFileSync(file, '"foo" "bar"')
+        return bfj.read(file)
+          .then(res => result = res)
+          .catch(err => {
+            failed = true
+            error = err
+          })
+      })
+
+      teardown(() => {
+        fs.unlinkSync(file)
+      })
+
+      test('result was correct', () => {
+        assert.isTrue(failed)
+        assert.isUndefined(result)
+        assert.instanceOf(error, Error)
+      })
+    })
+
+    suite('read missing file:', () => {
+      let failed, file, result, error
+
+      setup(() => {
+        failed = false
+        file = path.join(__dirname, 'missing.json')
+        assert.isFalse(fs.existsSync(file))
+        return bfj.read(file)
+          .then(res => result = res)
+          .catch(err => {
+            failed = true
+            error = err
+          })
+      })
+
+      test('result was correct', () => {
+        assert.isTrue(failed)
+        assert.isUndefined(result)
+        assert.instanceOf(error, Error)
+      })
+    })
+
+    suite('match predicate:', () => {
+      let file, results, errors
+
+      setup(done => {
+        file = path.join(__dirname, 'data.json')
+        fs.writeFileSync(file, JSON.stringify({
+          foo: 'bar',
+          baz: 'qux',
+          wibble: 'blee'
+        }))
+        results = []
+        errors = []
+        const datastream = bfj.match(
+          fs.createReadStream(file),
+          (k, v) => k === 'baz' || v === 'blee',
+          { minDepth: 1 }
+        )
+        datastream.on('data', item => results.push(item))
+        datastream.on('error', error => errors.push(error))
+        datastream.on('end', done)
+      })
+
+      test('the correct properties were matched', () => {
+        assert.deepEqual([ 'qux', 'blee' ], results)
+      })
+
+      test('no errors occurred', () => {
+        assert.deepEqual(errors, [])
+      })
+    })
+
+    suite('match nested:', () => {
+      let file, results, errors
+
+      setup(done => {
+        file = path.join(__dirname, 'data.json')
+        fs.writeFileSync(file, JSON.stringify({
+          foo: {
+            bar: 'baz'
+          }
+        }))
+        results = []
+        errors = []
+        const datastream = bfj.match(fs.createReadStream(file), () => true)
+        datastream.on('data', item => results.push(item))
+        datastream.on('error', error => errors.push(error))
+        datastream.on('end', done)
+      })
+
+      test('the correct properties were matched', () => {
+        assert.deepEqual([ 'baz', { bar: 'baz' }, { foo: { bar: 'baz' } } ], results)
+      })
+
+      test('no errors occurred', () => {
+        assert.deepEqual(errors, [])
+      })
+    })
+
+    suite('match ndjson:', () => {
+      let file, results, errors
+
+      setup(done => {
+        file = path.join(__dirname, 'data.ndjson')
+        fs.writeFileSync(file, [
+          JSON.stringify([ 'a', 'b' ]),
+          JSON.stringify(null),
+          '',
+          '',
+          JSON.stringify('wibble')
+        ].join('\n'))
+        results = []
+        errors = []
+        const datastream = bfj.match(fs.createReadStream(file), () => true, { ndjson: true })
+        datastream.on('data', item => results.push(item))
+        datastream.on('error', error => errors.push(error))
+        datastream.on('end', done)
+      })
+
+      test('the correct properties were matched', () => {
+        assert.deepEqual([ 'a', 'b', [ 'a', 'b' ], 'wibble' ], results)
+      })
+
+      test('no errors occurred', () => {
+        assert.deepEqual(errors, [])
+      })
+    })
+
+    suite('parse request:', () => {
+      let error, result
+
+      setup((done) => {
+        const jsonstream = new stream.PassThrough()
+        axios({
+          responseType: 'stream',
+          url: 'https://gitlab.com/philbooth/bfj/raw/master/package.json',
+        }).then((response) => response.data.pipe(bfj.unpipe((err, res) => {
+          error = err
+          result = res
+          done()
+        })))
+      })
+
+      test('result was correct', () => {
+        assert.isNull(error)
+        assert.deepEqual(result, require('../package.json'))
+      })
+    })
+
+    suite('parse NDJSON:', () => {
+      let failed, file, results
+
+      setup(() => {
+        failed = false
+        file = path.join(__dirname, 'data.ndjson')
+        results = []
+        fs.writeFileSync(file, [
+          JSON.stringify([ 'b', 'a', 'r' ]),
+          JSON.stringify(null),
+          '',
+          '',
+          JSON.stringify('wibble')
+        ].join('\n'))
+        const stream = fs.createReadStream(file)
+        return bfj.parse(stream, { ndjson: true })
+          .then(result => {
+            results.push(result)
+            return bfj.parse(stream, { ndjson: true })
+          })
+          .then(result => {
+            results.push(result)
+            return bfj.parse(stream, { ndjson: true })
+          })
+          .then(result => {
+            results.push(result)
+            return bfj.parse(stream, { ndjson: true })
+          })
+          .then(result => {
+            results.push(result)
+            return bfj.parse(stream, { ndjson: true })
+          })
+          .then(result => results.push(result))
+          .catch(e => {
+            failed = true
+          })
+      })
+
+      teardown(() => {
+        fs.unlinkSync(file)
+      })
+
+      test('results were correct', () => {
+        assert.isFalse(failed)
+        assert.lengthOf(results, 5)
+        assert.deepEqual(results, [
+          [ 'b', 'a', 'r' ],
+          null,
+          'wibble',
+          undefined,
+          undefined
+        ])
+      })
+    })
+
+    suite('stringify value:', () => {
+      let result
+
+      setup(() => {
+        return bfj.stringify(new Promise(resolve => {
+          setTimeout(resolve.bind(null, 'foo\t"\nbar'), 20)
+        }))
+        .then(res => result = res)
+      })
+
+      test('result was correct', () => {
+        assert.strictEqual(result, '"foo\\t\\"\\nbar"')
+      })
+    })
+
+    suite('write object:', () => {
+      let failed, file, result
+
+      setup(() => {
+        failed = false
+        file = path.join(__dirname, 'data.json')
+        return bfj.write(
+          file,
+          { foo: [ 'b', 'a', 'r' ], baz: null, qux: 3.14159265359e42 }
+        )
+        .then(() => {
+          result = fs.readFileSync(file, { encoding: 'utf8' })
+        })
+        .catch(error => {
+          failed = true
+          result = error
+        })
+      })
+
+      teardown(() => {
+        fs.unlinkSync(file)
+      })
+
+      test('did not fail', () => {
+        assert.isFalse(failed)
+      })
+
+      test('result was correct', () => {
+        assert.strictEqual(result, '{"foo":["b","a","r"],"baz":null,"qux":3.14159265359e+42}')
+      })
+    })
+  })
+})
+
Index: frontend/node_modules/bfj/test/performance.js
===================================================================
--- frontend/node_modules/bfj/test/performance.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/performance.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const check = require('check-types')
+const bfj = require('../src')
+
+const inPath = getDataPath('.json');
+
+let time = process.hrtime()
+
+if (process.argv.length === 4) {
+  const stuff = []
+  const stream = bfj.match(fs.createReadStream(inPath), process.argv[3])
+  stream.on('data', thing => stuff.push(thing))
+  stream.on('end', () => {
+    reportTime()
+    console.log('hooray!', stuff.length)
+    fs.writeFileSync(getDataPath('-result.ndjson'), stuff.map(s => JSON.stringify(s)).join('\n'), {
+      encoding: 'utf8',
+    })
+    process.exit(0)
+  })
+  stream.on('error', error => {
+    console.error('error!', error.stack)
+    process.exit(1)
+  })
+  stream.on('dataError', error => {
+    console.error('dataError!', error.stack)
+    process.exit(2)
+  })
+} else {
+  console.log('reading json')
+  bfj.read(inPath)
+    .then(data => {
+      reportTime()
+      console.log('writing json')
+      return bfj.write(getDataPath('-result.json'), data)
+    })
+    .then(() => done('succeeded'))
+    .catch(error => done(error.stack, 1))
+}
+
+function getDataPath (suffix) {
+  return path.resolve(__dirname, process.argv[2] + suffix)
+}
+
+function reportTime () {
+  let interimTime = process.hrtime(time)
+  console.log('%d seconds and %d nanoseconds', interimTime[0], interimTime[1])
+  time = process.hrtime()
+}
+
+function done (message, code) {
+  reportTime()
+  console.log(message)
+  process.exit(code)
+}
+
Index: frontend/node_modules/bfj/test/unit/datastream.js
===================================================================
--- frontend/node_modules/bfj/test/unit/datastream.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/unit/datastream.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,95 @@
+'use strict'
+
+const assert = require('chai').assert
+const spooks = require('spooks')
+
+const modulePath = '../../src/datastream'
+
+suite('datastream:', () => {
+  let log
+
+  setup(() => {
+    log = {}
+  })
+
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns function', () => {
+    assert.isFunction(require(modulePath))
+  })
+
+  suite('require:', () => {
+    let Stream
+
+    setup(() => {
+      Stream = require(modulePath)
+    })
+
+    test('Stream expects two arguments', () => {
+      assert.lengthOf(Stream, 2)
+    })
+
+    test('calling Stream with function argument doesNotThrow', () => {
+      assert.doesNotThrow(() => {
+        Stream(() => {})
+      })
+    })
+
+    test('calling Stream with object argument throws', () => {
+      assert.throws(() => {
+        Stream({ read: () => {} })
+      })
+    })
+
+    test('calling Stream with new returns Stream instance', () => {
+      assert.instanceOf(new Stream(() => {}), Stream)
+    })
+
+    test('calling Stream with new returns Readable instance', () => {
+      assert.instanceOf(new Stream(() => {}), require('stream').Readable)
+    })
+
+    test('calling Stream without new returns Stream instance', () => {
+      assert.instanceOf(Stream(() => {}), Stream)
+    })
+
+    suite('instantiate:', () => {
+      let datastream
+
+      setup(() => {
+        datastream = new Stream(spooks.fn({ name: 'read', log: log }))
+      })
+
+      test('datastream has _read method', () => {
+        assert.isFunction(datastream._read)
+      })
+
+      test('_read expects no arguments', () => {
+        assert.lengthOf(datastream._read, 0)
+      })
+
+      test('read was not called', () => {
+        assert.strictEqual(log.counts.read, 0)
+      })
+
+      suite('datastream._read:', () => {
+        setup(() => {
+          datastream._read()
+        })
+
+        test('read was called once', () => {
+          assert.strictEqual(log.counts.read, 1)
+          assert.isUndefined(log.these.read[0])
+        })
+
+        test('read was called correctly', () => {
+          assert.lengthOf(log.args.read[0], 0)
+        })
+      })
+    })
+  })
+})
Index: frontend/node_modules/bfj/test/unit/error.js
===================================================================
--- frontend/node_modules/bfj/test/unit/error.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/unit/error.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,80 @@
+'use strict'
+
+const assert = require('chai').assert
+const modulePath = '../../src/error'
+
+suite('error:', () => {
+  let log
+
+  setup(() => {
+    log = {}
+  })
+
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns object', () => {
+    assert.isObject(require(modulePath))
+  })
+
+  suite('require:', () => {
+    let error
+
+    setup(() => {
+      error = require(modulePath)
+    })
+
+    test('error has create method', () => {
+      assert.isFunction(error.create)
+    })
+
+    test('error has no other methods', () => {
+      assert.lengthOf(Object.keys(error), 1)
+    })
+
+    test('create expects four arguments', () => {
+      assert.lengthOf(error.create, 4)
+    })
+
+    test('create does not throw', () => {
+      assert.doesNotThrow(() => {
+        error.create()
+      })
+    })
+
+    test('create returns Error', () => {
+      assert.instanceOf(error.create(), Error)
+    })
+
+    suite('create:', () => {
+      let created
+
+      setup(() => {
+        created = error.create('foo', 'bar', 'baz', 'qux')
+      })
+
+      test('created has correct actual property', () => {
+        assert.strictEqual(created.actual, 'foo')
+      })
+
+      test('created has correct expected property', () => {
+        assert.strictEqual(created.expected, 'bar')
+      })
+
+      test('created has correct lineNumber property', () => {
+        assert.strictEqual(created.lineNumber, 'baz')
+      })
+
+      test('created has correct columnNumber property', () => {
+        assert.strictEqual(created.columnNumber, 'qux')
+      })
+
+      test('created has correct message property', () => {
+        assert.strictEqual(created.message, 'JSON error: encountered `foo` at line baz, column qux where `bar` was expected.')
+      })
+    })
+  })
+})
Index: frontend/node_modules/bfj/test/unit/eventify.js
===================================================================
--- frontend/node_modules/bfj/test/unit/eventify.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/unit/eventify.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,2357 @@
+'use strict'
+
+const assert = require('chai').assert
+const events = require('../../src/events')
+const Promise = require('bluebird')
+const spooks = require('spooks')
+
+const modulePath = '../../src/eventify'
+
+suite('eventify:', () => {
+  let log
+
+  setup(() => {
+    log = {}
+  })
+
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns function', () => {
+    assert.isFunction(require(modulePath))
+  })
+
+  suite('require:', () => {
+    let eventify
+
+    setup(() => {
+      eventify = require(modulePath)
+    })
+
+    test('eventify does not throw', () => {
+      assert.doesNotThrow(() => {
+        eventify()
+      })
+    })
+
+    test('eventify returns EventEmitter', () => {
+      assert.instanceOf(eventify(), require('events').EventEmitter)
+    })
+
+    test('EventEmitter is decorated with pause method', () => {
+      assert.isFunction(eventify().pause)
+      assert.lengthOf(eventify().pause, 0)
+    })
+
+    test('pause method returns continue function', () => {
+      assert.isFunction(eventify().pause())
+      assert.lengthOf(eventify().pause(), 0)
+    })
+
+    suite('undefined:', () => {
+      setup(done => {
+        const emitter = eventify(undefined)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('end event was dispatched correctly', () => {
+        assert.lengthOf(log.args.end[0], 1)
+        assert.isUndefined(log.args.end[0][0])
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('NaN:', () => {
+      setup(done => {
+        const emitter = eventify(NaN)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('end event was dispatched correctly', () => {
+        assert.lengthOf(log.args.end[0], 1)
+        assert.isUndefined(log.args.end[0][0])
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('Infinity:', () => {
+      setup(done => {
+        const emitter = eventify(Infinity)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('end event was dispatched correctly', () => {
+        assert.lengthOf(log.args.end[0], 1)
+        assert.isUndefined(log.args.end[0][0])
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('Number.NEGATIVE_INFINITY:', () => {
+      setup(done => {
+        const emitter = eventify(Number.NEGATIVE_INFINITY)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('end event was dispatched correctly', () => {
+        assert.lengthOf(log.args.end[0], 1)
+        assert.isUndefined(log.args.end[0][0])
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('function:', () => {
+      setup(done => {
+        const emitter = eventify(() => {})
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('symbol:', () => {
+      setup(done => {
+        const emitter = eventify(Symbol('foo'))
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('empty array:', () => {
+      setup(done => {
+        const emitter = eventify([])
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('array event was dispatched correctly', () => {
+        assert.lengthOf(log.args.array[0], 1)
+        assert.isUndefined(log.args.array[0][0])
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('endArray event was dispatched correctly', () => {
+        assert.lengthOf(log.args.endArray[0], 1)
+        assert.isUndefined(log.args.endArray[0][0])
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('empty object:', () => {
+      setup(done => {
+        const emitter = eventify({})
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('object event was dispatched correctly', () => {
+        assert.lengthOf(log.args.object[0], 1)
+        assert.isUndefined(log.args.object[0][0])
+      })
+
+      test('endObject event occurred once', () => {
+        assert.strictEqual(log.counts.endObject, 1)
+      })
+
+      test('endObject event was dispatched correctly', () => {
+        assert.lengthOf(log.args.endObject[0], 1)
+        assert.isUndefined(log.args.endObject[0][0])
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('string:', () => {
+      setup(done => {
+        const emitter = eventify('foo')
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.lengthOf(log.args.string[0], 1)
+        assert.strictEqual(log.args.string[0][0], 'foo')
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('string with special characters:', () => {
+      setup(done => {
+        const emitter = eventify('foo\nbar\t"baz"')
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.lengthOf(log.args.string[0], 1)
+        assert.strictEqual(log.args.string[0][0], 'foo\\nbar\\t\\"baz\\"')
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('number:', () => {
+      setup(done => {
+        const emitter = eventify(42)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('number event occurred once', () => {
+        assert.strictEqual(log.counts.number, 1)
+      })
+
+      test('number event was dispatched correctly', () => {
+        assert.lengthOf(log.args.number[0], 1)
+        assert.strictEqual(log.args.number[0][0], 42)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('false:', () => {
+      setup(done => {
+        const emitter = eventify(false)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('literal event occurred once', () => {
+        assert.strictEqual(log.counts.literal, 1)
+      })
+
+      test('literal event was dispatched correctly', () => {
+        assert.lengthOf(log.args.literal[0], 1)
+        assert.isFalse(log.args.literal[0][0])
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('true:', () => {
+      setup(done => {
+        const emitter = eventify(true)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('literal event occurred once', () => {
+        assert.strictEqual(log.counts.literal, 1)
+      })
+
+      test('literal event was dispatched correctly', () => {
+        assert.isTrue(log.args.literal[0][0])
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('null:', () => {
+      setup(done => {
+        const emitter = eventify(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('literal event occurred once', () => {
+        assert.strictEqual(log.counts.literal, 1)
+      })
+
+      test('literal event was dispatched correctly', () => {
+        assert.isNull(log.args.literal[0][0])
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('array with items:', () => {
+      setup(done => {
+        const emitter = eventify([
+          undefined,
+          NaN,
+          Number.POSITIVE_INFINITY,
+          Number.NEGATIVE_INFINITY,
+          'foo',
+          () => {},
+          'bar',
+          Symbol('baz')
+        ])
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('literal event occurred six times', () => {
+        assert.strictEqual(log.counts.literal, 6)
+      })
+
+      test('literal event was dispatched correctly first time', () => {
+        assert.isNull(log.args.literal[0][0])
+      })
+
+      test('literal event was dispatched correctly second time', () => {
+        assert.isNull(log.args.literal[1][0])
+      })
+
+      test('literal event was dispatched correctly third time', () => {
+        assert.isNull(log.args.literal[2][0])
+      })
+
+      test('literal event was dispatched correctly fourth time', () => {
+        assert.isNull(log.args.literal[3][0])
+      })
+
+      test('literal event was dispatched correctly fifth time', () => {
+        assert.isNull(log.args.literal[4][0])
+      })
+
+      test('literal event was dispatched correctly sixth time', () => {
+        assert.isNull(log.args.literal[5][0])
+      })
+
+      test('string event occurred twice', () => {
+        assert.strictEqual(log.counts.string, 2)
+      })
+
+      test('string event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.string[0][0], 'foo')
+      })
+
+      test('string event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.string[1][0], 'bar')
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('object with properties:', () => {
+      setup(done => {
+        const emitter = eventify({ foo: 42,
+          bar: undefined,
+          baz: 3.14159265359,
+          qux: Symbol('qux')
+        })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('property event occurred twice', () => {
+        assert.strictEqual(log.counts.property, 2)
+      })
+
+      test('property event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.property[0][0], 'foo')
+      })
+
+      test('property event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.property[1][0], 'baz')
+      })
+
+      test('number event occurred twice', () => {
+        assert.strictEqual(log.counts.number, 2)
+      })
+
+      test('number event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.number[0][0], 42)
+      })
+
+      test('number event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.number[1][0], 3.14159265359)
+      })
+
+      test('endObject event occurred once', () => {
+        assert.strictEqual(log.counts.endObject, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('object with keys containing special characters:', () => {
+      setup(done => {
+        const emitter = eventify({ 'foo\n"bar"': 42 })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('property event occurred once', () => {
+        assert.strictEqual(log.counts.property, 1)
+      })
+
+      test('property event was dispatched correctly', () => {
+        assert.strictEqual(log.args.property[0][0], 'foo\\n\\"bar\\"')
+      })
+
+      test('number event occurred once', () => {
+        assert.strictEqual(log.counts.number, 1)
+      })
+
+      test('number event was dispatched correctly', () => {
+        assert.strictEqual(log.args.number[0][0], 42)
+      })
+
+      test('endObject event occurred once', () => {
+        assert.strictEqual(log.counts.endObject, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('nested array:', () => {
+      setup(done => {
+        const emitter = eventify([ 'foo', [ 'bar', [ 'baz', 'qux' ] ] ])
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred three times', () => {
+        assert.strictEqual(log.counts.array, 3)
+      })
+
+      test('string event occurred four times', () => {
+        assert.strictEqual(log.counts.string, 4)
+      })
+
+      test('string event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.string[0][0], 'foo')
+      })
+
+      test('string event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.string[1][0], 'bar')
+      })
+
+      test('string event was dispatched correctly third time', () => {
+        assert.strictEqual(log.args.string[2][0], 'baz')
+      })
+
+      test('string event was dispatched correctly fourth time', () => {
+        assert.strictEqual(log.args.string[3][0], 'qux')
+      })
+
+      test('endArray event occurred three times', () => {
+        assert.strictEqual(log.counts.endArray, 3)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('nested object:', () => {
+      setup(done => {
+        const emitter = eventify({ foo: { bar: { baz: 1, qux: 2 }, wibble: 3 }, wobble: 4 })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred three times', () => {
+        assert.strictEqual(log.counts.object, 3)
+      })
+
+      test('property event occurred six times', () => {
+        assert.strictEqual(log.counts.property, 6)
+      })
+
+      test('property event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.property[0][0], 'foo')
+      })
+
+      test('property event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.property[1][0], 'bar')
+      })
+
+      test('property event was dispatched correctly third time', () => {
+        assert.strictEqual(log.args.property[2][0], 'baz')
+      })
+
+      test('property event was dispatched correctly fourth time', () => {
+        assert.strictEqual(log.args.property[3][0], 'qux')
+      })
+
+      test('property event was dispatched correctly fifth time', () => {
+        assert.strictEqual(log.args.property[4][0], 'wibble')
+      })
+
+      test('property event was dispatched correctly sixth time', () => {
+        assert.strictEqual(log.args.property[5][0], 'wobble')
+      })
+
+      test('number event occurred four times', () => {
+        assert.strictEqual(log.counts.number, 4)
+      })
+
+      test('number event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.number[0][0], 1)
+      })
+
+      test('number event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.number[1][0], 2)
+      })
+
+      test('number event was dispatched correctly third time', () => {
+        assert.strictEqual(log.args.number[2][0], 3)
+      })
+
+      test('number event was dispatched correctly fourth time', () => {
+        assert.strictEqual(log.args.number[3][0], 4)
+      })
+
+      test('endObject event occurred three times', () => {
+        assert.strictEqual(log.counts.endObject, 3)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('promise:', () => {
+      setup(done => {
+        let resolve
+
+        const emitter = eventify(new Promise(res => resolve = res), { poll: 4 })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+
+        setTimeout(resolve.bind(null, 'foo'), 20)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.lengthOf(log.args.string[0], 1)
+        assert.strictEqual(log.args.string[0][0], 'foo')
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('ignore promise:', () => {
+      setup(done => {
+        let resolve
+
+        const emitter = eventify(new Promise(res => resolve = res), { poll: 4, promises: 'ignore' })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+
+        setTimeout(resolve.bind(null, 'foo'), 20)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('buffer:', () => {
+      setup(done => {
+        let resolve
+
+        const emitter = eventify(new Buffer('foo bar baz qux'))
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.lengthOf(log.args.string[0], 1)
+        assert.strictEqual(log.args.string[0][0], 'foo bar baz qux')
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('ignore buffer:', () => {
+      setup(done => {
+        let resolve
+
+        const emitter = eventify(new Buffer('foo bar baz qux'), { buffers: 'ignore' })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('date:', () => {
+      setup(done => {
+        let resolve
+
+        const emitter = eventify(new Date('1977-06-10T10:30:00.000Z'))
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.lengthOf(log.args.string[0], 1)
+        assert.strictEqual(log.args.string[0][0], '1977-06-10T10:30:00.000Z')
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('object with toJSON method:', () => {
+      setup(done => {
+        let resolve
+
+        const emitter = eventify({ toJSON () { return 'foo' } })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.lengthOf(log.args.string[0], 1)
+        assert.strictEqual(log.args.string[0][0], 'foo')
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('map:', () => {
+      setup(done => {
+        let resolve
+
+        const emitter = eventify(new Map([['foo','bar'],['baz','qux']]))
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('property event occurred twice', () => {
+        assert.strictEqual(log.counts.property, 2)
+      })
+
+      test('property event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.property[0][0], 'foo')
+      })
+
+      test('property event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.property[1][0], 'baz')
+      })
+
+      test('string event occurred twice', () => {
+        assert.strictEqual(log.counts.string, 2)
+      })
+
+      test('string event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.string[0][0], 'bar')
+      })
+
+      test('string event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.string[1][0], 'qux')
+      })
+
+      test('endObject event occurred once', () => {
+        assert.strictEqual(log.counts.endObject, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('ignore map:', () => {
+      setup(done => {
+        let resolve
+
+        const emitter = eventify(new Map([['foo','bar'],['baz','qux']]), { maps: 'ignore' })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('set:', () => {
+      setup(done => {
+        let resolve
+
+        const emitter = eventify(new Set(['foo','bar']))
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('string event occurred twice', () => {
+        assert.strictEqual(log.counts.string, 2)
+      })
+
+      test('string event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.string[0][0], 'foo')
+      })
+
+      test('string event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.string[1][0], 'bar')
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('ignore set:', () => {
+      setup(done => {
+        let resolve
+
+        const emitter = eventify(new Set(['foo','bar']), { iterables: 'ignore' })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('promise resolved to a map:', () => {
+      setup(done => {
+        let resolve
+
+        const emitter = eventify(new Promise(res => resolve = res), { poll: 4 })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+
+        setImmediate(resolve.bind(null, new Map([['foo','bar'],['baz','qux']])))
+      })
+
+      test('object event occurred once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('property event occurred twice', () => {
+        assert.strictEqual(log.counts.property, 2)
+      })
+
+      test('property event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.property[0][0], 'foo')
+      })
+
+      test('property event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.property[1][0], 'baz')
+      })
+
+      test('string event occurred twice', () => {
+        assert.strictEqual(log.counts.string, 2)
+      })
+
+      test('string event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.string[0][0], 'bar')
+      })
+
+      test('string event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.string[1][0], 'qux')
+      })
+
+      test('endObject event occurred once', () => {
+        assert.strictEqual(log.counts.endObject, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('array circular reference:', () => {
+      setup(done => {
+        const array = [ 'foo' ]
+        array[1] = array
+        const emitter = eventify(array)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred twice', () => {
+        assert.strictEqual(log.counts.array, 2)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.strictEqual(log.args.string[0][0], 'foo')
+      })
+
+      test('endArray event occurred twice', () => {
+        assert.strictEqual(log.counts.endArray, 2)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 1)
+      })
+
+      test('dataError event was dispatched correctly', () => {
+        assert.lengthOf(log.args.dataError[0], 1)
+        assert.instanceOf(log.args.dataError[0][0], Error)
+        assert.strictEqual(log.args.dataError[0][0].message, 'Circular reference.')
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+    })
+
+    suite('object circular reference:', () => {
+      setup(done => {
+        const object = { foo: 'bar' }
+        object.self = object
+        const emitter = eventify(object)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred twice', () => {
+        assert.strictEqual(log.counts.object, 2)
+      })
+
+      test('property event occurred twice', () => {
+        assert.strictEqual(log.counts.property, 2)
+      })
+
+      test('property event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.property[0][0], 'foo')
+      })
+
+      test('property event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.property[1][0], 'self')
+      })
+
+      test('endObject event occurred twice', () => {
+        assert.strictEqual(log.counts.endObject, 2)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 1)
+      })
+
+      test('dataError event was dispatched correctly', () => {
+        assert.strictEqual(log.args.dataError[0][0].message, 'Circular reference.')
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+    })
+
+    suite('array circular reference with ignore set:', () => {
+      setup(done => {
+        const array = [ 'foo' ]
+        array[1] = array
+        const emitter = eventify(array, { circular: 'ignore' })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred twice', () => {
+        assert.strictEqual(log.counts.array, 2)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('endArray event occurred twice', () => {
+        assert.strictEqual(log.counts.endArray, 2)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('object circular reference with ignore set:', () => {
+      setup(done => {
+        const object = { foo: 'bar' }
+        object.self = object
+        const emitter = eventify(object, { circular: 'ignore' })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred twice', () => {
+        assert.strictEqual(log.counts.object, 2)
+      })
+
+      test('property event occurred twice', () => {
+        assert.strictEqual(log.counts.property, 2)
+      })
+
+      test('endObject event occurred twice', () => {
+        assert.strictEqual(log.counts.endObject, 2)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('parallel array reference:', () => {
+      setup(done => {
+        const array = [ 'foo' ]
+        const emitter = eventify([ array, array ])
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred three times', () => {
+        assert.strictEqual(log.counts.array, 3)
+      })
+
+      test('string event occurred twice', () => {
+        assert.strictEqual(log.counts.string, 2)
+      })
+
+      test('endArray event occurred three times', () => {
+        assert.strictEqual(log.counts.endArray, 3)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('parallel object reference:', () => {
+      setup(done => {
+        const object = { foo: 'bar' }
+        const emitter = eventify({ baz: object, qux: object })
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred three times', () => {
+        assert.strictEqual(log.counts.object, 3)
+      })
+
+      test('property event occurred four times', () => {
+        assert.strictEqual(log.counts.property, 4)
+      })
+
+      test('endObject event occurred three times', () => {
+        assert.strictEqual(log.counts.endObject, 3)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('throw errors from event handlers:', () => {
+      setup(done => {
+        const emitter = eventify([null,false,true,0,"",{"foo":"bar"}])
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+          if (value !== events.end) {
+            emitter.on(value, () => { throw 0 })
+          }
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event occured once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('literal event occured three times', () => {
+        assert.strictEqual(log.counts.literal, 3)
+      })
+
+      test('number event occured once', () => {
+        assert.strictEqual(log.counts.number, 1)
+      })
+
+      test('string event occured twice', () => {
+        assert.strictEqual(log.counts.string, 2)
+      })
+
+      test('object event occured once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('property event occured once', () => {
+        assert.strictEqual(log.counts.property, 1)
+      })
+
+      test('endObject event occured once', () => {
+        assert.strictEqual(log.counts.endObject, 1)
+      })
+
+      test('endArray event occured once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('error event occured eleven times', () => {
+        assert.strictEqual(log.counts.error, 11)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+  })
+})
Index: frontend/node_modules/bfj/test/unit/jsonstream.js
===================================================================
--- frontend/node_modules/bfj/test/unit/jsonstream.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/unit/jsonstream.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,95 @@
+'use strict'
+
+const assert = require('chai').assert
+const spooks = require('spooks')
+
+const modulePath = '../../src/jsonstream'
+
+suite('jsonstream:', () => {
+  let log
+
+  setup(() => {
+    log = {}
+  })
+
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns function', () => {
+    assert.isFunction(require(modulePath))
+  })
+
+  suite('require:', () => {
+    let Stream
+
+    setup(() => {
+      Stream = require(modulePath)
+    })
+
+    test('Stream expects two arguments', () => {
+      assert.lengthOf(Stream, 2)
+    })
+
+    test('calling Stream with function argument doesNotThrow', () => {
+      assert.doesNotThrow(() => {
+        Stream(() => {})
+      })
+    })
+
+    test('calling Stream with object argument throws', () => {
+      assert.throws(() => {
+        Stream({ read: () => {} })
+      })
+    })
+
+    test('calling Stream with new returns Stream instance', () => {
+      assert.instanceOf(new Stream(() => {}), Stream)
+    })
+
+    test('calling Stream with new returns Readable instance', () => {
+      assert.instanceOf(new Stream(() => {}), require('stream').Readable)
+    })
+
+    test('calling Stream without new returns Stream instance', () => {
+      assert.instanceOf(Stream(() => {}), Stream)
+    })
+
+    suite('instantiate:', () => {
+      let jsonstream
+
+      setup(() => {
+        jsonstream = new Stream(spooks.fn({ name: 'read', log: log }))
+      })
+
+      test('jsonstream has _read method', () => {
+        assert.isFunction(jsonstream._read)
+      })
+
+      test('_read expects no arguments', () => {
+        assert.lengthOf(jsonstream._read, 0)
+      })
+
+      test('read was not called', () => {
+        assert.strictEqual(log.counts.read, 0)
+      })
+
+      suite('jsonstream._read:', () => {
+        setup(() => {
+          jsonstream._read()
+        })
+
+        test('read was called once', () => {
+          assert.strictEqual(log.counts.read, 1)
+          assert.isUndefined(log.these.read[0])
+        })
+
+        test('read was called correctly', () => {
+          assert.lengthOf(log.args.read[0], 0)
+        })
+      })
+    })
+  })
+})
Index: frontend/node_modules/bfj/test/unit/match.js
===================================================================
--- frontend/node_modules/bfj/test/unit/match.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/unit/match.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,1257 @@
+'use strict'
+
+const assert = require('chai').assert
+const proxyquire = require('proxyquire')
+const spooks = require('spooks')
+
+const modulePath = '../../src/match'
+
+suite('match:', () => {
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns function', () => {
+    assert.isFunction(require(modulePath))
+  })
+
+  suite('require, results.push returns true:', () => {
+    let log, resume, results, match
+
+    setup(() => {
+      log = {}
+      resume = spooks.fn({ name: 'resume', log })
+      results = {
+        walk: [
+          {
+            on: spooks.fn({ name: 'on', log: log }),
+            pause: spooks.fn({ name: 'pause', log: log, results: [ resume ] })
+          }
+        ],
+        push: [ true ]
+      }
+      match = proxyquire(modulePath, {
+        './walk': spooks.fn({
+          name: 'walk',
+          log: log,
+          results: results.walk
+        }),
+        './datastream': spooks.ctor({
+          name: 'DataStream',
+          log: log,
+          archetype: { instance: { push: () => {}, emit: () => {} } },
+          results: results
+        })
+      })
+    })
+
+    test('match expects two arguments', () => {
+      assert.lengthOf(match, 2)
+    })
+
+    test('match does not throw with match function', () => {
+      assert.doesNotThrow(() => match(null, () => {}))
+    })
+
+    test('match does not throw with match string', () => {
+      assert.doesNotThrow(() => match(null, ' '))
+    })
+
+    test('match throws with empty match string', () => {
+      assert.throws(() => match(null, ''))
+    })
+
+    test('match does not throw with match regex', () => {
+      assert.doesNotThrow(() => match(null, /.*/))
+    })
+
+    test('match throws with invalid match arg', () => {
+      assert.throws(() => match(null, {}))
+    })
+
+    test('match returns stream', () => {
+      assert.isFunction(match(null, /.*/).push)
+      assert.isFunction(match(null, /.*/).emit)
+    })
+
+    test('DataStream was not called', () => {
+      assert.strictEqual(log.counts.DataStream, 0)
+    })
+
+    test('walk was not called', () => {
+      assert.strictEqual(log.counts.walk, 0)
+    })
+
+    test('EventEmitter.on was not called', () => {
+      assert.strictEqual(log.counts.on, 0)
+    })
+
+    test('EventEmitter.pause was not called', () => {
+      assert.strictEqual(log.counts.pause, 0)
+    })
+
+    suite('match with predicate returning true:', () => {
+      let stream, predicate, options, result
+
+      setup(() => {
+        stream = {}
+        predicate = spooks.fn({ name: 'predicate', log, results: [ true ] })
+        options = { foo: 'bar', highWaterMark: 42 }
+        result = match(stream, predicate, options)
+      })
+
+      test('DataStream was called once', () => {
+        assert.strictEqual(log.counts.DataStream, 1)
+        assert.isObject(log.these.DataStream[0])
+      })
+
+      test('DataStream was called correctly', () => {
+        assert.lengthOf(log.args.DataStream[0], 2)
+        assert.isFunction(log.args.DataStream[0][0])
+        assert.deepEqual(log.args.DataStream[0][1], { highWaterMark: 42 })
+      })
+
+      test('walk was called once', () => {
+        assert.strictEqual(log.counts.walk, 1)
+        assert.isUndefined(log.these.walk[0])
+      })
+
+      test('walk was called correctly', () => {
+        assert.lengthOf(log.args.walk[0], 2)
+        assert.strictEqual(log.args.walk[0][0], stream)
+        assert.lengthOf(Object.keys(log.args.walk[0][0]), 0)
+        assert.strictEqual(log.args.walk[0][1], options)
+        assert.lengthOf(Object.keys(log.args.walk[0][1]), 2)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+        assert.strictEqual(log.these.on[0], results.walk[0])
+        assert.strictEqual(log.these.on[1], results.walk[0])
+        assert.strictEqual(log.these.on[2], results.walk[0])
+        assert.strictEqual(log.these.on[3], results.walk[0])
+        assert.strictEqual(log.these.on[4], results.walk[0])
+        assert.strictEqual(log.these.on[5], results.walk[0])
+        assert.strictEqual(log.these.on[6], results.walk[0])
+        assert.strictEqual(log.these.on[7], results.walk[0])
+        assert.strictEqual(log.these.on[8], results.walk[0])
+        assert.strictEqual(log.these.on[9], results.walk[0])
+        assert.strictEqual(log.these.on[10], results.walk[0])
+      })
+
+      test('EventEmitter.on was called correctly first time', () => {
+        assert.lengthOf(log.args.on[0], 2)
+        assert.strictEqual(log.args.on[0][0], 'arr')
+        assert.isFunction(log.args.on[0][1])
+      })
+
+      test('EventEmitter.on was called correctly second time', () => {
+        assert.lengthOf(log.args.on[1], 2)
+        assert.strictEqual(log.args.on[1][0], 'obj')
+        assert.isFunction(log.args.on[1][1])
+      })
+
+      test('EventEmitter.on was called correctly third time', () => {
+        assert.lengthOf(log.args.on[2], 2)
+        assert.strictEqual(log.args.on[2][0], 'pro')
+        assert.isFunction(log.args.on[2][1])
+      })
+
+      test('EventEmitter.on was called correctly fourth time', () => {
+        assert.lengthOf(log.args.on[3], 2)
+        assert.strictEqual(log.args.on[3][0], 'end-arr')
+        assert.isFunction(log.args.on[3][1])
+      })
+
+      test('EventEmitter.on was called correctly fifth time', () => {
+        assert.lengthOf(log.args.on[4], 2)
+        assert.strictEqual(log.args.on[4][0], 'end-obj')
+        assert.isFunction(log.args.on[4][1])
+      })
+
+      test('EventEmitter.on was called correctly sixth time', () => {
+        assert.lengthOf(log.args.on[5], 2)
+        assert.strictEqual(log.args.on[5][0], 'str')
+        assert.isFunction(log.args.on[5][1])
+      })
+
+      test('EventEmitter.on was called correctly seventh time', () => {
+        assert.lengthOf(log.args.on[6], 2)
+        assert.strictEqual(log.args.on[6][0], 'num')
+        assert.isFunction(log.args.on[6][1])
+      })
+
+      test('EventEmitter.on was called correctly eighth time', () => {
+        assert.lengthOf(log.args.on[7], 2)
+        assert.strictEqual(log.args.on[7][0], 'lit')
+        assert.isFunction(log.args.on[7][1])
+      })
+
+      test('EventEmitter.on was called correctly ninth time', () => {
+        assert.lengthOf(log.args.on[8], 2)
+        assert.strictEqual(log.args.on[8][0], 'end')
+        assert.isFunction(log.args.on[8][1])
+      })
+
+      test('EventEmitter.on was called correctly tenth time', () => {
+        assert.lengthOf(log.args.on[9], 2)
+        assert.strictEqual(log.args.on[9][0], 'err')
+        assert.isFunction(log.args.on[9][1])
+      })
+
+      test('EventEmitter.on was called correctly eleventh time', () => {
+        assert.lengthOf(log.args.on[10], 2)
+        assert.strictEqual(log.args.on[10][0], 'err-data')
+        assert.isFunction(log.args.on[10][1])
+      })
+
+      suite('array event:', () => {
+        setup(() => {
+          log.args.on[0][1]()
+        })
+
+        test('results.push was not called', () => {
+          assert.strictEqual(log.counts.push, 0)
+        })
+
+        suite('end event:', () => {
+          setup(() => {
+            log.args.on[8][1]()
+          })
+
+          test('results.push was not called', () => {
+            assert.strictEqual(log.counts.push, 0)
+          })
+
+          suite('read stream:', () => {
+            setup(() => {
+              log.args.DataStream[0][0]()
+            })
+
+            test('results.push was called once', () => {
+              assert.strictEqual(log.counts.push, 1)
+            })
+
+            test('results.push was called correctly', () => {
+              assert.lengthOf(log.args.push[0], 1)
+              assert.isNull(log.args.push[0][0])
+            })
+
+            test('predicate was not called', () => {
+              assert.strictEqual(log.counts.predicate, 0)
+            })
+          })
+        })
+
+        suite('endArray and end events:', () => {
+          setup(() => {
+            log.args.on[3][1]()
+            log.args.on[8][1]()
+          })
+
+          test('predicate was called once', () => {
+            assert.strictEqual(log.counts.predicate, 1)
+          })
+
+          test('predicate was called correctly', () => {
+            assert.lengthOf(log.args.predicate[0], 3)
+            assert.isUndefined(log.args.predicate[0][0])
+            assert.deepEqual(log.args.predicate[0][1], [])
+            assert.strictEqual(log.args.predicate[0][2], 0)
+          })
+
+          test('results.push was not called', () => {
+            assert.strictEqual(log.counts.push, 0)
+          })
+
+          suite('read stream:', () => {
+            setup(() => {
+              log.args.DataStream[0][0]()
+            })
+
+            test('results.push was called twice', () => {
+              assert.strictEqual(log.counts.push, 2)
+            })
+
+            test('results.push was called correctly first time', () => {
+              assert.lengthOf(log.args.push[0], 1)
+              assert.deepEqual(log.args.push[0][0], [])
+            })
+
+            test('results.push was called correctly second time', () => {
+              assert.lengthOf(log.args.push[1], 1)
+              assert.isNull(log.args.push[1][0])
+            })
+
+            test('results.emit was not called', () => {
+              assert.strictEqual(log.counts.emit, 0)
+            })
+          })
+        })
+
+        suite('read stream:', () => {
+          setup(() => {
+            log.args.DataStream[0][0]()
+          })
+
+          test('results.push was not called', () => {
+            assert.strictEqual(log.counts.push, 0)
+          })
+
+          suite('end event:', () => {
+            setup(() => {
+              log.args.on[8][1]()
+            })
+
+            test('results.push was called once', () => {
+              assert.strictEqual(log.counts.push, 1)
+            })
+
+            test('results.push was called correctly', () => {
+              assert.isNull(log.args.push[0][0])
+            })
+
+            test('results.emit was not called', () => {
+              assert.strictEqual(log.counts.emit, 0)
+            })
+          })
+
+          suite('dataError event:', () => {
+            setup(() => {
+              log.args.on[10][1]('foo')
+            })
+
+            test('results.push was not called', () => {
+              assert.strictEqual(log.counts.push, 0)
+            })
+
+            test('results.emit was called once', () => {
+              assert.strictEqual(log.counts.emit, 1)
+            })
+
+            test('results.emit was called correctly', () => {
+              assert.lengthOf(log.args.emit[0], 2)
+              assert.strictEqual(log.args.emit[0][0], 'dataError')
+              assert.strictEqual(log.args.emit[0][1], 'foo')
+            })
+
+            test('predicate was not called', () => {
+              assert.strictEqual(log.counts.predicate, 0)
+            })
+          })
+
+          suite('string event:', () => {
+            setup(() => {
+              log.args.on[5][1]('foo')
+            })
+
+            test('predicate was called once', () => {
+              assert.strictEqual(log.counts.predicate, 1)
+            })
+
+            test('predicate was called correctly', () => {
+              assert.lengthOf(log.args.predicate[0], 3)
+              assert.strictEqual(log.args.predicate[0][0], 0)
+              assert.strictEqual(log.args.predicate[0][1], 'foo')
+              assert.strictEqual(log.args.predicate[0][2], 1)
+            })
+
+            test('results.push was called once', () => {
+              assert.strictEqual(log.counts.push, 1)
+            })
+
+            test('results.push was called correctly', () => {
+              assert.strictEqual(log.args.push[0][0], 'foo')
+            })
+
+            suite('string event:', () => {
+              setup(() => {
+                log.args.on[5][1]('bar')
+              })
+
+              test('predicate was called once', () => {
+                assert.strictEqual(log.counts.predicate, 2)
+              })
+
+              test('predicate was called correctly', () => {
+                assert.strictEqual(log.args.predicate[1][0], 1)
+                assert.strictEqual(log.args.predicate[1][1], 'bar')
+                assert.strictEqual(log.args.predicate[1][2], 1)
+              })
+
+              test('results.push was called once', () => {
+                assert.strictEqual(log.counts.push, 2)
+              })
+
+              test('results.push was called correctly', () => {
+                assert.strictEqual(log.args.push[1][0], 'bar')
+              })
+            })
+
+            suite('array event:', () => {
+              setup(() => {
+                log.args.on[0][1]()
+              })
+
+              test('predicate was not called', () => {
+                assert.strictEqual(log.counts.predicate, 1)
+              })
+
+              test('results.push was not called', () => {
+                assert.strictEqual(log.counts.push, 1)
+              })
+
+              suite('endArray event:', () => {
+                setup(() => {
+                  log.args.on[3][1]()
+                })
+
+                test('predicate was called once', () => {
+                  assert.strictEqual(log.counts.predicate, 2)
+                })
+
+                test('predicate was called correctly', () => {
+                  assert.strictEqual(log.args.predicate[1][0], 1)
+                  assert.deepEqual(log.args.predicate[1][1], [])
+                  assert.strictEqual(log.args.predicate[1][2], 1)
+                })
+
+                test('results.push was called once', () => {
+                  assert.strictEqual(log.counts.push, 2)
+                })
+
+                test('results.push was called correctly', () => {
+                  assert.deepEqual(log.args.push[1][0], [])
+                })
+
+                suite('endArray event:', () => {
+                  setup(() => {
+                    log.args.on[3][1]()
+                  })
+
+                  test('predicate was called once', () => {
+                    assert.strictEqual(log.counts.predicate, 3)
+                  })
+
+                  test('predicate was called correctly', () => {
+                    assert.isUndefined(log.args.predicate[2][0])
+                    assert.deepEqual(log.args.predicate[2][1], [ 'foo', [] ])
+                    assert.strictEqual(log.args.predicate[2][2], 0)
+                  })
+
+                  test('results.push was called once', () => {
+                    assert.strictEqual(log.counts.push, 3)
+                  })
+
+                  test('results.push was called correctly', () => {
+                    assert.deepEqual(log.args.push[2][0], [ 'foo', [] ])
+                  })
+
+                  test('EventEmitter.pause was not called', () => {
+                    assert.strictEqual(log.counts.pause, 0)
+                  })
+                })
+              })
+            })
+
+            suite('object event:', () => {
+              setup(() => {
+                log.args.on[1][1]()
+              })
+
+              test('results.push was not called', () => {
+                assert.strictEqual(log.counts.push, 1)
+              })
+
+              suite('property event:', () => {
+                setup(() => {
+                  log.args.on[2][1]('bar')
+                })
+
+                test('predicate was not called', () => {
+                  assert.strictEqual(log.counts.predicate, 1)
+                })
+
+                test('results.push was not called', () => {
+                  assert.strictEqual(log.counts.push, 1)
+                })
+
+                suite('string event:', () => {
+                  setup(() => {
+                    log.args.on[5][1]('baz')
+                  })
+
+                  test('predicate was called once', () => {
+                    assert.strictEqual(log.counts.predicate, 2)
+                  })
+
+                  test('predicate was called correctly', () => {
+                    assert.strictEqual(log.args.predicate[1][0], 'bar')
+                    assert.strictEqual(log.args.predicate[1][1], 'baz')
+                    assert.strictEqual(log.args.predicate[1][2], 2)
+                  })
+
+                  test('results.push was called once', () => {
+                    assert.strictEqual(log.counts.push, 2)
+                  })
+
+                  test('results.push was called correctly', () => {
+                    assert.strictEqual(log.args.push[1][0], 'baz')
+                  })
+
+                  suite('property event:', () => {
+                    setup(() => {
+                      log.args.on[2][1]('nested')
+                    })
+
+                    test('results.push was not called', () => {
+                      assert.strictEqual(log.counts.push, 2)
+                    })
+
+                    suite('object event:', () => {
+                      setup(() => {
+                        log.args.on[1][1]()
+                      })
+
+                      test('predicate was not called', () => {
+                        assert.strictEqual(log.counts.predicate, 2)
+                      })
+
+                      test('results.push was not called', () => {
+                        assert.strictEqual(log.counts.push, 2)
+                      })
+
+                      suite('endObject event:', () => {
+                        setup(() => {
+                          log.args.on[4][1]()
+                        })
+
+                        test('predicate was called once', () => {
+                          assert.strictEqual(log.counts.predicate, 3)
+                        })
+
+                        test('predicate was called correctly', () => {
+                          assert.strictEqual(log.args.predicate[2][0], 'nested')
+                          assert.deepEqual(log.args.predicate[2][1], {})
+                          assert.strictEqual(log.args.predicate[2][2], 2)
+                        })
+
+                        test('results.push was called once', () => {
+                          assert.strictEqual(log.counts.push, 3)
+                        })
+
+                        test('results.push was called correctly', () => {
+                          assert.deepEqual(log.args.push[2][0], {})
+                        })
+
+                        suite('endObject event:', () => {
+                          setup(() => {
+                            log.args.on[4][1]()
+                          })
+
+                          test('predicate was called once', () => {
+                            assert.strictEqual(log.counts.predicate, 4)
+                          })
+
+                          test('predicate was called correctly', () => {
+                            assert.strictEqual(log.args.predicate[3][0], 1)
+                            assert.deepEqual(log.args.predicate[3][1], { bar: 'baz', nested: {} })
+                            assert.strictEqual(log.args.predicate[3][2], 1)
+                          })
+
+                          test('results.push was called once', () => {
+                            assert.strictEqual(log.counts.push, 4)
+                          })
+
+                          test('results.push was called correctly', () => {
+                            assert.deepEqual(log.args.push[3][0], { bar: 'baz', nested: {} })
+                          })
+
+                          test('EventEmitter.pause was not called', () => {
+                            assert.strictEqual(log.counts.pause, 0)
+                          })
+                        })
+                      })
+                    })
+                  })
+                })
+              })
+            })
+          })
+
+          suite('string events, push returns false:', () => {
+            setup(() => {
+              results.push[0] = false
+              log.args.on[5][1]('foo')
+              log.args.on[5][1]('bar')
+            })
+
+            teardown(() => {
+              results.push[0] = true
+            })
+
+            test('predicate was called twice', () => {
+              assert.strictEqual(log.counts.predicate, 2)
+            })
+
+            test('results.push was called once', () => {
+              assert.strictEqual(log.counts.push, 1)
+            })
+
+            test('results.push was called correctly', () => {
+              assert.strictEqual(log.args.push[0][0], 'foo')
+            })
+
+            test('emitter.pause was called once', () => {
+              assert.strictEqual(log.counts.pause, 1)
+              assert.strictEqual(log.these.pause[0], results.walk[0])
+            })
+
+            test('emitter.pause was called correctly', () => {
+              assert.lengthOf(log.args.pause[0], 0)
+            })
+
+            test('resume was not called', () => {
+              assert.strictEqual(log.counts.resume, 0)
+            })
+
+            suite('read stream:', () => {
+              setup(() => {
+                log.args.DataStream[0][0]()
+              })
+
+              test('resume was called once', () => {
+                assert.strictEqual(log.counts.resume, 1)
+                assert.isUndefined(log.these.resume[0])
+              })
+
+              test('resume was called correctly', () => {
+                assert.lengthOf(log.args.resume[0], 0)
+              })
+
+              test('results.push was called once', () => {
+                assert.strictEqual(log.counts.push, 2)
+              })
+
+              test('results.push was called correctly', () => {
+                assert.strictEqual(log.args.push[1][0], 'bar')
+              })
+            })
+          })
+        })
+
+        suite('all events then read:', () => {
+          setup(() => {
+            log.args.on[1][1]()
+            log.args.on[2][1]('foo')
+            log.args.on[5][1]('bar')
+            log.args.on[4][1]()
+            log.args.on[5][1]('')
+            log.args.on[6][1](0)
+            log.args.on[7][1](null)
+            log.args.on[7][1](false)
+            log.args.on[3][1]()
+            log.args.on[8][1]()
+            log.args.DataStream[0][0]()
+          })
+
+          test('predicate was called six times', () => {
+            assert.strictEqual(log.counts.predicate, 6)
+          })
+
+          test('predicate was called correctly first time', () => {
+            assert.strictEqual(log.args.predicate[0][0], 'foo')
+            assert.strictEqual(log.args.predicate[0][1], 'bar')
+            assert.strictEqual(log.args.predicate[0][2], 2)
+          })
+
+          test('predicate was called correctly second time', () => {
+            assert.strictEqual(log.args.predicate[1][0], 0)
+            assert.deepEqual(log.args.predicate[1][1], { foo: 'bar' })
+            assert.strictEqual(log.args.predicate[1][2], 1)
+          })
+
+          test('predicate was called correctly third time', () => {
+            assert.strictEqual(log.args.predicate[2][0], 1)
+            assert.strictEqual(log.args.predicate[2][1], '')
+            assert.strictEqual(log.args.predicate[2][2], 1)
+          })
+
+          test('predicate was called correctly fourth time', () => {
+            assert.strictEqual(log.args.predicate[3][0], 2)
+            assert.strictEqual(log.args.predicate[3][1], 0)
+            assert.strictEqual(log.args.predicate[3][2], 1)
+          })
+
+          test('predicate was called correctly fifth time', () => {
+            assert.strictEqual(log.args.predicate[4][0], 4)
+            assert.strictEqual(log.args.predicate[4][1], false)
+            assert.strictEqual(log.args.predicate[4][2], 1)
+          })
+
+          test('predicate was called correctly sixth time', () => {
+            assert.isUndefined(log.args.predicate[5][0])
+            assert.deepEqual(log.args.predicate[5][1], [ { foo: 'bar' }, '', 0, null, false ])
+            assert.strictEqual(log.args.predicate[5][2], 0)
+          })
+
+          test('results.push was called seven times', () => {
+            assert.strictEqual(log.counts.push, 7)
+          })
+
+          test('results.push was called correctly', () => {
+            assert.strictEqual(log.args.push[0][0], 'bar')
+            assert.deepEqual(log.args.push[1][0], { foo: 'bar' })
+            assert.strictEqual(log.args.push[2][0], '')
+            assert.strictEqual(log.args.push[3][0], 0)
+            assert.strictEqual(log.args.push[4][0], false)
+            assert.deepEqual(log.args.push[5][0], [ { foo: 'bar' }, '', 0, null, false ])
+            assert.isNull(log.args.push[6][0])
+          })
+
+          test('results.emit was not called', () => {
+            assert.strictEqual(log.counts.emit, 0)
+          })
+        })
+      })
+
+      suite('read then all events:', () => {
+        setup(() => {
+          log.args.DataStream[0][0]()
+          log.args.on[0][1]()
+          log.args.on[1][1]()
+          log.args.on[2][1]('foo')
+          log.args.on[5][1]('bar')
+          log.args.on[4][1]()
+          log.args.on[5][1]('')
+          log.args.on[6][1](0)
+          log.args.on[7][1](null)
+          log.args.on[7][1](false)
+          log.args.on[3][1]()
+          log.args.on[8][1]()
+        })
+
+        test('results.push was called seven times', () => {
+          assert.strictEqual(log.counts.push, 7)
+        })
+
+        test('results.push was called correctly', () => {
+          assert.strictEqual(log.args.push[0][0], 'bar')
+          assert.deepEqual(log.args.push[1][0], { foo: 'bar' })
+          assert.strictEqual(log.args.push[2][0], '')
+          assert.strictEqual(log.args.push[3][0], 0)
+          assert.strictEqual(log.args.push[4][0], false)
+          assert.deepEqual(log.args.push[5][0], [ { foo: 'bar' }, '', 0, null, false ])
+          assert.isNull(log.args.push[6][0])
+        })
+
+        test('results.emit was not called', () => {
+          assert.strictEqual(log.counts.emit, 0)
+        })
+      })
+    })
+
+    suite('match with predicate returning false:', () => {
+      let stream, predicate, options, result
+
+      setup(() => {
+        predicate = spooks.fn({ name: 'predicate', log, results: [ false ] })
+        result = match({}, predicate, {})
+      })
+
+      test('DataStream was called once', () => {
+        assert.strictEqual(log.counts.DataStream, 1)
+      })
+
+      test('walk was called once', () => {
+        assert.strictEqual(log.counts.walk, 1)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+      })
+
+      suite('read events:', () => {
+        setup(() => {
+          log.args.DataStream[0][0]()
+          // [ { "foo": "bar" }, "baz", 1, true ]
+          log.args.on[0][1]()
+          log.args.on[1][1]()
+          log.args.on[2][1]('foo')
+          log.args.on[5][1]('bar')
+          log.args.on[4][1]()
+          log.args.on[5][1]('baz')
+          log.args.on[6][1](1)
+          log.args.on[7][1](true)
+          log.args.on[3][1]()
+          log.args.on[8][1]()
+        })
+
+        test('results.push was called once', () => {
+          assert.strictEqual(log.counts.push, 1)
+        })
+
+        test('results.push was called correctly', () => {
+          assert.isNull(log.args.push[0][0])
+        })
+
+        test('results.emit was not called', () => {
+          assert.strictEqual(log.counts.emit, 0)
+        })
+      })
+    })
+
+    suite('match with string:', () => {
+      let stream, options, result
+
+      setup(() => {
+        result = match({}, 'foo', {})
+      })
+
+      test('DataStream was called once', () => {
+        assert.strictEqual(log.counts.DataStream, 1)
+      })
+
+      test('walk was called once', () => {
+        assert.strictEqual(log.counts.walk, 1)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+      })
+
+      suite('read events:', () => {
+        setup(() => {
+          log.args.DataStream[0][0]()
+          // { "foo": "bar", "baz": "qux", "foo": "wibble" }
+          log.args.on[1][1]()
+          log.args.on[2][1]('foo')
+          log.args.on[5][1]('bar')
+          log.args.on[2][1]('baz')
+          log.args.on[5][1]('qux')
+          log.args.on[2][1]('foo')
+          log.args.on[5][1]('wibble')
+          log.args.on[4][1]()
+          log.args.on[8][1]()
+        })
+
+        test('results.push was called three times', () => {
+          assert.strictEqual(log.counts.push, 3)
+        })
+
+        test('results.push was called correctly first time', () => {
+          assert.strictEqual(log.args.push[0][0], 'bar')
+        })
+
+        test('results.push was called correctly second time', () => {
+          assert.strictEqual(log.args.push[1][0], 'wibble')
+        })
+
+        test('results.push was called correctly third time', () => {
+          assert.isNull(log.args.push[2][0])
+        })
+
+        test('results.emit was not called', () => {
+          assert.strictEqual(log.counts.emit, 0)
+        })
+      })
+    })
+
+    suite('match with regular expression:', () => {
+      let stream, options, result
+
+      setup(() => {
+        result = match({}, /oo/, {})
+      })
+
+      test('DataStream was called once', () => {
+        assert.strictEqual(log.counts.DataStream, 1)
+      })
+
+      test('walk was called once', () => {
+        assert.strictEqual(log.counts.walk, 1)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+      })
+
+      suite('read events:', () => {
+        setup(() => {
+          log.args.DataStream[0][0]()
+          // { "foo": "bar", "fo": "baz", "oo": "qux" }
+          log.args.on[1][1]()
+          log.args.on[2][1]('foo')
+          log.args.on[5][1]('bar')
+          log.args.on[2][1]('fo')
+          log.args.on[5][1]('baz')
+          log.args.on[2][1]('oo')
+          log.args.on[5][1]('qux')
+          log.args.on[4][1]()
+          log.args.on[8][1]()
+        })
+
+        test('results.push was called three times', () => {
+          assert.strictEqual(log.counts.push, 3)
+        })
+
+        test('results.push was called correctly first time', () => {
+          assert.strictEqual(log.args.push[0][0], 'bar')
+        })
+
+        test('results.push was called correctly second time', () => {
+          assert.strictEqual(log.args.push[1][0], 'qux')
+        })
+
+        test('results.push was called correctly third time', () => {
+          assert.isNull(log.args.push[2][0])
+        })
+
+        test('results.emit was not called', () => {
+          assert.strictEqual(log.counts.emit, 0)
+        })
+      })
+    })
+
+    suite('match with jsonpath expression:', () => {
+      let stream, options, result
+
+      setup(() => {
+        result = match({}, '$.foo.bar[*]', {})
+      })
+
+      test('DataStream was called once', () => {
+        assert.strictEqual(log.counts.DataStream, 1)
+      })
+
+      test('walk was called once', () => {
+        assert.strictEqual(log.counts.walk, 1)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+      })
+
+      suite('read events:', () => {
+        setup(() => {
+          log.args.DataStream[0][0]()
+          // { "foo": { "bar": [ "baz", "qux" ], "wibble": "blee" } }
+          log.args.on[1][1]()
+          log.args.on[2][1]('foo')
+          log.args.on[1][1]()
+          log.args.on[2][1]('bar')
+          log.args.on[0][1]()
+          log.args.on[5][1]('baz')
+          log.args.on[5][1]('qux')
+          log.args.on[3][1]()
+          log.args.on[2][1]('wibble')
+          log.args.on[5][1]('blee')
+          log.args.on[4][1]()
+          log.args.on[8][1]()
+        })
+
+        test('results.push was called three times', () => {
+          assert.strictEqual(log.counts.push, 3)
+        })
+
+        test('results.push was called correctly first time', () => {
+          assert.strictEqual(log.args.push[0][0], 'baz')
+        })
+
+        test('results.push was called correctly second time', () => {
+          assert.strictEqual(log.args.push[1][0], 'qux')
+        })
+
+        test('results.push was called correctly third time', () => {
+          assert.isNull(log.args.push[2][0])
+        })
+
+        test('results.emit was not called', () => {
+          assert.strictEqual(log.counts.emit, 0)
+        })
+      })
+    })
+
+    suite('match with numbers=true:', () => {
+      let stream, options, result
+
+      setup(() => {
+        result = match({}, '1', { numbers: true })
+      })
+
+      test('DataStream was called once', () => {
+        assert.strictEqual(log.counts.DataStream, 1)
+      })
+
+      test('walk was called once', () => {
+        assert.strictEqual(log.counts.walk, 1)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+      })
+
+      suite('read events:', () => {
+        setup(() => {
+          log.args.DataStream[0][0]()
+          // { "0": "foo", "1": "bar", "2": [ "baz", "qux" ] }
+          log.args.on[1][1]()
+          log.args.on[2][1]('0')
+          log.args.on[5][1]('foo')
+          log.args.on[2][1]('1')
+          log.args.on[5][1]('bar')
+          log.args.on[2][1]('2')
+          log.args.on[0][1]()
+          log.args.on[5][1]('baz')
+          log.args.on[5][1]('qux')
+          log.args.on[3][1]()
+          log.args.on[4][1]()
+          log.args.on[8][1]()
+        })
+
+        test('results.push was called three times', () => {
+          assert.strictEqual(log.counts.push, 3)
+        })
+
+        test('results.push was called correctly first time', () => {
+          assert.strictEqual(log.args.push[0][0], 'bar')
+        })
+
+        test('results.push was called correctly second time', () => {
+          assert.strictEqual(log.args.push[1][0], 'qux')
+        })
+
+        test('results.push was called correctly third time', () => {
+          assert.isNull(log.args.push[2][0])
+        })
+
+        test('results.emit was not called', () => {
+          assert.strictEqual(log.counts.emit, 0)
+        })
+      })
+    })
+
+    suite('match with bufferLength=3:', () => {
+      let stream, options, result
+
+      setup(() => {
+        result = match({}, 'foo', { bufferLength: 3 })
+      })
+
+      test('DataStream was called once', () => {
+        assert.strictEqual(log.counts.DataStream, 1)
+      })
+
+      test('walk was called once', () => {
+        assert.strictEqual(log.counts.walk, 1)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+      })
+
+      suite('two matching events:', () => {
+        setup(() => {
+          log.args.on[1][1]()
+          log.args.on[2][1]('foo')
+          log.args.on[5][1]('bar')
+          log.args.on[2][1]('baz')
+          log.args.on[5][1]('qux')
+          log.args.on[2][1]('foo')
+          log.args.on[5][1]('wibble')
+          log.args.on[2][1]('foo')
+        })
+
+        test('EventEmitter.pause was not called', () => {
+          assert.strictEqual(log.counts.pause, 0)
+        })
+
+        suite('matching event:', () => {
+          setup(() => {
+            log.args.on[5][1]('blee')
+          })
+
+          test('results.push was not called', () => {
+            assert.strictEqual(log.counts.push, 0)
+          })
+
+          test('EventEmitter.pause was called once', () => {
+            assert.strictEqual(log.counts.pause, 1)
+          })
+
+          test('resume was not called', () => {
+            assert.strictEqual(log.counts.resume, 0)
+          })
+
+          suite('read:', () => {
+            setup(() => {
+              log.args.DataStream[0][0]()
+            })
+
+            test('resume was called once', () => {
+              assert.strictEqual(log.counts.resume, 1)
+            })
+
+            test('results.push was called three times', () => {
+              assert.strictEqual(log.counts.push, 3)
+            })
+
+            test('results.push was called correctly first time', () => {
+              assert.strictEqual(log.args.push[0][0], 'bar')
+            })
+
+            test('results.push was called correctly second time', () => {
+              assert.strictEqual(log.args.push[1][0], 'wibble')
+            })
+
+            test('results.push was called correctly third time', () => {
+              assert.strictEqual(log.args.push[2][0], 'blee')
+            })
+
+            test('results.emit was not called', () => {
+              assert.strictEqual(log.counts.emit, 0)
+            })
+          })
+        })
+      })
+    })
+
+    suite('match with minDepth=1:', () => {
+      let stream, predicate, options, result
+
+      setup(() => {
+        predicate = spooks.fn({ name: 'predicate', log, results: [ true ] })
+        result = match({}, predicate, { minDepth: 1 })
+      })
+
+      test('DataStream was called once', () => {
+        assert.strictEqual(log.counts.DataStream, 1)
+      })
+
+      test('walk was called once', () => {
+        assert.strictEqual(log.counts.walk, 1)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+      })
+
+      suite('read events:', () => {
+        setup(() => {
+          log.args.DataStream[0][0]()
+          // { "foo": { "bar": { "baz": "qux" } } }
+          log.args.on[1][1]()
+          log.args.on[2][1]('foo')
+          log.args.on[1][1]()
+          log.args.on[2][1]('bar')
+          log.args.on[1][1]()
+          log.args.on[2][1]('baz')
+          log.args.on[5][1]('qux')
+          log.args.on[4][1]()
+          log.args.on[4][1]()
+          log.args.on[4][1]()
+          log.args.on[8][1]()
+        })
+
+        test('results.push was called four times', () => {
+          assert.strictEqual(log.counts.push, 4)
+        })
+
+        test('results.push was called correctly first time', () => {
+          const args = log.args.push[0]
+          assert.lengthOf(args, 1)
+          assert.equal(args[0], 'qux')
+        })
+
+        test('results.push was called correctly second time', () => {
+          const args = log.args.push[1]
+          assert.lengthOf(args, 1)
+          assert.deepEqual(args[0], { baz: 'qux' })
+        })
+
+        test('results.push was called correctly third time', () => {
+          const args = log.args.push[2]
+          assert.lengthOf(args, 1)
+          assert.deepEqual(args[0], { bar: { baz: 'qux' } })
+        })
+
+        test('results.push was called correctly fourth time', () => {
+          const args = log.args.push[3]
+          assert.lengthOf(args, 1)
+          assert.isNull(args[0])
+        })
+
+        test('results.emit was not called', () => {
+          assert.strictEqual(log.counts.emit, 0)
+        })
+      })
+    })
+
+    suite('match with minDepth=2:', () => {
+      let stream, predicate, options, result
+
+      setup(() => {
+        predicate = spooks.fn({ name: 'predicate', log, results: [ true ] })
+        result = match({}, predicate, { minDepth: 2 })
+      })
+
+      test('DataStream was called once', () => {
+        assert.strictEqual(log.counts.DataStream, 1)
+      })
+
+      test('walk was called once', () => {
+        assert.strictEqual(log.counts.walk, 1)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+      })
+
+      suite('read events:', () => {
+        setup(() => {
+          log.args.DataStream[0][0]()
+          // { "foo": { "bar": { "baz": "qux" } } }
+          log.args.on[1][1]()
+          log.args.on[2][1]('foo')
+          log.args.on[1][1]()
+          log.args.on[2][1]('bar')
+          log.args.on[1][1]()
+          log.args.on[2][1]('baz')
+          log.args.on[5][1]('qux')
+          log.args.on[4][1]()
+          log.args.on[4][1]()
+          log.args.on[4][1]()
+          log.args.on[8][1]()
+        })
+
+        test('results.push was called three times', () => {
+          assert.strictEqual(log.counts.push, 3)
+        })
+
+        test('results.push was called correctly first time', () => {
+          const args = log.args.push[0]
+          assert.lengthOf(args, 1)
+          assert.equal(args[0], 'qux')
+        })
+
+        test('results.push was called correctly second time', () => {
+          const args = log.args.push[1]
+          assert.lengthOf(args, 1)
+          assert.deepEqual(args[0], { baz: 'qux' })
+        })
+
+        test('results.push was called correctly third time', () => {
+          const args = log.args.push[2]
+          assert.lengthOf(args, 1)
+          assert.isNull(args[0])
+        })
+
+        test('results.emit was not called', () => {
+          assert.strictEqual(log.counts.emit, 0)
+        })
+      })
+    })
+  })
+})
Index: frontend/node_modules/bfj/test/unit/parse.js
===================================================================
--- frontend/node_modules/bfj/test/unit/parse.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/unit/parse.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,1020 @@
+'use strict'
+
+const assert = require('chai').assert
+const proxyquire = require('proxyquire')
+const spooks = require('spooks')
+const Promise = require('bluebird')
+
+const modulePath = '../../src/parse'
+
+suite('parse:', () => {
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns function', () => {
+    assert.isFunction(require(modulePath))
+  })
+
+  suite('require:', () => {
+    let log, results, parse
+
+    setup(() => {
+      log = {}
+      results = {
+        walk: [
+          {
+            on: spooks.fn({ name: 'on', log: log }),
+            pause: spooks.fn({ name: 'pause', log: log, results: [ () => {} ] }),
+            removeAllListeners: spooks.fn({ name: 'removeAllListeners', log: log })
+          }
+        ]
+      }
+      parse = proxyquire(modulePath, {
+        './walk': spooks.fn({
+          name: 'walk',
+          log: log,
+          results: results.walk
+        })
+      })
+    })
+
+    test('parse expects one argument', () => {
+      assert.lengthOf(parse, 1)
+    })
+
+    test('parse does not throw', () => {
+      assert.doesNotThrow(() => {
+        parse()
+      })
+    })
+
+    test('parse does not throw if reviver is an object', () => {
+      assert.doesNotThrow(() => {
+        parse({}, { reviver: {} }).catch(() => {})
+      })
+    })
+
+    test('parse does not throw if revive is a function', () => {
+      assert.doesNotThrow(() => {
+        parse({}, { reviver: () => {} })
+      })
+    })
+
+    test('parse returns a promise', () => {
+      assert.instanceOf(parse(), Promise)
+    })
+
+    test('parse returns a different type of promise if the option is set', () => {
+      assert.isFunction(global.Promise)
+      assert.notStrictEqual(Promise, global.Promise)
+      assert.instanceOf(parse('', { Promise: global.Promise }), global.Promise)
+    })
+
+    test('parse rejects immediately if reviver is an object', () => {
+      return parse({}, { reviver: {} })
+        .then(() => assert(false))
+        .catch(error => assert.instanceOf(error, Error))
+    })
+
+    test('parse does not reject immediately if reviver is a function', () => {
+      parse({}, { reviver: () => {} })
+        .catch(error => assert(false))
+    })
+
+    test('walk was not called', () => {
+      assert.strictEqual(log.counts.walk, 0)
+    })
+
+    test('EventEmitter.on was not called', () => {
+      assert.strictEqual(log.counts.on, 0)
+    })
+
+    suite('parse:', () => {
+      let stream, options
+
+      setup(() => {
+        stream = {}
+        options = {}
+        parse(stream, options)
+          .then(spooks.fn({ name: 'resolve', log: log }))
+          .catch(spooks.fn({ name: 'reject', log: log }))
+      })
+
+      test('walk was called once', () => {
+        assert.strictEqual(log.counts.walk, 1)
+        assert.isUndefined(log.these.walk[0])
+      })
+
+      test('walk was called correctly', () => {
+        assert.lengthOf(log.args.walk[0], 2)
+        assert.strictEqual(log.args.walk[0][0], stream)
+        assert.lengthOf(Object.keys(log.args.walk[0][0]), 0)
+        assert.strictEqual(log.args.walk[0][1], options)
+        assert.lengthOf(Object.keys(log.args.walk[0][1]), 0)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+        assert.strictEqual(log.these.on[0], results.walk[0])
+        assert.strictEqual(log.these.on[1], results.walk[0])
+        assert.strictEqual(log.these.on[2], results.walk[0])
+        assert.strictEqual(log.these.on[3], results.walk[0])
+        assert.strictEqual(log.these.on[4], results.walk[0])
+        assert.strictEqual(log.these.on[5], results.walk[0])
+        assert.strictEqual(log.these.on[6], results.walk[0])
+        assert.strictEqual(log.these.on[7], results.walk[0])
+        assert.strictEqual(log.these.on[8], results.walk[0])
+        assert.strictEqual(log.these.on[9], results.walk[0])
+        assert.strictEqual(log.these.on[10], results.walk[0])
+      })
+
+      test('EventEmitter.on was called correctly first time', () => {
+        assert.lengthOf(log.args.on[0], 2)
+        assert.strictEqual(log.args.on[0][0], 'arr')
+        assert.isFunction(log.args.on[0][1])
+      })
+
+      test('EventEmitter.on was called correctly second time', () => {
+        assert.lengthOf(log.args.on[1], 2)
+        assert.strictEqual(log.args.on[1][0], 'obj')
+        assert.isFunction(log.args.on[1][1])
+        assert.notStrictEqual(log.args.on[1][1], log.args.on[0][1])
+      })
+
+      test('EventEmitter.on was called correctly third time', () => {
+        assert.lengthOf(log.args.on[2], 2)
+        assert.strictEqual(log.args.on[2][0], 'pro')
+        assert.isFunction(log.args.on[2][1])
+        assert.notStrictEqual(log.args.on[2][1], log.args.on[0][1])
+        assert.notStrictEqual(log.args.on[2][1], log.args.on[1][1])
+      })
+
+      test('EventEmitter.on was called correctly fourth time', () => {
+        assert.lengthOf(log.args.on[3], 2)
+        assert.strictEqual(log.args.on[3][0], 'str')
+        assert.isFunction(log.args.on[3][1])
+        assert.notStrictEqual(log.args.on[3][1], log.args.on[0][1])
+        assert.notStrictEqual(log.args.on[3][1], log.args.on[1][1])
+        assert.notStrictEqual(log.args.on[3][1], log.args.on[2][1])
+      })
+
+      test('EventEmitter.on was called correctly fifth time', () => {
+        assert.lengthOf(log.args.on[4], 2)
+        assert.strictEqual(log.args.on[4][0], 'num')
+        assert.isFunction(log.args.on[4][1])
+        assert.strictEqual(log.args.on[4][1], log.args.on[3][1])
+      })
+
+      test('EventEmitter.on was called correctly sixth time', () => {
+        assert.lengthOf(log.args.on[5], 2)
+        assert.strictEqual(log.args.on[5][0], 'lit')
+        assert.isFunction(log.args.on[5][1])
+        assert.strictEqual(log.args.on[5][1], log.args.on[3][1])
+      })
+
+      test('EventEmitter.on was called correctly seventh time', () => {
+        assert.lengthOf(log.args.on[6], 2)
+        assert.strictEqual(log.args.on[6][0], 'end-arr')
+        assert.isFunction(log.args.on[6][1])
+        assert.notStrictEqual(log.args.on[6][1], log.args.on[0][1])
+        assert.notStrictEqual(log.args.on[6][1], log.args.on[1][1])
+        assert.notStrictEqual(log.args.on[6][1], log.args.on[2][1])
+        assert.notStrictEqual(log.args.on[6][1], log.args.on[3][1])
+      })
+
+      test('EventEmitter.on was called correctly eighth time', () => {
+        assert.lengthOf(log.args.on[7], 2)
+        assert.strictEqual(log.args.on[7][0], 'end-obj')
+        assert.isFunction(log.args.on[7][1])
+        assert.strictEqual(log.args.on[7][1], log.args.on[6][1])
+      })
+
+      test('EventEmitter.on was called correctly ninth time', () => {
+        assert.lengthOf(log.args.on[8], 2)
+        assert.strictEqual(log.args.on[8][0], 'end')
+        assert.isFunction(log.args.on[8][1])
+        assert.notStrictEqual(log.args.on[8][1], log.args.on[0][1])
+        assert.notStrictEqual(log.args.on[8][1], log.args.on[1][1])
+        assert.notStrictEqual(log.args.on[8][1], log.args.on[2][1])
+        assert.notStrictEqual(log.args.on[8][1], log.args.on[3][1])
+        assert.notStrictEqual(log.args.on[8][1], log.args.on[6][1])
+      })
+
+      test('EventEmitter.on was called correctly tenth time', () => {
+        assert.lengthOf(log.args.on[9], 2)
+        assert.strictEqual(log.args.on[9][0], 'err')
+        assert.isFunction(log.args.on[9][1])
+        assert.notStrictEqual(log.args.on[9][1], log.args.on[0][1])
+        assert.notStrictEqual(log.args.on[9][1], log.args.on[1][1])
+        assert.notStrictEqual(log.args.on[9][1], log.args.on[2][1])
+        assert.notStrictEqual(log.args.on[9][1], log.args.on[3][1])
+        assert.notStrictEqual(log.args.on[9][1], log.args.on[6][1])
+        assert.notStrictEqual(log.args.on[9][1], log.args.on[8][1])
+      })
+
+      test('EventEmitter.on was called correctly eleventh time', () => {
+        assert.lengthOf(log.args.on[10], 2)
+        assert.strictEqual(log.args.on[10][0], 'err-data')
+        assert.isFunction(log.args.on[10][1])
+        assert.strictEqual(log.args.on[10][1], log.args.on[9][1])
+      })
+
+      suite('array event:', () => {
+        setup(() => {
+          log.args.on[0][1]()
+        })
+
+        test('resolve was not called', () => {
+          assert.strictEqual(log.counts.resolve, 0)
+        })
+
+        suite('end event:', () => {
+          setup(done => {
+            log.args.on[8][1]()
+            setImmediate(done)
+          })
+
+          test('resolve was called once', () => {
+            assert.strictEqual(log.counts.resolve, 1)
+          })
+
+          test('resolve was called correctly', () => {
+            assert.isUndefined(log.these.resolve[0])
+            assert.lengthOf(log.args.resolve[0], 1)
+            assert.isArray(log.args.resolve[0][0])
+            assert.lengthOf(log.args.resolve[0][0], 0)
+          })
+
+          test('reject was not called', () => {
+            assert.strictEqual(log.counts.reject, 0)
+          })
+        })
+
+        suite('string event:', () => {
+          setup(() => {
+            log.args.on[3][1]('foo')
+          })
+
+          test('resolve was not called', () => {
+            assert.strictEqual(log.counts.resolve, 0)
+          })
+
+          suite('end event:', () => {
+            setup(done => {
+              log.args.on[8][1]()
+              setImmediate(done)
+            })
+
+            test('resolve was called once', () => {
+              assert.strictEqual(log.counts.resolve, 1)
+            })
+
+            test('resolve was called correctly', () => {
+              assert.lengthOf(log.args.resolve[0], 1)
+              assert.isArray(log.args.resolve[0][0])
+              assert.lengthOf(log.args.resolve[0][0], 1)
+              assert.strictEqual(log.args.resolve[0][0][0], 'foo')
+            })
+          })
+
+          suite('string event:', () => {
+            setup(() => {
+              log.args.on[3][1]('bar')
+            })
+
+            test('resolve was not called', () => {
+              assert.strictEqual(log.counts.resolve, 0)
+            })
+
+            suite('end event:', () => {
+              setup(done => {
+                log.args.on[8][1]()
+                setImmediate(done)
+              })
+
+              test('resolve was called once', () => {
+                assert.strictEqual(log.counts.resolve, 1)
+              })
+
+              test('resolve was called correctly', () => {
+                assert.lengthOf(log.args.resolve[0][0], 2)
+                assert.strictEqual(log.args.resolve[0][0][0], 'foo')
+                assert.strictEqual(log.args.resolve[0][0][1], 'bar')
+              })
+            })
+          })
+
+          suite('array event:', () => {
+            setup(() => {
+              log.args.on[0][1]()
+            })
+
+            test('resolve was not called', () => {
+              assert.strictEqual(log.counts.resolve, 0)
+            })
+
+            suite('end event:', () => {
+              setup(done => {
+                log.args.on[8][1]()
+                setImmediate(done)
+              })
+
+              test('resolve was called once', () => {
+                assert.strictEqual(log.counts.resolve, 1)
+              })
+
+              test('resolve was called correctly', () => {
+                assert.lengthOf(log.args.resolve[0][0], 2)
+                assert.strictEqual(log.args.resolve[0][0][0], 'foo')
+                assert.isArray(log.args.resolve[0][0][1])
+                assert.lengthOf(log.args.resolve[0][0][1], 0)
+              })
+            })
+
+            suite('string event:', () => {
+              setup(() => {
+                log.args.on[3][1]('bar')
+              })
+
+              test('resolve was not called', () => {
+                assert.strictEqual(log.counts.resolve, 0)
+              })
+
+              suite('end event:', () => {
+                setup(done => {
+                  log.args.on[8][1]()
+                  setImmediate(done)
+                })
+
+                test('resolve was called once', () => {
+                  assert.strictEqual(log.counts.resolve, 1)
+                })
+
+                test('resolve was called correctly', () => {
+                  assert.lengthOf(log.args.resolve[0][0], 2)
+                  assert.strictEqual(log.args.resolve[0][0][0], 'foo')
+                  assert.isArray(log.args.resolve[0][0][1])
+                  assert.lengthOf(log.args.resolve[0][0][1], 1)
+                  assert.strictEqual(log.args.resolve[0][0][1][0], 'bar')
+                })
+              })
+
+              suite('string event:', () => {
+                setup(() => {
+                  log.args.on[3][1]('baz')
+                })
+
+                test('resolve was not called', () => {
+                  assert.strictEqual(log.counts.resolve, 0)
+                })
+
+                suite('end event:', () => {
+                  setup(done => {
+                    log.args.on[8][1]()
+                    setImmediate(done)
+                  })
+
+                  test('resolve was called once', () => {
+                    assert.strictEqual(log.counts.resolve, 1)
+                  })
+
+                  test('resolve was called correctly', () => {
+                    assert.lengthOf(log.args.resolve[0][0], 2)
+                    assert.strictEqual(log.args.resolve[0][0][0], 'foo')
+                    assert.isArray(log.args.resolve[0][0][1])
+                    assert.lengthOf(log.args.resolve[0][0][1], 2)
+                    assert.strictEqual(log.args.resolve[0][0][1][0], 'bar')
+                    assert.strictEqual(log.args.resolve[0][0][1][1], 'baz')
+                  })
+                })
+              })
+
+              suite('endArray event:', () => {
+                setup(() => {
+                  log.args.on[6][1]()
+                })
+
+                suite('string event:', () => {
+                  setup(() => {
+                    log.args.on[3][1]('baz')
+                  })
+
+                  test('resolve was not called', () => {
+                    assert.strictEqual(log.counts.resolve, 0)
+                  })
+
+                  suite('end event:', () => {
+                    setup(done => {
+                      log.args.on[8][1]()
+                      setImmediate(done)
+                    })
+
+                    test('resolve was called once', () => {
+                      assert.strictEqual(log.counts.resolve, 1)
+                    })
+
+                    test('resolve was called correctly', () => {
+                      assert.lengthOf(log.args.resolve[0][0], 3)
+                      assert.strictEqual(log.args.resolve[0][0][0], 'foo')
+                      assert.isArray(log.args.resolve[0][0][1])
+                      assert.lengthOf(log.args.resolve[0][0][1], 1)
+                      assert.strictEqual(log.args.resolve[0][0][1][0], 'bar')
+                      assert.strictEqual(log.args.resolve[0][0][2], 'baz')
+                    })
+                  })
+                })
+              })
+            })
+          })
+
+          suite('object event:', () => {
+            setup(() => {
+              log.args.on[1][1]()
+            })
+
+            test('resolve was not called', () => {
+              assert.strictEqual(log.counts.resolve, 0)
+            })
+
+            suite('end event:', () => {
+              setup(done => {
+                log.args.on[8][1]()
+                setImmediate(done)
+              })
+
+              test('resolve was called once', () => {
+                assert.strictEqual(log.counts.resolve, 1)
+              })
+
+              test('resolve was called correctly', () => {
+                assert.lengthOf(log.args.resolve[0][0], 2)
+                assert.strictEqual(log.args.resolve[0][0][0], 'foo')
+                assert.isObject(log.args.resolve[0][0][1])
+                assert.lengthOf(Object.keys(log.args.resolve[0][0][1]), 0)
+              })
+            })
+
+            suite('property event:', () => {
+              setup(() => {
+                log.args.on[2][1]('bar')
+              })
+
+              suite('string event:', () => {
+                setup(() => {
+                  log.args.on[3][1]('baz')
+                })
+
+                test('resolve was not called', () => {
+                  assert.strictEqual(log.counts.resolve, 0)
+                })
+
+                suite('end event:', () => {
+                  setup(done => {
+                    log.args.on[8][1]()
+                    setImmediate(done)
+                  })
+
+                  test('resolve was called once', () => {
+                    assert.strictEqual(log.counts.resolve, 1)
+                  })
+
+                  test('resolve was called correctly', () => {
+                    assert.lengthOf(log.args.resolve[0][0], 2)
+                    assert.strictEqual(log.args.resolve[0][0][0], 'foo')
+                    assert.isObject(log.args.resolve[0][0][1])
+                    assert.lengthOf(Object.keys(log.args.resolve[0][0][1]), 1)
+                    assert.strictEqual(log.args.resolve[0][0][1].bar, 'baz')
+                  })
+                })
+
+                suite('property event:', () => {
+                  setup(() => {
+                    log.args.on[2][1]('qux')
+                  })
+
+                  suite('string event:', () => {
+                    setup(() => {
+                      log.args.on[3][1]('wibble')
+                    })
+
+                    test('resolve was not called', () => {
+                      assert.strictEqual(log.counts.resolve, 0)
+                    })
+
+                    suite('end event:', () => {
+                      setup(done => {
+                        log.args.on[8][1]()
+                        setImmediate(done)
+                      })
+
+                      test('resolve was called once', () => {
+                        assert.strictEqual(log.counts.resolve, 1)
+                      })
+
+                      test('resolve was called correctly', () => {
+                        assert.lengthOf(log.args.resolve[0][0], 2)
+                        assert.strictEqual(log.args.resolve[0][0][0], 'foo')
+                        assert.isObject(log.args.resolve[0][0][1])
+                        assert.lengthOf(Object.keys(log.args.resolve[0][0][1]), 2)
+                        assert.strictEqual(log.args.resolve[0][0][1].bar, 'baz')
+                        assert.strictEqual(log.args.resolve[0][0][1].qux, 'wibble')
+                      })
+                    })
+                  })
+                })
+
+                suite('endObject event:', () => {
+                  setup(() => {
+                    log.args.on[7][1]()
+                  })
+
+                  suite('string event:', () => {
+                    setup(() => {
+                      log.args.on[3][1]('wibble')
+                    })
+
+                    test('resolve was not called', () => {
+                      assert.strictEqual(log.counts.resolve, 0)
+                    })
+
+                    suite('end event:', () => {
+                      setup(done => {
+                        log.args.on[8][1]()
+                        setImmediate(done)
+                      })
+
+                      test('resolve was called once', () => {
+                        assert.strictEqual(log.counts.resolve, 1)
+                      })
+
+                      test('resolve was called correctly', () => {
+                        assert.lengthOf(log.args.resolve[0][0], 3)
+                        assert.strictEqual(log.args.resolve[0][0][0], 'foo')
+                        assert.isObject(log.args.resolve[0][0][1])
+                        assert.lengthOf(Object.keys(log.args.resolve[0][0][1]), 1)
+                        assert.strictEqual(log.args.resolve[0][0][1].bar, 'baz')
+                        assert.strictEqual(log.args.resolve[0][0][2], 'wibble')
+                      })
+                    })
+                  })
+                })
+              })
+            })
+          })
+        })
+
+        suite('error event:', () => {
+          setup(() => {
+            log.args.on[9][1]('foo')
+          })
+
+          test('reject was not called', () => {
+            assert.strictEqual(log.counts.reject, 0)
+          })
+
+          suite('end event:', () => {
+            setup(done => {
+              log.args.on[8][1]()
+              setImmediate(done)
+            })
+
+            test('reject was called once', () => {
+              assert.strictEqual(log.counts.reject, 1)
+            })
+
+            test('reject was called correctly', () => {
+              assert.isUndefined(log.these.reject[0])
+              assert.lengthOf(log.args.reject[0], 1)
+              assert.strictEqual(log.args.reject[0][0], 'foo')
+            })
+          })
+
+          suite('error event:', () => {
+            setup(() => {
+              log.args.on[9][1]('bar')
+            })
+
+            test('reject was not called', () => {
+              assert.strictEqual(log.counts.reject, 0)
+            })
+
+            suite('end event:', () => {
+              setup(done => {
+                log.args.on[8][1]()
+                setImmediate(done)
+              })
+
+              test('reject was called once', () => {
+                assert.strictEqual(log.counts.reject, 1)
+              })
+
+              test('reject was called correctly', () => {
+                assert.strictEqual(log.args.reject[0][0], 'foo')
+              })
+            })
+          })
+        })
+      })
+
+      suite('object event:', () => {
+        setup(() => {
+          log.args.on[1][1]()
+        })
+
+        test('resolve was not called', () => {
+          assert.strictEqual(log.counts.resolve, 0)
+        })
+
+        suite('end event:', () => {
+          setup(done => {
+            log.args.on[8][1]()
+            setImmediate(done)
+          })
+
+          test('resolve was called once', () => {
+            assert.strictEqual(log.counts.resolve, 1)
+          })
+
+          test('resolve was called correctly', () => {
+            assert.isObject(log.args.resolve[0][0])
+            assert.lengthOf(Object.keys(log.args.resolve[0][0]), 0)
+          })
+        })
+      })
+    })
+
+    suite('parse with reviver:', () => {
+      let stream, options
+
+      setup(() => {
+        stream = {}
+        options = { reviver: spooks.fn({ name: 'reviver', log: log, results: [ 'reviver result' ] }) }
+        parse(stream, options)
+          .then(spooks.fn({ name: 'resolve', log: log }))
+          .catch(spooks.fn({ name: 'reject', log: log }))
+      })
+
+      test('walk was called once', () => {
+        assert.strictEqual(log.counts.walk, 1)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+      })
+
+      suite('populated array events:', () => {
+        setup(() => {
+          log.args.on[0][1]()
+          log.args.on[3][1]('foo')
+          log.args.on[3][1]('bar')
+          log.args.on[0][1]()
+          log.args.on[0][1]()
+          log.args.on[3][1]('baz')
+          log.args.on[6][1]()
+          log.args.on[3][1]('qux')
+          log.args.on[6][1]()
+          log.args.on[6][1]()
+        })
+
+        test('resolve was not called', () => {
+          assert.strictEqual(log.counts.resolve, 0)
+        })
+
+        test('reviver was not called', () => {
+          assert.strictEqual(log.counts.resolve, 0)
+        })
+
+        suite('end event:', () => {
+          setup(done => {
+            log.args.on[8][1]()
+            setImmediate(done)
+          })
+
+          test('resolve was called once', () => {
+            assert.strictEqual(log.counts.resolve, 1)
+          })
+
+          test('reviver was called six times', () => {
+            assert.strictEqual(log.counts.reviver, 7)
+          })
+
+          test('reviver was called correctly first time', () => {
+            assert.lengthOf(log.args.reviver[0], 2)
+            assert.strictEqual(log.args.reviver[0][0], '0')
+            assert.strictEqual(log.args.reviver[0][1], 'foo')
+          })
+
+          test('reviver was called correctly second time', () => {
+            assert.strictEqual(log.args.reviver[1][0], '1')
+            assert.strictEqual(log.args.reviver[1][1], 'bar')
+          })
+
+          test('reviver was called correctly third time', () => {
+            assert.strictEqual(log.args.reviver[2][0], '0')
+            assert.strictEqual(log.args.reviver[2][1], 'baz')
+          })
+
+          test('reviver was called correctly fourth time', () => {
+            assert.strictEqual(log.args.reviver[3][0], '0')
+            assert.isArray(log.args.reviver[3][1])
+            assert.lengthOf(log.args.reviver[3][1], 1)
+            assert.strictEqual(log.args.reviver[3][1][0], 'reviver result')
+          })
+
+          test('reviver was called correctly fifth time', () => {
+            assert.strictEqual(log.args.reviver[4][0], '1')
+            assert.strictEqual(log.args.reviver[4][1], 'qux')
+          })
+
+          test('reviver was called correctly sixth time', () => {
+            assert.strictEqual(log.args.reviver[5][0], '2')
+            assert.isArray(log.args.reviver[5][1])
+            assert.lengthOf(log.args.reviver[5][1], 2)
+            assert.strictEqual(log.args.reviver[5][1][0], 'reviver result')
+            assert.strictEqual(log.args.reviver[5][1][1], 'reviver result')
+          })
+
+          test('reviver was called correctly seventh time', () => {
+            assert.strictEqual(log.args.reviver[6][0], '')
+            assert.isArray(log.args.reviver[6][1])
+            assert.lengthOf(log.args.reviver[6][1], 3)
+            assert.strictEqual(log.args.reviver[6][1][0], 'reviver result')
+            assert.strictEqual(log.args.reviver[6][1][1], 'reviver result')
+            assert.strictEqual(log.args.reviver[6][1][2], 'reviver result')
+          })
+        })
+      })
+
+      suite('populated object events:', () => {
+        setup(() => {
+          log.args.on[1][1]()
+          log.args.on[2][1]('foo')
+          log.args.on[1][1]()
+          log.args.on[2][1]('bar')
+          log.args.on[4][1](3.14159265359)
+          log.args.on[7][1]()
+          log.args.on[2][1]('baz')
+          log.args.on[5][1](null)
+          log.args.on[7][1]()
+        })
+
+        test('resolve was not called', () => {
+          assert.strictEqual(log.counts.resolve, 0)
+        })
+
+        test('reviver was not called', () => {
+          assert.strictEqual(log.counts.resolve, 0)
+        })
+
+        suite('end event:', () => {
+          setup(done => {
+            log.args.on[8][1]()
+            setImmediate(done)
+          })
+
+          test('resolve was called once', () => {
+            assert.strictEqual(log.counts.resolve, 1)
+          })
+
+          test('reviver was called four times', () => {
+            assert.strictEqual(log.counts.reviver, 4)
+          })
+
+          test('reviver was called correctly first time', () => {
+            assert.lengthOf(log.args.reviver[0], 2)
+            assert.strictEqual(log.args.reviver[0][0], 'bar')
+            assert.strictEqual(log.args.reviver[0][1], 3.14159265359)
+          })
+
+          test('reviver was called correctly second time', () => {
+            assert.strictEqual(log.args.reviver[1][0], 'foo')
+            assert.isObject(log.args.reviver[1][1])
+            assert.lengthOf(Object.keys(log.args.reviver[1][1]), 1)
+            assert.strictEqual(log.args.reviver[1][1].bar, 'reviver result')
+          })
+
+          test('reviver was called correctly third time', () => {
+            assert.strictEqual(log.args.reviver[2][0], 'baz')
+            assert.isNull(log.args.reviver[2][1])
+          })
+
+          test('reviver was called correctly fourth time', () => {
+            assert.strictEqual(log.args.reviver[3][0], '')
+            assert.isObject(log.args.reviver[3][1])
+            assert.lengthOf(Object.keys(log.args.reviver[3][1]), 2)
+            assert.strictEqual(log.args.reviver[3][1].foo, 'reviver result')
+            assert.strictEqual(log.args.reviver[3][1].baz, 'reviver result')
+          })
+        })
+      })
+    })
+
+    suite('parse with ndjson:', () => {
+      let stream
+
+      setup(() => {
+        stream = {}
+        parse(stream, { ndjson: true })
+          .then(spooks.fn({ name: 'resolve', log: log }))
+          .catch(spooks.fn({ name: 'reject', log: log }))
+      })
+
+      test('walk was called once', () => {
+        assert.strictEqual(log.counts.walk, 1)
+      })
+
+      test('EventEmitter.on was called twelve times', () => {
+        assert.strictEqual(log.counts.on, 12)
+        assert.strictEqual(log.these.on[11], results.walk[0])
+      })
+
+      test('EventEmitter.on was called correctly first eleven times', () => {
+        assert.strictEqual(log.args.on[0][0], 'arr')
+        assert.strictEqual(log.args.on[1][0], 'obj')
+        assert.strictEqual(log.args.on[2][0], 'pro')
+        assert.strictEqual(log.args.on[3][0], 'str')
+        assert.strictEqual(log.args.on[4][0], 'num')
+        assert.strictEqual(log.args.on[5][0], 'lit')
+        assert.strictEqual(log.args.on[6][0], 'end-arr')
+        assert.strictEqual(log.args.on[7][0], 'end-obj')
+        assert.strictEqual(log.args.on[8][0], 'end')
+        assert.strictEqual(log.args.on[9][0], 'err')
+        assert.strictEqual(log.args.on[10][0], 'err-data')
+      })
+
+      test('EventEmitter.on was called correctly twelfth time', () => {
+        assert.lengthOf(log.args.on[11], 2)
+        assert.strictEqual(log.args.on[11][0], 'end-line')
+        assert.isFunction(log.args.on[11][1])
+        assert.notStrictEqual(log.args.on[11][1], log.args.on[0][1])
+        assert.notStrictEqual(log.args.on[11][1], log.args.on[1][1])
+        assert.notStrictEqual(log.args.on[11][1], log.args.on[2][1])
+        assert.notStrictEqual(log.args.on[11][1], log.args.on[3][1])
+        assert.notStrictEqual(log.args.on[11][1], log.args.on[6][1])
+        assert.notStrictEqual(log.args.on[11][1], log.args.on[8][1])
+        assert.notStrictEqual(log.args.on[11][1], log.args.on[9][1])
+      })
+
+      test('emitter.pause was not called', () => {
+        assert.strictEqual(log.counts.pause, 0)
+      })
+
+      test('emitter.removeAllListeners was not called', () => {
+        assert.strictEqual(log.counts.removeAllListeners, 0)
+      })
+
+      suite('array, endArray, endLine:', () => {
+        setup(done => {
+          log.args.on[0][1]()
+          log.args.on[6][1]()
+          log.args.on[11][1]()
+          setImmediate(done)
+        })
+
+        test('resolve was called once', () => {
+          assert.strictEqual(log.counts.resolve, 1)
+        })
+
+        test('resolve was called correctly', () => {
+          assert.lengthOf(log.args.resolve[0], 1)
+          assert.isArray(log.args.resolve[0][0])
+          assert.lengthOf(log.args.resolve[0][0], 0)
+        })
+
+        test('emitter.pause was called once', () => {
+          assert.strictEqual(log.counts.pause, 1)
+        })
+
+        test('emitter.pause was called correctly', () => {
+          assert.lengthOf(log.args.pause[0], 0)
+        })
+
+        test('emitter.removeAllListeners was called once', () => {
+          assert.strictEqual(log.counts.removeAllListeners, 1)
+        })
+
+        test('emitter.removeAllListeners was called correctly', () => {
+          assert.lengthOf(log.args.removeAllListeners[0], 0)
+        })
+
+        test('reject was not called', () => {
+          assert.strictEqual(log.counts.reject, 0)
+        })
+
+        suite('parse with ndjson:', () => {
+          setup(() => {
+            parse(stream, { ndjson: true })
+              .then(spooks.fn({ name: 'resolve2', log: log }))
+              .catch(spooks.fn({ name: 'reject2', log: log }))
+          })
+
+          test('EventEmitter.on was called twelve times', () => {
+            assert.strictEqual(log.counts.on, 24)
+          })
+
+          test('walk was not called', () => {
+            assert.strictEqual(log.counts.walk, 1)
+          })
+
+          suite('string, end:', () => {
+            setup(done => {
+              log.args.on[15][1]('foo')
+              log.args.on[20][1]()
+              setImmediate(done)
+            })
+
+            test('resolve was called once', () => {
+              assert.strictEqual(log.counts.resolve, 1)
+              assert.strictEqual(log.counts.resolve2, 1)
+            })
+
+            test('resolve was called correctly', () => {
+              assert.lengthOf(log.args.resolve2[0], 1)
+              assert.strictEqual(log.args.resolve2[0][0], 'foo')
+            })
+
+            test('emitter.pause was called once', () => {
+              assert.strictEqual(log.counts.pause, 2)
+            })
+
+            test('emitter.removeAllListeners was called once', () => {
+              assert.strictEqual(log.counts.removeAllListeners, 2)
+            })
+
+            test('reject was not called', () => {
+              assert.strictEqual(log.counts.reject, 0)
+              assert.strictEqual(log.counts.reject2, 0)
+            })
+
+            suite('parse with ndjson:', () => {
+              setup(() => {
+                parse(stream, { ndjson: true })
+                  .then(spooks.fn({ name: 'resolve3', log: log }))
+                  .catch(spooks.fn({ name: 'reject3', log: log }))
+              })
+
+              test('EventEmitter.on was called twelve times', () => {
+                assert.strictEqual(log.counts.on, 36)
+              })
+
+              test('walk was not called', () => {
+                assert.strictEqual(log.counts.walk, 1)
+              })
+
+              suite('end:', () => {
+                setup(done => {
+                  log.args.on[32][1]()
+                  setImmediate(done)
+                })
+
+                test('resolve was called once', () => {
+                  assert.strictEqual(log.counts.resolve, 1)
+                  assert.strictEqual(log.counts.resolve2, 1)
+                  assert.strictEqual(log.counts.resolve3, 1)
+                })
+
+                test('resolve was called correctly', () => {
+                  assert.lengthOf(log.args.resolve3[0], 1)
+                  assert.strictEqual(log.args.resolve3[0][0], undefined)
+                })
+
+                test('emitter.pause was called once', () => {
+                  assert.strictEqual(log.counts.pause, 3)
+                })
+
+                test('emitter.removeAllListeners was called once', () => {
+                  assert.strictEqual(log.counts.removeAllListeners, 3)
+                })
+
+                test('reject was not called', () => {
+                  assert.strictEqual(log.counts.reject, 0)
+                  assert.strictEqual(log.counts.reject2, 0)
+                  assert.strictEqual(log.counts.reject3, 0)
+                })
+              })
+            })
+          })
+        })
+
+        suite('parse with ndjson and fresh stream:', () => {
+          setup(() => {
+            parse({}, { ndjson: true })
+              .then(spooks.fn({ name: 'resolve2', log: log }))
+              .catch(spooks.fn({ name: 'reject2', log: log }))
+          })
+
+          test('EventEmitter.on was called twelve times', () => {
+            assert.strictEqual(log.counts.on, 24)
+          })
+
+          test('walk was called once', () => {
+            assert.strictEqual(log.counts.walk, 2)
+          })
+        })
+      })
+    })
+  })
+})
Index: frontend/node_modules/bfj/test/unit/read.js
===================================================================
--- frontend/node_modules/bfj/test/unit/read.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/unit/read.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,102 @@
+'use strict'
+
+const assert = require('chai').assert
+const proxyquire = require('proxyquire')
+const spooks = require('spooks')
+
+const modulePath = '../../src/read'
+
+suite('read:', () => {
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns function', () => {
+    assert.isFunction(require(modulePath))
+  })
+
+  suite('require:', () => {
+    let log, results, read
+
+    setup(() => {
+      log = {}
+      results = {
+        parse: [ {} ],
+        createReadStream: [ {} ]
+      }
+      read = proxyquire(modulePath, {
+        fs: {
+          createReadStream: spooks.fn({
+            name: 'createReadStream',
+            log: log,
+            results: results.createReadStream
+          })
+        },
+        './parse': spooks.fn({
+          name: 'parse',
+          log: log,
+          results: results.parse
+        })
+      })
+    })
+
+    test('read expects two arguments', () => {
+      assert.lengthOf(read, 2)
+    })
+
+    test('read does not throw', () => {
+      assert.doesNotThrow(() => {
+        read()
+      })
+    })
+
+    test('parse was not called', () => {
+      assert.strictEqual(log.counts.parse, 0)
+    })
+
+    test('fs.createReadStream was not called', () => {
+      assert.strictEqual(log.counts.createReadStream, 0)
+    })
+
+    suite('read:', () => {
+      let path, options, result
+
+      setup(() => {
+        path = {}
+        options = { foo: 'bar', ndjson: true }
+        result = read(path, options)
+      })
+
+      test('fs.createReadStream was called once', () => {
+        assert.strictEqual(log.counts.createReadStream, 1)
+      })
+
+      test('fs.createReadStream was called correctly', () => {
+        assert.lengthOf(log.args.createReadStream[0], 2)
+        assert.strictEqual(log.args.createReadStream[0][0], path)
+        assert.lengthOf(Object.keys(log.args.createReadStream[0][0]), 0)
+        assert.strictEqual(log.args.createReadStream[0][1], options)
+        assert.lengthOf(Object.keys(log.args.createReadStream[0][1]), 2)
+      })
+
+      test('parse was called once', () => {
+        assert.strictEqual(log.counts.parse, 1)
+      })
+
+      test('parse was called correctly', () => {
+        assert.isUndefined(log.these.parse[0])
+        assert.lengthOf(log.args.parse[0], 2)
+        assert.strictEqual(log.args.parse[0][0], results.createReadStream[0])
+        assert.lengthOf(Object.keys(log.args.parse[0][0]), 0)
+        assert.notStrictEqual(log.args.parse[0][1], options)
+        assert.deepEqual(log.args.parse[0][1], { foo: 'bar', ndjson: false })
+      })
+
+      test('parse result was returned', () => {
+        assert.strictEqual(result, results.parse[0])
+      })
+    })
+  })
+})
Index: frontend/node_modules/bfj/test/unit/streamify.js
===================================================================
--- frontend/node_modules/bfj/test/unit/streamify.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/unit/streamify.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,1005 @@
+'use strict'
+
+const assert = require('chai').assert
+const proxyquire = require('proxyquire')
+const spooks = require('spooks')
+
+const modulePath = '../../src/streamify'
+
+suite('streamify:', () => {
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns function', () => {
+    assert.isFunction(require(modulePath))
+  })
+
+  suite('require:', () => {
+    let log, results, streamify
+
+    setup(() => {
+      log = {}
+      results = {
+        eventify: [
+          { on: spooks.fn({ name: 'on', log: log }) }
+        ],
+        push: [ true ]
+      }
+      streamify = proxyquire(modulePath, {
+        './eventify': spooks.fn({
+          name: 'eventify',
+          log: log,
+          results: results.eventify
+        }),
+        './jsonstream': spooks.ctor({
+          name: 'JsonStream',
+          log: log,
+          archetype: { instance: { push: () => {}, emit: () => {} } },
+          results: results
+        })
+      })
+    })
+
+    test('streamify expects one argument', () => {
+      assert.lengthOf(streamify, 1)
+    })
+
+    test('streamify does not throw', () => {
+      assert.doesNotThrow(() => {
+        streamify()
+      })
+    })
+
+    test('streamify returns stream', () => {
+      assert.isFunction(streamify().push)
+      assert.isFunction(streamify().emit)
+    })
+
+    test('JsonStream was not called', () => {
+      assert.strictEqual(log.counts.JsonStream, 0)
+    })
+
+    test('eventify was not called', () => {
+      assert.strictEqual(log.counts.eventify, 0)
+    })
+
+    test('EventEmitter.on was not called', () => {
+      assert.strictEqual(log.counts.on, 0)
+    })
+
+    suite('streamify:', () => {
+      let data, options, result
+
+      setup(() => {
+        data = {}
+        options = { foo: 'bar', highWaterMark: 42 }
+        result = streamify(data, options)
+      })
+
+      test('JsonStream was called once', () => {
+        assert.strictEqual(log.counts.JsonStream, 1)
+        assert.isObject(log.these.JsonStream[0])
+      })
+
+      test('JsonStream was called correctly', () => {
+        assert.lengthOf(log.args.JsonStream[0], 2)
+        assert.isFunction(log.args.JsonStream[0][0])
+        assert.deepEqual(log.args.JsonStream[0][1], { highWaterMark: 42 })
+      })
+
+      test('eventify was called once', () => {
+        assert.strictEqual(log.counts.eventify, 1)
+        assert.isUndefined(log.these.eventify[0])
+      })
+
+      test('eventify was called correctly', () => {
+        assert.lengthOf(log.args.eventify[0], 2)
+        assert.strictEqual(log.args.eventify[0][0], data)
+        assert.lengthOf(Object.keys(log.args.eventify[0][0]), 0)
+        assert.strictEqual(log.args.eventify[0][1], options)
+        assert.lengthOf(Object.keys(log.args.eventify[0][1]), 2)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+        assert.strictEqual(log.these.on[0], results.eventify[0])
+        assert.strictEqual(log.these.on[1], results.eventify[0])
+        assert.strictEqual(log.these.on[2], results.eventify[0])
+        assert.strictEqual(log.these.on[3], results.eventify[0])
+        assert.strictEqual(log.these.on[4], results.eventify[0])
+        assert.strictEqual(log.these.on[5], results.eventify[0])
+        assert.strictEqual(log.these.on[6], results.eventify[0])
+        assert.strictEqual(log.these.on[7], results.eventify[0])
+        assert.strictEqual(log.these.on[8], results.eventify[0])
+        assert.strictEqual(log.these.on[9], results.eventify[0])
+        assert.strictEqual(log.these.on[10], results.eventify[0])
+      })
+
+      test('EventEmitter.on was called correctly first time', () => {
+        assert.lengthOf(log.args.on[0], 2)
+        assert.strictEqual(log.args.on[0][0], 'arr')
+        assert.isFunction(log.args.on[0][1])
+      })
+
+      test('EventEmitter.on was called correctly second time', () => {
+        assert.lengthOf(log.args.on[1], 2)
+        assert.strictEqual(log.args.on[1][0], 'obj')
+        assert.isFunction(log.args.on[1][1])
+      })
+
+      test('EventEmitter.on was called correctly third time', () => {
+        assert.lengthOf(log.args.on[2], 2)
+        assert.strictEqual(log.args.on[2][0], 'pro')
+        assert.isFunction(log.args.on[2][1])
+      })
+
+      test('EventEmitter.on was called correctly fourth time', () => {
+        assert.lengthOf(log.args.on[3], 2)
+        assert.strictEqual(log.args.on[3][0], 'str')
+        assert.isFunction(log.args.on[3][1])
+      })
+
+      test('EventEmitter.on was called correctly fifth time', () => {
+        assert.lengthOf(log.args.on[4], 2)
+        assert.strictEqual(log.args.on[4][0], 'num')
+        assert.isFunction(log.args.on[4][1])
+      })
+
+      test('EventEmitter.on was called correctly sixth time', () => {
+        assert.lengthOf(log.args.on[5], 2)
+        assert.strictEqual(log.args.on[5][0], 'lit')
+        assert.isFunction(log.args.on[5][1])
+      })
+
+      test('EventEmitter.on was called correctly seventh time', () => {
+        assert.lengthOf(log.args.on[6], 2)
+        assert.strictEqual(log.args.on[6][0], 'end-arr')
+        assert.isFunction(log.args.on[6][1])
+      })
+
+      test('EventEmitter.on was called correctly eighth time', () => {
+        assert.lengthOf(log.args.on[7], 2)
+        assert.strictEqual(log.args.on[7][0], 'end-obj')
+        assert.isFunction(log.args.on[7][1])
+      })
+
+      test('EventEmitter.on was called correctly ninth time', () => {
+        assert.lengthOf(log.args.on[8], 2)
+        assert.strictEqual(log.args.on[8][0], 'end')
+        assert.isFunction(log.args.on[8][1])
+      })
+
+      test('EventEmitter.on was called correctly tenth time', () => {
+        assert.lengthOf(log.args.on[9], 2)
+        assert.strictEqual(log.args.on[9][0], 'err')
+        assert.isFunction(log.args.on[9][1])
+      })
+
+      test('EventEmitter.on was called correctly eleventh time', () => {
+        assert.lengthOf(log.args.on[10], 2)
+        assert.strictEqual(log.args.on[10][0], 'err-data')
+        assert.isFunction(log.args.on[10][1])
+      })
+
+      suite('array event:', () => {
+        setup(() => {
+          return log.args.on[0][1]()
+        })
+
+        test('stream.push was not called', () => {
+          assert.strictEqual(log.counts.push, 0)
+        })
+
+        suite('end event:', () => {
+          setup(() => {
+            return log.args.on[8][1]()
+          })
+
+          test('stream.push was not called', () => {
+            assert.strictEqual(log.counts.push, 0)
+          })
+
+          suite('read stream:', () => {
+            setup(() => {
+              log.args.JsonStream[0][0]()
+            })
+
+            test('stream.push was called twice', () => {
+              assert.strictEqual(log.counts.push, 2)
+            })
+
+            test('stream.push was called correctly first time', () => {
+              assert.lengthOf(log.args.push[0], 2)
+              assert.strictEqual(log.args.push[0][0], '[')
+              assert.strictEqual(log.args.push[0][1], 'utf8')
+            })
+
+            test('stream.push was called correctly second time', () => {
+              assert.lengthOf(log.args.push[1], 1)
+              assert.isNull(log.args.push[1][0])
+            })
+
+            test('stream.emit was not called', () => {
+              assert.strictEqual(log.counts.emit, 0)
+            })
+          })
+        })
+
+        suite('read stream:', () => {
+          setup(() => {
+            log.args.JsonStream[0][0]()
+          })
+
+          test('stream.push was not called', () => {
+            assert.strictEqual(log.counts.push, 0)
+          })
+
+          suite('end event:', () => {
+            setup(() => {
+              return log.args.on[8][1]()
+            })
+
+            test('stream.push was called twice', () => {
+              assert.strictEqual(log.counts.push, 2)
+            })
+
+            test('stream.push was called correctly first time', () => {
+              assert.strictEqual(log.args.push[0][0], '[')
+            })
+
+            test('stream.push was called correctly second time', () => {
+              assert.isNull(log.args.push[1][0])
+            })
+
+            test('stream.emit was not called', () => {
+              assert.strictEqual(log.counts.emit, 0)
+            })
+          })
+
+          suite('string event:', () => {
+            setup(() => {
+              return log.args.on[3][1]('foo')
+            })
+
+            test('stream.push was called twice', () => {
+              assert.strictEqual(log.counts.push, 2)
+            })
+
+            test('stream.push was called correctly', () => {
+              assert.strictEqual(log.args.push[0][0], '[')
+              assert.strictEqual(log.args.push[1][0], '"foo"')
+            })
+
+            suite('string event:', () => {
+              setup(() => {
+                return log.args.on[3][1]('bar')
+              })
+
+              test('stream.push was called twice', () => {
+                assert.strictEqual(log.counts.push, 4)
+              })
+
+              test('stream.push was called correctly', () => {
+                assert.strictEqual(log.args.push[2][0], ',')
+                assert.strictEqual(log.args.push[3][0], '"bar"')
+              })
+            })
+
+            suite('array event:', () => {
+              setup(() => {
+                return log.args.on[0][1]()
+              })
+
+              test('stream.push was called twice', () => {
+                assert.strictEqual(log.counts.push, 4)
+              })
+
+              test('stream.push was called correctly', () => {
+                assert.strictEqual(log.args.push[2][0], ',')
+                assert.strictEqual(log.args.push[3][0], '[')
+              })
+
+              suite('array event:', () => {
+                setup(() => {
+                  return log.args.on[0][1]()
+                })
+
+                test('stream.push was called once', () => {
+                  assert.strictEqual(log.counts.push, 5)
+                })
+
+                test('stream.push was called correctly', () => {
+                  assert.strictEqual(log.args.push[4][0], '[')
+                })
+
+                suite('endArray event:', () => {
+                  setup(() => {
+                    return log.args.on[6][1]()
+                  })
+
+                  test('stream.push was called once', () => {
+                    assert.strictEqual(log.counts.push, 6)
+                  })
+
+                  test('stream.push was called correctly', () => {
+                    assert.strictEqual(log.args.push[5][0], ']')
+                  })
+
+                  suite('string event:', () => {
+                    setup(() => {
+                      return log.args.on[3][1]('bar')
+                    })
+
+                    test('stream.push was called twice', () => {
+                      assert.strictEqual(log.counts.push, 8)
+                    })
+
+                    test('stream.push was called correctly', () => {
+                      assert.strictEqual(log.args.push[6][0], ',')
+                      assert.strictEqual(log.args.push[7][0], '"bar"')
+                    })
+
+                    suite('string event:', () => {
+                      setup(() => {
+                        return log.args.on[3][1]('baz')
+                      })
+
+                      test('stream.push was called twice', () => {
+                        assert.strictEqual(log.counts.push, 10)
+                      })
+
+                      test('stream.push was called correctly', () => {
+                        assert.strictEqual(log.args.push[8][0], ',')
+                        assert.strictEqual(log.args.push[9][0], '"baz"')
+                      })
+                    })
+
+                    suite('endArray event:', () => {
+                      setup(() => {
+                        return log.args.on[6][1]()
+                      })
+
+                      test('stream.push was called once', () => {
+                        assert.strictEqual(log.counts.push, 9)
+                      })
+
+                      test('stream.push was called correctly', () => {
+                        assert.strictEqual(log.args.push[8][0], ']')
+                      })
+
+                      suite('string event:', () => {
+                        setup(() => {
+                          return log.args.on[3][1]('baz')
+                        })
+
+                        test('stream.push was called twice', () => {
+                          assert.strictEqual(log.counts.push, 11)
+                        })
+
+                        test('stream.push was called correctly', () => {
+                          assert.strictEqual(log.args.push[9][0], ',')
+                          assert.strictEqual(log.args.push[10][0], '"baz"')
+                        })
+
+                        test('stream.emit was not called', () => {
+                          assert.strictEqual(log.counts.emit, 0)
+                        })
+                      })
+                    })
+                  })
+                })
+              })
+            })
+
+            suite('object event:', () => {
+              setup(() => {
+                return log.args.on[1][1]()
+              })
+
+              test('stream.push was called twice', () => {
+                assert.strictEqual(log.counts.push, 4)
+              })
+
+              test('stream.push was called correctly', () => {
+                assert.strictEqual(log.args.push[2][0], ',')
+                assert.strictEqual(log.args.push[3][0], '{')
+              })
+
+              suite('property event:', () => {
+                setup(() => {
+                  return log.args.on[2][1]('bar')
+                })
+
+                test('stream.push was called once', () => {
+                  assert.strictEqual(log.counts.push, 5)
+                })
+
+                test('stream.push was called correctly', () => {
+                  assert.strictEqual(log.args.push[4][0], '"bar":')
+                })
+
+                suite('string event:', () => {
+                  setup(() => {
+                    return log.args.on[3][1]('baz')
+                  })
+
+                  test('stream.push was called once', () => {
+                    assert.strictEqual(log.counts.push, 6)
+                  })
+
+                  test('stream.push was called correctly', () => {
+                    assert.strictEqual(log.args.push[5][0], '"baz"')
+                  })
+
+                  suite('property event:', () => {
+                    setup(() => {
+                      return log.args.on[2][1]('nested')
+                    })
+
+                    test('stream.push was called twice', () => {
+                      assert.strictEqual(log.counts.push, 8)
+                    })
+
+                    test('stream.push was called correctly', () => {
+                      assert.strictEqual(log.args.push[6][0], ',')
+                      assert.strictEqual(log.args.push[7][0], '"nested":')
+                    })
+
+                    suite('object event:', () => {
+                      setup(() => {
+                        return log.args.on[1][1]()
+                      })
+
+                      test('stream.push was called once', () => {
+                        assert.strictEqual(log.counts.push, 9)
+                      })
+
+                      test('stream.push was called correctly', () => {
+                        assert.strictEqual(log.args.push[8][0], '{')
+                      })
+
+                      suite('endObject event:', () => {
+                        setup(() => {
+                          return log.args.on[7][1]()
+                        })
+
+                        test('stream.push was called once', () => {
+                          assert.strictEqual(log.counts.push, 10)
+                        })
+
+                        test('stream.push was called correctly', () => {
+                          assert.strictEqual(log.args.push[9][0], '}')
+                        })
+
+                        suite('property event:', () => {
+                          setup(() => {
+                            return log.args.on[2][1]('qux')
+                          })
+
+                          test('stream.push was called twice', () => {
+                            assert.strictEqual(log.counts.push, 12)
+                          })
+
+                          test('stream.push was called correctly', () => {
+                            assert.strictEqual(log.args.push[10][0], ',')
+                            assert.strictEqual(log.args.push[11][0], '"qux":')
+                          })
+
+                          suite('string event:', () => {
+                            setup(() => {
+                              return log.args.on[3][1]('wibble')
+                            })
+
+                            test('stream.push was called once', () => {
+                              assert.strictEqual(log.counts.push, 13)
+                            })
+
+                            test('stream.push was called correctly', () => {
+                              assert.strictEqual(log.args.push[12][0], '"wibble"')
+                            })
+                          })
+                        })
+
+                        suite('endObject event:', () => {
+                          setup(() => {
+                            return log.args.on[7][1]()
+                          })
+
+                          test('stream.push was called once', () => {
+                            assert.strictEqual(log.counts.push, 11)
+                          })
+
+                          test('stream.push was called correctly', () => {
+                            assert.strictEqual(log.args.push[10][0], '}')
+                          })
+
+                          suite('string event:', () => {
+                            setup(() => {
+                              return log.args.on[3][1]('wibble')
+                            })
+
+                            test('stream.push was called twice', () => {
+                              assert.strictEqual(log.counts.push, 13)
+                            })
+
+                            test('stream.push was called correctly', () => {
+                              assert.strictEqual(log.args.push[11][0], ',')
+                              assert.strictEqual(log.args.push[12][0], '"wibble"')
+                            })
+
+                            test('stream.emit was not called', () => {
+                              assert.strictEqual(log.counts.emit, 0)
+                            })
+                          })
+                        })
+                      })
+                    })
+                  })
+                })
+              })
+            })
+          })
+
+          suite('string event, push returns false:', () => {
+            setup(() => {
+              results.push[0] = false
+              return log.args.on[3][1]('foo')
+            })
+
+            teardown(() => {
+              results.push[0] = true
+            })
+
+            test('stream.push was called once', () => {
+              assert.strictEqual(log.counts.push, 1)
+            })
+
+            test('stream.push was called correctly', () => {
+              assert.strictEqual(log.args.push[0][0], '[')
+            })
+
+            suite('string event:', () => {
+              setup(() => {
+                return log.args.on[3][1]('bar')
+              })
+
+              test('stream.push was not called', () => {
+                assert.strictEqual(log.counts.push, 1)
+              })
+
+              suite('read stream, endArrayEvent:', () => {
+                setup(() => {
+                  log.args.JsonStream[0][0]()
+                  return log.args.on[6][1]()
+                })
+
+                test('stream.push was called once', () => {
+                  assert.strictEqual(log.counts.push, 2)
+                })
+
+                test('stream.push was called correctly', () => {
+                  assert.strictEqual(log.args.push[1][0], '"foo"')
+                })
+
+                suite('read stream:', () => {
+                  setup(() => {
+                    log.args.JsonStream[0][0]()
+                  })
+
+                  test('stream.push was not called', () => {
+                    assert.strictEqual(log.counts.push, 2)
+                  })
+
+                  test('stream.emit was not called', () => {
+                    assert.strictEqual(log.counts.emit, 0)
+                  })
+                })
+              })
+
+              suite('end event:', () => {
+                setup(() => {
+                  return log.args.on[8][1]()
+                })
+
+                test('stream.push was not called', () => {
+                  assert.strictEqual(log.counts.push, 1)
+                })
+
+                suite('read stream:', () => {
+                  setup(() => {
+                    log.args.JsonStream[0][0]()
+                  })
+
+                  test('stream.push was called once', () => {
+                    assert.strictEqual(log.counts.push, 2)
+                  })
+
+                  test('stream.push was called correctly', () => {
+                    assert.strictEqual(log.args.push[1][0], '"foo"')
+                  })
+
+                  suite('read stream:', () => {
+                    setup(() => {
+                      log.args.JsonStream[0][0]()
+                    })
+
+                    test('stream.push was called once', () => {
+                      assert.strictEqual(log.counts.push, 3)
+                    })
+
+                    test('stream.push was called correctly', () => {
+                      assert.strictEqual(log.args.push[2][0], ',')
+                    })
+
+                    suite('read stream:', () => {
+                      setup(() => {
+                        log.args.JsonStream[0][0]()
+                      })
+
+                      test('stream.push was called once', () => {
+                        assert.strictEqual(log.counts.push, 4)
+                      })
+
+                      test('stream.push was called correctly', () => {
+                        assert.strictEqual(log.args.push[3][0], '"bar"')
+                      })
+
+                      suite('read stream:', () => {
+                        setup(() => {
+                          log.args.JsonStream[0][0]()
+                        })
+
+                        test('stream.push was called once', () => {
+                          assert.strictEqual(log.counts.push, 5)
+                        })
+
+                        test('stream.push was called correctly', () => {
+                          assert.isNull(log.args.push[4][0])
+                        })
+                      })
+                    })
+                  })
+                })
+
+                suite('read stream, push returns true:', () => {
+                  setup(() => {
+                    results.push[0] = true
+                    log.args.JsonStream[0][0]()
+                  })
+
+                  test('stream.push was called four times', () => {
+                    assert.strictEqual(log.counts.push, 5)
+                  })
+
+                  test('stream.push was called correctly', () => {
+                    assert.strictEqual(log.args.push[1][0], '"foo"')
+                    assert.strictEqual(log.args.push[2][0], ',')
+                    assert.strictEqual(log.args.push[3][0], '"bar"')
+                    assert.isNull(log.args.push[4][0])
+                  })
+
+                  suite('read stream:', () => {
+                    setup(() => {
+                      log.args.JsonStream[0][0]()
+                    })
+
+                    test('stream.push was not called', () => {
+                      assert.strictEqual(log.counts.push, 5)
+                    })
+
+                    test('stream.emit was not called', () => {
+                      assert.strictEqual(log.counts.emit, 0)
+                    })
+                  })
+                })
+              })
+            })
+          })
+        })
+
+        suite('object event:', () => {
+          setup(() => {
+            log.args.JsonStream[0][0]()
+            return log.args.on[1][1]()
+          })
+
+          test('stream.push was called twice', () => {
+            assert.strictEqual(log.counts.push, 2)
+          })
+
+          test('stream.push was called correctly', () => {
+            assert.strictEqual(log.args.push[0][0], '[')
+            assert.strictEqual(log.args.push[1][0], '{')
+          })
+
+          test('stream.emit was not called', () => {
+            assert.strictEqual(log.counts.emit, 0)
+          })
+        })
+      })
+    })
+
+    suite('streamify with space option:', () => {
+      let data, options, result
+
+      setup(() => {
+        data = {}
+        options = { space: 2 }
+        result = streamify(data, options)
+      })
+
+      test('JsonStream was called once', () => {
+        assert.strictEqual(log.counts.JsonStream, 1)
+      })
+
+      test('eventify was called once', () => {
+        assert.strictEqual(log.counts.eventify, 1)
+      })
+
+      test('EventEmitter.on was called eleven times', () => {
+        assert.strictEqual(log.counts.on, 11)
+      })
+
+      test('stream.push was not called', () => {
+        assert.strictEqual(log.counts.push, 0)
+      })
+
+      suite('read stream, object event:', () => {
+        setup(() => {
+          log.args.JsonStream[0][0]()
+          return log.args.on[1][1]()
+        })
+
+        test('stream.push was called once', () => {
+          assert.strictEqual(log.counts.push, 1)
+        })
+
+        test('stream.push was called correctly', () => {
+          assert.strictEqual(log.args.push[0][0], '{')
+        })
+
+        suite('property event:', () => {
+          setup(() => {
+            return log.args.on[2][1]('foo')
+          })
+
+          test('stream.push was called twice', () => {
+            assert.strictEqual(log.counts.push, 3)
+          })
+
+          test('stream.push was called correctly', () => {
+            assert.strictEqual(log.args.push[1][0], '\n  ')
+            assert.strictEqual(log.args.push[2][0], '"foo":')
+          })
+
+          suite('string event:', () => {
+            setup(() => {
+              return log.args.on[3][1]('bar')
+            })
+
+            test('stream.push was called twice', () => {
+              assert.strictEqual(log.counts.push, 5)
+            })
+
+            test('stream.push was called correctly', () => {
+              assert.strictEqual(log.args.push[3][0], ' ')
+              assert.strictEqual(log.args.push[4][0], '"bar"')
+            })
+
+            suite('property event:', () => {
+              setup(() => {
+                return log.args.on[2][1]('baz')
+              })
+
+              test('stream.push was called three times', () => {
+                assert.strictEqual(log.counts.push, 8)
+              })
+
+              test('stream.push was called correctly', () => {
+                assert.strictEqual(log.args.push[5][0], ',')
+                assert.strictEqual(log.args.push[6][0], '\n  ')
+                assert.strictEqual(log.args.push[7][0], '"baz":')
+              })
+
+              suite('string event:', () => {
+                setup(() => {
+                  return log.args.on[3][1]('qux')
+                })
+
+                test('stream.push was called twice', () => {
+                  assert.strictEqual(log.counts.push, 10)
+                })
+
+                test('stream.push was called correctly', () => {
+                  assert.strictEqual(log.args.push[8][0], ' ')
+                  assert.strictEqual(log.args.push[9][0], '"qux"')
+                })
+
+                suite('property event:', () => {
+                  setup(() => {
+                    return log.args.on[2][1]('wibble')
+                  })
+
+                  test('stream.push was called three times', () => {
+                    assert.strictEqual(log.counts.push, 13)
+                  })
+
+                  test('stream.push was called correctly', () => {
+                    assert.strictEqual(log.args.push[10][0], ',')
+                    assert.strictEqual(log.args.push[11][0], '\n  ')
+                    assert.strictEqual(log.args.push[12][0], '"wibble":')
+                  })
+
+                  suite('array event:', () => {
+                    setup(() => {
+                      return log.args.on[0][1]()
+                    })
+
+                    test('stream.push was called twice', () => {
+                      assert.strictEqual(log.counts.push, 15)
+                    })
+
+                    test('stream.push was called correctly', () => {
+                      assert.strictEqual(log.args.push[13][0], ' ')
+                      assert.strictEqual(log.args.push[14][0], '[')
+                    })
+
+                    suite('string event:', () => {
+                      setup(() => {
+                        return log.args.on[3][1]('0')
+                      })
+
+                      test('stream.push was called twice', () => {
+                        assert.strictEqual(log.counts.push, 17)
+                      })
+
+                      test('stream.push was called correctly', () => {
+                        assert.strictEqual(log.args.push[15][0], '\n    ')
+                        assert.strictEqual(log.args.push[16][0], '"0"')
+                      })
+
+                      suite('string event:', () => {
+                        setup(() => {
+                          return log.args.on[3][1]('1')
+                        })
+
+                        test('stream.push was called three times', () => {
+                          assert.strictEqual(log.counts.push, 20)
+                        })
+
+                        test('stream.push was called correctly', () => {
+                          assert.strictEqual(log.args.push[17][0], ',')
+                          assert.strictEqual(log.args.push[18][0], '\n    ')
+                          assert.strictEqual(log.args.push[19][0], '"1"')
+                        })
+
+                        suite('endArray event:', () => {
+                          setup(() => {
+                            return log.args.on[6][1]()
+                          })
+
+                          test('stream.push was called twice', () => {
+                            assert.strictEqual(log.counts.push, 22)
+                          })
+
+                          test('stream.push was called correctly', () => {
+                            assert.strictEqual(log.args.push[20][0], '\n  ')
+                            assert.strictEqual(log.args.push[21][0], ']')
+                          })
+
+                          suite('property event:', () => {
+                            setup(() => {
+                              return log.args.on[2][1]('a')
+                            })
+
+                            test('stream.push was called three times', () => {
+                              assert.strictEqual(log.counts.push, 25)
+                            })
+
+                            test('stream.push was called correctly', () => {
+                              assert.strictEqual(log.args.push[22][0], ',')
+                              assert.strictEqual(log.args.push[23][0], '\n  ')
+                              assert.strictEqual(log.args.push[24][0], '"a":')
+                            })
+
+                            suite('string event:', () => {
+                              setup(() => {
+                                return log.args.on[3][1]('b')
+                              })
+
+                              test('stream.push was called twice', () => {
+                                assert.strictEqual(log.counts.push, 27)
+                              })
+
+                              test('stream.push was called correctly', () => {
+                                assert.strictEqual(log.args.push[25][0], ' ')
+                                assert.strictEqual(log.args.push[26][0], '"b"')
+                              })
+
+                              suite('endObject event:', () => {
+                                setup(() => {
+                                  return log.args.on[7][1]()
+                                })
+
+                                test('stream.push was called twice', () => {
+                                  assert.strictEqual(log.counts.push, 29)
+                                })
+
+                                test('stream.push was called correctly', () => {
+                                  assert.strictEqual(log.args.push[27][0], '\n')
+                                  assert.strictEqual(log.args.push[28][0], '}')
+                                })
+
+                                test('stream.emit was not called', () => {
+                                  assert.strictEqual(log.counts.emit, 0)
+                                })
+                              })
+                            })
+                          })
+                        })
+                      })
+                    })
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+
+      suite('read stream, end event:', () => {
+        setup(() => {
+          log.args.JsonStream[0][0]()
+          return log.args.on[8][1]()
+        })
+
+        test('stream.push was called once', () => {
+          assert.strictEqual(log.counts.push, 1)
+        })
+
+        test('stream.push was called correctly', () => {
+          assert.isNull(log.args.push[0][0])
+        })
+
+        test('stream.emit was not called', () => {
+          assert.strictEqual(log.counts.emit, 0)
+        })
+      })
+
+      suite('error event:', () => {
+        setup(() => {
+          return log.args.on[9][1]('foo')
+        })
+
+        test('stream.emit was called once', () => {
+          assert.strictEqual(log.counts.emit, 1)
+        })
+
+        test('stream.emit was called correctly', () => {
+          assert.lengthOf(log.args.emit[0], 2)
+          assert.strictEqual(log.args.emit[0][0], 'error')
+          assert.strictEqual(log.args.emit[0][1], 'foo')
+        })
+      })
+
+      suite('dataError event:', () => {
+        setup(() => {
+          return log.args.on[10][1]('bar')
+        })
+
+        test('stream.emit was called once', () => {
+          assert.strictEqual(log.counts.emit, 1)
+        })
+
+        test('stream.emit was called correctly', () => {
+          assert.lengthOf(log.args.emit[0], 2)
+          assert.strictEqual(log.args.emit[0][0], 'dataError')
+          assert.strictEqual(log.args.emit[0][1], 'bar')
+        })
+      })
+    })
+  })
+})
Index: frontend/node_modules/bfj/test/unit/stringify.js
===================================================================
--- frontend/node_modules/bfj/test/unit/stringify.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/unit/stringify.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,195 @@
+'use strict'
+
+const assert = require('chai').assert
+const proxyquire = require('proxyquire')
+const spooks = require('spooks')
+const Promise = require('bluebird')
+
+const modulePath = '../../src/stringify'
+
+suite('stringify:', () => {
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns function', () => {
+    assert.isFunction(require(modulePath))
+  })
+
+  suite('require:', () => {
+    let log, stringify
+
+    setup(() => {
+      log = {}
+
+      stringify = proxyquire(modulePath, {
+        './streamify': spooks.fn({
+          name: 'streamify',
+          log: log,
+          results: [
+            { on: spooks.fn({ name: 'on', log: log }) }
+          ]
+        })
+      })
+    })
+
+    test('stringify expects two arguments', () => {
+      assert.lengthOf(stringify, 2)
+    })
+
+    test('stringify does not throw', () => {
+      assert.doesNotThrow(() => {
+        stringify()
+      })
+    })
+
+    test('stringify returns promise', () => {
+      assert.instanceOf(stringify(), Promise)
+    })
+
+    test('streamify was not called', () => {
+      assert.strictEqual(log.counts.streamify, 0)
+    })
+
+    suite('stringify:', () => {
+      let data, options, resolved, rejected, result, done
+
+      setup(() => {
+        data = {}
+        options = {}
+        stringify(data, options)
+          .then(res => {
+            resolved = res
+            done()
+          })
+          .catch(rej => {
+            rejected = rej
+            done()
+          })
+      })
+
+      teardown(() => {
+        resolved = rejected = undefined
+      })
+
+      test('streamify was called once', () => {
+        assert.strictEqual(log.counts.streamify, 1)
+        assert.isUndefined(log.these.streamify[0])
+      })
+
+      test('streamify was called correctly', () => {
+        assert.lengthOf(log.args.streamify[0], 2)
+        assert.strictEqual(log.args.streamify[0][0], data)
+        assert.lengthOf(Object.keys(log.args.streamify[0][0]), 0)
+        assert.strictEqual(log.args.streamify[0][1], options)
+        assert.lengthOf(Object.keys(log.args.streamify[0][1]), 0)
+      })
+
+      test('stream.on was called four times', () => {
+        assert.strictEqual(log.counts.on, 4)
+      })
+
+      test('stream.on was called correctly first time', () => {
+        assert.lengthOf(log.args.on[0], 2)
+        assert.strictEqual(log.args.on[0][0], 'data')
+        assert.isFunction(log.args.on[0][1])
+      })
+
+      test('stream.on was called correctly second time', () => {
+        assert.strictEqual(log.args.on[1][0], 'end')
+        assert.isFunction(log.args.on[1][1])
+        assert.notStrictEqual(log.args.on[1][1], log.args.on[0][1])
+      })
+
+      test('stream.on was called correctly third time', () => {
+        assert.strictEqual(log.args.on[2][0], 'error')
+        assert.isFunction(log.args.on[2][1])
+        assert.notStrictEqual(log.args.on[2][1], log.args.on[0][1])
+        assert.notStrictEqual(log.args.on[2][1], log.args.on[1][1])
+      })
+
+      test('stream.on was called correctly fourth time', () => {
+        assert.strictEqual(log.args.on[3][0], 'dataError')
+        assert.isFunction(log.args.on[3][1])
+        assert.strictEqual(log.args.on[3][1], log.args.on[2][1])
+      })
+
+      test('promise is unfulfilled', () => {
+        assert.isUndefined(resolved)
+        assert.isUndefined(rejected)
+      })
+
+      suite('data event:', () => {
+        setup(() => {
+          log.args.on[0][1]('foo')
+        })
+
+        test('promise is unfulfilled', () => {
+          assert.isUndefined(resolved)
+          assert.isUndefined(rejected)
+        })
+
+        suite('end event:', () => {
+          setup(d => {
+            done = d
+            log.args.on[1][1]()
+          })
+
+          test('promise is resolved', () => {
+            assert.strictEqual(resolved, 'foo')
+          })
+
+          test('promise is not rejected', () => {
+            assert.isUndefined(rejected)
+          })
+        })
+
+        suite('data event:', () => {
+          setup(() => {
+            log.args.on[0][1]('bar')
+          })
+
+          test('promise is unfulfilled', () => {
+            assert.isUndefined(resolved)
+            assert.isUndefined(rejected)
+          })
+
+          suite('end event:', () => {
+            setup(d => {
+              done = d
+              log.args.on[1][1]()
+            })
+
+            test('promise is resolved', () => {
+              assert.strictEqual(resolved, 'foobar')
+            })
+          })
+
+          suite('error event:', () => {
+            setup(d => {
+              done = d
+              log.args.on[2][1]('wibble')
+            })
+
+            test('promise is rejected', () => {
+              assert.strictEqual(rejected, 'wibble')
+            })
+          })
+
+          suite('dataError event:', () => {
+            setup(d => {
+              done = d
+              log.args.on[3][1]('wibble')
+            })
+
+            test('promise is rejected', () => {
+              assert.strictEqual(rejected, 'wibble')
+            })
+          })
+        })
+      })
+    })
+  })
+})
Index: frontend/node_modules/bfj/test/unit/unpipe.js
===================================================================
--- frontend/node_modules/bfj/test/unit/unpipe.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/unit/unpipe.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,125 @@
+'use strict'
+
+const assert = require('chai').assert
+const proxyquire = require('proxyquire')
+const spooks = require('spooks')
+const Promise = require('bluebird')
+
+const modulePath = '../../src/unpipe'
+
+suite('unpipe:', () => {
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns function', () => {
+    assert.isFunction(require(modulePath))
+  })
+
+  suite('require:', () => {
+    let log, results, unpipe
+
+    setup(() => {
+      log = {}
+      results = {
+        parse: [ Promise.resolve() ]
+      }
+      unpipe = proxyquire(modulePath, {
+        './parse': spooks.fn({
+          name: 'parse',
+          log: log,
+          results: results.parse
+        })
+      })
+    })
+
+    test('unpipe expects two arguments', () => {
+      assert.lengthOf(unpipe, 2)
+    })
+
+    test('unpipe does not throw', () => {
+      assert.doesNotThrow(() => {
+        unpipe(() => {})
+      })
+    })
+
+    test('unpipe throws if callback is not provided', () => {
+      assert.throws(() => {
+        unpipe()
+      })
+    })
+
+    test('parse was not called', () => {
+      assert.strictEqual(log.counts.parse, 0)
+    })
+
+    suite('unpipe success:', () => {
+      let result, error, options
+
+      setup(done => {
+        results.parse[0] = Promise.resolve('foo')
+        options = { foo: 'bar', ndjson: true }
+        unpipe((err, res) => {
+          error = err
+          result = res
+          done()
+        }, options)
+      })
+
+      test('parse was called once', () => {
+        assert.strictEqual(log.counts.parse, 1)
+      })
+
+      test('parse was called correctly', () => {
+        assert.isUndefined(log.these.parse[0])
+        assert.lengthOf(log.args.parse[0], 2)
+        assert.isObject(log.args.parse[0][0])
+        assert.isTrue(log.args.parse[0][0].readable)
+        assert.isTrue(log.args.parse[0][0].writable)
+        assert.isFunction(log.args.parse[0][0].pipe)
+        assert.isFunction(log.args.parse[0][0].read)
+        assert.isFunction(log.args.parse[0][0]._read)
+        assert.isFunction(log.args.parse[0][0].write)
+        assert.isFunction(log.args.parse[0][0]._write)
+        assert.notStrictEqual(log.args.parse[0][1], options)
+        assert.deepEqual(log.args.parse[0][1], { foo: 'bar', ndjson: false })
+      })
+
+      test('parse result was returned', () => {
+        assert.strictEqual(result, 'foo')
+      })
+
+      test('did not fail', () => {
+        assert.isNull(error)
+      })
+    })
+
+    suite('unpipe error:', () => {
+      let result, error, options
+
+      setup(done => {
+        results.parse[0] = Promise.reject('bar')
+        options = {}
+        unpipe((err, res) => {
+          error = err
+          result = res
+          done()
+        }, options)
+      })
+
+      test('parse was called once', () => {
+        assert.strictEqual(log.counts.parse, 1)
+      })
+
+      test('parse result was not returned', () => {
+        assert.isUndefined(result)
+      })
+
+      test('failed', () => {
+        assert.strictEqual(error, 'bar')
+      })
+    })
+  })
+})
Index: frontend/node_modules/bfj/test/unit/walk.js
===================================================================
--- frontend/node_modules/bfj/test/unit/walk.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/unit/walk.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,3255 @@
+'use strict'
+
+const assert = require('chai').assert
+const spooks = require('spooks')
+const Readable = require('stream').Readable
+const events = require('../../src/events')
+
+const modulePath = '../../src/walk'
+
+suite('walk:', () => {
+  let log
+
+  setup(() => {
+    log = {}
+  })
+
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns function', () => {
+    assert.isFunction(require(modulePath))
+  })
+
+  suite('require:', () => {
+    let walk
+
+    setup(() => {
+      walk = require(modulePath)
+    })
+
+    test('walk throws without readable stream', () => {
+      assert.throws(() => {
+        walk({ on: () => {} })
+      })
+    })
+
+    test('walk does not throw with readable stream', () => {
+      assert.doesNotThrow(() => {
+        walk(new Readable())
+      })
+    })
+
+    test('walk returns emitter', () => {
+      assert.instanceOf(walk(new Readable()), require('events').EventEmitter)
+    })
+
+    test('EventEmitter is decorated with pause method', () => {
+      assert.isFunction(walk(new Readable()).pause)
+      assert.lengthOf(walk(new Readable()).pause, 0)
+    })
+
+    test('pause method returns continue function', () => {
+      assert.isFunction(walk(new Readable()).pause())
+      assert.lengthOf(walk(new Readable()).pause(), 0)
+    })
+
+    suite('empty json:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('end event was dispatched correctly', () => {
+        assert.lengthOf(log.args.end[0], 0)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('empty array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('array event was dispatched correctly', () => {
+        assert.lengthOf(log.args.array[0], 0)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('endArray event was dispatched correctly', () => {
+        assert.lengthOf(log.args.endArray[0], 0)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('empty object:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('{}')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('object event was dispatched correctly', () => {
+        assert.lengthOf(log.args.object[0], 0)
+      })
+
+      test('endObject event occurred once', () => {
+        assert.strictEqual(log.counts.endObject, 1)
+      })
+
+      test('endObject event was dispatched correctly', () => {
+        assert.lengthOf(log.args.endObject[0], 0)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('string:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('"\\"the quick brown fox\r\n\\tjumps\\u00a0over the lazy\\u1680dog\\""')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.lengthOf(log.args.string[0], 1)
+        assert.strictEqual(log.args.string[0][0], '"the quick brown fox\r\n\tjumps\u00a0over the lazy\u1680dog"')
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('number:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('-3.14159265359e+42')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('number event occurred once', () => {
+        assert.strictEqual(log.counts.number, 1)
+      })
+
+      test('number event was dispatched correctly', () => {
+        assert.lengthOf(log.args.number[0], 1)
+        assert.strictEqual(log.args.number[0][0], -3.14159265359e+42)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('literal false:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('false')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('literal event occurred once', () => {
+        assert.strictEqual(log.counts.literal, 1)
+      })
+
+      test('literal event was dispatched correctly', () => {
+        assert.lengthOf(log.args.literal[0], 1)
+        assert.strictEqual(log.args.literal[0][0], false)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('literal null:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('null')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('literal event occurred once', () => {
+        assert.strictEqual(log.counts.literal, 1)
+      })
+
+      test('literal event was dispatched correctly', () => {
+        assert.strictEqual(log.args.literal[0][0], null)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('literal true:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('true')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('literal event occurred once', () => {
+        assert.strictEqual(log.counts.literal, 1)
+      })
+
+      test('literal event was dispatched correctly', () => {
+        assert.strictEqual(log.args.literal[0][0], true)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('property event did not occur', () => {
+        assert.strictEqual(log.counts.property, 0)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+
+      test('endPrefix event did not occur', () => {
+        assert.strictEqual(log.counts.endPrefix, 0)
+      })
+    })
+
+    suite('badly-closed array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[}')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('dataError event occurred twice', () => {
+        assert.strictEqual(log.counts.dataError, 2)
+      })
+
+      test('dataError event was dispatched correctly first time', () => {
+        assert.lengthOf(log.args.dataError[0], 1)
+        assert.instanceOf(log.args.dataError[0][0], Error)
+        assert.strictEqual(log.args.dataError[0][0].actual, '}')
+        assert.strictEqual(log.args.dataError[0][0].expected, 'value')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 2)
+      })
+
+      test('dataError event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.dataError[1][0].actual, 'EOF')
+        assert.strictEqual(log.args.dataError[1][0].expected, ']')
+        assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[1][0].columnNumber, 3)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+    })
+
+    suite('badly-closed object:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('{]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('dataError event occurred three times', () => {
+        assert.strictEqual(log.counts.dataError, 3)
+      })
+
+      test('dataError event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, ']')
+        assert.strictEqual(log.args.dataError[0][0].expected, '"')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 2)
+      })
+
+      test('dataError event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.dataError[1][0].actual, 'EOF')
+        assert.strictEqual(log.args.dataError[1][0].expected, '"')
+        assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[1][0].columnNumber, 3)
+      })
+
+      test('dataError event was dispatched correctly third time', () => {
+        assert.strictEqual(log.args.dataError[2][0].actual, 'EOF')
+        assert.strictEqual(log.args.dataError[2][0].expected, '}')
+        assert.strictEqual(log.args.dataError[2][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[2][0].columnNumber, 3)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('array event did not occur', () => {
+        assert.strictEqual(log.counts.array, 0)
+      })
+
+      test('endArray event did not occur', () => {
+        assert.strictEqual(log.counts.endArray, 0)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+    })
+
+    suite('string containing bad escape sequence:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('"\\"the quick brown fox\r\n\\tjumps over the lazy\\xdog\\""')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 1)
+      })
+
+      test('dataError event was dispatched correctly', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, 'x')
+        assert.strictEqual(log.args.dataError[0][0].expected, 'escape character')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 2)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 23)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.strictEqual(log.args.string[0][0], '"the quick brown fox\r\n\tjumps over the lazy\\xdog"')
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+    })
+
+    suite('string containing bad unicode escape sequence:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('"\\u012g"')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 1)
+      })
+
+      test('dataError event was dispatched correctly', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, 'g')
+        assert.strictEqual(log.args.dataError[0][0].expected, 'hex digit')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 7)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.strictEqual(log.args.string[0][0], '\\u012g')
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+    })
+
+    suite('unterminated string:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('"foo')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 1)
+      })
+
+      test('dataError event was dispatched correctly', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, 'EOF')
+        assert.strictEqual(log.args.dataError[0][0].expected, '"')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 5)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('string event did not occur', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+    })
+
+    suite('bad number:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('1e')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('number event did not occur', () => {
+        assert.strictEqual(log.counts.number, 0)
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 1)
+      })
+
+      test('dataError event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, 'EOF')
+        assert.strictEqual(log.args.dataError[0][0].expected, 'exponent')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 3)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+    })
+
+    suite('alternative bad number:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('42f')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('number event occurred once', () => {
+        assert.strictEqual(log.counts.number, 1)
+      })
+
+      test('number event was dispatched correctly', () => {
+        assert.strictEqual(log.args.number[0][0], 42)
+      })
+
+      test('dataError event occurred twice', () => {
+        assert.strictEqual(log.counts.dataError, 2)
+      })
+
+      test('dataError event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, 'f')
+        assert.strictEqual(log.args.dataError[0][0].expected, 'EOF')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 3)
+      })
+
+      test('dataError event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.dataError[1][0].actual, 'EOF')
+        assert.strictEqual(log.args.dataError[1][0].expected, 'a')
+        assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[1][0].columnNumber, 4)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+    })
+
+    suite('bad literal false:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('falsd')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 1)
+      })
+
+      test('dataError event was dispatched correctly', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, 'd')
+        assert.strictEqual(log.args.dataError[0][0].expected, 'e')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 5)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+    })
+
+    suite('bad literal null:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('nul')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 1)
+      })
+
+      test('dataError event was dispatched correctly', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, 'EOF')
+        assert.strictEqual(log.args.dataError[0][0].expected, 'l')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 4)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+    })
+
+    suite('bad literal true:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('tRue')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('dataError event occurred four times', () => {
+        assert.strictEqual(log.counts.dataError, 4)
+      })
+
+      test('dataError event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, 'R')
+        assert.strictEqual(log.args.dataError[0][0].expected, 'r')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 2)
+      })
+
+      test('dataError event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.dataError[1][0].actual, 'u')
+        assert.strictEqual(log.args.dataError[1][0].expected, 'EOF')
+        assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[1][0].columnNumber, 3)
+      })
+
+      test('dataError event was dispatched correctly third time', () => {
+        assert.strictEqual(log.args.dataError[2][0].actual, 'u')
+        assert.strictEqual(log.args.dataError[2][0].expected, 'value')
+        assert.strictEqual(log.args.dataError[2][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[2][0].columnNumber, 3)
+      })
+
+      test('dataError event was dispatched correctly fourth time', () => {
+        assert.strictEqual(log.args.dataError[3][0].actual, 'e')
+        assert.strictEqual(log.args.dataError[3][0].expected, 'value')
+        assert.strictEqual(log.args.dataError[3][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[3][0].columnNumber, 4)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('literal event did not occur', () => {
+        assert.strictEqual(log.counts.literal, 0)
+      })
+    })
+
+    suite('array inside array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[[]]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred twice', () => {
+        assert.strictEqual(log.counts.array, 2)
+      })
+
+      test('endArray event occurred twice', () => {
+        assert.strictEqual(log.counts.endArray, 2)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+    })
+
+    suite('two arrays inside array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[[],[]]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred three times', () => {
+        assert.strictEqual(log.counts.array, 3)
+      })
+
+      test('endArray event occurred three times', () => {
+        assert.strictEqual(log.counts.endArray, 3)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two arrays inside array with whitespace:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push(' [ [] , [] ] ')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred three times', () => {
+        assert.strictEqual(log.counts.array, 3)
+      })
+
+      test('endArray event occurred three times', () => {
+        assert.strictEqual(log.counts.endArray, 3)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two arrays inside array without comma:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[[][]]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred three times', () => {
+        assert.strictEqual(log.counts.array, 3)
+      })
+
+      test('endArray event occurred three times', () => {
+        assert.strictEqual(log.counts.endArray, 3)
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 1)
+      })
+
+      test('dataError event was dispatched correctly', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, '[')
+        assert.strictEqual(log.args.dataError[0][0].expected, ',')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 4)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('endObject event did not occur', () => {
+        assert.strictEqual(log.counts.endObject, 0)
+      })
+    })
+
+    suite('object inside array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[{}]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('object event occurred once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('endObject event occurred once', () => {
+        assert.strictEqual(log.counts.endObject, 1)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+    })
+
+    suite('two objects inside array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[{},{}]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('object event occurred twice', () => {
+        assert.strictEqual(log.counts.object, 2)
+      })
+
+      test('endObject event occurred twice', () => {
+        assert.strictEqual(log.counts.endObject, 2)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two objects inside array with whitespace:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('\t[\t{}\t,\r{}\n]\r\n')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('object event occurred twice', () => {
+        assert.strictEqual(log.counts.object, 2)
+      })
+
+      test('endObject event occurred twice', () => {
+        assert.strictEqual(log.counts.endObject, 2)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two objects inside array without comma:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[ {} {} ]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('object event occurred twice', () => {
+        assert.strictEqual(log.counts.object, 2)
+      })
+
+      test('endObject event occurred twice', () => {
+        assert.strictEqual(log.counts.endObject, 2)
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 1)
+      })
+
+      test('dataError event was dispatched correctly', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, '{')
+        assert.strictEqual(log.args.dataError[0][0].expected, ',')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 6)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+    })
+
+    suite('string inside array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('["foo"]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.strictEqual(log.args.string[0][0], 'foo')
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('object event did not occur', () => {
+        assert.strictEqual(log.counts.object, 0)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+    })
+
+    suite('two strings inside array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('["foo","bar"]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('string event occurred twice', () => {
+        assert.strictEqual(log.counts.string, 2)
+      })
+
+      test('string event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.string[0][0], 'foo')
+      })
+
+      test('string event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.string[1][0], 'bar')
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two strings inside array with whitespace:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('  [  "baz"  ,  "qux"  ]  ')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('string event occurred twice', () => {
+        assert.strictEqual(log.counts.string, 2)
+      })
+
+      test('string event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.string[0][0], 'baz')
+      })
+
+      test('string event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.string[1][0], 'qux')
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('literal inside array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[false]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('literal event occurred once', () => {
+        assert.strictEqual(log.counts.literal, 1)
+      })
+
+      test('literal event was dispatched correctly', () => {
+        assert.strictEqual(log.args.literal[0][0], false)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two literals inside array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[true,null]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('literal event occurred twice', () => {
+        assert.strictEqual(log.counts.literal, 2)
+      })
+
+      test('literal event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.literal[0][0], true)
+      })
+
+      test('literal event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.literal[1][0], null)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two literals inside array with whitespace:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[ null , false ]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('literal event occurred twice', () => {
+        assert.strictEqual(log.counts.literal, 2)
+      })
+
+      test('literal event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.literal[0][0], null)
+      })
+
+      test('literal event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.literal[1][0], false)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('number inside array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[0]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('number event occurred once', () => {
+        assert.strictEqual(log.counts.number, 1)
+      })
+
+      test('number event was dispatched correctly', () => {
+        assert.strictEqual(log.args.number[0][0], 0)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two numbers inside array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[1,2]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('number event occurred twice', () => {
+        assert.strictEqual(log.counts.number, 2)
+      })
+
+      test('number event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.number[0][0], 1)
+      })
+
+      test('number event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.number[1][0], 2)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two numbers inside array with whitespace:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[ 1977 , -1977 ]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('number event occurred twice', () => {
+        assert.strictEqual(log.counts.number, 2)
+      })
+
+      test('number event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.number[0][0], 1977)
+      })
+
+      test('number event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.number[1][0], -1977)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('object inside object:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('{"foo":{}}')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred twice', () => {
+        assert.strictEqual(log.counts.object, 2)
+      })
+
+      test('property event occurred once', () => {
+        assert.strictEqual(log.counts.property, 1)
+      })
+
+      test('property event was dispatched correctly', () => {
+        assert.lengthOf(log.args.property[0], 1)
+        assert.strictEqual(log.args.property[0][0], 'foo')
+      })
+
+      test('endObject event occurred twice', () => {
+        assert.strictEqual(log.counts.endObject, 2)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('array and object inside object:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('{"wibble wobble":[],"jelly on the plate":{}}')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred twice', () => {
+        assert.strictEqual(log.counts.object, 2)
+      })
+
+      test('property event occurred twice', () => {
+        assert.strictEqual(log.counts.property, 2)
+      })
+
+      test('property event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.property[0][0], 'wibble wobble')
+      })
+
+      test('property event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.property[1][0], 'jelly on the plate')
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('endObject event occurred twice', () => {
+        assert.strictEqual(log.counts.endObject, 2)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('string, literal and number inside object with whitespace:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('   { "foo" : "bar" ,\t"baz"\t:\tnull\t,\r\n"qux"\r\n:\r\n3.14159265359\r\n} ')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('property event occurred three times', () => {
+        assert.strictEqual(log.counts.property, 3)
+      })
+
+      test('property event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.property[0][0], 'foo')
+      })
+
+      test('property event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.property[1][0], 'baz')
+      })
+
+      test('property event was dispatched correctly third time', () => {
+        assert.strictEqual(log.args.property[2][0], 'qux')
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.strictEqual(log.args.string[0][0], 'bar')
+      })
+
+      test('literal event occurred once', () => {
+        assert.strictEqual(log.counts.literal, 1)
+      })
+
+      test('literal event was dispatched correctly', () => {
+        assert.isNull(log.args.literal[0][0])
+      })
+
+      test('number event occurred once', () => {
+        assert.strictEqual(log.counts.number, 1)
+      })
+
+      test('number event was dispatched correctly', () => {
+        assert.strictEqual(log.args.number[0][0], 3.14159265359)
+      })
+
+      test('endObject event occurred once', () => {
+        assert.strictEqual(log.counts.endObject, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two objects inside object without comma:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('{"foo":{}"bar":{}}')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred three times', () => {
+        assert.strictEqual(log.counts.object, 3)
+      })
+
+      test('property event occurred twice', () => {
+        assert.strictEqual(log.counts.property, 2)
+      })
+
+      test('property event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.property[0][0], 'foo')
+      })
+
+      test('property event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.property[1][0], 'bar')
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 1)
+      })
+
+      test('dataError event was dispatched correctly', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, '"')
+        assert.strictEqual(log.args.dataError[0][0].expected, ',')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 10)
+      })
+
+      test('endObject event occurred three times', () => {
+        assert.strictEqual(log.counts.endObject, 3)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+    })
+
+    suite('unquoted property:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('{foo:{}}')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 3)
+      })
+
+      test('dataError event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.dataError[0][0].actual, 'f')
+        assert.strictEqual(log.args.dataError[0][0].expected, '"')
+        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[0][0].columnNumber, 2)
+      })
+
+      test('dataError event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.dataError[1][0].actual, 'EOF')
+        assert.strictEqual(log.args.dataError[1][0].expected, '"')
+        assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[1][0].columnNumber, 9)
+      })
+
+      test('dataError event was dispatched correctly third time', () => {
+        assert.strictEqual(log.args.dataError[2][0].actual, 'EOF')
+        assert.strictEqual(log.args.dataError[2][0].expected, '}')
+        assert.strictEqual(log.args.dataError[2][0].lineNumber, 1)
+        assert.strictEqual(log.args.dataError[2][0].columnNumber, 9)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+    })
+
+    suite('duplicate property:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        // NOTE: RFC 7159 is wishy washy on the subject of duplicates:
+        //
+        //   "The names within an object SHOULD be unique
+        //
+        //   ...
+        //
+        //   An object whose names are all unique is interoperable
+        //   in the sense that all software implementations receiving
+        //   that object will agree on the name/value mappings. When
+        //   the names within an object are not unique, the behavior
+        //   of software that receives such an object is unpredictable.
+        //   Many implementations report the last name/value pair only.
+        //   Other implementations report an error or fail to parse the
+        //   object, and some implementations report all of the name/value
+        //   pairs, including duplicates."
+        //
+        //   https://tools.ietf.org/html/rfc7159#section-4
+        stream.push('{"foo":{},"foo":{}}')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('object event occurred three times', () => {
+        assert.strictEqual(log.counts.object, 3)
+      })
+
+      test('property event occurred twice', () => {
+        assert.strictEqual(log.counts.property, 2)
+      })
+
+      test('property event was dispatched correctly first time', () => {
+        assert.strictEqual(log.args.property[0][0], 'foo')
+      })
+
+      test('property event was dispatched correctly second time', () => {
+        assert.strictEqual(log.args.property[1][0], 'foo')
+      })
+
+      test('endObject event occurred three times', () => {
+        assert.strictEqual(log.counts.endObject, 3)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('empty array containing whitespace:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[ ]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('chunked empty array:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[')
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+        emitter.on(events.array, stream.push.bind(stream, ']'))
+        emitter.on(events.endArray, stream.push.bind(stream, null))
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('chunked empty object with whitespace:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push(' {')
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+
+        emitter.on(events.object, () => {
+          setTimeout(stream.push.bind(stream, ' }'), 20)
+        })
+
+        emitter.on(events.endObject, () => {
+          setTimeout(stream.push.bind(stream, null), 20)
+        })
+      })
+
+      test('object event occurred once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('endObject event occurred once', () => {
+        assert.strictEqual(log.counts.endObject, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('chunked string:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('"')
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+
+        emitter.on(events.string, () => {
+          setTimeout(stream.push.bind(stream, null), 20)
+        })
+
+        setTimeout(stream.push.bind(stream, '\\'), 20)
+        setTimeout(stream.push.bind(stream, 't\\u'), 40)
+        setTimeout(stream.push.bind(stream, '00'), 60)
+        setTimeout(stream.push.bind(stream, 'a0'), 80)
+        setTimeout(stream.push.bind(stream, '"'), 100)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.strictEqual(log.args.string[0][0], '\t\u00a0')
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('chunked number:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('-')
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+
+        setTimeout(stream.push.bind(stream, '3'), 20)
+        setTimeout(stream.push.bind(stream, '.'), 40)
+        setTimeout(stream.push.bind(stream, '14159'), 60)
+        setTimeout(stream.push.bind(stream, '265359'), 80)
+        setTimeout(stream.push.bind(stream, 'e'), 100)
+        setTimeout(stream.push.bind(stream, '-'), 120)
+        setTimeout(stream.push.bind(stream, '7'), 140)
+        setTimeout(stream.push.bind(stream, null), 160)
+      })
+
+      test('number event occurred once', () => {
+        assert.strictEqual(log.counts.number, 1)
+      })
+
+      test('number event was dispatched correctly', () => {
+        assert.strictEqual(log.args.number[0][0], -3.14159265359e-7)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('chunked literal:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('n')
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+
+        setTimeout(stream.push.bind(stream, 'u'), 20)
+        setTimeout(stream.push.bind(stream, 'l'), 40)
+        setTimeout(stream.push.bind(stream, 'l'), 60)
+        setTimeout(stream.push.bind(stream, null), 80)
+      })
+
+      test('literal event occurred once', () => {
+        assert.strictEqual(log.counts.literal, 1)
+      })
+
+      test('literal event was dispatched correctly', () => {
+        assert.strictEqual(log.args.literal[0][0], null)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('populated array with discard=1:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream, { discard: 1 })
+
+        stream.push(' ')
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+
+        emitter.on(events.array, () => {
+          stream.push(' ""')
+        })
+
+        emitter.on(events.string, () => {
+          stream.push(' ]')
+        })
+
+        emitter.on(events.endArray, () => {
+          stream.push(null)
+        })
+
+        setImmediate(stream.push.bind(stream, '['))
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.strictEqual(log.args.string[0][0], "")
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('throw errors from event handlers:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[null,false,true,0,"",{"foo":"bar"}]')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+          if (value !== events.end) {
+            emitter.on(value, () => { throw 0 })
+          }
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('literal event occurred three times', () => {
+        assert.strictEqual(log.counts.literal, 3)
+      })
+
+      test('number event occurred once', () => {
+        assert.strictEqual(log.counts.number, 1)
+      })
+
+      test('string event occurred twice', () => {
+        assert.strictEqual(log.counts.string, 2)
+      })
+
+      test('property event occurred once', () => {
+        assert.strictEqual(log.counts.property, 1)
+      })
+
+      test('object event occurred once', () => {
+        assert.strictEqual(log.counts.object, 1)
+      })
+
+      test('endObject event occurred once', () => {
+        assert.strictEqual(log.counts.endObject, 1)
+      })
+
+      test('error event occurred eleven times', () => {
+        assert.strictEqual(log.counts.error, 11)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('error occurs on stream:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        stream.emit('error', new Error('wibble'))
+        stream.push(null)
+
+        emitter.on(events.end, done)
+      })
+
+      test('error event occurred once', () => {
+        assert.strictEqual(log.counts.error, 1)
+      })
+
+      test('error event was dispatched correctly', () => {
+        assert.strictEqual(log.args.error[0][0].message, 'wibble')
+        assert.isUndefined(log.args.error[0][0].actual)
+        assert.isUndefined(log.args.error[0][0].expected)
+        assert.isUndefined(log.args.error[0][0].lineNumber)
+        assert.isUndefined(log.args.error[0][0].columnNumber)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two values separated by newline:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream)
+
+        stream.push('[]\n"foo"')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('dataError event occurred once', () => {
+        assert.strictEqual(log.counts.dataError, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+    })
+
+    suite('two values separated by newline, ndjson=true:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream, { ndjson: true })
+
+        stream.push('[]\n"foo"')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('endLine event occurred once', () => {
+        assert.strictEqual(log.counts.endLine, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two values separated by newline, ndjson=true, with embedded newlines in a value:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream, { ndjson: true })
+
+        stream.push('[\n\n\n"foo"\n\n,\n"bar"]\n"baz"')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('string event occurred three times', () => {
+        assert.strictEqual(log.counts.string, 3)
+      })
+
+      test('endLine event occurred once', () => {
+        assert.strictEqual(log.counts.endLine, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('two values not separated by newline, ndjson=true:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream, { ndjson: true })
+
+        stream.push('[]"foo"')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('dataError event occurred five times', () => {
+        assert.strictEqual(log.counts.dataError, 5)
+      })
+
+      test('string event did not occurr', () => {
+        assert.strictEqual(log.counts.string, 0)
+      })
+
+      test('endLine event did not occur', () => {
+        assert.strictEqual(log.counts.endLine, 0)
+      })
+    })
+
+    suite('two values separated by two newlines, ndjson=true:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream, { ndjson: true })
+
+        stream.push('[]\r\n\r\n"foo"')
+        stream.push(null)
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('endLine event occurred twice', () => {
+        assert.strictEqual(log.counts.endLine, 2)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
+    suite('chunked ndjson:', () => {
+      let stream, emitter
+
+      setup(done => {
+        stream = new Readable()
+        stream._read = () => {}
+
+        emitter = walk(stream, { ndjson: true })
+
+        stream.push('[]')
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+
+        setTimeout(stream.push.bind(stream, ' '), 20)
+        setTimeout(stream.push.bind(stream, '\n'), 40)
+        setTimeout(stream.push.bind(stream, ' '), 60)
+        setTimeout(stream.push.bind(stream, '"'), 80)
+        setTimeout(stream.push.bind(stream, 'foo"'), 100)
+        setTimeout(stream.push.bind(stream, null), 120)
+      })
+
+      test('array event occurred once', () => {
+        assert.strictEqual(log.counts.array, 1)
+      })
+
+      test('endArray event occurred once', () => {
+        assert.strictEqual(log.counts.endArray, 1)
+      })
+
+      test('endLine event occurred once', () => {
+        assert.strictEqual(log.counts.endLine, 1)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('end event occurred once', () => {
+        assert.strictEqual(log.counts.end, 1)
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+  })
+})
Index: frontend/node_modules/bfj/test/unit/write.js
===================================================================
--- frontend/node_modules/bfj/test/unit/write.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/bfj/test/unit/write.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,260 @@
+'use strict'
+
+const assert = require('chai').assert
+const proxyquire = require('proxyquire')
+const spooks = require('spooks')
+const Promise = require('bluebird')
+
+const modulePath = '../../src/write'
+
+suite('write:', () => {
+  test('require does not throw', () => {
+    assert.doesNotThrow(() => {
+      require(modulePath)
+    })
+  })
+
+  test('require returns function', () => {
+    assert.isFunction(require(modulePath))
+  })
+
+  suite('require:', () => {
+    let log, results, write
+
+    setup(() => {
+      log = {}
+      results = {
+        createWriteStream: [ {} ]
+      }
+
+      write = proxyquire(modulePath, {
+        'fs': {
+          createWriteStream: spooks.fn({
+            name: 'createWriteStream',
+            log: log,
+            results: results.createWriteStream
+          })
+        },
+        './streamify': spooks.fn({
+          name: 'streamify',
+          log: log,
+          results: [
+            {
+              pipe: spooks.fn({ name: 'pipe', log: log, chain: true }),
+              on: spooks.fn({ name: 'on', log: log, chain: true })
+            }
+          ]
+        })
+      })
+    })
+
+    test('write expects three arguments', () => {
+      assert.lengthOf(write, 3)
+    })
+
+    test('write does not throw', () => {
+      assert.doesNotThrow(() => {
+        write()
+      })
+    })
+
+    test('streamify was not called', () => {
+      assert.strictEqual(log.counts.streamify, 0)
+    })
+
+    test('fs.createWriteStream was not called', () => {
+      assert.strictEqual(log.counts.createWriteStream, 0)
+    })
+
+    test('stream.pipe was not called', () => {
+      assert.strictEqual(log.counts.pipe, 0)
+    })
+
+    test('stream.on was not called', () => {
+      assert.strictEqual(log.counts.on, 0)
+    })
+
+    suite('write:', () => {
+      let path, data, options, result
+
+      setup(() => {
+        path = {}
+        data = {}
+        options = {}
+        result = write(path, data, options)
+      })
+
+      test('streamify was called once', () => {
+        assert.strictEqual(log.counts.streamify, 1)
+        assert.isUndefined(log.these.streamify[0])
+      })
+
+      test('streamify was called correctly', () => {
+        assert.lengthOf(log.args.streamify[0], 2)
+        assert.strictEqual(log.args.streamify[0][0], data)
+        assert.lengthOf(Object.keys(log.args.streamify[0][0]), 0)
+        assert.strictEqual(log.args.streamify[0][1], options)
+        assert.lengthOf(Object.keys(log.args.streamify[0][1]), 0)
+      })
+
+      test('fs.createWriteStream was called once', () => {
+        assert.strictEqual(log.counts.createWriteStream, 1)
+      })
+
+      test('fs.createWriteStream was called correctly', () => {
+        assert.lengthOf(log.args.createWriteStream[0], 2)
+        assert.strictEqual(log.args.createWriteStream[0][0], path)
+        assert.lengthOf(Object.keys(log.args.createWriteStream[0][0]), 0)
+        assert.strictEqual(log.args.createWriteStream[0][1], options)
+        assert.lengthOf(Object.keys(log.args.createWriteStream[0][1]), 0)
+      })
+
+      test('stream.pipe was called once', () => {
+        assert.strictEqual(log.counts.pipe, 1)
+      })
+
+      test('stream.pipe was called correctly', () => {
+        assert.lengthOf(log.args.pipe[0], 1)
+        assert.strictEqual(log.args.pipe[0][0], results.createWriteStream[0])
+        assert.lengthOf(Object.keys(log.args.pipe[0][0]), 0)
+      })
+
+      test('stream.on was called three times', () => {
+        assert.strictEqual(log.counts.on, 3)
+      })
+
+      test('stream.on was called correctly first time', () => {
+        assert.lengthOf(log.args.on[0], 2)
+        assert.strictEqual(log.args.on[0][0], 'finish')
+        assert.isFunction(log.args.on[0][1])
+      })
+
+      test('stream.on was called correctly second time', () => {
+        assert.lengthOf(log.args.on[1], 2)
+        assert.strictEqual(log.args.on[1][0], 'error')
+        assert.isFunction(log.args.on[1][1])
+        assert.notStrictEqual(log.args.on[1][1], log.args.on[0][1])
+      })
+
+      test('stream.on was called correctly third time', () => {
+        assert.lengthOf(log.args.on[2], 2)
+        assert.strictEqual(log.args.on[2][0], 'dataError')
+        assert.isFunction(log.args.on[2][1])
+        assert.notStrictEqual(log.args.on[2][1], log.args.on[0][1])
+        assert.strictEqual(log.args.on[2][1], log.args.on[1][1])
+      })
+
+      test('promise was returned', () => {
+        assert.instanceOf(result, Promise)
+      })
+
+      suite('dispatch finish event:', () => {
+        let resolved, error, passed, failed
+
+        setup(done => {
+          passed = failed = false
+
+          result.then(res => {
+            resolved = res
+            passed = true
+            done()
+          }).catch(err => {
+            error = err
+            failed = true
+            done()
+          })
+          log.args.on[0][1]('foo')
+        })
+
+        test('promise was resolved', () => {
+          assert.isTrue(passed)
+          assert.isFalse(failed)
+          assert.isUndefined(resolved)
+        })
+      })
+
+      suite('dispatch error event:', () => {
+        let resolved, error, passed, failed
+
+        setup(done => {
+          passed = failed = false
+
+          result.then(r => {
+            resolved = r
+            passed = true
+            done()
+          }).catch(e => {
+            error = e
+            failed = true
+            done()
+          })
+          log.args.on[1][1]('foo')
+        })
+
+        test('promise was rejected', () => {
+          assert.isTrue(failed)
+          assert.isFalse(passed)
+          assert.strictEqual(error, 'foo')
+        })
+      })
+
+      suite('dispatch dataError event:', () => {
+        let resolved, error, passed, failed
+
+        setup(done => {
+          passed = failed = false
+
+          result.then(r => {
+            resolved = r
+            passed = true
+            done()
+          }).catch(e => {
+            error = e
+            failed = true
+            done()
+          })
+          log.args.on[2][1]('wibble')
+        })
+
+        test('promise was rejected', () => {
+          assert.isTrue(failed)
+          assert.isFalse(passed)
+          assert.strictEqual(error, 'wibble')
+        })
+      })
+    })
+  })
+})
+
+suite('write with error thrown by fs.createWriteStream:', () => {
+  let write
+
+  setup(() => {
+    write = proxyquire(modulePath, {
+      fs: {
+        createWriteStream () {
+          throw new Error('foo')
+        }
+      },
+      './streamify': () => ({
+        pipe: spooks.fn({ name: 'pipe', log: {}, chain: true }),
+        on: spooks.fn({ name: 'on', log: {}, chain: true })
+      })
+    })
+  })
+
+  test('write does not throw', () => {
+    assert.doesNotThrow(() => {
+      write().catch(() => {})
+    })
+  })
+
+  test('write rejects', () => {
+    write()
+      .then(() => assert.fail('write should reject'))
+      .catch(error => {
+        assert.instanceOf(error, Error)
+        assert.equal(error.message, 'foo')
+      })
+  })
+})