FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/abstract-leveldown/test/batch-test.js

@@ -0,0 +1,318 @@
+var db
+var verifyNotFoundError = require('./util').verifyNotFoundError
+var isTypedArray = require('./util').isTypedArray
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+  test('setUp db', function (t) {
+    db = testCommon.factory()
+    db.open(t.end.bind(t))
+  })
+}
+
+exports.args = function (test, testCommon) {
+  test('test callback-less, 2-arg, batch() throws', function (t) {
+    t.throws(
+      db.batch.bind(db, 'foo', {}),
+      /Error: batch\(array\) requires a callback argument/,
+      'callback-less, 2-arg batch() throws'
+    )
+    t.end()
+  })
+
+  test('test batch() with missing `value`', function (t) {
+    db.batch([{ type: 'put', key: 'foo1' }], function (err) {
+      t.is(err.message, 'value cannot be `null` or `undefined`', 'correct error message')
+      t.end()
+    })
+  })
+
+  test('test batch() with null or undefined `value`', function (t) {
+    var illegalValues = [null, undefined]
+
+    t.plan(illegalValues.length)
+
+    illegalValues.forEach(function (value) {
+      db.batch([{ type: 'put', key: 'foo1', value: value }], function (err) {
+        t.is(err.message, 'value cannot be `null` or `undefined`', 'correct error message')
+      })
+    })
+  })
+
+  test('test batch() with missing `key`', function (t) {
+    var async = false
+
+    db.batch([{ type: 'put', value: 'foo1' }], function (err) {
+      t.ok(err, 'got error')
+      t.equal(err.message, 'key cannot be `null` or `undefined`', 'correct error message')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+
+  test('test batch() with null or undefined `key`', function (t) {
+    var illegalKeys = [null, undefined]
+
+    t.plan(illegalKeys.length * 3)
+
+    illegalKeys.forEach(function (key) {
+      var async = false
+
+      db.batch([{ type: 'put', key: key, value: 'foo1' }], function (err) {
+        t.ok(err, 'got error')
+        t.equal(err.message, 'key cannot be `null` or `undefined`', 'correct error message')
+        t.ok(async, 'callback is asynchronous')
+      })
+
+      async = true
+    })
+  })
+
+  test('test batch() with empty `key`', function (t) {
+    var illegalKeys = [
+      { type: 'String', key: '' },
+      { type: 'Buffer', key: Buffer.alloc(0) },
+      { type: 'Array', key: [] }
+    ]
+
+    t.plan(illegalKeys.length * 3)
+
+    illegalKeys.forEach(function (item) {
+      var async = false
+
+      db.batch([{ type: 'put', key: item.key, value: 'foo1' }], function (err) {
+        t.ok(err, 'got error')
+        t.equal(err.message, 'key cannot be an empty ' + item.type, 'correct error message')
+        t.ok(async, 'callback is asynchronous')
+      })
+
+      async = true
+    })
+  })
+
+  test('test batch() with missing `key` and `value`', function (t) {
+    var async = false
+
+    db.batch([{ type: 'put' }], function (err) {
+      t.ok(err, 'got error')
+      t.equal(err.message, 'key cannot be `null` or `undefined`', 'correct error message')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+
+  test('test batch() with missing `type`', function (t) {
+    var async = false
+
+    db.batch([{ key: 'key', value: 'value' }], function (err) {
+      t.ok(err, 'got error')
+      t.equal(err.message, "`type` must be 'put' or 'del'", 'correct error message')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+
+  test('test batch() with wrong `type`', function (t) {
+    var async = false
+
+    db.batch([{ key: 'key', value: 'value', type: 'foo' }], function (err) {
+      t.ok(err, 'got error')
+      t.equal(err.message, "`type` must be 'put' or 'del'", 'correct error message')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+
+  test('test batch() with missing array', function (t) {
+    var async = false
+
+    db.batch(function (err) {
+      t.ok(err, 'got error')
+      t.equal(err.message, 'batch(array) requires an array argument', 'correct error message')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+
+  test('test batch() with undefined array', function (t) {
+    var async = false
+
+    db.batch(undefined, function (err) {
+      t.ok(err, 'got error')
+      t.equal(err.message, 'batch(array) requires an array argument', 'correct error message')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+
+  test('test batch() with null array', function (t) {
+    var async = false
+
+    db.batch(null, function (err) {
+      t.ok(err, 'got error')
+      t.equal(err.message, 'batch(array) requires an array argument', 'correct error message')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+
+  test('test batch() with null options', function (t) {
+    db.batch([], null, function (err) {
+      t.error(err)
+      t.end()
+    })
+  })
+
+  ;[null, undefined, 1, true].forEach(function (element) {
+    var type = element === null ? 'null' : typeof element
+
+    test('test batch() with ' + type + ' element', function (t) {
+      var async = false
+
+      db.batch([element], function (err) {
+        t.ok(err, 'got error')
+        t.equal(err.message, 'batch(array) element must be an object and not `null`', 'correct error message')
+        t.ok(async, 'callback is asynchronous')
+        t.end()
+      })
+
+      async = true
+    })
+  })
+
+  test('test batch() with empty array', function (t) {
+    var async = false
+
+    db.batch([], function (err) {
+      t.error(err, 'no error from batch()')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+}
+
+exports.batch = function (test, testCommon) {
+  test('test simple batch()', function (t) {
+    db.batch([{ type: 'put', key: 'foo', value: 'bar' }], function (err) {
+      t.error(err)
+
+      db.get('foo', function (err, value) {
+        t.error(err)
+        var result
+        if (isTypedArray(value)) {
+          result = String.fromCharCode.apply(null, new Uint16Array(value))
+        } else {
+          t.ok(typeof Buffer !== 'undefined' && value instanceof Buffer)
+          result = value.toString()
+        }
+        t.equal(result, 'bar')
+        t.end()
+      })
+    })
+  })
+
+  test('test multiple batch()', function (t) {
+    db.batch([
+      { type: 'put', key: 'foobatch1', value: 'bar1' },
+      { type: 'put', key: 'foobatch2', value: 'bar2' },
+      { type: 'put', key: 'foobatch3', value: 'bar3' },
+      { type: 'del', key: 'foobatch2' }
+    ], function (err) {
+      t.error(err)
+
+      var r = 0
+      var done = function () {
+        if (++r === 3) { t.end() }
+      }
+
+      db.get('foobatch1', function (err, value) {
+        t.error(err)
+        var result
+        if (isTypedArray(value)) {
+          result = String.fromCharCode.apply(null, new Uint16Array(value))
+        } else {
+          t.ok(typeof Buffer !== 'undefined' && value instanceof Buffer)
+          result = value.toString()
+        }
+        t.equal(result, 'bar1')
+        done()
+      })
+
+      db.get('foobatch2', function (err, value) {
+        t.ok(err, 'entry not found')
+        t.ok(typeof value === 'undefined', 'value is undefined')
+        t.ok(verifyNotFoundError(err), 'NotFound error')
+        done()
+      })
+
+      db.get('foobatch3', function (err, value) {
+        t.error(err)
+        var result
+        if (isTypedArray(value)) {
+          result = String.fromCharCode.apply(null, new Uint16Array(value))
+        } else {
+          t.ok(typeof Buffer !== 'undefined' && value instanceof Buffer)
+          result = value.toString()
+        }
+        t.equal(result, 'bar3')
+        done()
+      })
+    })
+  })
+}
+
+exports.atomic = function (test, testCommon) {
+  test('test multiple batch()', function (t) {
+    t.plan(4)
+
+    var async = false
+
+    db.batch([
+      { type: 'put', key: 'foobah1', value: 'bar1' },
+      { type: 'put', value: 'bar2' },
+      { type: 'put', key: 'foobah3', value: 'bar3' }
+    ], function (err) {
+      t.ok(err, 'should error')
+      t.ok(async, 'callback is asynchronous')
+
+      db.get('foobah1', function (err) {
+        t.ok(err, 'should not be found')
+      })
+      db.get('foobah3', function (err) {
+        t.ok(err, 'should not be found')
+      })
+    })
+
+    async = true
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', function (t) {
+    db.close(testCommon.tearDown.bind(null, t))
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.batch(test, testCommon)
+  exports.atomic(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/chained-batch-test.js

@@ -0,0 +1,298 @@
+var collectEntries = require('level-concat-iterator')
+
+var db
+
+function collectBatchOps (batch) {
+  var _put = batch._put
+  var _del = batch._del
+  var _operations = []
+
+  if (typeof _put !== 'function' || typeof _del !== 'function') {
+    return batch._operations
+  }
+
+  batch._put = function (key, value) {
+    _operations.push({ type: 'put', key: key, value: value })
+    return _put.apply(this, arguments)
+  }
+
+  batch._del = function (key) {
+    _operations.push({ type: 'del', key: key })
+    return _del.apply(this, arguments)
+  }
+
+  return _operations
+}
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+  test('setUp db', function (t) {
+    db = testCommon.factory()
+    db.open(t.end.bind(t))
+  })
+}
+
+exports.args = function (test, testCommon) {
+  test('test batch has db reference', function (t) {
+    t.ok(db.batch().db === db)
+    t.end()
+  })
+
+  test('test batch#put() with missing `value`', function (t) {
+    t.plan(1)
+
+    try {
+      db.batch().put('foo1')
+    } catch (err) {
+      t.is(err.message, 'value cannot be `null` or `undefined`', 'correct error message')
+    }
+  })
+
+  test('test batch#put() with missing `key`', function (t) {
+    try {
+      db.batch().put(undefined, 'foo1')
+    } catch (err) {
+      t.equal(err.message, 'key cannot be `null` or `undefined`', 'correct error message')
+      return t.end()
+    }
+    t.fail('should have thrown')
+    t.end()
+  })
+
+  test('test batch#put() with null `key`', function (t) {
+    try {
+      db.batch().put(null, 'foo1')
+    } catch (err) {
+      t.equal(err.message, 'key cannot be `null` or `undefined`', 'correct error message')
+      return t.end()
+    }
+    t.fail('should have thrown')
+    t.end()
+  })
+
+  test('test batch#put() with missing `key` and `value`', function (t) {
+    try {
+      db.batch().put()
+    } catch (err) {
+      t.equal(err.message, 'key cannot be `null` or `undefined`', 'correct error message')
+      return t.end()
+    }
+    t.fail('should have thrown')
+    t.end()
+  })
+
+  test('test batch#put() with null or undefined `value`', function (t) {
+    var illegalValues = [null, undefined]
+    t.plan(illegalValues.length)
+
+    illegalValues.forEach(function (value) {
+      try {
+        db.batch().put('key', value)
+      } catch (err) {
+        t.is(err.message, 'value cannot be `null` or `undefined`', 'correct error message')
+      }
+    })
+  })
+
+  test('test batch#del() with missing `key`', function (t) {
+    try {
+      db.batch().del()
+    } catch (err) {
+      t.equal(err.message, 'key cannot be `null` or `undefined`', 'correct error message')
+      return t.end()
+    }
+    t.fail('should have thrown')
+    t.end()
+  })
+
+  test('test batch#del() with null or undefined `key`', function (t) {
+    var illegalKeys = [null, undefined]
+    t.plan(illegalKeys.length)
+
+    illegalKeys.forEach(function (key) {
+      try {
+        db.batch().del(key)
+      } catch (err) {
+        t.equal(err.message, 'key cannot be `null` or `undefined`', 'correct error message')
+      }
+    })
+  })
+
+  test('test batch#clear() doesn\'t throw', function (t) {
+    db.batch().clear()
+    t.end()
+  })
+
+  test('test batch#write() with no callback', function (t) {
+    try {
+      db.batch().write()
+    } catch (err) {
+      t.equal(err.message, 'write() requires a callback argument', 'correct error message')
+      return t.end()
+    }
+    t.fail('should have thrown')
+    t.end()
+  })
+
+  test('test batch#put() after write()', function (t) {
+    var batch = db.batch().put('foo', 'bar')
+    batch.write(function () {})
+    try {
+      batch.put('boom', 'bang')
+    } catch (err) {
+      t.equal(err.message, 'write() already called on this batch', 'correct error message')
+      return t.end()
+    }
+    t.fail('should have thrown')
+    t.end()
+  })
+
+  test('test batch#del() after write()', function (t) {
+    var batch = db.batch().put('foo', 'bar')
+    batch.write(function () {})
+    try {
+      batch.del('foo')
+    } catch (err) {
+      t.equal(err.message, 'write() already called on this batch', 'correct error message')
+      return t.end()
+    }
+    t.fail('should have thrown')
+    t.end()
+  })
+
+  test('test batch#clear() after write()', function (t) {
+    var batch = db.batch().put('foo', 'bar')
+    batch.write(function () {})
+    try {
+      batch.clear()
+    } catch (err) {
+      t.equal(err.message, 'write() already called on this batch', 'correct error message')
+      return t.end()
+    }
+    t.fail('should have thrown')
+    t.end()
+  })
+
+  test('test batch#write() after write()', function (t) {
+    var batch = db.batch().put('foo', 'bar')
+    batch.write(function () {})
+    try {
+      batch.write(function () {})
+    } catch (err) {
+      t.equal(err.message, 'write() already called on this batch', 'correct error message')
+      return t.end()
+    }
+    t.fail('should have thrown')
+    t.end()
+  })
+
+  test('test serialize object', function (t) {
+    var batch = db.batch()
+    var ops = collectBatchOps(batch)
+
+    batch
+      .put({ foo: 'bar' }, { beep: 'boop' })
+      .del({ bar: 'baz' })
+    ops.forEach(function (op) {
+      t.ok(op.key, '.key is set for .put and .del operations')
+      if (op.type === 'put') {
+        t.ok(op.value, '.value is set for .put operation')
+      }
+    })
+    t.end()
+  })
+
+  test('test custom _serialize*', function (t) {
+    t.plan(4)
+
+    var _db = Object.create(db)
+    var batch = _db.batch()
+    var ops = collectBatchOps(batch)
+
+    _db._serializeKey = function (key) {
+      t.same(key, { foo: 'bar' })
+      return 'key1'
+    }
+
+    _db._serializeValue = function (value) {
+      t.same(value, { beep: 'boop' })
+      return 'value1'
+    }
+
+    batch.put({ foo: 'bar' }, { beep: 'boop' })
+
+    _db._serializeKey = function (key) {
+      t.same(key, { bar: 'baz' })
+      return 'key2'
+    }
+
+    batch.del({ bar: 'baz' })
+
+    t.deepEqual(ops, [
+      { type: 'put', key: 'key1', value: 'value1' },
+      { type: 'del', key: 'key2' }
+    ])
+  })
+
+  test('test batch#write() with no operations', function (t) {
+    var async = false
+
+    db.batch().write(function (err) {
+      t.ifError(err, 'no error from write()')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+}
+
+exports.batch = function (test, testCommon) {
+  test('test basic batch', function (t) {
+    db.batch([
+      { type: 'put', key: 'one', value: '1' },
+      { type: 'put', key: 'two', value: '2' },
+      { type: 'put', key: 'three', value: '3' }
+    ], function (err) {
+      t.error(err)
+      db.batch()
+        .put('1', 'one')
+        .del('2', 'two')
+        .put('3', 'three')
+        .clear()
+        .put('one', 'I')
+        .put('two', 'II')
+        .del('three')
+        .put('foo', 'bar')
+        .write(function (err) {
+          t.error(err)
+          collectEntries(
+            db.iterator({ keyAsBuffer: false, valueAsBuffer: false }), function (err, data) {
+              t.error(err)
+              t.equal(data.length, 3, 'correct number of entries')
+              var expected = [
+                { key: 'foo', value: 'bar' },
+                { key: 'one', value: 'I' },
+                { key: 'two', value: 'II' }
+              ]
+              t.deepEqual(data, expected)
+              t.end()
+            }
+          )
+        })
+    })
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', function (t) {
+    db.close(testCommon.tearDown.bind(null, t))
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.batch(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/clear-range-test.js

@@ -0,0 +1,258 @@
+var concat = require('level-concat-iterator')
+
+var data = (function () {
+  var d = []
+  var i = 0
+  var k
+  for (; i < 100; i++) {
+    k = (i < 10 ? '0' : '') + i
+    d.push({
+      key: k,
+      value: String(Math.random())
+    })
+  }
+  return d
+}())
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+}
+
+exports.range = function (test, testCommon) {
+  function rangeTest (name, opts, expected) {
+    test('db#clear() with ' + name, function (t) {
+      prepare(t, function (db) {
+        db.clear(opts, function (err) {
+          t.ifError(err, 'no clear error')
+          verify(t, db, expected)
+        })
+      })
+    })
+  }
+
+  function prepare (t, callback) {
+    var db = testCommon.factory()
+
+    db.open(function (err) {
+      t.ifError(err, 'no open error')
+
+      db.batch(data.map(function (d) {
+        return {
+          type: 'put',
+          key: d.key,
+          value: d.value
+        }
+      }), function (err) {
+        t.ifError(err, 'no batch error')
+        callback(db)
+      })
+    })
+  }
+
+  function verify (t, db, expected) {
+    var it = db.iterator({ keyAsBuffer: false, valueAsBuffer: false })
+
+    concat(it, function (err, result) {
+      t.ifError(err, 'no concat error')
+      t.is(result.length, expected.length, 'correct number of entries')
+      t.same(result, expected)
+
+      db.close(t.end.bind(t))
+    })
+  }
+
+  function exclude (data, start, end, expectedLength) {
+    data = data.slice()
+    var removed = data.splice(start, end - start + 1) // Inclusive
+    if (expectedLength != null) checkLength(removed, expectedLength)
+    return data
+  }
+
+  // For sanity checks on test arguments
+  function checkLength (arr, length) {
+    if (arr.length !== length) {
+      throw new RangeError('Expected ' + length + ' elements, got ' + arr.length)
+    }
+
+    return arr
+  }
+
+  rangeTest('full range', {}, [])
+
+  // Reversing has no effect without limit
+  rangeTest('reverse=true', {
+    reverse: true
+  }, [])
+
+  rangeTest('gte=00', {
+    gte: '00'
+  }, [])
+
+  rangeTest('gte=50', {
+    gte: '50'
+  }, data.slice(0, 50))
+
+  rangeTest('lte=50 and reverse=true', {
+    lte: '50',
+    reverse: true
+  }, data.slice(51))
+
+  rangeTest('gte=49.5 (midway)', {
+    gte: '49.5'
+  }, data.slice(0, 50))
+
+  rangeTest('gte=49999 (midway)', {
+    gte: '49999'
+  }, data.slice(0, 50))
+
+  rangeTest('lte=49.5 (midway) and reverse=true', {
+    lte: '49.5',
+    reverse: true
+  }, data.slice(50))
+
+  rangeTest('lt=49.5 (midway) and reverse=true', {
+    lt: '49.5',
+    reverse: true
+  }, data.slice(50))
+
+  rangeTest('lt=50 and reverse=true', {
+    lt: '50',
+    reverse: true
+  }, data.slice(50))
+
+  rangeTest('lte=50', {
+    lte: '50'
+  }, data.slice(51))
+
+  rangeTest('lte=50.5 (midway)', {
+    lte: '50.5'
+  }, data.slice(51))
+
+  rangeTest('lte=50555 (midway)', {
+    lte: '50555'
+  }, data.slice(51))
+
+  rangeTest('lt=50555 (midway)', {
+    lt: '50555'
+  }, data.slice(51))
+
+  rangeTest('gte=50.5 (midway) and reverse=true', {
+    gte: '50.5',
+    reverse: true
+  }, data.slice(0, 51))
+
+  rangeTest('gt=50.5 (midway) and reverse=true', {
+    gt: '50.5',
+    reverse: true
+  }, data.slice(0, 51))
+
+  rangeTest('gt=50 and reverse=true', {
+    gt: '50',
+    reverse: true
+  }, data.slice(0, 51))
+
+  // Starting key is actually '00' so it should avoid it
+  rangeTest('lte=0', {
+    lte: '0'
+  }, data)
+
+  // Starting key is actually '00' so it should avoid it
+  rangeTest('lt=0', {
+    lt: '0'
+  }, data)
+
+  rangeTest('gte=30 and lte=70', {
+    gte: '30',
+    lte: '70'
+  }, exclude(data, 30, 70))
+
+  rangeTest('gt=29 and lt=71', {
+    gt: '29',
+    lt: '71'
+  }, exclude(data, 30, 70))
+
+  rangeTest('gte=30 and lte=70 and reverse=true', {
+    lte: '70',
+    gte: '30',
+    reverse: true
+  }, exclude(data, 30, 70))
+
+  rangeTest('gt=29 and lt=71 and reverse=true', {
+    lt: '71',
+    gt: '29',
+    reverse: true
+  }, exclude(data, 30, 70))
+
+  rangeTest('limit=20', {
+    limit: 20
+  }, data.slice(20))
+
+  rangeTest('limit=20 and gte=20', {
+    limit: 20,
+    gte: '20'
+  }, exclude(data, 20, 39, 20))
+
+  rangeTest('limit=20 and reverse=true', {
+    limit: 20,
+    reverse: true
+  }, data.slice(0, -20))
+
+  rangeTest('limit=20 and lte=79 and reverse=true', {
+    limit: 20,
+    lte: '79',
+    reverse: true
+  }, exclude(data, 60, 79, 20))
+
+  rangeTest('limit=-1 should clear whole database', {
+    limit: -1
+  }, [])
+
+  rangeTest('limit=0 should not clear anything', {
+    limit: 0
+  }, data)
+
+  rangeTest('lte after limit', {
+    limit: 20,
+    lte: '50'
+  }, data.slice(20))
+
+  rangeTest('lte before limit', {
+    limit: 50,
+    lte: '19'
+  }, data.slice(20))
+
+  rangeTest('gte after database end', {
+    gte: '9a'
+  }, data)
+
+  rangeTest('gt after database end', {
+    gt: '9a'
+  }, data)
+
+  rangeTest('lte after database end and reverse=true', {
+    lte: '9a',
+    reverse: true
+  }, [])
+
+  rangeTest('lte and gte after database and reverse=true', {
+    lte: '9b',
+    gte: '9a',
+    reverse: true
+  }, data)
+
+  rangeTest('lt and gt after database and reverse=true', {
+    lt: '9b',
+    gt: '9a',
+    reverse: true
+  }, data)
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', testCommon.tearDown)
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.range(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/clear-test.js

@@ -0,0 +1,83 @@
+var concat = require('level-concat-iterator')
+var db
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+  test('setUp db', function (t) {
+    db = testCommon.factory()
+    db.open(t.end.bind(t))
+  })
+}
+
+exports.args = function (test, testCommon) {
+  test('test argument-less clear() throws', function (t) {
+    t.throws(
+      db.clear.bind(db),
+      /Error: clear\(\) requires a callback argument/,
+      'no-arg clear() throws'
+    )
+    t.end()
+  })
+}
+
+exports.clear = function (test, testCommon) {
+  makeTest('string', ['a', 'b'])
+
+  if (testCommon.bufferKeys) {
+    makeTest('buffer', [Buffer.from('a'), Buffer.from('b')])
+    makeTest('mixed', [Buffer.from('a'), 'b'])
+
+    // These keys would be equal when compared as utf8 strings
+    makeTest('non-utf8 buffer', [Buffer.from('80', 'hex'), Buffer.from('c0', 'hex')])
+  }
+
+  function makeTest (type, keys) {
+    test('test simple clear() on ' + type + ' keys', function (t) {
+      t.plan(8)
+
+      var db = testCommon.factory()
+      var ops = keys.map(function (key) {
+        return { type: 'put', key: key, value: 'foo' }
+      })
+
+      db.open(function (err) {
+        t.ifError(err, 'no open error')
+
+        db.batch(ops, function (err) {
+          t.ifError(err, 'no batch error')
+
+          concat(db.iterator(), function (err, entries) {
+            t.ifError(err, 'no concat error')
+            t.is(entries.length, keys.length, 'has entries')
+
+            db.clear(function (err) {
+              t.ifError(err, 'no clear error')
+
+              concat(db.iterator(), function (err, entries) {
+                t.ifError(err, 'no concat error')
+                t.is(entries.length, 0, 'has no entries')
+
+                db.close(function (err) {
+                  t.ifError(err, 'no close error')
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+  }
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', function (t) {
+    db.close(testCommon.tearDown.bind(null, t))
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.clear(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/close-test.js

@@ -0,0 +1,39 @@
+var db
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+  test('setUp db', function (t) {
+    db = testCommon.factory()
+    db.open(t.end.bind(t))
+  })
+}
+
+exports.close = function (test, testCommon) {
+  test('test close()', function (t) {
+    t.throws(
+      db.close.bind(db),
+      /Error: close\(\) requires a callback argument/,
+      'no-arg close() throws'
+    )
+    t.throws(
+      db.close.bind(db, 'foo'),
+      /Error: close\(\) requires a callback argument/,
+      'non-callback close() throws'
+    )
+
+    db.close(function (err) {
+      t.error(err)
+      t.end()
+    })
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', testCommon.tearDown)
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.close(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/common.js

@@ -0,0 +1,37 @@
+function testCommon (options) {
+  var factory = options.factory
+  var test = options.test
+
+  if (typeof factory !== 'function') {
+    throw new TypeError('factory must be a function')
+  }
+
+  if (typeof test !== 'function') {
+    throw new TypeError('test must be a function')
+  }
+
+  return {
+    test: test,
+    factory: factory,
+
+    // TODO (next major): remove
+    setUp: options.setUp || noopTest(),
+    tearDown: options.tearDown || noopTest(),
+
+    // TODO (next major): use db.supports instead
+    bufferKeys: options.bufferKeys !== false,
+    createIfMissing: options.createIfMissing !== false,
+    errorIfExists: options.errorIfExists !== false,
+    snapshots: options.snapshots !== false,
+    seek: options.seek !== false,
+    clear: !!options.clear
+  }
+}
+
+function noopTest () {
+  return function (t) {
+    t.end()
+  }
+}
+
+module.exports = testCommon

node_modules/abstract-leveldown/test/del-test.js

@@ -0,0 +1,92 @@
+var db
+var verifyNotFoundError = require('./util').verifyNotFoundError
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+  test('setUp db', function (t) {
+    db = testCommon.factory()
+    db.open(t.end.bind(t))
+  })
+}
+
+exports.args = function (test, testCommon) {
+  test('test argument-less del() throws', function (t) {
+    t.throws(
+      db.del.bind(db),
+      /Error: del\(\) requires a callback argument/,
+      'no-arg del() throws'
+    )
+    t.end()
+  })
+
+  test('test callback-less, 1-arg, del() throws', function (t) {
+    t.throws(
+      db.del.bind(db, 'foo'),
+      /Error: del\(\) requires a callback argument/,
+      'callback-less, 1-arg del() throws'
+    )
+    t.end()
+  })
+
+  test('test callback-less, 3-arg, del() throws', function (t) {
+    t.throws(
+      db.del.bind(db, 'foo', {}),
+      /Error: del\(\) requires a callback argument/,
+      'callback-less, 2-arg del() throws'
+    )
+    t.end()
+  })
+
+  test('test custom _serialize*', function (t) {
+    t.plan(3)
+    var db = testCommon.factory()
+    db._serializeKey = function (data) { return data }
+    db._del = function (key, options, callback) {
+      t.deepEqual(key, { foo: 'bar' })
+      process.nextTick(callback)
+    }
+    db.open(function () {
+      db.del({ foo: 'bar' }, function (err) {
+        t.error(err)
+        db.close(t.error.bind(t))
+      })
+    })
+  })
+}
+
+exports.del = function (test, testCommon) {
+  test('test simple del()', function (t) {
+    db.put('foo', 'bar', function (err) {
+      t.error(err)
+      db.del('foo', function (err) {
+        t.error(err)
+        db.get('foo', function (err, value) {
+          t.ok(err, 'entry properly deleted')
+          t.ok(typeof value === 'undefined', 'value is undefined')
+          t.ok(verifyNotFoundError(err), 'NotFound error')
+          t.end()
+        })
+      })
+    })
+  })
+
+  test('test del on non-existent key', function (t) {
+    db.del('blargh', function (err) {
+      t.error(err)
+      t.end()
+    })
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', function (t) {
+    db.close(testCommon.tearDown.bind(null, t))
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.del(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/factory-test.js

@@ -0,0 +1,37 @@
+var concat = require('level-concat-iterator')
+
+module.exports = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+
+  test('testCommon.factory() returns a unique database', function (t) {
+    var db1 = testCommon.factory()
+    var db2 = testCommon.factory()
+
+    function close () {
+      db1.close(function (err) {
+        t.error(err, 'no error while closing db1')
+        db2.close(function (err) {
+          t.error(err, 'no error while closing db2')
+          t.end()
+        })
+      })
+    }
+
+    db1.open(function (err) {
+      t.error(err, 'no error while opening db1')
+      db2.open(function (err) {
+        t.error(err, 'no error while opening db2')
+        db1.put('key', 'value', function (err) {
+          t.error(err, 'put key in db1')
+          concat(db2.iterator(), function (err, entries) {
+            t.error(err, 'got items from db2')
+            t.same(entries, [], 'db2 should be empty')
+            close()
+          })
+        })
+      })
+    })
+  })
+
+  test('tearDown', testCommon.tearDown)
+}

node_modules/abstract-leveldown/test/get-test.js

@@ -0,0 +1,169 @@
+var db
+var verifyNotFoundError = require('./util').verifyNotFoundError
+var isTypedArray = require('./util').isTypedArray
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+  test('setUp db', function (t) {
+    db = testCommon.factory()
+    db.open(t.end.bind(t))
+  })
+}
+
+exports.args = function (test, testCommon) {
+  test('test argument-less get() throws', function (t) {
+    t.throws(
+      db.get.bind(db),
+      /Error: get\(\) requires a callback argument/,
+      'no-arg get() throws'
+    )
+    t.end()
+  })
+
+  test('test callback-less, 1-arg, get() throws', function (t) {
+    t.throws(
+      db.get.bind(db, 'foo'),
+      /Error: get\(\) requires a callback argument/,
+      'callback-less, 1-arg get() throws'
+    )
+    t.end()
+  })
+
+  test('test callback-less, 3-arg, get() throws', function (t) {
+    t.throws(
+      db.get.bind(db, 'foo', {}),
+      /Error: get\(\) requires a callback argument/,
+      'callback-less, 2-arg get() throws'
+    )
+    t.end()
+  })
+
+  test('test custom _serialize*', function (t) {
+    t.plan(3)
+    var db = testCommon.factory()
+    db._serializeKey = function (data) { return data }
+    db._get = function (key, options, callback) {
+      t.deepEqual(key, { foo: 'bar' })
+      process.nextTick(callback)
+    }
+    db.open(function () {
+      db.get({ foo: 'bar' }, function (err) {
+        t.error(err)
+        db.close(t.error.bind(t))
+      })
+    })
+  })
+}
+
+exports.get = function (test, testCommon) {
+  test('test simple get()', function (t) {
+    db.put('foo', 'bar', function (err) {
+      t.error(err)
+      db.get('foo', function (err, value) {
+        t.error(err)
+        t.ok(typeof value !== 'string', 'should not be string by default')
+
+        var result
+        if (isTypedArray(value)) {
+          result = String.fromCharCode.apply(null, new Uint16Array(value))
+        } else {
+          t.ok(typeof Buffer !== 'undefined' && value instanceof Buffer)
+          try {
+            result = value.toString()
+          } catch (e) {
+            t.error(e, 'should not throw when converting value to a string')
+          }
+        }
+
+        t.equal(result, 'bar')
+
+        db.get('foo', {}, function (err, value) { // same but with {}
+          t.error(err)
+          t.ok(typeof value !== 'string', 'should not be string by default')
+
+          var result
+          if (isTypedArray(value)) {
+            result = String.fromCharCode.apply(null, new Uint16Array(value))
+          } else {
+            t.ok(typeof Buffer !== 'undefined' && value instanceof Buffer)
+            try {
+              result = value.toString()
+            } catch (e) {
+              t.error(e, 'should not throw when converting value to a string')
+            }
+          }
+
+          t.equal(result, 'bar')
+
+          db.get('foo', { asBuffer: false }, function (err, value) {
+            t.error(err)
+            t.ok(typeof value === 'string', 'should be string if not buffer')
+            t.equal(value, 'bar')
+            t.end()
+          })
+        })
+      })
+    })
+  })
+
+  test('test simultaniously get()', function (t) {
+    db.put('hello', 'world', function (err) {
+      t.error(err)
+      var r = 0
+      var done = function () {
+        if (++r === 20) { t.end() }
+      }
+      var i = 0
+      var j = 0
+
+      for (; i < 10; ++i) {
+        db.get('hello', function (err, value) {
+          t.error(err)
+          t.equal(value.toString(), 'world')
+          done()
+        })
+      }
+
+      for (; j < 10; ++j) {
+        db.get('not found', function (err, value) {
+          t.ok(err, 'should error')
+          t.ok(verifyNotFoundError(err), 'should have correct error message')
+          t.ok(typeof value === 'undefined', 'value is undefined')
+          done()
+        })
+      }
+    })
+  })
+
+  test('test get() not found error is asynchronous', function (t) {
+    t.plan(5)
+
+    db.put('hello', 'world', function (err) {
+      t.error(err)
+
+      var async = false
+
+      db.get('not found', function (err, value) {
+        t.ok(err, 'should error')
+        t.ok(verifyNotFoundError(err), 'should have correct error message')
+        t.ok(typeof value === 'undefined', 'value is undefined')
+        t.ok(async, 'callback is asynchronous')
+      })
+
+      async = true
+    })
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', function (t) {
+    db.close(testCommon.tearDown.bind(null, t))
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.get(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/index.js

@@ -0,0 +1,50 @@
+var common = require('./common')
+
+function suite (options) {
+  var testCommon = common(options)
+  var test = testCommon.test
+
+  require('./factory-test')(test, testCommon)
+  require('./manifest-test')(test, testCommon)
+
+  require('./leveldown-test')(test, testCommon)
+  require('./open-test').all(test, testCommon)
+  require('./close-test').all(test, testCommon)
+
+  if (testCommon.createIfMissing) {
+    require('./open-create-if-missing-test').all(test, testCommon)
+  }
+
+  if (testCommon.errorIfExists) {
+    require('./open-error-if-exists-test').all(test, testCommon)
+  }
+
+  require('./put-test').all(test, testCommon)
+  require('./get-test').all(test, testCommon)
+  require('./del-test').all(test, testCommon)
+  require('./put-get-del-test').all(test, testCommon)
+
+  require('./batch-test').all(test, testCommon)
+  require('./chained-batch-test').all(test, testCommon)
+
+  require('./iterator-test').all(test, testCommon)
+  require('./iterator-range-test').all(test, testCommon)
+
+  if (testCommon.seek) {
+    require('./iterator-seek-test').all(test, testCommon)
+  }
+
+  if (testCommon.snapshots) {
+    require('./iterator-snapshot-test').all(test, testCommon)
+  } else {
+    require('./iterator-no-snapshot-test').all(test, testCommon)
+  }
+
+  if (testCommon.clear) {
+    require('./clear-test').all(test, testCommon)
+    require('./clear-range-test').all(test, testCommon)
+  }
+}
+
+suite.common = common
+module.exports = suite

node_modules/abstract-leveldown/test/iterator-no-snapshot-test.js

@@ -0,0 +1,72 @@
+var collectEntries = require('level-concat-iterator')
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+}
+
+exports.noSnapshot = function (test, testCommon) {
+  function make (run) {
+    return function (t) {
+      var db = testCommon.factory()
+      var operations = [
+        { type: 'put', key: 'a', value: 'a' },
+        { type: 'put', key: 'b', value: 'b' },
+        { type: 'put', key: 'c', value: 'c' }
+      ]
+
+      db.open(function (err) {
+        t.ifError(err, 'no open error')
+
+        db.batch(operations, function (err) {
+          t.ifError(err, 'no batch error')
+
+          // For this test it is important that we don't read eagerly.
+          // NOTE: highWaterMark is not an abstract option atm, but
+          // it is supported by leveldown, rocksdb and others.
+          var it = db.iterator({ highWaterMark: 0 })
+
+          run(db, function (err) {
+            t.ifError(err, 'no run error')
+            verify(t, it, db)
+          })
+        })
+      })
+    }
+  }
+
+  function verify (t, it, db) {
+    collectEntries(it, function (err, entries) {
+      t.ifError(err, 'no iterator error')
+
+      var kv = entries.map(function (entry) {
+        return entry.key.toString() + entry.value.toString()
+      })
+
+      if (kv.length === 3) {
+        t.same(kv, ['aa', 'bb', 'cc'], 'maybe supports snapshots')
+      } else {
+        t.same(kv, ['aa', 'cc'], 'ignores keys that have been deleted in the mean time')
+      }
+
+      db.close(t.end.bind(t))
+    })
+  }
+
+  test('delete key after creating iterator', make(function (db, done) {
+    db.del('b', done)
+  }))
+
+  test('batch delete key after creating iterator', make(function (db, done) {
+    db.batch([{ type: 'del', key: 'b' }], done)
+  }))
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', testCommon.tearDown)
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.noSnapshot(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/iterator-range-test.js

@@ -0,0 +1,381 @@
+var collectEntries = require('level-concat-iterator')
+var xtend = require('xtend')
+
+var db
+
+var data = (function () {
+  var d = []
+  var i = 0
+  var k
+  for (; i < 100; i++) {
+    k = (i < 10 ? '0' : '') + i
+    d.push({
+      key: k,
+      value: String(Math.random())
+    })
+  }
+  return d
+}())
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+  test('setUp db', function (t) {
+    db = testCommon.factory()
+    db.open(function () {
+      db.batch(data.map(function (d) {
+        return {
+          type: 'put',
+          key: d.key,
+          value: d.value
+        }
+      }), t.end.bind(t))
+    })
+  })
+}
+
+exports.range = function (test, testCommon) {
+  function rangeTest (name, opts, expected) {
+    opts.keyAsBuffer = false
+    opts.valueAsBuffer = false
+    test(name, function (t) {
+      collectEntries(db.iterator(opts), function (err, result) {
+        t.error(err)
+        t.is(result.length, expected.length, 'correct number of entries')
+        t.same(result, expected)
+        t.end()
+      })
+    })
+
+    // Test the documented promise that in reverse mode,
+    // "the returned entries are the same, but in reverse".
+    if (!opts.reverse && !('limit' in opts)) {
+      var reverseOpts = xtend(opts, { reverse: true })
+
+      // Swap start & end options
+      if (('start' in opts) && ('end' in opts)) {
+        reverseOpts.end = opts.start
+        reverseOpts.start = opts.end
+      } else if ('start' in opts) {
+        reverseOpts.end = opts.start
+        delete reverseOpts.start
+      } else if ('end' in opts) {
+        reverseOpts.start = opts.end
+        delete reverseOpts.end
+      }
+
+      rangeTest(
+        name + ' (flipped)',
+        reverseOpts,
+        expected.slice().reverse()
+      )
+    }
+  }
+
+  rangeTest('test full data collection', {}, data)
+
+  rangeTest('test iterator with reverse=true', {
+    reverse: true
+  }, data.slice().reverse())
+
+  rangeTest('test iterator with gte=00', {
+    gte: '00'
+  }, data)
+
+  rangeTest('test iterator with start=00 - legacy', {
+    start: '00'
+  }, data)
+
+  rangeTest('test iterator with gte=50', {
+    gte: '50'
+  }, data.slice(50))
+
+  rangeTest('test iterator with start=50 - legacy', {
+    start: '50'
+  }, data.slice(50))
+
+  rangeTest('test iterator with lte=50 and reverse=true', {
+    lte: '50',
+    reverse: true
+  }, data.slice().reverse().slice(49))
+
+  rangeTest('test iterator with start=50 and reverse=true - legacy', {
+    start: '50',
+    reverse: true
+  }, data.slice().reverse().slice(49))
+
+  rangeTest('test iterator with gte=49.5 (midway)', {
+    gte: '49.5'
+  }, data.slice(50))
+
+  rangeTest('test iterator with start=49.5 (midway) - legacy', {
+    start: '49.5'
+  }, data.slice(50))
+
+  rangeTest('test iterator with gte=49999 (midway)', {
+    gte: '49999'
+  }, data.slice(50))
+
+  rangeTest('test iterator with start=49999 (midway) - legacy', {
+    start: '49999'
+  }, data.slice(50))
+
+  rangeTest('test iterator with lte=49.5 (midway) and reverse=true', {
+    lte: '49.5',
+    reverse: true
+  }, data.slice().reverse().slice(50))
+
+  rangeTest('test iterator with lt=49.5 (midway) and reverse=true', {
+    lt: '49.5',
+    reverse: true
+  }, data.slice().reverse().slice(50))
+
+  rangeTest('test iterator with lt=50 and reverse=true', {
+    lt: '50',
+    reverse: true
+  }, data.slice().reverse().slice(50))
+
+  rangeTest('test iterator with start=49.5 (midway) and reverse=true - legacy', {
+    start: '49.5',
+    reverse: true
+  }, data.slice().reverse().slice(50))
+
+  rangeTest('test iterator with lte=50', {
+    lte: '50'
+  }, data.slice(0, 51))
+
+  rangeTest('test iterator with end=50 - legacy', {
+    end: '50'
+  }, data.slice(0, 51))
+
+  rangeTest('test iterator with lte=50.5 (midway)', {
+    lte: '50.5'
+  }, data.slice(0, 51))
+
+  rangeTest('test iterator with end=50.5 (midway) - legacy', {
+    end: '50.5'
+  }, data.slice(0, 51))
+
+  rangeTest('test iterator with lte=50555 (midway)', {
+    lte: '50555'
+  }, data.slice(0, 51))
+
+  rangeTest('test iterator with lt=50555 (midway)', {
+    lt: '50555'
+  }, data.slice(0, 51))
+
+  rangeTest('test iterator with end=50555 (midway) - legacy', {
+    end: '50555'
+  }, data.slice(0, 51))
+
+  rangeTest('test iterator with gte=50.5 (midway) and reverse=true', {
+    gte: '50.5',
+    reverse: true
+  }, data.slice().reverse().slice(0, 49))
+
+  rangeTest('test iterator with gt=50.5 (midway) and reverse=true', {
+    gt: '50.5',
+    reverse: true
+  }, data.slice().reverse().slice(0, 49))
+
+  rangeTest('test iterator with end=50.5 (midway) and reverse=true - legacy', {
+    end: '50.5',
+    reverse: true
+  }, data.slice().reverse().slice(0, 49))
+
+  rangeTest('test iterator with gt=50 and reverse=true', {
+    gt: '50',
+    reverse: true
+  }, data.slice().reverse().slice(0, 49))
+
+  // end='0', starting key is actually '00' so it should avoid it
+  rangeTest('test iterator with lte=0', {
+    lte: '0'
+  }, [])
+
+  // end='0', starting key is actually '00' so it should avoid it
+  rangeTest('test iterator with lt=0', {
+    lt: '0'
+  }, [])
+
+  // end='0', starting key is actually '00' so it should avoid it
+  rangeTest('test iterator with end=0 - legacy', {
+    end: '0'
+  }, [])
+
+  rangeTest('test iterator with gte=30 and lte=70', {
+    gte: '30',
+    lte: '70'
+  }, data.slice(30, 71))
+
+  rangeTest('test iterator with gt=29 and lt=71', {
+    gt: '29',
+    lt: '71'
+  }, data.slice(30, 71))
+
+  rangeTest('test iterator with start=30 and end=70 - legacy', {
+    start: '30',
+    end: '70'
+  }, data.slice(30, 71))
+
+  rangeTest('test iterator with gte=30 and lte=70 and reverse=true', {
+    lte: '70',
+    gte: '30',
+    reverse: true
+  }, data.slice().reverse().slice(29, 70))
+
+  rangeTest('test iterator with gt=29 and lt=71 and reverse=true', {
+    lt: '71',
+    gt: '29',
+    reverse: true
+  }, data.slice().reverse().slice(29, 70))
+
+  rangeTest('test iterator with start=70 and end=30 and reverse=true - legacy', {
+    start: '70',
+    end: '30',
+    reverse: true
+  }, data.slice().reverse().slice(29, 70))
+
+  rangeTest('test iterator with limit=20', {
+    limit: 20
+  }, data.slice(0, 20))
+
+  rangeTest('test iterator with limit=20 and gte=20', {
+    limit: 20,
+    gte: '20'
+  }, data.slice(20, 40))
+
+  rangeTest('test iterator with limit=20 and start=20 - legacy', {
+    limit: 20,
+    start: '20'
+  }, data.slice(20, 40))
+
+  rangeTest('test iterator with limit=20 and reverse=true', {
+    limit: 20,
+    reverse: true
+  }, data.slice().reverse().slice(0, 20))
+
+  rangeTest('test iterator with limit=20 and lte=79 and reverse=true', {
+    limit: 20,
+    lte: '79',
+    reverse: true
+  }, data.slice().reverse().slice(20, 40))
+
+  rangeTest('test iterator with limit=20 and start=79 and reverse=true - legacy', {
+    limit: 20,
+    start: '79',
+    reverse: true
+  }, data.slice().reverse().slice(20, 40))
+
+  // the default limit value from levelup is -1
+  rangeTest('test iterator with limit=-1 should iterate over whole database', {
+    limit: -1
+  }, data)
+
+  rangeTest('test iterator with limit=0 should not iterate over anything', {
+    limit: 0
+  }, [])
+
+  rangeTest('test iterator with lte after limit', {
+    limit: 20,
+    lte: '50'
+  }, data.slice(0, 20))
+
+  rangeTest('test iterator with end after limit - legacy', {
+    limit: 20,
+    end: '50'
+  }, data.slice(0, 20))
+
+  rangeTest('test iterator with lte before limit', {
+    limit: 50,
+    lte: '19'
+  }, data.slice(0, 20))
+
+  rangeTest('test iterator with end before limit - legacy', {
+    limit: 50,
+    end: '19'
+  }, data.slice(0, 20))
+
+  rangeTest('test iterator with gte after database end', {
+    gte: '9a'
+  }, [])
+
+  rangeTest('test iterator with gt after database end', {
+    gt: '9a'
+  }, [])
+
+  rangeTest('test iterator with start after database end - legacy', {
+    start: '9a'
+  }, [])
+
+  rangeTest('test iterator with lte after database end and reverse=true', {
+    lte: '9a',
+    reverse: true
+  }, data.slice().reverse())
+
+  rangeTest('test iterator with start after database end and reverse=true - legacy', {
+    start: '9a',
+    reverse: true
+  }, data.slice().reverse())
+
+  rangeTest('test iterator with lt after database end', {
+    lt: 'a'
+  }, data.slice())
+
+  rangeTest('test iterator with end after database end - legacy', {
+    end: 'a'
+  }, data.slice())
+
+  rangeTest('test iterator with lt at database end', {
+    lt: data[data.length - 1].key
+  }, data.slice(0, -1))
+
+  rangeTest('test iterator with lte at database end', {
+    lte: data[data.length - 1].key
+  }, data.slice())
+
+  rangeTest('test iterator with end at database end - legacy', {
+    end: data[data.length - 1].key
+  }, data.slice())
+
+  rangeTest('test iterator with lt before database end', {
+    lt: data[data.length - 2].key
+  }, data.slice(0, -2))
+
+  rangeTest('test iterator with lte before database end', {
+    lte: data[data.length - 2].key
+  }, data.slice(0, -1))
+
+  rangeTest('test iterator with end before database end - legacy', {
+    end: data[data.length - 2].key
+  }, data.slice(0, -1))
+
+  rangeTest('test iterator with lte and gte after database and reverse=true', {
+    lte: '9b',
+    gte: '9a',
+    reverse: true
+  }, [])
+
+  rangeTest('test iterator with lt and gt after database and reverse=true', {
+    lt: '9b',
+    gt: '9a',
+    reverse: true
+  }, [])
+
+  rangeTest('test iterator with start and end after database and reverse=true - legacy', {
+    start: '9b',
+    end: '9a',
+    reverse: true
+  }, [])
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', function (t) {
+    db.close(testCommon.tearDown.bind(null, t))
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.range(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/iterator-seek-test.js

@@ -0,0 +1,281 @@
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.sequence(test, testCommon)
+  exports.seek(test, testCommon)
+  exports.tearDown(test, testCommon)
+}
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+}
+
+exports.sequence = function (test, testCommon) {
+  function make (name, testFn) {
+    test(name, function (t) {
+      var db = testCommon.factory()
+      var done = function (err) {
+        t.error(err, 'no error from done()')
+
+        db.close(function (err) {
+          t.error(err, 'no error from close()')
+          t.end()
+        })
+      }
+
+      db.open(function (err) {
+        t.error(err, 'no error from open()')
+        testFn(db, t, done)
+      })
+    })
+  }
+
+  make('iterator#seek() throws if next() has not completed', function (db, t, done) {
+    var ite = db.iterator()
+    var error
+    var async = false
+
+    ite.next(function (err, key, value) {
+      t.error(err, 'no error from next()')
+      t.ok(async, 'next is asynchronous')
+      ite.end(done)
+    })
+
+    async = true
+
+    try {
+      ite.seek('two')
+    } catch (err) {
+      error = err.message
+    }
+
+    t.is(error, 'cannot call seek() before next() has completed', 'got error')
+  })
+
+  make('iterator#seek() throws after end()', function (db, t, done) {
+    var ite = db.iterator()
+
+    // TODO: why call next? Can't we end immediately?
+    ite.next(function (err, key, value) {
+      t.error(err, 'no error from next()')
+
+      ite.end(function (err) {
+        t.error(err, 'no error from end()')
+        var error
+
+        try {
+          ite.seek('two')
+        } catch (err) {
+          error = err.message
+        }
+
+        t.is(error, 'cannot call seek() after end()', 'got error')
+        done()
+      })
+    })
+  })
+}
+
+exports.seek = function (test, testCommon) {
+  function make (name, testFn) {
+    test(name, function (t) {
+      var db = testCommon.factory()
+      var done = function (err) {
+        t.error(err, 'no error from done()')
+
+        db.close(function (err) {
+          t.error(err, 'no error from close()')
+          t.end()
+        })
+      }
+
+      db.open(function (err) {
+        t.error(err, 'no error from open()')
+
+        db.batch([
+          { type: 'put', key: 'one', value: '1' },
+          { type: 'put', key: 'two', value: '2' },
+          { type: 'put', key: 'three', value: '3' }
+        ], function (err) {
+          t.error(err, 'no error from batch()')
+          testFn(db, t, done)
+        })
+      })
+    })
+  }
+
+  make('iterator#seek() to string target', function (db, t, done) {
+    var ite = db.iterator()
+    ite.seek('two')
+    ite.next(function (err, key, value) {
+      t.error(err, 'no error')
+      t.same(key.toString(), 'two', 'key matches')
+      t.same(value.toString(), '2', 'value matches')
+      ite.next(function (err, key, value) {
+        t.error(err, 'no error')
+        t.same(key, undefined, 'end of iterator')
+        t.same(value, undefined, 'end of iterator')
+        ite.end(done)
+      })
+    })
+  })
+
+  if (testCommon.bufferKeys) {
+    make('iterator#seek() to buffer target', function (db, t, done) {
+      var ite = db.iterator()
+      ite.seek(Buffer.from('two'))
+      ite.next(function (err, key, value) {
+        t.error(err, 'no error from next()')
+        t.equal(key.toString(), 'two', 'key matches')
+        t.equal(value.toString(), '2', 'value matches')
+        ite.next(function (err, key, value) {
+          t.error(err, 'no error from next()')
+          t.equal(key, undefined, 'end of iterator')
+          t.equal(value, undefined, 'end of iterator')
+          ite.end(done)
+        })
+      })
+    })
+  }
+
+  make('iterator#seek() on reverse iterator', function (db, t, done) {
+    var ite = db.iterator({ reverse: true, limit: 1 })
+    ite.seek('three!')
+    ite.next(function (err, key, value) {
+      t.error(err, 'no error')
+      t.same(key.toString(), 'three', 'key matches')
+      t.same(value.toString(), '3', 'value matches')
+      ite.end(done)
+    })
+  })
+
+  make('iterator#seek() to out of range target', function (db, t, done) {
+    var ite = db.iterator()
+    ite.seek('zzz')
+    ite.next(function (err, key, value) {
+      t.error(err, 'no error')
+      t.same(key, undefined, 'end of iterator')
+      t.same(value, undefined, 'end of iterator')
+      ite.end(done)
+    })
+  })
+
+  make('iterator#seek() on reverse iterator to out of range target', function (db, t, done) {
+    var ite = db.iterator({ reverse: true })
+    ite.seek('zzz')
+    ite.next(function (err, key, value) {
+      t.error(err, 'no error')
+      t.same(key.toString(), 'two')
+      t.same(value.toString(), '2')
+      ite.end(done)
+    })
+  })
+
+  test('iterator#seek() respects range', function (t) {
+    var db = testCommon.factory()
+
+    db.open(function (err) {
+      t.error(err, 'no error from open()')
+
+      // Can't use Array.fill() because IE
+      var ops = []
+
+      for (var i = 0; i < 10; i++) {
+        ops.push({ type: 'put', key: String(i), value: String(i) })
+      }
+
+      db.batch(ops, function (err) {
+        t.error(err, 'no error from batch()')
+
+        var pending = 0
+
+        expect({ gt: '5' }, '4', undefined)
+        expect({ gt: '5' }, '5', undefined)
+        expect({ gt: '5' }, '6', '6')
+
+        expect({ gte: '5' }, '4', undefined)
+        expect({ gte: '5' }, '5', '5')
+        expect({ gte: '5' }, '6', '6')
+
+        expect({ start: '5' }, '4', undefined)
+        expect({ start: '5' }, '5', '5')
+        expect({ start: '5' }, '6', '6')
+
+        expect({ lt: '5' }, '4', '4')
+        expect({ lt: '5' }, '5', undefined)
+        expect({ lt: '5' }, '6', undefined)
+
+        expect({ lte: '5' }, '4', '4')
+        expect({ lte: '5' }, '5', '5')
+        expect({ lte: '5' }, '6', undefined)
+
+        expect({ end: '5' }, '4', '4')
+        expect({ end: '5' }, '5', '5')
+        expect({ end: '5' }, '6', undefined)
+
+        expect({ lt: '5', reverse: true }, '4', '4')
+        expect({ lt: '5', reverse: true }, '5', undefined)
+        expect({ lt: '5', reverse: true }, '6', undefined)
+
+        expect({ lte: '5', reverse: true }, '4', '4')
+        expect({ lte: '5', reverse: true }, '5', '5')
+        expect({ lte: '5', reverse: true }, '6', undefined)
+
+        expect({ start: '5', reverse: true }, '4', '4')
+        expect({ start: '5', reverse: true }, '5', '5')
+        expect({ start: '5', reverse: true }, '6', undefined)
+
+        expect({ gt: '5', reverse: true }, '4', undefined)
+        expect({ gt: '5', reverse: true }, '5', undefined)
+        expect({ gt: '5', reverse: true }, '6', '6')
+
+        expect({ gte: '5', reverse: true }, '4', undefined)
+        expect({ gte: '5', reverse: true }, '5', '5')
+        expect({ gte: '5', reverse: true }, '6', '6')
+
+        expect({ end: '5', reverse: true }, '4', undefined)
+        expect({ end: '5', reverse: true }, '5', '5')
+        expect({ end: '5', reverse: true }, '6', '6')
+
+        expect({ gt: '7', lt: '8' }, '7', undefined)
+        expect({ gte: '7', lt: '8' }, '7', '7')
+        expect({ gte: '7', lt: '8' }, '8', undefined)
+        expect({ gt: '7', lte: '8' }, '8', '8')
+
+        function expect (range, target, expected) {
+          pending++
+          var ite = db.iterator(range)
+
+          ite.seek(target)
+          ite.next(function (err, key, value) {
+            t.error(err, 'no error from next()')
+
+            var json = JSON.stringify(range)
+            var msg = 'seek(' + target + ') on ' + json + ' yields ' + expected
+
+            if (expected === undefined) {
+              t.equal(value, undefined, msg)
+            } else {
+              t.equal(value.toString(), expected, msg)
+            }
+
+            ite.end(function (err) {
+              t.error(err, 'no error from end()')
+              if (!--pending) done()
+            })
+          })
+        }
+
+        function done () {
+          db.close(function (err) {
+            t.error(err, 'no error from close()')
+            t.end()
+          })
+        }
+      })
+    })
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', testCommon.tearDown)
+}

node_modules/abstract-leveldown/test/iterator-snapshot-test.js

@@ -0,0 +1,89 @@
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+}
+
+exports.snapshot = function (test, testCommon) {
+  function make (run) {
+    return function (t) {
+      var db = testCommon.factory()
+
+      db.open(function (err) {
+        t.ifError(err, 'no open error')
+
+        db.put('z', 'from snapshot', function (err) {
+          t.ifError(err, 'no put error')
+
+          // For this test it is important that we don't read eagerly.
+          // NOTE: highWaterMark is not an abstract option atm, but
+          // it is supported by leveldown, rocksdb and others.
+          var it = db.iterator({ highWaterMark: 0 })
+
+          run(t, db, it, function end (err) {
+            t.ifError(err, 'no run error')
+
+            it.end(function (err) {
+              t.ifError(err, 'no iterator end error')
+              db.close(t.end.bind(t))
+            })
+          })
+        })
+      })
+    }
+  }
+
+  test('delete key after snapshotting', make(function (t, db, it, end) {
+    db.del('z', function (err) {
+      t.ifError(err, 'no del error')
+
+      it.next(function (err, key, value) {
+        t.ifError(err, 'no next error')
+        t.ok(key, 'got a key')
+        t.is(key.toString(), 'z', 'correct key')
+        t.is(value.toString(), 'from snapshot', 'correct value')
+
+        end()
+      })
+    })
+  }))
+
+  test('overwrite key after snapshotting', make(function (t, db, it, end) {
+    db.put('z', 'not from snapshot', function (err) {
+      t.ifError(err, 'no put error')
+
+      it.next(function (err, key, value) {
+        t.ifError(err, 'no next error')
+        t.ok(key, 'got a key')
+        t.is(key.toString(), 'z', 'correct key')
+        t.is(value.toString(), 'from snapshot', 'correct value')
+
+        end()
+      })
+    })
+  }))
+
+  test('add key after snapshotting that sorts first', make(function (t, db, it, end) {
+    db.put('a', 'not from snapshot', function (err) {
+      t.ifError(err, 'no put error')
+
+      it.next(function (err, key, value) {
+        t.ifError(err, 'no next error')
+
+        t.ok(key, 'got a key')
+        t.is(key.toString(), 'z', 'correct key')
+        t.is(value.toString(), 'from snapshot', 'correct value')
+
+        end()
+      })
+    })
+  }))
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', testCommon.tearDown)
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.snapshot(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/iterator-test.js

@@ -0,0 +1,172 @@
+var db
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+  test('setUp db', function (t) {
+    db = testCommon.factory()
+    db.open(t.end.bind(t))
+  })
+}
+
+exports.args = function (test, testCommon) {
+  test('test iterator has db reference', function (t) {
+    var iterator = db.iterator()
+    t.ok(iterator.db === db)
+    iterator.end(t.end.bind(t))
+  })
+
+  test('test argument-less iterator#next() throws', function (t) {
+    var iterator = db.iterator()
+    t.throws(
+      iterator.next.bind(iterator),
+      /Error: next\(\) requires a callback argument/,
+      'no-arg iterator#next() throws'
+    )
+    iterator.end(t.end.bind(t))
+  })
+
+  test('test argument-less iterator#end() after next() throws', function (t) {
+    var iterator = db.iterator()
+    iterator.next(function () {
+      t.throws(
+        iterator.end.bind(iterator),
+        /Error: end\(\) requires a callback argument/,
+        'no-arg iterator#end() throws'
+      )
+      iterator.end(t.end.bind(t))
+    })
+  })
+
+  test('test argument-less iterator#end() throws', function (t) {
+    var iterator = db.iterator()
+    t.throws(
+      iterator.end.bind(iterator),
+      /Error: end\(\) requires a callback argument/,
+      'no-arg iterator#end() throws'
+    )
+    iterator.end(t.end.bind(t))
+  })
+
+  test('test iterator#next returns this', function (t) {
+    var iterator = db.iterator()
+    var self = iterator.next(function () {})
+    t.ok(iterator === self)
+    iterator.end(t.end.bind(t))
+  })
+}
+
+exports.sequence = function (test, testCommon) {
+  test('test twice iterator#end() callback with error', function (t) {
+    var iterator = db.iterator()
+    iterator.end(function (err) {
+      t.error(err)
+
+      var async = false
+
+      iterator.end(function (err2) {
+        t.ok(err2, 'returned error')
+        t.is(err2.name, 'Error', 'correct error')
+        t.is(err2.message, 'end() already called on iterator')
+        t.ok(async, 'callback is asynchronous')
+        t.end()
+      })
+
+      async = true
+    })
+  })
+
+  test('test iterator#next after iterator#end() callback with error', function (t) {
+    var iterator = db.iterator()
+    iterator.end(function (err) {
+      t.error(err)
+
+      var async = false
+
+      iterator.next(function (err2) {
+        t.ok(err2, 'returned error')
+        t.is(err2.name, 'Error', 'correct error')
+        t.is(err2.message, 'cannot call next() after end()', 'correct message')
+        t.ok(async, 'callback is asynchronous')
+        t.end()
+      })
+
+      async = true
+    })
+  })
+
+  test('test twice iterator#next() throws', function (t) {
+    var iterator = db.iterator()
+    iterator.next(function (err) {
+      t.error(err)
+      iterator.end(function (err) {
+        t.error(err)
+        t.end()
+      })
+    })
+
+    var async = false
+
+    iterator.next(function (err) {
+      t.ok(err, 'returned error')
+      t.is(err.name, 'Error', 'correct error')
+      t.is(err.message, 'cannot call next() before previous next() has completed')
+      t.ok(async, 'callback is asynchronous')
+    })
+
+    async = true
+  })
+}
+
+exports.iterator = function (test, testCommon) {
+  test('test simple iterator()', function (t) {
+    var data = [
+      { type: 'put', key: 'foobatch1', value: 'bar1' },
+      { type: 'put', key: 'foobatch2', value: 'bar2' },
+      { type: 'put', key: 'foobatch3', value: 'bar3' }
+    ]
+    var idx = 0
+
+    db.batch(data, function (err) {
+      t.error(err)
+      var iterator = db.iterator()
+      var fn = function (err, key, value) {
+        t.error(err)
+        if (key && value) {
+          t.ok(Buffer.isBuffer(key), 'key argument is a Buffer')
+          t.ok(Buffer.isBuffer(value), 'value argument is a Buffer')
+          t.is(key.toString(), data[idx].key, 'correct key')
+          t.is(value.toString(), data[idx].value, 'correct value')
+          process.nextTick(next)
+          idx++
+        } else { // end
+          t.ok(typeof err === 'undefined', 'err argument is undefined')
+          t.ok(typeof key === 'undefined', 'key argument is undefined')
+          t.ok(typeof value === 'undefined', 'value argument is undefined')
+          t.is(idx, data.length, 'correct number of entries')
+          iterator.end(function () {
+            t.end()
+          })
+        }
+      }
+      var next = function () {
+        iterator.next(fn)
+      }
+
+      next()
+    })
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', function (t) {
+    db.close(testCommon.tearDown.bind(null, t))
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.sequence(test, testCommon)
+  exports.iterator(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/leveldown-test.js

@@ -0,0 +1,12 @@
+module.exports = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+
+  test('test database open method exists', function (t) {
+    var db = testCommon.factory()
+    t.ok(db, 'database object returned')
+    t.ok(typeof db.open === 'function', 'open() function exists')
+    t.end()
+  })
+
+  test('tearDown', testCommon.tearDown)
+}

node_modules/abstract-leveldown/test/manifest-test.js

@@ -0,0 +1,21 @@
+var suite = require('level-supports/test')
+
+module.exports = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+
+  suite(test, testCommon)
+
+  test('manifest has status', function (t) {
+    var db = testCommon.factory()
+    t.is(db.supports.status, true)
+
+    // The semantics of not opening or closing a new db are unclear
+    // atm, so let's open it before closing, like every other test.
+    db.open(function (err) {
+      t.ifError(err, 'no open error')
+      db.close(t.end.bind(t))
+    })
+  })
+
+  test('tearDown', testCommon.tearDown)
+}

node_modules/abstract-leveldown/test/open-create-if-missing-test.js

@@ -0,0 +1,29 @@
+exports.setUp = function (test, testCommon) {
+  test('setUp', testCommon.setUp)
+}
+
+exports.createIfMissing = function (test, testCommon) {
+  test('test database open createIfMissing:false', function (t) {
+    var db = testCommon.factory()
+    var async = false
+
+    db.open({ createIfMissing: false }, function (err) {
+      t.ok(err, 'error')
+      t.ok(/does not exist/.test(err.message), 'error is about dir not existing')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', testCommon.tearDown)
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.createIfMissing(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/open-error-if-exists-test.js

@@ -0,0 +1,37 @@
+exports.setUp = function (test, testCommon) {
+  test('setUp', testCommon.setUp)
+}
+
+exports.errorIfExists = function (test, testCommon) {
+  test('test database open errorIfExists:true', function (t) {
+    var db = testCommon.factory()
+
+    db.open({}, function (err) {
+      t.error(err)
+      db.close(function (err) {
+        t.error(err)
+
+        var async = false
+
+        db.open({ createIfMissing: false, errorIfExists: true }, function (err) {
+          t.ok(err, 'error')
+          t.ok(/exists/.test(err.message), 'error is about already existing')
+          t.ok(async, 'callback is asynchronous')
+          t.end()
+        })
+
+        async = true
+      })
+    })
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', testCommon.tearDown)
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.errorIfExists(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/open-test.js

@@ -0,0 +1,79 @@
+exports.setUp = function (test, testCommon) {
+  test('setUp', testCommon.setUp)
+}
+
+exports.args = function (test, testCommon) {
+  test('test database open no-arg throws', function (t) {
+    var db = testCommon.factory()
+    t.throws(
+      db.open.bind(db),
+      /Error: open\(\) requires a callback argument/,
+      'no-arg open() throws'
+    )
+    t.end()
+  })
+
+  test('test callback-less, 1-arg, open() throws', function (t) {
+    var db = testCommon.factory()
+    t.throws(
+      db.open.bind(db, {}),
+      /Error: open\(\) requires a callback argument/,
+      'callback-less, 1-arg open() throws'
+    )
+    t.end()
+  })
+}
+
+exports.open = function (test, testCommon) {
+  test('test database open, no options', function (t) {
+    var db = testCommon.factory()
+
+    // default createIfMissing=true, errorIfExists=false
+    db.open(function (err) {
+      t.error(err)
+      db.close(function () {
+        t.end()
+      })
+    })
+  })
+
+  test('test database open, options and callback', function (t) {
+    var db = testCommon.factory()
+
+    // default createIfMissing=true, errorIfExists=false
+    db.open({}, function (err) {
+      t.error(err)
+      db.close(function () {
+        t.end()
+      })
+    })
+  })
+
+  test('test database open, close and open', function (t) {
+    var db = testCommon.factory()
+
+    db.open(function (err) {
+      t.error(err)
+      db.close(function (err) {
+        t.error(err)
+        db.open(function (err) {
+          t.error(err)
+          db.close(function () {
+            t.end()
+          })
+        })
+      })
+    })
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', testCommon.tearDown)
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.open(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/put-get-del-test.js

@@ -0,0 +1,176 @@
+'use strict'
+
+var db
+var verifyNotFoundError = require('./util').verifyNotFoundError
+var testBuffer = Buffer.from('testbuffer')
+
+function makeGetDelErrorTests (test, type, key, expectedError) {
+  test('test get() with ' + type + ' causes error', function (t) {
+    var async = false
+
+    db.get(key, function (err) {
+      t.ok(err, 'has error')
+      t.ok(err instanceof Error)
+      t.ok(err.message.match(expectedError), 'correct error message')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+
+  test('test del() with ' + type + ' causes error', function (t) {
+    var async = false
+
+    db.del(key, function (err) {
+      t.ok(err, 'has error')
+      t.ok(err instanceof Error)
+      t.ok(err.message.match(expectedError), 'correct error message')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+}
+
+function makePutErrorTest (test, type, key, value, expectedError) {
+  test('test put() with ' + type + ' causes error', function (t) {
+    var async = false
+
+    db.put(key, value, function (err) {
+      t.ok(err, 'has error')
+      t.ok(err instanceof Error)
+      t.ok(err.message.match(expectedError), 'correct error message')
+      t.ok(async, 'callback is asynchronous')
+      t.end()
+    })
+
+    async = true
+  })
+}
+
+function makePutGetDelSuccessfulTest (test, type, key, value, expectedResult) {
+  var hasExpectedResult = arguments.length === 5
+  test('test put()/get()/del() with ' + type, function (t) {
+    db.put(key, value, function (err) {
+      t.error(err)
+      db.get(key, function (err, _value) {
+        t.error(err, 'no error, has key/value for `' + type + '`')
+        t.ok(Buffer.isBuffer(_value), 'is a Buffer')
+        var result = _value
+        if (hasExpectedResult) {
+          t.equal(result.toString(), expectedResult)
+        } else {
+          if (result != null) { result = _value.toString() }
+          if (value != null) { value = value.toString() }
+          t.equals(result, value)
+        }
+        db.del(key, function (err) {
+          t.error(err, 'no error, deleted key/value for `' + type + '`')
+
+          var async = false
+
+          db.get(key, function (err, value) {
+            t.ok(err, 'entry properly deleted')
+            t.ok(verifyNotFoundError(err), 'should have correct error message')
+            t.equal(typeof value, 'undefined', 'value is undefined')
+            t.ok(async, 'callback is asynchronous')
+            t.end()
+          })
+
+          async = true
+        })
+      })
+    })
+  })
+}
+
+function makeErrorKeyTest (test, type, key, expectedError) {
+  makeGetDelErrorTests(test, type, key, expectedError)
+  makePutErrorTest(test, type, key, 'foo', expectedError)
+}
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+  test('setUp db', function (t) {
+    db = testCommon.factory()
+    db.open(t.end.bind(t))
+  })
+}
+
+exports.errorKeys = function (test, testCommon) {
+  makeErrorKeyTest(test, 'null key', null, /key cannot be `null` or `undefined`/)
+  makeErrorKeyTest(test, 'undefined key', undefined, /key cannot be `null` or `undefined`/)
+  makeErrorKeyTest(test, 'empty String key', '', /key cannot be an empty String/)
+  makeErrorKeyTest(test, 'empty Buffer key', Buffer.alloc(0), /key cannot be an empty \w*Buffer/)
+  makeErrorKeyTest(test, 'empty Array key', [], /key cannot be an empty Array/)
+}
+
+exports.errorValues = function (test, testCommon) {
+  makePutErrorTest(test, 'null value', 'key', null, /value cannot be `null` or `undefined`/)
+  makePutErrorTest(test, 'undefined value', 'key', undefined, /value cannot be `null` or `undefined`/)
+}
+
+exports.nonErrorKeys = function (test, testCommon) {
+  // valid falsey keys
+  makePutGetDelSuccessfulTest(test, '`0` key', 0, 'foo 0')
+
+  // standard String key
+  makePutGetDelSuccessfulTest(
+    test
+    , 'long String key'
+    , 'some long string that I\'m using as a key for this unit test, cross your fingers human, we\'re going in!'
+    , 'foo'
+  )
+
+  if (testCommon.bufferKeys) {
+    makePutGetDelSuccessfulTest(test, 'Buffer key', testBuffer, 'foo')
+  }
+
+  // non-empty Array as a value
+  makePutGetDelSuccessfulTest(test, 'Array value', 'foo', [1, 2, 3, 4])
+}
+
+exports.nonErrorValues = function (test, testCommon) {
+  // valid falsey values
+  makePutGetDelSuccessfulTest(test, '`false` value', 'foo false', false)
+  makePutGetDelSuccessfulTest(test, '`0` value', 'foo 0', 0)
+  makePutGetDelSuccessfulTest(test, '`NaN` value', 'foo NaN', NaN)
+
+  // all of the following result in an empty-string value:
+  makePutGetDelSuccessfulTest(test, 'empty String value', 'foo', '', '')
+  makePutGetDelSuccessfulTest(test, 'empty Buffer value', 'foo', Buffer.alloc(0), '')
+
+  // note that an implementation may return the value as an array
+  makePutGetDelSuccessfulTest(test, 'empty Array value', 'foo', [], '')
+
+  // standard String value
+  makePutGetDelSuccessfulTest(
+    test
+    , 'long String value'
+    , 'foo'
+    , 'some long string that I\'m using as a key for this unit test, cross your fingers human, we\'re going in!'
+  )
+
+  // standard Buffer value
+  makePutGetDelSuccessfulTest(test, 'Buffer value', 'foo', testBuffer)
+
+  // non-empty Array as a key
+  makePutGetDelSuccessfulTest(test, 'Array key', [1, 2, 3, 4], 'foo')
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', function (t) {
+    db.close(testCommon.tearDown.bind(null, t))
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.errorKeys(test, testCommon)
+  exports.errorValues(test, testCommon)
+  exports.nonErrorKeys(test, testCommon)
+  exports.nonErrorValues(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/put-test.js

@@ -0,0 +1,108 @@
+var db
+var isTypedArray = require('./util').isTypedArray
+
+exports.setUp = function (test, testCommon) {
+  test('setUp common', testCommon.setUp)
+  test('setUp db', function (t) {
+    db = testCommon.factory()
+    db.open(t.end.bind(t))
+  })
+}
+
+exports.args = function (test, testCommon) {
+  test('test argument-less put() throws', function (t) {
+    t.throws(
+      db.put.bind(db),
+      /Error: put\(\) requires a callback argument/,
+      'no-arg put() throws'
+    )
+    t.end()
+  })
+
+  test('test callback-less, 1-arg, put() throws', function (t) {
+    t.throws(
+      db.put.bind(db, 'foo'),
+      /Error: put\(\) requires a callback argument/,
+      'callback-less, 1-arg put() throws'
+    )
+    t.end()
+  })
+
+  test('test callback-less, 2-arg, put() throws', function (t) {
+    t.throws(
+      db.put.bind(db, 'foo', 'bar'),
+      /Error: put\(\) requires a callback argument/,
+      'callback-less, 2-arg put() throws'
+    )
+    t.end()
+  })
+
+  test('test callback-less, 3-arg, put() throws', function (t) {
+    t.throws(
+      db.put.bind(db, 'foo', 'bar', {}),
+      /Error: put\(\) requires a callback argument/,
+      'callback-less, 3-arg put() throws'
+    )
+    t.end()
+  })
+
+  test('test _serialize object', function (t) {
+    t.plan(3)
+    var db = testCommon.factory()
+    db._put = function (key, value, opts, callback) {
+      t.ok(key)
+      t.ok(value)
+      process.nextTick(callback)
+    }
+    db.put({}, {}, function (err, val) {
+      t.error(err)
+    })
+  })
+
+  test('test custom _serialize*', function (t) {
+    t.plan(4)
+    var db = testCommon.factory()
+    db._serializeKey = db._serializeValue = function (data) { return data }
+    db._put = function (key, value, options, callback) {
+      t.deepEqual(key, { foo: 'bar' })
+      t.deepEqual(value, { beep: 'boop' })
+      process.nextTick(callback)
+    }
+    db.open(function () {
+      db.put({ foo: 'bar' }, { beep: 'boop' }, function (err) {
+        t.error(err)
+        db.close(t.error.bind(t))
+      })
+    })
+  })
+}
+
+exports.put = function (test, testCommon) {
+  test('test simple put()', function (t) {
+    db.put('foo', 'bar', function (err) {
+      t.error(err)
+      db.get('foo', function (err, value) {
+        t.error(err)
+        var result = value.toString()
+        if (isTypedArray(value)) {
+          result = String.fromCharCode.apply(null, new Uint16Array(value))
+        }
+        t.equal(result, 'bar')
+        t.end()
+      })
+    })
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', function (t) {
+    db.close(testCommon.tearDown.bind(null, t))
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.put(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

node_modules/abstract-leveldown/test/util.js

@@ -0,0 +1,10 @@
+var nfre = /NotFound/i
+
+exports.verifyNotFoundError = function verifyNotFoundError (err) {
+  return nfre.test(err.message) || nfre.test(err.name)
+}
+
+exports.isTypedArray = function isTypedArray (value) {
+  return (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) ||
+    (typeof Uint8Array !== 'undefined' && value instanceof Uint8Array)
+}