compact-encoding 2.8.0 → 2.11.0

package/README.md

@@ -11,13 +11,13 @@ npm install compact-encoding
 ``` js
 const cenc = require('compact-encoding')
 
-const state = { start: 0, end: 0, buffer: null }
+const state = cenc.state()
 
 // use preencode to figure out how big a buffer is needed
 cenc.uint.preencode(state, 42)
 cenc.string.preencode(state, 'hi')
 
-console.log(state) // { start: 0, end: 4, buffer: null }
+console.log(state) // { start: 0, end: 4, buffer: null, cache: null }
 
 state.buffer = Buffer.allocUnsafe(state.end)
 
@@ -36,13 +36,14 @@ cenc.string.decode(state) // 'hi'
 
 #### `state`
 
-Should be an object that looks like this `{ start, end, buffer }`.
+Should be an object that looks like this `{ start, end, buffer, cache }`.
 
 You can also get a blank state object using `cenc.state()`.
 
 * `start` is the byte offset to start encoding/decoding at.
 * `end` is the byte offset indicating the end of the buffer.
 * `buffer` should be either a Node.js Buffer or Uint8Array.
+* `cache` is used internally be codecs, starts out as `null`.
 
 #### `enc.preencode(state, val)`
 
@@ -74,6 +75,7 @@ const bool = cenc.decode(cenc.bool, buf)
 The following encodings are bundled as they are primitives that can be used
 to build others on top. Feel free to PR more that are missing.
 
+* `cenc.raw` - Pass through encodes a buffer, i.e. a basic copy.
 * `cenc.uint` - Encodes a uint using [compact-uint](https://github.com/mafintosh/compact-uint).
 * `cenc.uint8` - Encodes a fixed size uint8.
 * `cenc.uint16` - Encodes a fixed size uint16. Useful for things like ports.
@@ -96,27 +98,48 @@ to build others on top. Feel free to PR more that are missing.
 * `cenc.float32` - Encodes a fixed size float32.
 * `cenc.float64` - Encodes a fixed size float64.
 * `cenc.buffer` - Encodes a buffer with its length uint prefixed. When decoding an empty buffer, `null` is returned.
-* `cenc.raw` - Pass through encodes a buffer, i.e. a basic copy.
+* `cenc.raw.buffer` - Encodes a buffer without a length prefixed.
 * `cenc.uint8array` - Encodes a uint8array with its element length uint prefixed.
+* `cenc.raw.uint8array` - Encodes a uint8array without a length prefixed.
 * `cenc.uint16array` - Encodes a uint16array with its element length uint prefixed.
+* `cenc.raw.uint16array` - Encodes a uint16array without a length prefixed.
 * `cenc.uint32array` - Encodes a uint32array with its element length uint prefixed.
+* `cenc.raw.uint32array` - Encodes a uint32array without a length prefixed.
 * `cenc.int8array` - Encodes a int8array with its element length uint prefixed.
+* `cenc.raw.int8array` - Encodes a int8array without a length prefixed.
 * `cenc.int16array` - Encodes a int16array with its element length uint prefixed.
+* `cenc.raw.int16array` - Encodes a int16array without a length prefixed.
 * `cenc.int32array` - Encodes a int32array with its element length uint prefixed.
+* `cenc.raw.int32array` - Encodes a int32array without a length prefixed.
 * `cenc.float32array` - Encodes a float32array with its element length uint prefixed.
+* `cenc.raw.float32array` - Encodes a float32array without a length prefixed.
 * `cenc.float64array` - Encodes a float64array with its element length uint prefixed.
+* `cenc.raw.float64array` - Encodes a float64array without a length prefixed.
 * `cenc.bool` - Encodes a boolean as 1 or 0.
 * `cenc.string`, `cenc.utf8` - Encodes a utf-8 string, similar to buffer.
+* `cenc.raw.string`, `cenc.raw.utf8` - Encodes a utf-8 string without a length prefixed.
+* `cenc.string.fixed(n)`, `cenc.utf8.fixed(n)` - Encodes a fixed sized utf-8 string.
 * `cenc.ascii` - Encodes an ascii string.
+* `cenc.raw.ascii` - Encodes an ascii string without a length prefixed.
+* `cenc.ascii.fixed(n)` - Encodes a fixed size ascii string.
 * `cenc.hex` - Encodes a hex string.
+* `cenc.raw.hex` - Encodes a hex string without a length prefixed.
+* `cenc.hex.fixed(n)` - Encodes a fixed size hex string.
 * `cenc.base64` - Encodes a base64 string.
+* `cenc.raw.base64` - Encodes a base64 string without a length prefixed.
+* `cenc.base64.fixed(n)` - Encodes a fixed size base64 string.
 * `cenc.utf16le`, `cenc.ucs2` - Encodes a utf16le string.
+* `cenc.raw.utf16le`, `cenc.raw.ucs2` - Encodes a utf16le string without a length prefixed.
+* `cenc.utf16le.fixed(n)`, `cenc.ucs2.fixed(n)` - Encodes a fixed size utf16le string.
 * `cenc.fixed32` - Encodes a fixed 32 byte buffer.
 * `cenc.fixed64` - Encodes a fixed 64 byte buffer.
 * `cenc.fixed(n)` - Makes a fixed sized encoder.
 * `cenc.array(enc)` - Makes an array encoder from another encoder. Arrays are uint prefixed with their length.
+* `cenc.raw.array(enc)` - Makes an array encoder from another encoder, without a length prefixed.
 * `cenc.json` - Encodes a JSON value as utf-8.
+* `cenc.raw.json` - Encodes a JSON value as utf-8 without a length prefixed.
 * `cenc.ndjson` - Encodes a JSON value as newline delimited utf-8.
+* `cenc.raw.ndjson` - Encodes a JSON value as newline delimited utf-8 without a length prefixed.
 * `cenc.from(enc)` - Makes a compact encoder from a [codec](https://github.com/mafintosh/codecs) or [abstract-encoding](https://github.com/mafintosh/abstract-encoding).
 
 ## License

package/endian.js

@@ -0,0 +1,3 @@
+const LE = exports.LE = (new Uint8Array(new Uint16Array([0xff]).buffer))[0] === 0xff
+
+exports.BE = !LE

package/index.js

@@ -1,12 +1,13 @@
 const b4a = require('b4a')
 
-const LE = (new Uint8Array(new Uint16Array([0xff]).buffer))[0] === 0xff
-const BE = !LE
+const { BE } = require('./endian')
 
-exports.state = function () {
-  return { start: 0, end: 0, buffer: null }
+exports.state = function (start = 0, end = 0, buffer = null) {
+  return { start, end, buffer, cache: null }
 }
 
+const raw = exports.raw = require('./raw')
+
 const uint = exports.uint = {
   preencode (state, n) {
     state.end += n <= 0xfc ? 1 : n <= 0xffff ? 3 : n <= 0xffffffff ? 5 : 9
@@ -211,7 +212,7 @@ exports.float64 = {
   }
 }
 
-exports.buffer = {
+const buffer = exports.buffer = {
   preencode (state, b) {
     if (b) uint8array.preencode(state, b)
     else state.end++
@@ -228,18 +229,15 @@ exports.buffer = {
   }
 }
 
-const raw = exports.raw = {
+exports.binary = {
+  ...buffer,
   preencode (state, b) {
-    state.end += b.byteLength
+    if (typeof b === 'string') utf8.preencode(state, b)
+    else buffer.preencode(state, b)
   },
   encode (state, b) {
-    state.buffer.set(b, state.start)
-    state.start += b.byteLength
-  },
-  decode (state) {
-    const b = state.buffer.subarray(state.start, state.end)
-    state.start = state.end
-    return b
+    if (typeof b === 'string') utf8.encode(state, b)
+    else buffer.encode(state, b)
   }
 }
 
@@ -303,6 +301,21 @@ function string (encoding) {
       const len = uint.decode(state)
       if (state.end - state.start < len) throw new Error('Out of bounds')
       return b4a.toString(state.buffer, encoding, state.start, (state.start += len))
+    },
+    fixed (n) {
+      return {
+        preencode (state) {
+          state.end += n
+        },
+        encode (state, s) {
+          b4a.write(state.buffer, s, state.start, n, encoding)
+          state.start += n
+        },
+        decode (state) {
+          if (state.end - state.start < n) throw new Error('Out of bounds')
+          return b4a.toString(state.buffer, encoding, state.start, (state.start += n))
+        }
+      }
     }
   }
 }
@@ -402,11 +415,30 @@ exports.ndjson = {
 }
 
 exports.from = function from (enc) {
+  if (typeof enc === 'string') return fromNamed(enc)
   if (enc.preencode) return enc
   if (enc.encodingLength) return fromAbstractEncoder(enc)
   return fromCodec(enc)
 }
 
+function fromNamed (enc) {
+  switch (enc) {
+    case 'ascii': return raw.ascii
+    case 'utf-8':
+    case 'utf8': return raw.utf8
+    case 'hex': return raw.hex
+    case 'base64': return raw.base64
+    case 'utf16-le':
+    case 'utf16le':
+    case 'ucs-2':
+    case 'ucs2': return raw.ucs2
+    case 'ndjson': return raw.ndjson
+    case 'json': return raw.json
+    case 'binary':
+    default: return raw.binary
+  }
+}
+
 function fromCodec (enc) {
   let tmpM = null
   let tmpBuf = null
@@ -445,7 +477,7 @@ function fromAbstractEncoder (enc) {
 }
 
 exports.encode = function encode (enc, m) {
-  const state = { start: 0, end: 0, buffer: null }
+  const state = exports.state()
   enc.preencode(state, m)
   state.buffer = b4a.allocUnsafe(state.end)
   enc.encode(state, m)
@@ -453,7 +485,7 @@ exports.encode = function encode (enc, m) {
 }
 
 exports.decode = function decode (enc, buffer) {
-  return enc.decode({ start: 0, end: buffer.byteLength, buffer })
+  return enc.decode(exports.state(0, buffer.byteLength, buffer))
 }
 
 function zigZag (enc) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "compact-encoding",
-  "version": "2.8.0",
+  "version": "2.11.0",
   "description": "A series of compact encoding schemes for building small and fast parsers and serializers",
   "main": "index.js",
   "dependencies": {

package/raw.js

@@ -0,0 +1,148 @@
+const b4a = require('b4a')
+
+const { BE } = require('./endian')
+
+exports = module.exports = {
+  preencode (state, b) {
+    state.end += b.byteLength
+  },
+  encode (state, b) {
+    state.buffer.set(b, state.start)
+    state.start += b.byteLength
+  },
+  decode (state) {
+    const b = state.buffer.subarray(state.start, state.end)
+    state.start = state.end
+    return b
+  }
+}
+
+const buffer = exports.buffer = {
+  preencode (state, b) {
+    if (b) uint8array.preencode(state, b)
+    else state.end++
+  },
+  encode (state, b) {
+    if (b) uint8array.encode(state, b)
+    else state.buffer[state.start++] = 0
+  },
+  decode (state) {
+    const b = state.buffer.subarray(state.start)
+    if (b.byteLength === 0) return null
+    state.start = state.end
+    return b
+  }
+}
+
+exports.binary = {
+  ...buffer,
+  preencode (state, b) {
+    if (typeof b === 'string') utf8.preencode(state, b)
+    else buffer.preencode(state, b)
+  },
+  encode (state, b) {
+    if (typeof b === 'string') utf8.encode(state, b)
+    else buffer.encode(state, b)
+  }
+}
+
+function typedarray (TypedArray, swap) {
+  const n = TypedArray.BYTES_PER_ELEMENT
+
+  return {
+    preencode (state, b) {
+      state.end += b.byteLength
+    },
+    encode (state, b) {
+      const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength)
+
+      if (BE && swap) swap(view)
+
+      state.buffer.set(view, state.start)
+      state.start += b.byteLength
+    },
+    decode (state) {
+      let b = state.buffer.subarray(state.start)
+      if ((b.byteOffset % n) !== 0) b = new Uint8Array(b)
+
+      if (BE && swap) swap(b)
+
+      state.start = state.end
+
+      return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n)
+    }
+  }
+}
+
+const uint8array = exports.uint8array = typedarray(Uint8Array)
+exports.uint16array = typedarray(Uint16Array, b4a.swap16)
+exports.uint32array = typedarray(Uint32Array, b4a.swap32)
+
+exports.int8array = typedarray(Int8Array)
+exports.int16array = typedarray(Int16Array, b4a.swap16)
+exports.int32array = typedarray(Int32Array, b4a.swap32)
+
+exports.float32array = typedarray(Float32Array, b4a.swap32)
+exports.float64array = typedarray(Float64Array, b4a.swap64)
+
+function string (encoding) {
+  return {
+    preencode (state, s) {
+      state.end += b4a.byteLength(s, encoding)
+    },
+    encode (state, s) {
+      state.start += b4a.write(state.buffer, s, state.start, encoding)
+    },
+    decode (state) {
+      const s = b4a.toString(state.buffer, encoding, state.start)
+      state.start = state.end
+      return s
+    }
+  }
+}
+
+const utf8 = exports.string = exports.utf8 = string('utf-8')
+exports.ascii = string('ascii')
+exports.hex = string('hex')
+exports.base64 = string('base64')
+exports.ucs2 = exports.utf16le = string('utf16le')
+
+exports.array = function array (enc) {
+  return {
+    preencode (state, list) {
+      for (const value of list) enc.preencode(state, value)
+    },
+    encode (state, list) {
+      for (const value of list) enc.encode(state, value)
+    },
+    decode (state) {
+      const arr = []
+      while (state.start < state.end) arr.push(enc.decode(state))
+      return arr
+    }
+  }
+}
+
+exports.json = {
+  preencode (state, v) {
+    utf8.preencode(state, JSON.stringify(v))
+  },
+  encode (state, v) {
+    utf8.encode(state, JSON.stringify(v))
+  },
+  decode (state) {
+    return JSON.parse(utf8.decode(state))
+  }
+}
+
+exports.ndjson = {
+  preencode (state, v) {
+    utf8.preencode(state, JSON.stringify(v) + '\n')
+  },
+  encode (state, v) {
+    utf8.encode(state, JSON.stringify(v) + '\n')
+  },
+  decode (state) {
+    return JSON.parse(utf8.decode(state))
+  }
+}

package/test.js

@@ -1,23 +1,24 @@
 const enc = require('./')
-const tape = require('brittle')
+const test = require('brittle')
+const b4a = require('b4a')
 
-tape('uint', function (t) {
+test('uint', function (t) {
   const state = enc.state()
 
   enc.uint.preencode(state, 42)
-  t.alike(state, { start: 0, end: 1, buffer: null })
+  t.alike(state, enc.state(0, 1))
   enc.uint.preencode(state, 4200)
-  t.alike(state, { start: 0, end: 4, buffer: null })
+  t.alike(state, enc.state(0, 4))
   enc.uint.preencode(state, Number.MAX_SAFE_INTEGER)
-  t.alike(state, { start: 0, end: 13, buffer: null })
+  t.alike(state, enc.state(0, 13))
 
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.uint.encode(state, 42)
-  t.alike(state, { start: 1, end: 13, buffer: Buffer.from([42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) })
+  t.alike(state, enc.state(1, 13, b4a.from([42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
   enc.uint.encode(state, 4200)
-  t.alike(state, { start: 4, end: 13, buffer: Buffer.from([42, 0xfd, 104, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0]) })
+  t.alike(state, enc.state(4, 13, b4a.from([42, 0xfd, 104, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
   enc.uint.encode(state, Number.MAX_SAFE_INTEGER)
-  t.alike(state, { start: 13, end: 13, buffer: Buffer.from([42, 0xfd, 104, 16, 0xff, 255, 255, 255, 255, 255, 255, 31, 0]) })
+  t.alike(state, enc.state(13, 13, b4a.from([42, 0xfd, 104, 16, 0xff, 255, 255, 255, 255, 255, 255, 31, 0])))
 
   state.start = 0
   t.is(enc.uint.decode(state), 42)
@@ -28,19 +29,19 @@ tape('uint', function (t) {
   t.exception(() => enc.uint.decode(state))
 })
 
-tape('int', function (t) {
+test('int', function (t) {
   const state = enc.state()
 
   enc.int.preencode(state, 42)
-  t.alike(state, { start: 0, end: 1, buffer: null })
+  t.alike(state, enc.state(0, 1))
   enc.int.preencode(state, -4200)
-  t.alike(state, { start: 0, end: 4, buffer: null })
+  t.alike(state, enc.state(0, 4))
 
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.int.encode(state, 42)
-  t.alike(state, { start: 1, end: 4, buffer: Buffer.from([84, 0, 0, 0]) })
+  t.alike(state, enc.state(1, 4, b4a.from([84, 0, 0, 0])))
   enc.int.encode(state, -4200)
-  t.alike(state, { start: 4, end: 4, buffer: Buffer.from([84, 0xfd, 207, 32]) })
+  t.alike(state, enc.state(4, 4, b4a.from([84, 0xfd, 207, 32])))
 
   state.start = 0
   t.is(enc.int.decode(state), 42)
@@ -50,16 +51,16 @@ tape('int', function (t) {
   t.exception(() => enc.int.decode(state))
 })
 
-tape('float64', function (t) {
+test('float64', function (t) {
   const state = enc.state()
 
   enc.float64.preencode(state, 162.2377294)
-  t.alike(state, { start: 0, end: 8, buffer: null })
+  t.alike(state, enc.state(0, 8))
 
-  state.buffer = Buffer.alloc(state.end)
-  t.alike(state, { start: 0, end: 8, buffer: Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]) })
+  state.buffer = b4a.alloc(state.end)
+  t.alike(state, enc.state(0, 8, b4a.from([0, 0, 0, 0, 0, 0, 0, 0])))
   enc.float64.encode(state, 162.2377294)
-  t.alike(state, { start: 8, end: 8, buffer: Buffer.from([0x87, 0xc9, 0xaf, 0x7a, 0x9b, 0x47, 0x64, 0x40]) })
+  t.alike(state, enc.state(8, 8, b4a.from([0x87, 0xc9, 0xaf, 0x7a, 0x9b, 0x47, 0x64, 0x40])))
 
   state.start = 0
   t.is(enc.float64.decode(state), 162.2377294)
@@ -74,13 +75,13 @@ tape('float64', function (t) {
 
   enc.int.preencode(state, 0)
   enc.float64.preencode(state, 162.2377294)
-  t.alike(state, { start: 0, end: 9, buffer: null })
+  t.alike(state, enc.state(0, 9))
 
-  state.buffer = Buffer.alloc(state.end)
-  t.alike(state, { start: 0, end: 9, buffer: Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0]) })
+  state.buffer = b4a.alloc(state.end)
+  t.alike(state, enc.state(0, 9, b4a.from([0, 0, 0, 0, 0, 0, 0, 0, 0])))
   enc.int.encode(state, 0)
   enc.float64.encode(state, 162.2377294)
-  t.alike(state, { start: 9, end: 9, buffer: Buffer.from([0, 0x87, 0xc9, 0xaf, 0x7a, 0x9b, 0x47, 0x64, 0x40]) })
+  t.alike(state, enc.state(9, 9, b4a.from([0, 0x87, 0xc9, 0xaf, 0x7a, 0x9b, 0x47, 0x64, 0x40])))
 
   state.start = 0
   t.is(enc.int.decode(state), 0)
@@ -88,14 +89,14 @@ tape('float64', function (t) {
   t.is(state.start, state.end)
 
   // subarray
-  const buf = Buffer.alloc(10)
+  const buf = b4a.alloc(10)
   state.start = 0
   state.buffer = buf.subarray(1)
-  t.alike(state, { start: 0, end: 9, buffer: Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0]) })
+  t.alike(state, enc.state(0, 9, b4a.from([0, 0, 0, 0, 0, 0, 0, 0, 0])))
   enc.int.encode(state, 0)
   enc.float64.encode(state, 162.2377294)
-  t.alike(state, { start: 9, end: 9, buffer: Buffer.from([0, 0x87, 0xc9, 0xaf, 0x7a, 0x9b, 0x47, 0x64, 0x40]) })
-  t.alike(buf, Buffer.from([0, 0, 0x87, 0xc9, 0xaf, 0x7a, 0x9b, 0x47, 0x64, 0x40]))
+  t.alike(state, enc.state(9, 9, b4a.from([0, 0x87, 0xc9, 0xaf, 0x7a, 0x9b, 0x47, 0x64, 0x40])))
+  t.alike(buf, b4a.from([0, 0, 0x87, 0xc9, 0xaf, 0x7a, 0x9b, 0x47, 0x64, 0x40]))
 
   state.start = 0
   t.is(enc.int.decode(state), 0)
@@ -108,9 +109,9 @@ tape('float64', function (t) {
   state.buffer = null
 
   enc.float64.preencode(state, 162.2377294)
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.float64.encode(state, 0)
-  t.alike(state, { start: 8, end: 8, buffer: Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]) })
+  t.alike(state, enc.state(8, 8, b4a.from([0, 0, 0, 0, 0, 0, 0, 0])))
 
   state.start = 0
   t.is(enc.float64.decode(state), 0)
@@ -122,9 +123,9 @@ tape('float64', function (t) {
   state.buffer = null
 
   enc.float64.preencode(state, Infinity)
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.float64.encode(state, Infinity)
-  t.alike(state, { start: 8, end: 8, buffer: Buffer.from([0, 0, 0, 0, 0, 0, 0xf0, 0x7f]) })
+  t.alike(state, enc.state(8, 8, b4a.from([0, 0, 0, 0, 0, 0, 0xf0, 0x7f])))
 
   state.start = 0
   t.is(enc.float64.decode(state), Infinity)
@@ -136,66 +137,85 @@ tape('float64', function (t) {
   state.buffer = null
 
   enc.float64.preencode(state, 0.1 + 0.2)
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.float64.encode(state, 0.1 + 0.2)
-  t.alike(state, { start: 8, end: 8, buffer: Buffer.from([0x34, 0x33, 0x33, 0x33, 0x33, 0x33, 0xd3, 0x3f]) })
+  t.alike(state, enc.state(8, 8, b4a.from([0x34, 0x33, 0x33, 0x33, 0x33, 0x33, 0xd3, 0x3f])))
 
   state.start = 0
   t.is(enc.float64.decode(state), 0.1 + 0.2)
   t.is(state.start, state.end)
 })
 
-tape('buffer', function (t) {
+test('buffer', function (t) {
   const state = enc.state()
 
-  enc.buffer.preencode(state, Buffer.from('hi'))
-  t.alike(state, { start: 0, end: 3, buffer: null })
-  enc.buffer.preencode(state, Buffer.from('hello'))
-  t.alike(state, { start: 0, end: 9, buffer: null })
+  enc.buffer.preencode(state, b4a.from('hi'))
+  t.alike(state, enc.state(0, 3))
+  enc.buffer.preencode(state, b4a.from('hello'))
+  t.alike(state, enc.state(0, 9))
   enc.buffer.preencode(state, null)
-  t.alike(state, { start: 0, end: 10, buffer: null })
+  t.alike(state, enc.state(0, 10))
 
-  state.buffer = Buffer.alloc(state.end)
-  enc.buffer.encode(state, Buffer.from('hi'))
-  t.alike(state, { start: 3, end: 10, buffer: Buffer.from('\x02hi\x00\x00\x00\x00\x00\x00\x00') })
-  enc.buffer.encode(state, Buffer.from('hello'))
-  t.alike(state, { start: 9, end: 10, buffer: Buffer.from('\x02hi\x05hello\x00') })
+  state.buffer = b4a.alloc(state.end)
+  enc.buffer.encode(state, b4a.from('hi'))
+  t.alike(state, enc.state(3, 10, b4a.from('\x02hi\x00\x00\x00\x00\x00\x00\x00')))
+  enc.buffer.encode(state, b4a.from('hello'))
+  t.alike(state, enc.state(9, 10, b4a.from('\x02hi\x05hello\x00')))
   enc.buffer.encode(state, null)
-  t.alike(state, { start: 10, end: 10, buffer: Buffer.from('\x02hi\x05hello\x00') })
+  t.alike(state, enc.state(10, 10, b4a.from('\x02hi\x05hello\x00')))
 
   state.start = 0
-  t.alike(enc.buffer.decode(state), Buffer.from('hi'))
-  t.alike(enc.buffer.decode(state), Buffer.from('hello'))
+  t.alike(enc.buffer.decode(state), b4a.from('hi'))
+  t.alike(enc.buffer.decode(state), b4a.from('hello'))
   t.is(enc.buffer.decode(state), null)
   t.is(state.start, state.end)
 
   t.exception(() => enc.buffer.decode(state))
 })
 
-tape('raw', function (t) {
+test('raw', function (t) {
   const state = enc.state()
 
-  enc.raw.preencode(state, Buffer.from('hi'))
-  t.alike(state, { start: 0, end: 2, buffer: null })
+  enc.raw.preencode(state, b4a.from('hi'))
+  t.alike(state, enc.state(0, 2))
 
-  state.buffer = Buffer.alloc(state.end)
-  enc.raw.encode(state, Buffer.from('hi'))
-  t.alike(state, { start: 2, end: 2, buffer: Buffer.from('hi') })
+  state.buffer = b4a.alloc(state.end)
+  enc.raw.encode(state, b4a.from('hi'))
+  t.alike(state, enc.state(2, 2, b4a.from('hi')))
 
   state.start = 0
-  t.alike(enc.raw.decode(state), Buffer.from('hi'))
+  t.alike(enc.raw.decode(state), b4a.from('hi'))
   t.is(state.start, state.end)
 })
 
-tape('uint16array', function (t) {
+test('raw uint8array', function (t) {
+  const state = enc.state()
+
+  enc.raw.uint8array.preencode(state, Uint8Array.of(1, 2))
+  t.alike(state, enc.state(0, 2))
+  enc.raw.uint8array.preencode(state, Uint8Array.of(3, 4))
+  t.alike(state, enc.state(0, 4))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.raw.uint8array.encode(state, Uint8Array.of(1, 2))
+  t.alike(state, enc.state(2, 4, b4a.from([1, 2, 0, 0])))
+  enc.raw.uint8array.encode(state, Uint8Array.of(3, 4))
+  t.alike(state, enc.state(4, 4, b4a.from([1, 2, 3, 4])))
+
+  state.start = 0
+  t.alike(enc.raw.uint8array.decode(state), Uint8Array.of(1, 2, 3, 4))
+  t.alike(enc.raw.uint8array.decode(state), Uint8Array.of())
+})
+
+test('uint16array', function (t) {
   const state = enc.state()
 
   enc.uint16array.preencode(state, new Uint16Array([1, 2, 3]))
-  t.alike(state, { start: 0, end: 7, buffer: null })
+  t.alike(state, enc.state(0, 7))
 
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.uint16array.encode(state, new Uint16Array([1, 2, 3]))
-  t.alike(state, { start: 7, end: 7, buffer: Buffer.from([3, 1, 0, 2, 0, 3, 0]) })
+  t.alike(state, enc.state(7, 7, b4a.from([3, 1, 0, 2, 0, 3, 0])))
 
   state.start = 0
   t.alike(enc.uint16array.decode(state), new Uint16Array([1, 2, 3]))
@@ -204,19 +224,19 @@ tape('uint16array', function (t) {
   t.exception(() => enc.uint16array.decode(state))
 })
 
-tape('uint32array', function (t) {
+test('uint32array', function (t) {
   const state = enc.state()
 
   enc.uint32array.preencode(state, new Uint32Array([1]))
-  t.alike(state, { start: 0, end: 5, buffer: null })
+  t.alike(state, enc.state(0, 5))
   enc.uint32array.preencode(state, new Uint32Array([42, 43]))
-  t.alike(state, { start: 0, end: 14, buffer: null })
+  t.alike(state, enc.state(0, 14))
 
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.uint32array.encode(state, new Uint32Array([1]))
-  t.alike(state, { start: 5, end: 14, buffer: Buffer.from([1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) })
+  t.alike(state, enc.state(5, 14, b4a.from([1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
   enc.uint32array.encode(state, new Uint32Array([42, 43]))
-  t.alike(state, { start: 14, end: 14, buffer: Buffer.from([1, 1, 0, 0, 0, 2, 42, 0, 0, 0, 43, 0, 0, 0]) })
+  t.alike(state, enc.state(14, 14, b4a.from([1, 1, 0, 0, 0, 2, 42, 0, 0, 0, 43, 0, 0, 0])))
 
   state.start = 0
   t.alike(enc.uint32array.decode(state), new Uint32Array([1]))
@@ -226,15 +246,15 @@ tape('uint32array', function (t) {
   t.exception(() => enc.uint32array.decode(state))
 })
 
-tape('int16array', function (t) {
+test('int16array', function (t) {
   const state = enc.state()
 
   enc.int16array.preencode(state, new Int16Array([1, -2, 3]))
-  t.alike(state, { start: 0, end: 7, buffer: null })
+  t.alike(state, enc.state(0, 7))
 
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.int16array.encode(state, new Int16Array([1, -2, 3]))
-  t.alike(state, { start: 7, end: 7, buffer: Buffer.from([3, 1, 0, 0xfe, 0xff, 3, 0]) })
+  t.alike(state, enc.state(7, 7, b4a.from([3, 1, 0, 0xfe, 0xff, 3, 0])))
 
   state.start = 0
   t.alike(enc.int16array.decode(state), new Int16Array([1, -2, 3]))
@@ -243,15 +263,15 @@ tape('int16array', function (t) {
   t.exception(() => enc.int16array.decode(state))
 })
 
-tape('int32array', function (t) {
+test('int32array', function (t) {
   const state = enc.state()
 
   enc.int32array.preencode(state, new Int32Array([1, -2, 3]))
-  t.alike(state, { start: 0, end: 13, buffer: null })
+  t.alike(state, enc.state(0, 13))
 
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.int32array.encode(state, new Int32Array([1, -2, 3]))
-  t.alike(state, { start: 13, end: 13, buffer: Buffer.from([3, 1, 0, 0, 0, 0xfe, 0xff, 0xff, 0xff, 3, 0, 0, 0]) })
+  t.alike(state, enc.state(13, 13, b4a.from([3, 1, 0, 0, 0, 0xfe, 0xff, 0xff, 0xff, 3, 0, 0, 0])))
 
   state.start = 0
   t.alike(enc.int32array.decode(state), new Int32Array([1, -2, 3]))
@@ -260,15 +280,15 @@ tape('int32array', function (t) {
   t.exception(() => enc.int32array.decode(state))
 })
 
-tape('float32array', function (t) {
+test('float32array', function (t) {
   const state = enc.state()
 
   enc.float32array.preencode(state, new Float32Array([1.1, -2.2, 3.3]))
-  t.alike(state, { start: 0, end: 13, buffer: null })
+  t.alike(state, enc.state(0, 13))
 
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.float32array.encode(state, new Float32Array([1.1, -2.2, 3.3]))
-  t.alike(state, { start: 13, end: 13, buffer: Buffer.from([3, 0xcd, 0xcc, 0x8c, 0x3f, 0xcd, 0xcc, 0x0c, 0xc0, 0x33, 0x33, 0x53, 0x40]) })
+  t.alike(state, enc.state(13, 13, b4a.from([3, 0xcd, 0xcc, 0x8c, 0x3f, 0xcd, 0xcc, 0x0c, 0xc0, 0x33, 0x33, 0x53, 0x40])))
 
   state.start = 0
   t.alike(enc.float32array.decode(state), new Float32Array([1.1, -2.2, 3.3]))
@@ -277,15 +297,15 @@ tape('float32array', function (t) {
   t.exception(() => enc.float32array.decode(state))
 })
 
-tape('float64array', function (t) {
+test('float64array', function (t) {
   const state = enc.state()
 
   enc.float64array.preencode(state, new Float64Array([1.1, -2.2, 3.3]))
-  t.alike(state, { start: 0, end: 25, buffer: null })
+  t.alike(state, enc.state(0, 25))
 
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.float64array.encode(state, new Float64Array([1.1, -2.2, 3.3]))
-  t.alike(state, { start: 25, end: 25, buffer: Buffer.from([3, 0x9a, 0x99, 0x99, 0x99, 0x99, 0x99, 0xf1, 0x3f, 0x9a, 0x99, 0x99, 0x99, 0x99, 0x99, 0x01, 0xc0, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x0a, 0x40]) })
+  t.alike(state, enc.state(25, 25, b4a.from([3, 0x9a, 0x99, 0x99, 0x99, 0x99, 0x99, 0xf1, 0x3f, 0x9a, 0x99, 0x99, 0x99, 0x99, 0x99, 0x01, 0xc0, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x0a, 0x40])))
 
   state.start = 0
   t.alike(enc.float64array.decode(state), new Float64Array([1.1, -2.2, 3.3]))
@@ -294,19 +314,19 @@ tape('float64array', function (t) {
   t.exception(() => enc.float64array.decode(state))
 })
 
-tape('string', function (t) {
+test('string', function (t) {
   const state = enc.state()
 
   enc.string.preencode(state, '🌾')
-  t.alike(state, { start: 0, end: 5, buffer: null })
+  t.alike(state, enc.state(0, 5))
   enc.string.preencode(state, 'høsten er fin')
-  t.alike(state, { start: 0, end: 20, buffer: null })
+  t.alike(state, enc.state(0, 20))
 
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.string.encode(state, '🌾')
-  t.alike(state, { start: 5, end: 20, buffer: Buffer.from('\x04🌾\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00') })
+  t.alike(state, enc.state(5, 20, b4a.from('\x04🌾\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')))
   enc.string.encode(state, 'høsten er fin')
-  t.alike(state, { start: 20, end: 20, buffer: Buffer.from('\x04🌾\x0ehøsten er fin') })
+  t.alike(state, enc.state(20, 20, b4a.from('\x04🌾\x0ehøsten er fin')))
 
   state.start = 0
   t.is(enc.string.decode(state), '🌾')
@@ -316,68 +336,86 @@ tape('string', function (t) {
   t.exception(() => enc.string.decode(state))
 })
 
-tape('fixed32', function (t) {
+test('raw string', function (t) {
   const state = enc.state()
 
-  enc.fixed32.preencode(state, Buffer.alloc(32).fill('a'))
-  t.alike(state, { start: 0, end: 32, buffer: null })
-  enc.fixed32.preencode(state, Buffer.alloc(32).fill('b'))
-  t.alike(state, { start: 0, end: 64, buffer: null })
+  enc.raw.string.preencode(state, 'hello')
+  t.alike(state, enc.state(0, 5))
+  enc.raw.string.preencode(state, ' world')
+  t.alike(state, enc.state(0, 11))
 
-  state.buffer = Buffer.alloc(state.end)
-  enc.fixed32.encode(state, Buffer.alloc(32).fill('a'))
-  t.alike(state, { start: 32, end: 64, buffer: Buffer.alloc(64).fill('a', 0, 32) })
-  enc.fixed32.encode(state, Buffer.alloc(32).fill('b'))
-  t.alike(state, { start: 64, end: 64, buffer: Buffer.alloc(64).fill('a', 0, 32).fill('b', 32, 64) })
+  state.buffer = b4a.alloc(state.end)
+  enc.raw.string.encode(state, 'hello')
+  enc.raw.string.encode(state, ' world')
+  t.alike(state, enc.state(11, 11, b4a.from('hello world')))
 
   state.start = 0
-  t.alike(enc.fixed32.decode(state), Buffer.alloc(32).fill('a'))
-  t.alike(enc.fixed32.decode(state), Buffer.alloc(32).fill('b'))
+  t.is(enc.raw.string.decode(state), 'hello world')
+  t.is(enc.raw.string.decode(state), '')
+})
+
+test('fixed32', function (t) {
+  const state = enc.state()
+
+  enc.fixed32.preencode(state, b4a.alloc(32).fill('a'))
+  t.alike(state, enc.state(0, 32))
+  enc.fixed32.preencode(state, b4a.alloc(32).fill('b'))
+  t.alike(state, enc.state(0, 64))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.fixed32.encode(state, b4a.alloc(32).fill('a'))
+  t.alike(state, enc.state(32, 64, b4a.alloc(64).fill('a', 0, 32)))
+  enc.fixed32.encode(state, b4a.alloc(32).fill('b'))
+  t.alike(state, enc.state(64, 64, b4a.alloc(64).fill('a', 0, 32).fill('b', 32, 64)))
+
+  state.start = 0
+  t.alike(enc.fixed32.decode(state), b4a.alloc(32).fill('a'))
+  t.alike(enc.fixed32.decode(state), b4a.alloc(32).fill('b'))
   t.is(state.start, state.end)
 
   t.exception(() => enc.fixed32.decode(state))
 })
 
-tape('fixed64', function (t) {
+test('fixed64', function (t) {
   const state = enc.state()
 
-  enc.fixed64.preencode(state, Buffer.alloc(64).fill('a'))
-  t.alike(state, { start: 0, end: 64, buffer: null })
-  enc.fixed64.preencode(state, Buffer.alloc(64).fill('b'))
-  t.alike(state, { start: 0, end: 128, buffer: null })
+  enc.fixed64.preencode(state, b4a.alloc(64).fill('a'))
+  t.alike(state, enc.state(0, 64))
+  enc.fixed64.preencode(state, b4a.alloc(64).fill('b'))
+  t.alike(state, enc.state(0, 128))
 
-  state.buffer = Buffer.alloc(state.end)
-  enc.fixed64.encode(state, Buffer.alloc(64).fill('a'))
-  t.alike(state, { start: 64, end: 128, buffer: Buffer.alloc(128).fill('a', 0, 64) })
-  enc.fixed64.encode(state, Buffer.alloc(64).fill('b'))
-  t.alike(state, { start: 128, end: 128, buffer: Buffer.alloc(128).fill('a', 0, 64).fill('b', 64, 128) })
+  state.buffer = b4a.alloc(state.end)
+  enc.fixed64.encode(state, b4a.alloc(64).fill('a'))
+  t.alike(state, enc.state(64, 128, b4a.alloc(128).fill('a', 0, 64)))
+  enc.fixed64.encode(state, b4a.alloc(64).fill('b'))
+  t.alike(state, enc.state(128, 128, b4a.alloc(128).fill('a', 0, 64).fill('b', 64, 128)))
 
   state.start = 0
-  t.alike(enc.fixed64.decode(state), Buffer.alloc(64).fill('a'))
-  t.alike(enc.fixed64.decode(state), Buffer.alloc(64).fill('b'))
+  t.alike(enc.fixed64.decode(state), b4a.alloc(64).fill('a'))
+  t.alike(enc.fixed64.decode(state), b4a.alloc(64).fill('b'))
   t.is(state.start, state.end)
 
   t.exception(() => enc.fixed64.decode(state))
 })
 
-tape('fixed n', function (t) {
+test('fixed n', function (t) {
   const state = enc.state()
   const fixed = enc.fixed(3)
 
-  fixed.preencode(state, Buffer.alloc(3).fill('a'))
-  t.alike(state, { start: 0, end: 3, buffer: null })
-  fixed.preencode(state, Buffer.alloc(3).fill('b'))
-  t.alike(state, { start: 0, end: 6, buffer: null })
+  fixed.preencode(state, b4a.alloc(3).fill('a'))
+  t.alike(state, enc.state(0, 3))
+  fixed.preencode(state, b4a.alloc(3).fill('b'))
+  t.alike(state, enc.state(0, 6))
 
-  state.buffer = Buffer.alloc(state.end)
-  fixed.encode(state, Buffer.alloc(3).fill('a'))
-  t.alike(state, { start: 3, end: 6, buffer: Buffer.alloc(6).fill('a', 0, 3) })
-  fixed.encode(state, Buffer.alloc(3).fill('b'))
-  t.alike(state, { start: 6, end: 6, buffer: Buffer.alloc(6).fill('a', 0, 3).fill('b', 3, 6) })
+  state.buffer = b4a.alloc(state.end)
+  fixed.encode(state, b4a.alloc(3).fill('a'))
+  t.alike(state, enc.state(3, 6, b4a.alloc(6).fill('a', 0, 3)))
+  fixed.encode(state, b4a.alloc(3).fill('b'))
+  t.alike(state, enc.state(6, 6, b4a.alloc(6).fill('a', 0, 3).fill('b', 3, 6)))
 
   state.start = 0
-  t.alike(fixed.decode(state), Buffer.alloc(3).fill('a'))
-  t.alike(fixed.decode(state), Buffer.alloc(3).fill('b'))
+  t.alike(fixed.decode(state), b4a.alloc(3).fill('a'))
+  t.alike(fixed.decode(state), b4a.alloc(3).fill('b'))
   t.is(state.start, state.end)
 
   t.exception(() => fixed.decode(state))
@@ -385,20 +423,20 @@ tape('fixed n', function (t) {
   t.exception(() => fixed.decode(state))
 })
 
-tape('array', function (t) {
+test('array', function (t) {
   const state = enc.state()
   const arr = enc.array(enc.bool)
 
   arr.preencode(state, [true, false, true])
-  t.alike(state, { start: 0, end: 4, buffer: null })
+  t.alike(state, enc.state(0, 4))
   arr.preencode(state, [false, false, true, true])
-  t.alike(state, { start: 0, end: 9, buffer: null })
+  t.alike(state, enc.state(0, 9))
 
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   arr.encode(state, [true, false, true])
-  t.alike(state, { start: 4, end: 9, buffer: Buffer.from([3, 1, 0, 1, 0, 0, 0, 0, 0]) })
+  t.alike(state, enc.state(4, 9, b4a.from([3, 1, 0, 1, 0, 0, 0, 0, 0])))
   arr.encode(state, [false, false, true, true])
-  t.alike(state, { start: 9, end: 9, buffer: Buffer.from([3, 1, 0, 1, 4, 0, 0, 1, 1]) })
+  t.alike(state, enc.state(9, 9, b4a.from([3, 1, 0, 1, 4, 0, 0, 1, 1])))
 
   state.start = 0
   t.alike(arr.decode(state), [true, false, true])
@@ -408,22 +446,38 @@ tape('array', function (t) {
   t.exception(() => arr.decode(state))
 })
 
-tape('json', function (t) {
+test('raw array', function (t) {
+  const state = enc.state()
+  const arr = enc.raw.array(enc.bool)
+
+  arr.preencode(state, [true])
+  t.alike(state, enc.state(0, 1))
+  arr.preencode(state, [true])
+  t.alike(state, enc.state(0, 2))
+
+  state.buffer = b4a.alloc(state.end)
+  arr.encode(state, [true])
+  t.alike(state, enc.state(1, 2, b4a.from([1, 0])))
+  arr.encode(state, [true])
+  t.alike(state, enc.state(2, 2, b4a.from([1, 1])))
+
+  state.start = 0
+  t.alike(arr.decode(state), [true, true])
+  t.alike(arr.decode(state), [])
+})
+
+test('json', function (t) {
   const state = enc.state()
 
   enc.json.preencode(state, { a: 1, b: 2 })
-  t.alike(state, { start: 0, end: 14, buffer: null })
+  t.alike(state, enc.state(0, 14))
 
-  state.buffer = Buffer.alloc(state.end)
+  state.buffer = b4a.alloc(state.end)
   enc.json.encode(state, { a: 1, b: 2 })
-  t.alike(state, {
-    start: 14,
-    end: 14,
-    buffer: Buffer.concat([
-      Buffer.from([13]),
-      Buffer.from('{"a":1,"b":2}')
-    ])
-  })
+  t.alike(state, enc.state(14, 14, b4a.concat([
+    b4a.from([13]),
+    b4a.from('{"a":1,"b":2}')
+  ])))
 
   state.start = 0
   t.alike(enc.json.decode(state), { a: 1, b: 2 })
@@ -431,7 +485,23 @@ tape('json', function (t) {
   t.exception(() => enc.json.decode(state))
 })
 
-tape('lexint: big numbers', function (t) {
+test('raw json', function (t) {
+  const state = enc.state()
+
+  enc.raw.json.preencode(state, { a: 1, b: 2 })
+  t.alike(state, enc.state(0, 13))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.raw.json.encode(state, { a: 1, b: 2 })
+  t.alike(state, enc.state(13, 13, b4a.from('{"a":1,"b":2}')))
+
+  state.start = 0
+  t.alike(enc.raw.json.decode(state), { a: 1, b: 2 })
+
+  t.exception(() => enc.json.decode(state))
+})
+
+test('lexint: big numbers', function (t) {
   t.plan(1)
 
   let prev = enc.encode(enc.lexint, 0)
@@ -441,14 +511,14 @@ tape('lexint: big numbers', function (t) {
 
   for (n = 1; n < Number.MAX_VALUE; n += skip) {
     const cur = enc.encode(enc.lexint, n)
-    if (Buffer.compare(cur, prev) < 1) break
+    if (b4a.compare(cur, prev) < 1) break
     prev = cur
     skip = 1 + Math.pow(245, Math.ceil(Math.log(n) / Math.log(256)))
   }
   t.is(n, Infinity)
 })
 
-tape('lexint: range precision', function (t) {
+test('lexint: range precision', function (t) {
   t.plan(2)
   const a = 1e55
   const b = 1.0000000000001e55
@@ -458,44 +528,40 @@ tape('lexint: range precision', function (t) {
   t.not(ha, hb)
 })
 
-tape('lexint: range precision', function (t) {
+test('lexint: range precision', function (t) {
   let prev = enc.encode(enc.lexint, 0)
   const skip = 0.000000001e55
   for (let i = 0, n = 1e55; i < 1000; n = 1e55 + skip * ++i) {
     const cur = enc.encode(enc.lexint, n)
-    if (Buffer.compare(cur, prev) < 1) t.fail('cur <= prev')
+    if (b4a.compare(cur, prev) < 1) t.fail('cur <= prev')
     prev = cur
   }
   t.ok(true)
   t.end()
 })
 
-tape('lexint: small numbers', function (t) {
+test('lexint: small numbers', function (t) {
   let prev = enc.encode(enc.lexint, 0)
   for (let n = 1; n < 256 * 256 * 16; n++) {
     const cur = enc.encode(enc.lexint, n)
-    if (Buffer.compare(cur, prev) < 1) t.fail('cur <= prev')
+    if (b4a.compare(cur, prev) < 1) t.fail('cur <= prev')
     prev = cur
   }
   t.ok(true)
   t.end()
 })
 
-tape('lexint: throws', function (t) {
+test('lexint: throws', function (t) {
   t.exception(() => {
-    enc.decode(enc.lexint, Buffer.alloc(1, 251))
+    enc.decode(enc.lexint, b4a.alloc(1, 251))
   })
 
   let num = 252
 
-  const state = {
-    start: 0,
-    end: 0,
-    buffer: null
-  }
+  const state = enc.state()
 
   enc.lexint.preencode(state, num)
-  state.buffer = Buffer.alloc(state.end - state.start)
+  state.buffer = b4a.alloc(state.end - state.start)
   enc.lexint.encode(state, num)
 
   t.exception(() => {
@@ -509,7 +575,7 @@ tape('lexint: throws', function (t) {
   state.buffer = null
 
   enc.lexint.preencode(state, num)
-  state.buffer = Buffer.alloc(state.end - state.start)
+  state.buffer = b4a.alloc(state.end - state.start)
   enc.lexint.encode(state, num)
 
   t.exception(() => {
@@ -523,7 +589,7 @@ tape('lexint: throws', function (t) {
   state.buffer = null
 
   enc.lexint.preencode(state, num)
-  state.buffer = Buffer.alloc(state.end - state.start)
+  state.buffer = b4a.alloc(state.end - state.start)
   enc.lexint.encode(state, num)
 
   t.exception(() => {
@@ -537,7 +603,7 @@ tape('lexint: throws', function (t) {
   state.buffer = null
 
   enc.lexint.preencode(state, num)
-  state.buffer = Buffer.alloc(state.end - state.start)
+  state.buffer = b4a.alloc(state.end - state.start)
   enc.lexint.encode(state, num)
 
   t.exception(() => {
@@ -551,7 +617,7 @@ tape('lexint: throws', function (t) {
   state.buffer = null
 
   enc.lexint.preencode(state, num)
-  state.buffer = Buffer.alloc(state.end - state.start)
+  state.buffer = b4a.alloc(state.end - state.start)
   enc.lexint.encode(state, num)
 
   t.exception(() => {
@@ -561,7 +627,7 @@ tape('lexint: throws', function (t) {
   t.end()
 })
 
-tape('lexint: unpack', function (t) {
+test('lexint: unpack', function (t) {
   let n
   let skip = 1