cbor-x 0.8.0 → 0.9.0

package/encode.js

@@ -43,11 +43,8 @@ export class Encoder extends Decoder {
 		let recordIdsToRemove = []
 		let transitionsCount = 0
 		let serializationsSinceTransitionRebuild = 0
-		if (this.structures && this.structures.length > maxSharedStructures) {
-			throw new Error('Too many shared structures')
-		}
 
-		this.encode = function(value) {
+		this.encode = function(value, encodeOptions) {
 			if (!target) {
 				target = new ByteArrayAllocate(8192)
 				targetView = new DataView(target.buffer, 0, 8192)
@@ -60,7 +57,8 @@ export class Encoder extends Decoder {
 				targetView = new DataView(target.buffer, 0, target.length)
 				safeEnd = target.length - 10
 				position = 0
-			}
+			} else if (encodeOptions === REUSE_BUFFER_MODE)
+				position = (position + 7) & 0x7ffffff8 // Word align to make any future copying of this buffer faster
 			start = position
 			referenceMap = encoder.structuredClone ? new Map() : null
 			sharedStructures = encoder.structures
@@ -68,7 +66,7 @@ export class Encoder extends Decoder {
 				if (sharedStructures.uninitialized)
 					encoder.structures = sharedStructures = encoder.getStructures()
 				let sharedStructuresLength = sharedStructures.length
-				if (sharedStructuresLength >  maxSharedStructures && !isSequential)
+				if (sharedStructuresLength > maxSharedStructures && !isSequential)
 					sharedStructuresLength = maxSharedStructures
 				if (!sharedStructures.transitions) {
 					// rebuild our structure transitions
@@ -78,8 +76,8 @@ export class Encoder extends Decoder {
 						if (!keys)
 							continue
 						let nextTransition, transition = sharedStructures.transitions
-						for (let i =0, l = keys.length; i < l; i++) {
-							let key = keys[i]
+						for (let j = 0, l = keys.length; j < l; j++) {
+							let key = keys[j]
 							nextTransition = transition[key]
 							if (!nextTransition) {
 								nextTransition = transition[key] = Object.create(null)
@@ -108,7 +106,12 @@ export class Encoder extends Decoder {
 					referenceMap = null
 					return serialized
 				}
-				return target.subarray(start, position) // position can change if we call encode again in saveStructures, so we get the buffer now
+				if (encodeOptions === REUSE_BUFFER_MODE) {
+					target.start = start
+					target.end = position
+					return target
+				}
+				return target.subarray(start, position) // position can change if we call pack again in saveStructures, so we get the buffer now
 			} finally {
 				if (sharedStructures) {
 					if (serializationsSinceTransitionRebuild < 10)
@@ -122,7 +125,7 @@ export class Encoder extends Decoder {
 							recordIdsToRemove = []
 					} else if (recordIdsToRemove.length > 0 && !isSequential) {
 						for (let i = 0, l = recordIdsToRemove.length; i < l; i++) {
-							recordIdsToRemove[i][RECORD_SYMBOL] = 0
+							recordIdsToRemove[i][RECORD_SYMBOL] = undefined
 						}
 						recordIdsToRemove = []
 					}
@@ -130,13 +133,15 @@ export class Encoder extends Decoder {
 						if (encoder.structures.length > maxSharedStructures) {
 							encoder.structures = encoder.structures.slice(0, maxSharedStructures)
 						}
-
+						// we can't rely on start/end with REUSE_BUFFER_MODE since they will (probably) change when we save
+						let returnBuffer = target.subarray(start, position)
 						if (encoder.saveStructures(encoder.structures, lastSharedStructuresLength) === false) {
 							// get updated structures and try again if the update failed
 							encoder.structures = encoder.getStructures() || []
 							return encoder.encode(value)
 						}
 						lastSharedStructuresLength = encoder.structures.length
+						return returnBuffer
 					}
 				}
 			}
@@ -257,7 +262,7 @@ export class Encoder extends Decoder {
 						targetView.setFloat32(position, value)
 						let xShifted
 						if (useFloat32 < 4 ||
-							// this checks for  rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
+								// this checks for rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
 								((xShifted = value * mult10[((target[position] & 0x7f) << 1) | (target[position + 1] >> 7)]) >> 0) === xShifted) {
 							position += 4
 							return
@@ -303,6 +308,12 @@ export class Encoder extends Decoder {
 							encode(value[i])
 						}
 					} else if (constructor === Map) {
+						if (this.mapsAsObjects ? this.useTag259ForMaps !== false : this.useTag259ForMaps) {
+							// use Tag 259 (https://github.com/shanewholloway/js-cbor-codec/blob/master/docs/CBOR-259-spec--explicit-maps.md) for maps if the user wants it that way
+							target[position++] = 0xd9
+							target[position++] = 1
+							target[position++] = 3
+						}
 						length = value.size
 						if (length < 0x18) {
 							target[position++] = 0xa0 | length
@@ -380,10 +391,9 @@ export class Encoder extends Decoder {
 				}
 				position += 8
 			} else if (type === 'undefined') {
-				//target[position++] = 0xc1 // this is the "never-used" byte
 				target[position++] = 0xf7
 			} else {
-				throw new Error('Unknown type ' + type)
+				throw new Error('Unknown type: ' + type)
 			}
 		}
 
@@ -472,7 +482,7 @@ export class Encoder extends Decoder {
 			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null))
 			let newTransitions = 0
 			let length = keys.length
-			for (let i =0; i < length; i++) {
+			for (let i = 0; i < length; i++) {
 				let key = keys[i]
 				nextTransition = transition[key]
 				if (!nextTransition) {
@@ -482,7 +492,7 @@ export class Encoder extends Decoder {
 				transition = nextTransition
 			}
 			let recordId = transition[RECORD_SYMBOL]
-			if (recordId) {
+			if (recordId !== undefined) {
 				target[position++] = 0xd9 // tag two byte
 				target[position++] = RECORD_STARTING_ID_PREFIX
 				target[position++] = recordId
@@ -509,7 +519,7 @@ export class Encoder extends Decoder {
 						transitionsCount += serializationsSinceTransitionRebuild * newTransitions
 					// record the removal of the id, we can maintain our shared structure
 					if (recordIdsToRemove.length >= MAX_STRUCTURES - maxSharedStructures)
-						recordIdsToRemove.shift()[RECORD_SYMBOL] = 0 // we are cycling back through, and have to remove old ones
+						recordIdsToRemove.shift()[RECORD_SYMBOL] = undefined // we are cycling back through, and have to remove old ones
 					recordIdsToRemove.push(transition)
 					if (length < 0x16)
 						target[position++] = 0x82 + length // array header, length of values + 2
@@ -655,7 +665,9 @@ function typedArrayEncoder(tag) {
 }
 function writeBuffer(buffer, makeRoom) {
 	let length = buffer.byteLength
-	if (length < 0x100) {
+	if (length < 0x18) {
+		target[position++] = 0x40 + length
+	} else if (length < 0x100) {
 		target[position++] = 0x58
 		target[position++] = length
 	} else if (length < 0x10000) {
@@ -713,3 +725,4 @@ export const encode = defaultEncoder.encode
 export { FLOAT32_OPTIONS } from './decode.js'
 import { FLOAT32_OPTIONS } from './decode.js'
 export const { NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT } = FLOAT32_OPTIONS
+export const REUSE_BUFFER_MODE = 1000

package/index.d.ts

@@ -1,10 +1,11 @@
-export { Decoder, decode, addExtension, FLOAT32_OPTIONS } from './decode.js'
+export { Decoder, decode, addExtension, FLOAT32_OPTIONS, clearSource, roundFloat32 } from './decode.js'
 export { Encoder, encode } from './encode.js'
+import { Transform, Readable } from 'stream'
 
-export as namespace msgpackr;
-export class DecoderStream {
+export as namespace CBOR;
+export class DecoderStream extends Transform {
+	constructor(options?: Options | { highWaterMark: number, emitClose: boolean, allowHalfOpen: boolean })
 }
-export class EncoderStream {
-	write(value: any): void
-	end(value?: any): void
+export class EncoderStream extends Transform {
+	constructor(options?: Options | { highWaterMark: number, emitClose: boolean, allowHalfOpen: boolean })
 }

package/index.js

@@ -1,5 +1,5 @@
 export { Encoder, addExtension, encode, NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT } from './encode.js'
-export { Tag, Decoder, decodeMultiple, decode, FLOAT32_OPTIONS } from './decode.js'
+export { Tag, Decoder, decodeMultiple, decode, FLOAT32_OPTIONS, clearSource, roundFloat32 } from './decode.js'
+export { decodeIter, encodeIter } from './iterators.js'
 export const useRecords = false
 export const mapsAsObjects = true
-

package/iterators.js

@@ -0,0 +1,85 @@
+import { Encoder } from './encode.js'
+import { Decoder } from './decode.js'
+
+/**
+ * Given an Iterable first argument, returns an Iterable where each value is encoded as a Buffer
+ * If the argument is only Async Iterable, the return value will be an Async Iterable.
+ * @param {Iterable|Iterator|AsyncIterable|AsyncIterator} objectIterator - iterable source, like a Readable object stream, an array, Set, or custom object
+ * @param {options} [options] - cbor-x Encoder options
+ * @returns {IterableIterator|Promise.<AsyncIterableIterator>}
+ */
+export function encodeIter (objectIterator, options = {}) {
+  if (!objectIterator || typeof objectIterator !== 'object') {
+    throw new Error('first argument must be an Iterable, Async Iterable, or a Promise for an Async Iterable')
+  } else if (typeof objectIterator[Symbol.iterator] === 'function') {
+    return encodeIterSync(objectIterator, options)
+  } else if (typeof objectIterator.then === 'function' || typeof objectIterator[Symbol.asyncIterator] === 'function') {
+    return encodeIterAsync(objectIterator, options)
+  } else {
+    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a Promise')
+  }
+}
+
+function * encodeIterSync (objectIterator, options) {
+  const encoder = new Encoder(options)
+  for (const value of objectIterator) {
+    yield encoder.encode(value)
+  }
+}
+
+async function * encodeIterAsync (objectIterator, options) {
+  const encoder = new Encoder(options)
+  for await (const value of objectIterator) {
+    yield encoder.encode(value)
+  }
+}
+
+/**
+ * Given an Iterable/Iterator input which yields buffers, returns an IterableIterator which yields sync decoded objects
+ * Or, given an Async Iterable/Iterator which yields promises resolving in buffers, returns an AsyncIterableIterator.
+ * @param {Iterable|Iterator|AsyncIterable|AsyncIterableIterator} bufferIterator
+ * @param {object} [options] - Decoder options
+ * @returns {IterableIterator|Promise.<AsyncIterableIterator}
+ */
+export function decodeIter (bufferIterator, options = {}) {
+  if (!bufferIterator || typeof bufferIterator !== 'object') {
+    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a promise')
+  }
+
+  const decoder = new Decoder(options)
+  let incomplete
+  const parser = (chunk) => {
+    let yields
+    // if there's incomplete data from previous chunk, concatinate and try again
+    if (incomplete) {
+      chunk = Buffer.concat([incomplete, chunk])
+      incomplete = undefined
+    }
+
+    try {
+      yields = decoder.decodeMultiple(chunk)
+    } catch (err) {
+      if (err.incomplete) {
+        incomplete = chunk.slice(err.lastPosition)
+        yields = err.values
+      } else {
+        throw err
+      }
+    }
+    return yields
+  }
+
+  if (typeof bufferIterator[Symbol.iterator] === 'function') {
+    return (function * iter () {
+      for (const value of bufferIterator) {
+        yield * parser(value)
+      }
+    })()
+  } else if (typeof bufferIterator[Symbol.asyncIterator] === 'function') {
+    return (async function * iter () {
+      for await (const value of bufferIterator) {
+        yield * parser(value)
+      }
+    })()
+  }
+}

package/node-index.js

@@ -0,0 +1,24 @@
+export { Encoder, addExtension, encode, NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT, REUSE_BUFFER_MODE } from './encode.js'
+export { Tag, Decoder, decodeMultiple, decode, FLOAT32_OPTIONS, clearSource, roundFloat32 } from './decode.js'
+export { EncoderStream, DecoderStream } from './stream.js'
+export { decodeIter, encodeIter } from './iterators.js'
+export const useRecords = false
+export const mapsAsObjects = true
+import { setExtractor } from './decode.js'
+import { createRequire } from 'module'
+
+const extractor = tryRequire('cbor-extract')
+if (extractor)
+	setExtractor(extractor.extractStrings)
+
+function tryRequire(moduleId) {
+	try {
+		let require = createRequire(import.meta.url)
+		return require(moduleId)
+	} catch (error) {
+		if (typeof window == 'undefined')
+			console.warn('Native extraction module not loaded, cbor-x will still run, but with decreased performance. ' + error.message.split('\n')[0])
+		else
+			console.warn('For browser usage, directly use cbor-x/decode or cbor-x/encode modules. ' + error.message.split('\n')[0])
+	}
+}

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "cbor-x",
   "author": "Kris Zyp",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Ultra-fast CBOR implementation with tag extensions for records and structured cloning",
   "license": "MIT",
   "types": "./index.d.ts",
+  "main": "./dist/node.cjs",
+  "module": "./index.js",
   "keywords": [
     "CBOR",
     "performance",
@@ -16,55 +18,52 @@
     "url": "http://github.com/kriszyp/cbor-x"
   },
   "scripts": {
-    "benchmark": "node ./tests/benchmark.js",
+    "benchmark": "node ./tests/benchmark.cjs",
     "build": "rollup -c",
+    "dry-run": "npm publish --dry-run",
     "prepare": "npm run build",
-    "test": "./node_modules/.bin/mocha --experimental-json-modules tests/test.js -u tdd"
+    "test": "mocha tests/test**.*js -u tdd --experimental-json-modules"
   },
   "type": "module",
-  "main": "./dist/node.cjs",
   "exports": {
     ".": {
       "node": {
         "require": "./dist/node.cjs",
-        "import": "./node.js"
+        "import": "./node-index.js"
       },
-      "default": {
-        "import": "./index.js"
-      }
+      "default": "./index.js"
     },
-    "./pack": {
+    "./encode": {
       "node": {
         "import": "./index.js",
         "require": "./dist/node.cjs"
       },
       "default": {
-        "import": "./pack.js"
+        "import": "./encode.js"
       }
     },
-    "./unpack": {
+    "./decode": {
       "node": {
         "import": "./index.js",
         "require": "./dist/node.cjs"
       },
       "default": {
-        "import": "./unpack.js"
+        "import": "./decode.js"
       }
     }
   },
   "optionalDependencies": {
-    "cbor-extract": "^0.2.2"
+    "cbor-extract": "^0.3.2"
   },
   "devDependencies": {
+    "@types/node": "latest",
     "async": "^3",
     "cbor": "^5",
     "cbor-sync": "^1.0.4",
-    "@types/node": "latest",
-    "chai": "^4",
+    "chai": "^4.3.4",
     "esm": "^3.2.25",
     "mocha": "^8.1.3",
     "rollup": "^1.20.3",
-    "rollup-plugin-babel-minify": "^9.0.0",
-    "@rollup/plugin-json": "^4.1.0"
+    "rollup-plugin-babel-minify": "^9.0.0"
   }
 }

package/rollup.config.js

@@ -3,7 +3,7 @@ import json  from "@rollup/plugin-json";
 
 export default [
     {
-        input: "node.js",
+        input: "node-index.js",
         output: [
             {
                 file: "dist/node.cjs",
@@ -16,7 +16,7 @@ export default [
         output: {
             file: "dist/index.js",
             format: "umd",
-            name: "msgpackr"
+            name: "CBOR"
         }
     },    
     {
@@ -26,7 +26,7 @@ export default [
         output: {
             file: "dist/index.min.js",
             format: "umd",
-            name: "msgpackr"
+            name: "CBOR"
         }
     },
     {
@@ -38,8 +38,8 @@ export default [
             format: "iife",
             globals: {
                 chai: 'chai',
-                './index.js': 'msgpackr',
+                './index.js': 'CBOR',
             },
         }
     }
-];
+];

package/stream.js

@@ -1,24 +1,20 @@
 import { Transform } from 'stream'
 import { Encoder } from './encode.js'
-import { read, getPosition, Decoder, clearSource } from './decode.js'
+import { checkedRead, getPosition, Decoder, clearSource } from './decode.js'
 var DEFAULT_OPTIONS = {objectMode: true}
 
 export class EncoderStream extends Transform {
 	constructor(options) {
 		if (!options)
 			options = {}
+		options.writableObjectMode = true
 		super(options)
 		options.sequential = true
-		this.encoder = new Encoder(options)
+		this.encoder = options.encoder || new Encoder(options)
 	}
-	write(value) {
+	_transform(value, encoding, callback) {
 		this.push(this.encoder.encode(value))
-	}
-
-	end(value) {
-		if (value != null)
-			this.push(this.encoder.encode(value))
-		this.push(null)
+		callback()
 	}
 }
 
@@ -29,31 +25,33 @@ export class DecoderStream extends Transform {
 		options.objectMode = true
 		super(options)
 		options.structures = []
-		this.decoder = new Decoder(options)
+		this.decoder = options.decoder || new Decoder(options)
 	}
 	_transform(chunk, encoding, callback) {
 		if (this.incompleteBuffer) {
 			chunk = Buffer.concat([this.incompleteBuffer, chunk])
 			this.incompleteBuffer = null
 		}
-		let position = 0
-		let size = chunk.length
+		let values
 		try {
-			this.push(this.decoder.decode(chunk, size, true))
-			position = getPosition()
-			while (position < size) {
-				let value = read()
-				this.push(value)
-				position = getPosition()
-			}
+			values = this.decoder.decodeMultiple(chunk)
 		} catch(error) {
-			if (error.incomplete)
-				this.incompleteBuffer = chunk.slice(position)
+			if (error.incomplete) {
+				this.incompleteBuffer = chunk.slice(error.lastPosition)
+				values = error.values
+			}
 			else
 				throw error
 		} finally {
-			clearSource()
+			for (let value of values || []) {
+				if (value === null)
+					value = this.getNullValue()
+				this.push(value)
+			}
 		}
 		if (callback) callback()
 	}
+	getNullValue() {
+		return Symbol.for(null)
+	}
 }

package/tests/benchmark.cjs

@@ -1,4 +1,4 @@
-var cborX = tryRequire("..");
+var cborX = tryRequire("../dist/node.cjs");
 var msgpack_node = tryRequire("msgpack");
 var msgpack_msgpack = tryRequire("@msgpack/msgpack");
 var msgpack_lite = tryRequire("msgpack-lite");
@@ -43,12 +43,6 @@ console.log(rpad("", COL1, "-"), "|", lpad(":", COL2, "-"), "|", lpad(":", COL3,
 
 var buf, obj;
 
-if (JSON) {
-  buf = bench('buf = Buffer(JSON.stringify(obj));', JSON_stringify, data);
-  obj = bench('obj = JSON.parse(buf);', JSON.parse, buf);
-  test(obj);
-}
-
 if (cborX) {
 //  let packr = new msgpackr.Packr({ objectsAsMaps: true })
   buf = bench('require("cbor-x").encode(obj);', cborX.encode, data);
@@ -63,6 +57,18 @@ if (cborX) {
   obj = bench('cbor-x w/ shared structures: encoder.decode(buf);', encoder.decode.bind(encoder), buf);
   test(obj);
 }
+if (JSON) {
+  buf = bench('buf = Buffer(JSON.stringify(obj));', JSON_stringify, data);
+  obj = bench('obj = JSON.parse(buf);', JSON.parse, buf);
+  test(obj);
+}
+
+
+if (JSON) {
+  buf = bench('buf = Buffer(JSON.stringify(obj));', JSON_stringify, data);
+  obj = bench('obj = JSON.parse(buf);', JSON.parse, buf);
+  test(obj);
+}
 
 if (msgpack_lite) {
   buf = bench('buf = require("msgpack-lite").encode(obj);', msgpack_lite.encode, data);

package/tests/{test-compatibility.js → test-compatibility.cjs}

@@ -1,26 +1,21 @@
-import * as data from './example4.json';
-import * as msgpackr from '..'
-import * as chai from 'chai'
+const data = require('./example4.json');
+const cborX = require('..');
+const chai = require('chai');
 
-/*function tryRequire(module) {
+function tryRequire(module) {
 	try {
 		return require(module)
 	} catch(error) {
+		console.log(error)
 	}
 }
 //if (typeof chai === 'undefined') { chai = require('chai') }
-assert = chai.assert
-if (typeof cborX === 'undefined') { cborX = require('..') }
+const assert = chai.assert
 var cbor_module = tryRequire('cbor');
 var decode = cborX.decode
 var encode = cborX.encode
-//if (typeof msgpackr === 'undefined') { msgpackr = require('..') }
-var msgpack_msgpack = tryRequire('@msgpack/msgpack');
-var msgpack_lite = tryRequire('msgpack-lite');*/
-var unpack = msgpackr.unpack
-var pack = msgpackr.pack
 
-addCompatibilitySuite = (data) => () => {
+const addCompatibilitySuite = (data) => () => {
 	if (cbor_module) {
 		test('from cbor', function(){
 			var serialized = cbor_module.encode(data)

package/tests/test-incomplete.js

@@ -0,0 +1,41 @@
+import { encode } from '../index.js'
+import { assert } from 'chai'
+import { Encoder } from '../encode.js'
+
+const tests = {
+  string: 'interesting string',
+  number: 12345,
+  buffer: Buffer.from('hello world'),
+  bigint: 12345678910n,
+  array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+  'many-strings': [],
+  set: new Set('abcdefghijklmnopqrstuvwxyz'.split('')),
+  object: { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 }
+}
+for (let i = 0; i < 100; i++) {
+  tests['many-strings'].push('test-data-' + i)
+}
+
+suite('encode and decode tests with partial values', function () {
+  const encoder = new Encoder({ objectMode: true, structures: [] })
+
+  for (const [label, testData] of Object.entries(tests)) {
+    test(label, () => {
+      const encoded = encoder.encode(testData)
+      assert.isTrue(Buffer.isBuffer(encoded), 'encode returns a Buffer')
+      assert.deepStrictEqual(encoder.decode(encoded, encoded.length, true), testData, 'full buffer decodes well')
+      const firstHalf = encoded.slice(0, Math.floor(encoded.length / 2))
+      let value
+      try {
+        value = encoder.decode(firstHalf, firstHalf.length, true)
+      } catch (err) {
+        if (err.incomplete !== true) {
+          assert.fail(`Should throw an error with .incomplete set to true, instead threw error <${err}>`)
+        } else {
+          return; // victory! correct outcome!
+        }
+      }
+      assert.fail(`Should throw an error with .incomplete set to true, instead returned value ${JSON.stringify(value)}`)
+    })
+  }
+})

package/tests/test-node-iterators.js

@@ -0,0 +1,72 @@
+import { encodeIter, decodeIter } from '../index.js'
+import { decode } from '../index.js'
+import { assert } from 'chai'
+
+const tests = [
+  null,
+  false,
+  true,
+  'interesting string',
+  12345,
+  123456789n,
+  123.456,
+  Buffer.from('Hello World'),
+  new Set('abcdefghijklmnopqrstuvwxyz'.split(''))
+]
+
+suite('cbor-x iterators interface tests', function () {
+  test('sync encode iterator', () => {
+    const encodings = [...encodeIter(tests)]
+    const decodings = encodings.map(x => decode(x))
+    assert.deepStrictEqual(decodings, tests)
+  })
+
+  test('async encode iterator', async () => {
+    async function * generate () {
+      for (const test of tests) {
+        await new Promise((resolve, reject) => setImmediate(resolve))
+        yield test
+      }
+    }
+
+    const chunks = []
+    for await (const chunk of encodeIter(generate())) {
+      chunks.push(chunk)
+    }
+
+    const decodings = chunks.map(x => decode(x))
+    assert.deepStrictEqual(decodings, tests)
+  })
+
+  test('sync encode and decode iterator', () => {
+    const encodings = [...encodeIter(tests)]
+    assert.isTrue(encodings.every(v => Buffer.isBuffer(v)))
+    const decodings = [...decodeIter(encodings)]
+    assert.deepStrictEqual(decodings, tests)
+
+    // also test decodings work with buffers multiple values in a buffer
+    const concatEncoding = Buffer.concat([...encodings])
+    const decodings2 = [...decodeIter([concatEncoding])]
+    assert.deepStrictEqual(decodings2, tests)
+
+    // also test decodings work with partial buffers that don't align to values perfectly
+    const half1 = concatEncoding.slice(0, Math.floor(concatEncoding.length / 2))
+    const half2 = concatEncoding.slice(Math.floor(concatEncoding.length / 2))
+    const decodings3 = [...decodeIter([half1, half2])]
+    assert.deepStrictEqual(decodings3, tests)
+  })
+
+  test('async encode and decode iterator', async () => {
+    async function * generator () {
+      for (const obj of tests) {
+        await new Promise((resolve, reject) => setImmediate(resolve))
+        yield obj
+      }
+    }
+    const yields = []
+    for await (const value of decodeIter(encodeIter(generator()))) {
+      yields.push(value)
+    }
+    assert.deepStrictEqual(yields, tests)
+  })
+})