cbor-x 0.8.2 → 0.9.2

package/dist/test.js

@@ -581,7 +581,7 @@
 		outcomesScore: outcomesScore
 	};
 
-	//import inspector from 'inspector'; inspector.open(9330, null, true); debugger
+	//import inspector from 'inspector'; inspector.open(9229, null, true); debugger
 	function tryRequire(module) {
 		try {
 			return require(module)
@@ -659,6 +659,13 @@
 			assert.deepEqual(deserialized, data);
 		});
 
+		test('255 chars', function() {
+			const data = 'RRZG9A6I7xupPeOZhxcOcioFsuhszGOdyDUcbRf4Zef2kdPIfC9RaLO4jTM5JhuZvTsF09fbRHMGtqk7YAgu3vespeTe9l61ziZ6VrMnYu2CamK96wCkmz0VUXyqaiUoTPgzk414LS9yYrd5uh7w18ksJF5SlC2e91rukWvNqAZJjYN3jpkqHNOFchCwFrhbxq2Lrv1kSJPYCx9blRg2hGmYqTbElLTZHv20iNqwZeQbRMgSBPT6vnbCBPnOh1W';
+			var serialized = CBOR.encode(data);
+			var deserialized = CBOR.decode(serialized);
+			assert.equal(deserialized, data);
+		});
+
 		test('encode/decode sample data', function(){
 			var data = sampleData;
 			var serialized = CBOR.encode(data);
@@ -676,6 +683,55 @@
 			var deserialized = encoder.decode(serialized);
 			assert.deepEqual(deserialized, data);
 		});
+		test('encode/decode sample data with packing', function(){
+			var data = sampleData;
+			let encoder = new Encoder({ pack: true, useRecords: false });
+			var serialized = encoder.encode(data);
+			var deserialized = encoder.decode(serialized);
+			assert.deepEqual(deserialized, data);
+		});
+		test('encode/decode sample data with packing and records', function(){
+			var data = sampleData;
+			let structures = [];
+			let encoder = new Encoder({ structures, pack: true, useRecords: true });
+			var serialized = encoder.encode(data);
+			var deserialized = encoder.decode(serialized);
+			assert.deepEqual(deserialized, data);
+		});
+		test('encode/decode sample data with shared packing and records', function(){
+			let encoder = new Encoder({ useRecords: true });
+			let finishPack = encoder.findCommonStringsToPack();
+			for (let i = 0; i < 20; i++) {
+				let data = {
+					shouldShare: 'same each time',
+					shouldShare2: 'same each time 2',
+					shouldntShare: 'different each time ' + i
+				};
+				if (i == 10)
+					finishPack({});
+				var serialized = encoder.encode(data);
+				var deserialized = encoder.decode(serialized);
+				assert.deepEqual(deserialized, data);
+			}
+		});
+		test('encode/decode sample data with individual packing, shared packing and records', function(){
+			let encoder = new Encoder({ pack: true, useRecords: true });
+			let finishPack = encoder.findCommonStringsToPack();
+			for (let i = 0; i < 20; i++) {
+				let data = {
+					shouldShare: 'same each time',
+					shouldShare2: 'same each time',
+					shouldntShare: 'different each time ' + i,
+					shouldntShare2: 'different each time ' + i,
+					noPack: 'no packing ' + i,
+				};
+				if (i == 10)
+					finishPack({ threshold: 5 });
+				var serialized = encoder.encode(data);
+				var deserialized = encoder.decode(serialized);
+				assert.deepEqual(deserialized, data);
+			}
+		});
 		if (typeof Buffer != 'undefined')
 		test('replace data', function(){
 			var data1 = {
@@ -787,10 +843,13 @@
 			let fa = new Float32Array(b.buffer, 8, 2);
 			fa[0] = 2.25;
 			fa[1] = 6;
+			let map = new Map();
+			map.set('key', 'value');
 			let object = {
 				error: new Error('test'),
 				set: new Set(['a', 'b']),
 				regexp: /test/gi,
+				map,
 				float32Array: fa,
 				uint16Array: new Uint16Array([3,4])
 			};
@@ -800,6 +859,7 @@
 			var serialized = encoder.encode(object);
 			var deserialized = encoder.decode(serialized);
 			assert.deepEqual(Array.from(deserialized.set), Array.from(object.set));
+			assert.equal(deserialized.map.get('key'), 'value');
 			assert.equal(deserialized.error.message, object.error.message);
 			assert.equal(deserialized.regexp.test('TEST'), true);
 			assert.equal(deserialized.float32Array.constructor.name, 'Float32Array');
@@ -810,6 +870,19 @@
 			assert.equal(deserialized.uint16Array[1], 4);
 		});
 
+		test('explicit maps and sets', function () {
+			let map = new Map();
+			map.set('key', { inside: 'value'});
+			let object = {
+				set: new Set(['a', 'b']),
+				map,
+			};
+			var serialized = encode(object); // default encoder
+			var deserialized = decode(serialized);
+			assert.deepEqual(Array.from(deserialized.set), Array.from(object.set));
+			assert.equal(deserialized.map.get('key').inside, 'value');
+		});
+
 		test('object without prototype', function(){
 			var data = Object.create(null);
 			data.test = 3;
@@ -825,6 +898,13 @@
 			var decoded = decode(encoded);
 			assert.equal(decoded.length, size);
 		});
+		test('little buffer', function() {
+			var data = typeof Buffer == 'undefined' ? new Uint8Array(0) : Buffer.alloc(0);
+			var encoded = encode(data);
+			assert.equal(encoded.length, 1); // make sure to use canonical form
+			var decoded = decode(encoded);
+			assert.equal(decoded.length, 0);
+		});
 
 		test('random strings', function(){
 			var data = [];
@@ -872,6 +952,7 @@
 			let encoder = new Encoder({
 				mapsAsObjects: true,
 				useTimestamp32: true,
+				useTag259ForMaps: false,
 			});
 			var serialized = encoder.encode(data);
 			var deserialized = encoder.decode(serialized);

package/encode.d.ts

@@ -0,0 +1,6 @@
+import { Decoder } from './decode'
+export { addExtension, FLOAT32_OPTIONS } from './unpack'
+export class Encoder extends Decoder {
+	encode(value: any): Buffer
+}
+export function encode(value: any): Buffer

package/encode.js

@@ -10,6 +10,7 @@ const ByteArray = hasNodeBuffer ? Buffer : Uint8Array
 const RECORD_STARTING_ID_PREFIX = 0x69 // tag 105/0x69
 const MAX_STRUCTURES = 0x100
 const MAX_BUFFER_SIZE = hasNodeBuffer ? 0x100000000 : 0x7fd00000
+let serializationId = 1
 let target
 let targetView
 let position = 0
@@ -25,6 +26,7 @@ export class Encoder extends Decoder {
 		let hasSharedUpdate
 		let structures
 		let referenceMap
+		options = options || {}
 		let lastSharedStructuresLength = 0
 		let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position, maxBytes) {
 			return target.utf8Write(string, position, maxBytes)
@@ -35,19 +37,25 @@ export class Encoder extends Decoder {
 
 		let encoder = this
 		let maxSharedStructures = 64
-		let isSequential = options && options.sequential
+		let isSequential = options.sequential
 		if (isSequential) {
 			maxSharedStructures = 0
 			this.structures = []
 		}
+		let samplingPackedValues, packedObjectMap, sharedValues = options.sharedValues
+		let sharedPackedObjectMap
+		if (sharedValues) {
+			sharedPackedObjectMap = Object.create(null)
+			for (let i = 0, l = sharedValues.length; i < l; i++) {
+				sharedPackedObjectMap[sharedValues[i]] = i
+			}
+
+		}
 		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 +68,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 +77,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 +87,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)
@@ -96,6 +105,29 @@ export class Encoder extends Decoder {
 			if (hasSharedUpdate)
 				hasSharedUpdate = false
 			structures = sharedStructures || []
+			packedObjectMap = sharedPackedObjectMap
+			if (options.pack) {
+				let packedValues = new Map()
+				packedValues.values = []
+				packedValues.encoder = encoder
+				packedValues.maxValues = options.maxPrivatePackedValues || (sharedPackedObjectMap ? 16 : Infinity)
+				packedValues.objectMap = sharedPackedObjectMap || false
+				packedValues.samplingPackedValues = samplingPackedValues
+				findRepetitiveStrings(value, packedValues)
+				if (packedValues.values.length > 0) {
+					target[position++] = 0xd8 // one-byte tag
+					target[position++] = 51 // tag 51 for packed shared structures https://www.potaroo.net/ietf/ids/draft-ietf-cbor-packed-03.txt
+					writeArrayHeader(4)
+					let valuesArray = packedValues.values
+					encode(valuesArray)
+					writeArrayHeader(0) // prefixes
+					writeArrayHeader(0) // suffixes
+					packedObjectMap = Object.create(sharedPackedObjectMap || null)
+					for (let i = 0, l = valuesArray.length; i < l; i++) {
+						packedObjectMap[valuesArray[i]] = i
+					}
+				}
+			}
 			try {
 				encode(value)
 				encoder.offset = position // update the offset so next serialization doesn't write over our buffer, but can continue writing to same buffer sequentially
@@ -108,7 +140,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 +159,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,15 +167,41 @@ 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)
+						let shared = encoder.structures || []
+						if (sharedValues) {
+							shared = shared.concat(sharedValues)
+						}
 
 						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
+						lastSharedStructuresLength = shared.length
+						return returnBuffer
+					}
+				}
+			}
+		}
+		this.findCommonStringsToPack = () => {
+			samplingPackedValues = new Map()
+			if (!sharedPackedObjectMap)
+				sharedPackedObjectMap = Object.create(null)
+			return ({ threshold }) => {
+				threshold = threshold || 4
+				let position = this.pack ? options.maxPrivatePackedValues || 16 : 0
+				if (!sharedValues)
+					sharedValues = this.sharedValues = []
+				for (let [ key, status ] of samplingPackedValues) {
+					if (status.count > threshold) {
+						sharedPackedObjectMap[key] = position++
+						sharedValues.push(key)
+						hasSharedUpdate = true
 					}
 				}
+				samplingPackedValues = null
 			}
 		}
 		const encode = (value) => {
@@ -148,6 +211,43 @@ export class Encoder extends Decoder {
 			var type = typeof value
 			var length
 			if (type === 'string') {
+				if (packedObjectMap) {
+					let packedPosition = packedObjectMap[value]
+					if (packedPosition >= 0) {
+						if (packedPosition < 16)
+							target[position++] = packedPosition + 0xe0 // simple values, defined in https://www.potaroo.net/ietf/ids/draft-ietf-cbor-packed-03.txt
+						else {
+							target[position++] = 0xc6 // tag 6 defined in https://www.potaroo.net/ietf/ids/draft-ietf-cbor-packed-03.txt
+							if (packedPosition & 1)
+								encode((15 - packedPosition) >> 1)
+							else
+								encode((packedPosition - 16) >> 1)
+						}
+						return
+/*						} else if (packedStatus.serializationId != serializationId) {
+							packedStatus.serializationId = serializationId
+							packedStatus.count = 1
+							if (options.sharedPack) {
+								let sharedCount = packedStatus.sharedCount = (packedStatus.sharedCount || 0) + 1
+								if (shareCount > (options.sharedPack.threshold || 5)) {
+									let sharedPosition = packedStatus.position = packedStatus.nextSharedPosition
+									hasSharedUpdate = true
+									if (sharedPosition < 16)
+										target[position++] = sharedPosition + 0xc0
+
+								}
+							}
+						} // else any in-doc incrementation?*/
+					} else if (samplingPackedValues && !options.pack) {
+						let status = samplingPackedValues.get(value)
+						if (status)
+							status.count++
+						else
+							samplingPackedValues.set(value, {
+								count: 1,
+							})
+					}
+				}
 				let strLength = value.length
 				let headerSize
 				// first we estimate the header size, so we can write to the correct location
@@ -257,7 +357,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 +403,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 +486,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 +577,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 +587,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,12 +614,9 @@ 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
-					else
-						writeArrayHeader(length + 2)
+					writeArrayHeader(length + 2)
 					encode(keys)
 					target[position++] = 0x19 // uint16
 					target[position++] = RECORD_STARTING_ID_PREFIX
@@ -570,7 +672,9 @@ function copyBinary(source, target, targetOffset, offset, endOffset) {
 }
 
 function writeArrayHeader(length) {
-	if (length < 0x100) {
+	if (length < 0x18)
+		target[position++] = 0x80 | length
+	else if (length < 0x100) {
 		target[position++] = 0x98
 		target[position++] = length
 	} else if (length < 0x10000) {
@@ -584,6 +688,56 @@ function writeArrayHeader(length) {
 	}
 }
 
+function findRepetitiveStrings(value, packedValues) {
+	switch(typeof value) {
+		case 'string':
+			if (value.length > 3) {
+				if (packedValues.objectMap[value] > -1 || packedValues.values.length >= packedValues.maxValues)
+					return
+				let packedStatus = packedValues.get(value)
+				if (packedStatus) {
+					if (++packedStatus.count == 2) {
+						packedValues.values.push(value)
+					}
+				} else {
+					packedValues.set(value, {
+						count: 1,
+					})
+					if (packedValues.samplingPackedValues) {
+						let status = packedValues.samplingPackedValues.get(value)
+						if (status)
+							status.count++
+						else
+							packedValues.samplingPackedValues.set(value, {
+								count: 1,
+							})
+					}
+				}
+			}
+			break
+		case 'object':
+			if (value) {
+				if (value instanceof Array) {
+					for (let i = 0, l = value.length; i < l; i++) {
+						findRepetitiveStrings(value[i], packedValues)
+					}
+
+				} else {
+					let includeKeys = !packedValues.encoder.useRecords
+					for (var key in value) {
+						if (value.hasOwnProperty(key)) {
+							if (includeKeys)
+								findRepetitiveStrings(key, packedValues)
+							findRepetitiveStrings(value[key], packedValues)
+						}
+					}
+				}
+			}
+			break
+		case 'function': console.log(value)
+	}
+}
+
 extensionClasses = [ Date, Set, Error, RegExp, ArrayBuffer, ByteArray,
 	Uint8Array, Uint8ClampedArray, Uint16Array, Uint32Array, BigUint64Array, Int8Array, Int16Array, Int32Array, BigInt64Array,
 	Float32Array, Float64Array]
@@ -655,7 +809,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 +869,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.js → node-index.js}

@@ -1,6 +1,7 @@
-export { Encoder, addExtension, encode, NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT } from './encode.js'
-export { Tag, Decoder, decodeMultiple, decode, FLOAT32_OPTIONS } from './decode.js'
+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'
@@ -20,4 +21,4 @@ function tryRequire(moduleId) {
 		else
 			console.warn('For browser usage, directly use cbor-x/decode or cbor-x/encode modules. ' + error.message.split('\n')[0])
 	}
-}
+}