cbor-x 1.6.7 → 1.6.9

package/dist/node.cjs

@@ -17,7 +17,6 @@ const RECORD_DEFINITIONS_ID = 0xdffe;
 const RECORD_INLINE_ID = 0xdfff; // temporary first-come first-serve tag // proposed tag: 0x7265 // 're'
 const BUNDLED_STRINGS_ID = 0xdff9;
 const PACKED_REFERENCE_TAG_ID = 6;
-const STOP_CODE = {};
 let maxArraySize = 112810000; // This is the maximum array size in V8. We would potentially detect and set it higher
 // for JSC, but this is pretty large and should be sufficient for most use cases
 let maxMapSize = 16810000; // JavaScript has a fixed maximum map size of about 16710000, but JS itself enforces this,
@@ -128,16 +127,11 @@ class Decoder {
 			// re-entrant execution, save the state and restore it after we do this decode
 			return saveState(() => {
 				clearSource();
-				try {
-					return this ? this.decode(source, end) : Decoder.prototype.decode.call(defaultOptions, source, end)
-				} catch (error) {
-					if (error && typeof error == 'object')
-						nestedDecodeErrors.add(error);
-					throw error
-				}
+				return this ? this.decode(source, end) : Decoder.prototype.decode.call(defaultOptions, source, end)
 			})
 		}
-		srcEnd = end > -1 ? end : source.length;
+		// past the view, the JS string readers would decode the missing bytes as zeros instead of failing as truncated
+		srcEnd = end > -1 && end < source.length ? end : source.length;
 		position$1 = 0;
 		stringPosition = 0;
 		srcStringEnd = 0;
@@ -177,18 +171,28 @@ class Decoder {
 		return checkedRead()
 	}
 	decodeMultiple(source, forEach) {
+		if (src) {
+			// Keep the complete nested sequence inside its own decoder state.
+			return saveState(() => {
+				clearSource();
+				return this ? this.decodeMultiple(source, forEach) : defaultDecoder.decodeMultiple(source, forEach)
+			})
+		}
 		let values, lastPosition = 0;
 		try {
 			let size = source.length;
 			sequentialMode = true;
 			let value = this ? this.decode(source, size) : defaultDecoder.decode(source, size);
 			if (forEach) {
+				let end = position$1;
 				if (forEach(value) === false) {
 					return
 				}
-				while(position$1 < size) {
-					lastPosition = position$1;
-					if (forEach(checkedRead()) === false) {
+				while(end < size) {
+					lastPosition = end;
+					value = checkedRead();
+					end = position$1;
+					if (forEach(value) === false) {
 						return
 					}
 				}
@@ -202,8 +206,10 @@ class Decoder {
 				return values
 			}
 		} catch(error) {
-			error.lastPosition = lastPosition;
-			error.values = values;
+			if (error && (typeof error == 'object' || typeof error == 'function')) {
+				error.lastPosition = lastPosition;
+				error.values = values;
+			}
 			throw error
 		} finally {
 			sequentialMode = false;
@@ -212,8 +218,10 @@ class Decoder {
 	}
 }
 const nestedDecodeErrors = new WeakSet();
+let arrayAllocationBudget;
 function checkedRead() {
 	try {
+		arrayAllocationBudget = srcEnd - position$1;
 		let result = read();
 		if (bundledStrings$1) {
 			if (position$1 >= bundledStrings$1.postBundlePosition)
@@ -255,9 +263,21 @@ function checkedRead() {
 	}
 }
 
-function endOfCBORError() {
+function readBreak() {
+	if (position$1 < srcEnd && src[position$1] === 0xff) {
+		position$1++;
+		return true
+	}
+	return false
+}
+// neededEnd, from a length check, is a position that the source must extend to before the item can decode. It is a
+// lower bound for any completion of the source: every byte read before the check was within the source, so a longer
+// source reaches the same check with the same length. Streams wait for it instead of decoding on every chunk.
+function endOfCBORError(neededEnd) {
 	let error = new Error('Unexpected end of CBOR data');
 	error.incomplete = true;
+	if (neededEnd)
+		error.neededEnd = neededEnd;
 	return error
 }
 
@@ -309,6 +329,9 @@ function read() {
 				} else if (currentDecoder.int64AsNumber) {
 					token = dataView.getUint32(position$1) * 0x100000000;
 					token += dataView.getUint32(position$1 + 4);
+					position$1 += 8;
+					if (majorType === 1) return -1 - token
+					break
 				} else token = dataView.getBigUint64(position$1);
 				position$1 += 8;
 				break
@@ -320,10 +343,10 @@ function read() {
 						throw new Error('Indefinite length not supported for byte or text strings')
 					case 4: // array
 						let array = [];
-						let value, i = 0;
-						while ((value = read()) != STOP_CODE) {
+						let i = 0;
+						while (!readBreak()) {
 							if (i >= maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`)
-							array[i++] = value;
+							array[i++] = read();
 						}
 						return majorType == 4 ? array : majorType == 3 ? array.join('') : Buffer.concat(array)
 					case 5: // map
@@ -332,13 +355,15 @@ function read() {
 							let object = {};
 							let i = 0;
 							if (currentDecoder.keyMap) {
-								while((key = read()) != STOP_CODE) {
+								while (!readBreak()) {
+									key = read();
 									if (i++ >= objectSizeLimit) throw new Error(`Property count exceeds ${objectSizeLimit}`)
 									object[safeKey(currentDecoder.decodeKey(key))] = read();
 								}
 							}
 							else {
-								while ((key = read()) != STOP_CODE) {
+								while (!readBreak()) {
+									key = read();
 									if (i++ >= objectSizeLimit) throw new Error(`Property count exceeds ${objectSizeLimit}`)
 									object[safeKey(key)] = read();
 								}
@@ -352,7 +377,8 @@ function read() {
 							let map = new Map();
 							if (currentDecoder.keyMap) {
 								let i = 0;
-								while((key = read()) != STOP_CODE) {
+								while (!readBreak()) {
+									key = read();
 									if (i++ >= maxMapSize) {
 										throw new Error(`Map size exceeds ${maxMapSize}`);
 									}
@@ -361,7 +387,8 @@ function read() {
 							}
 							else {
 								let i = 0;
-								while ((key = read()) != STOP_CODE) {
+								while (!readBreak()) {
+									key = read();
 									if (i++ >= maxMapSize) {
 										throw new Error(`Map size exceeds ${maxMapSize}`);
 									}
@@ -371,7 +398,8 @@ function read() {
 							return map
 						}
 					case 7:
-						return STOP_CODE
+						// readBreak consumes every break that ends an indefinite-length item
+						throw new Error('Unexpected break stop code outside of an indefinite-length item')
 					default:
 						throw new Error('Invalid major type for indefinite length ' + majorType)
 				}
@@ -385,13 +413,13 @@ function read() {
 		case 1: // negative int
 			return ~token
 		case 2: // buffer
-			if (token > srcEnd - position$1) throw endOfCBORError()
+			if (token > srcEnd - position$1) throw endOfCBORError(position$1 + token)
 			return readBin(token)
 		case 3: // string
 			if (srcStringEnd >= position$1) { // already extracted, which only covers complete strings
 				return srcString.slice(position$1 - srcStringStart, (position$1 += token) - srcStringStart)
 			}
-			if (token > srcEnd - position$1) throw endOfCBORError()
+			if (token > srcEnd - position$1) throw endOfCBORError(position$1 + token)
 			if (srcStringEnd == 0 && srcEnd < 140 && token < 32) {
 				// for small blocks, avoiding the overhead of the extract call is helpful
 				let string = token < 16 ? shortStringInJS(token) : longStringInJS(token);
@@ -403,7 +431,9 @@ function read() {
 			if (token > maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`)
 			// every element occupies at least one byte, so a length beyond what remains in the source can
 			// never be satisfied; check before allocating so a tiny header can not force a huge allocation
-			if (token > srcEnd - position$1) throw endOfCBORError()
+			// nested arrays each pass the check above yet still preallocate, so also spend from a
+			// per-decode budget of the remaining bytes; the summed lengths of any valid tree stay under it
+			if (token > srcEnd - position$1 || (arrayAllocationBudget -= token) < 0) throw endOfCBORError(position$1 + token)
 			let array = new Array(token);
 		  //if (currentDecoder.keyMap) for (let i = 0; i < token; i++) array[i] = currentDecoder.decodeKey(read())	
 			//else 
@@ -412,7 +442,7 @@ function read() {
 		case 5: // map
 			if (currentDecoder.mapsAsObjects) {
 				if (token > objectSizeLimit) throw new Error(`Property count exceeds ${objectSizeLimit}`)
-				if (token > (srcEnd - position$1) / 2) throw endOfCBORError() // each entry needs at least two bytes
+				if (token > (srcEnd - position$1) / 2) throw endOfCBORError(position$1 + 2 * token) // each entry needs at least two bytes
 				let object = {};
 				if (currentDecoder.keyMap) for (let i = 0; i < token; i++) object[safeKey(currentDecoder.decodeKey(read()))] = read();
 				else for (let i = 0; i < token; i++) object[safeKey(read())] = read();
@@ -423,7 +453,7 @@ function read() {
 					restoreMapsAsObject = false;
 				}
 				if (token > maxMapSize) throw new Error(`Map size exceeds ${maxMapSize}`)
-				if (token > (srcEnd - position$1) / 2) throw endOfCBORError()
+				if (token > (srcEnd - position$1) / 2) throw endOfCBORError(position$1 + 2 * token)
 				let map = new Map();
 				if (currentDecoder.keyMap) for (let i = 0; i < token; i++) map.set(currentDecoder.decodeKey(read()),read());
 				else for (let i = 0; i < token; i++) map.set(read(), read());
@@ -939,6 +969,7 @@ currentExtensions[LEGACY_RECORD_INLINE_ID] = (data) => {
 	}
 	return object
 };
+const legacyRecordDefinition = currentExtensions[LEGACY_RECORD_INLINE_ID];
 currentExtensions[14] = (value) => {
 	if (bundledStrings$1)
 		return bundledStrings$1[0].slice(bundledStrings$1.position0, bundledStrings$1.position0 += value)
@@ -1211,6 +1242,9 @@ function loadShared() {
 }
 
 function saveState(callback) {
+	let savedFragmentEnd = fragmentEnd;
+	let savedFragmentReader = fragmentReadString;
+	let savedReadFixedString = readFixedString;
 	let savedSrcEnd = srcEnd;
 	let savedPosition = position$1;
 	let savedStringPosition = stringPosition;
@@ -1220,6 +1254,7 @@ function saveState(callback) {
 	let savedStrings = strings;
 	let savedReferenceMap = referenceMap;
 	let savedBundledStrings = bundledStrings$1;
+	let savedPackedValues = packedValues;
 
 	// TODO: We may need to revisit this if we do more external calls to user code (since it could be slow)
 	let savedSrc = new Uint8Array(src.slice(0, srcEnd)); // we copy the data in case it changes while external data is processed
@@ -1227,10 +1262,23 @@ function saveState(callback) {
 	let savedDecoder = currentDecoder;
 	let savedSequentialMode = sequentialMode;
 	let savedRestoreMapsAsObject = restoreMapsAsObject;
+	let savedArrayAllocationBudget = arrayAllocationBudget;
+	fragmentEnd = 0;
+	if (fragmentReadString) readFixedString = fragmentReadString;
+	fragmentReadString = null;
 	restoreMapsAsObject = false;
 	try {
 		return callback()
+	} catch (error) {
+		// the callback decodes its own source (a shared structures blob, or an extension's embedded data), so a
+		// truncation there cannot be completed by more of the outer input; checkedRead() clears the flag
+		if (error && (typeof error == 'object' || typeof error == 'function'))
+			nestedDecodeErrors.add(error);
+		throw error
 	} finally {
+		fragmentEnd = savedFragmentEnd;
+		fragmentReadString = savedFragmentReader;
+		readFixedString = savedReadFixedString;
 		srcEnd = savedSrcEnd;
 		position$1 = savedPosition;
 		stringPosition = savedStringPosition;
@@ -1240,11 +1288,13 @@ function saveState(callback) {
 		strings = savedStrings;
 		referenceMap = savedReferenceMap;
 		bundledStrings$1 = savedBundledStrings;
+		packedValues = savedPackedValues;
 		src = savedSrc;
 		sequentialMode = savedSequentialMode;
 		currentStructures = savedStructures;
 		currentDecoder = savedDecoder;
 		restoreMapsAsObject = savedRestoreMapsAsObject;
+		arrayAllocationBudget = savedArrayAllocationBudget;
 		dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
 	}
 }
@@ -1254,8 +1304,87 @@ function clearSource() {
 	currentStructures = null;
 }
 
+const registeredExtensions = new Map();
+let fragmentEnd = 0;
+let fragmentReadString;
+
+const builtinScanTags = new Map([[LEGACY_RECORD_INLINE_ID, legacyRecordDefinition], [259, currentExtensions[259]]]);
+function isBuiltinScanTag(tag) {
+	return builtinScanTags.has(tag) && currentExtensions[tag] === builtinScanTags.get(tag)
+}
+
+function getScanTag(tag, decoder) {
+	return tag >= BUNDLED_STRINGS_ID && decoder.structures && decoder.structures[tag & 0x1fff]
+}
+
+function checkScanContainer(major, length, mapsAsObjects) {
+	if (major === 4) {
+		if (length > maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`)
+	} else if (mapsAsObjects) {
+		if (length > objectSizeLimit) throw new Error(`Property count exceeds ${objectSizeLimit}`)
+	} else if (length > maxMapSize) throw new Error(`Map size exceeds ${maxMapSize}`)
+}
+
+function decodeScanned(decoder, source, end) {
+	const boundStrings = exports.isNativeAccelerationEnabled && end < source.length;
+	if (!registeredExtensions.size && !boundStrings) return decoder.decodeMultiple(source)
+	const savedEnd = fragmentEnd;
+	const savedReader = readFixedString;
+	const savedFragmentReader = fragmentReadString;
+	const originals = [];
+	fragmentEnd = end;
+	fragmentReadString = savedReader;
+	try {
+		if (boundStrings) readFixedString = (length) => {
+			if (!fragmentEnd || position$1 >= fragmentEnd) return savedReader(length)
+			const savedSrcEnd = srcEnd;
+			srcEnd = fragmentEnd;
+			try { return savedReader(length) } finally { srcEnd = savedSrcEnd; }
+		};
+		for (const [tag, extension] of registeredExtensions) {
+			if (!extension.handlesRead) continue
+			const original = currentExtensions[tag];
+			const guarded = (read) => {
+				if (!fragmentEnd || position$1 >= fragmentEnd) return extension(read)
+				let calls = 0, framingError;
+				const value = extension(() => {
+					if (calls++) {
+						framingError = new Error('Tag ' + tag + ': fragmented decoding cannot frame multi-item handlesRead extensions');
+						throw framingError
+					}
+					return read()
+				});
+				if (framingError) throw framingError
+				return value
+			};
+			guarded.handlesRead = true;
+			originals.push([tag, original, guarded]);
+			currentExtensions[tag] = guarded;
+		}
+		return decoder.decodeMultiple(source)
+	} finally {
+		fragmentEnd = savedEnd;
+		fragmentReadString = savedFragmentReader;
+		readFixedString = savedReader;
+		for (const [tag, original, guarded] of originals) {
+			if (currentExtensions[tag] === guarded) currentExtensions[tag] = original;
+		}
+	}
+}
+
+// Internal streaming hooks; not part of the public decoder API.
+const _stream = {
+	getTag: getScanTag,
+	isBuiltinTag: isBuiltinScanTag,
+	checkContainer: checkScanContainer,
+	decode: decodeScanned,
+	get readThreshold() { return inlineObjectReadThreshold }
+};
+
 function addExtension$1(extension) {
 	currentExtensions[extension.tag] = extension.decode;
+	if (typeof extension.decode === 'function') registeredExtensions.set(extension.tag, extension.decode);
+	else registeredExtensions.delete(extension.tag);
 }
 
 function setSizeLimits(limits) {
@@ -1855,6 +1984,11 @@ class Encoder extends Decoder {
 								return encode(json)
 						}
 
+						// not in extensions, so class instances that reach writeObject do not pay another instanceof
+						if (constructor === DataView) {
+							writeBuffer(new Uint8Array(value.buffer, value.byteOffset, value.byteLength), makeRoom);
+							return
+						}
 						// no extension found, write as a plain object
 						writeObject(value);
 					}
@@ -1948,8 +2082,22 @@ class Encoder extends Decoder {
 					size++;
 				}
 			}
-			target[objectOffset++ + start] = size >> 8;
-			target[objectOffset + start] = size & 0xff;
+			if (size < 0x10000) {
+				// fits in a map-16 (uint16) count: back-patch the reserved 2 bytes
+				target[objectOffset++ + start] = size >> 8;
+				target[objectOffset + start] = size & 0xff;
+			} else {
+				// too many entries for a map-16 count: widen the already-written header
+				// to map-32, mirroring writeArrayHeader's 0x9a/setUint32 path. Shift the
+				// encoded entries 2 bytes forward to make room for the wider (uint32) count.
+				if (position + 2 > safeEnd)
+					makeRoom(position + 2);
+				let headerPosition = objectOffset + start;
+				target.copyWithin(headerPosition + 4, headerPosition + 2, position);
+				position += 2;
+				target[headerPosition - 1] = 0xba; // map 32
+				targetView.setUint32(headerPosition, size);
+			}
 		} :
 		(object, skipValues) => {
 			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
@@ -2516,59 +2664,256 @@ const REUSE_BUFFER_MODE = 512;
 const RESET_BUFFER_MODE = 1024;
 const THROW_ON_ITERABLE = 2048;
 
-class EncoderStream extends stream.Transform {
-	constructor(options) {
-		if (!options)
-			options = {};
-		options.writableObjectMode = true;
-		super(options);
-		options.sequential = true;
-		this.encoder = options.encoder || new Encoder(options);
-	}
-	async _transform(value, encoding, callback) {
-		try {
-			for await (let chunk of this.encoder.encodeAsAsyncIterable(value)) {
-				this.push(chunk);
-			}
-			callback();
-		} catch(error) { callback (error); }
-	}
-}
+// Positions are relative to the retained value, including bundle pointers. Frames and their storage survive appends.
+class StructureScanner {
+  constructor (decoder) {
+    this.decoder = decoder;
+    this.frames = [];
+    this.records = new Map();
+    this.readers = new Map();
+    this.reset();
+  }
 
-class DecoderStream extends stream.Transform {
-	constructor(options) {
-		if (!options)
-			options = {};
-		options.objectMode = true;
-		super(options);
-		options.structures = [];
-		this.decoder = options.decoder || new Decoder(options);
-	}
-	_transform(chunk, encoding, callback) {
-		if (this.incompleteBuffer) {
-			chunk = Buffer.concat([this.incompleteBuffer, chunk]);
-			this.incompleteBuffer = null;
-		}
-		let values, fatalError;
-		try {
-			values = this.decoder.decodeMultiple(chunk);
-		} catch(error) {
-			values = error.values;
-			if (error.incomplete)
-				this.incompleteBuffer = chunk.slice(error.lastPosition);
-			else
-				fatalError = error;
-		}
-		for (let value of values || []) {
-			if (value === null)
-				value = this.getNullValue();
-			this.push(value);
-		}
-		callback(fatalError);
-	}
-	getNullValue() {
-		return Symbol.for(null)
-	}
+  reset () {
+    this.position = 0;
+    this.depth = 0;
+    this.neededLength = 0;
+    this.postBundlePosition = 0;
+    this.headers = 0;
+    this.mapsAsObjects = !!this.decoder.mapsAsObjects;
+    this.restoreMap = false;
+    this.records.clear();
+    this.readers.clear();
+    this.push('items', 1);
+  }
+
+  push (kind, remaining) {
+    if (this.depth === 16384) throw new RangeError('Maximum CBOR nesting depth exceeded')
+    const frame = this.frames[this.depth] || (this.frames[this.depth] = {});
+    frame.kind = kind;
+    frame.remaining = remaining;
+    frame.stage = 0;
+    frame.id = undefined;
+    frame.restoreMap = false;
+    frame.legacy = false;
+    frame.definition = undefined;
+    frame.limitMajor = 0;
+    frame.count = 0;
+    this.depth++;
+    return frame
+  }
+
+  header (source, end, lengthOnly = false) {
+    const start = this.position;
+    if (start >= end) {
+      this.neededLength = start + 1;
+      return false
+    }
+    const byte = source[start];
+    const major = byte >> 5;
+    const info = byte & 31;
+    const width = info < 24 || (lengthOnly && info > 26) ? 0 : info === 24 ? 1 : info === 25 ? 2 : info === 26 ? 4 : info === 27 ? 8 : 0;
+    if (!lengthOnly && info >= 28 && info <= 30) throw new Error('Unknown token ' + info)
+    if (start + 1 + width > end) {
+      this.neededLength = start + 1 + width;
+      return false
+    }
+    let value = info;
+    if (width) {
+      value = 0;
+      for (let i = start + 1; i <= start + width; i++) value = value * 256 + source[i];
+      if (width === 8 && major > 1 && major !== 7 && value > 0xffffffff) {
+        throw new Error('JavaScript does not support arrays, maps, or strings with length over 4294967295')
+      }
+    }
+    this.major = major;
+    this.info = info;
+    this.argument = value;
+    this.position = start + 1 + width;
+    this.headers++;
+    return true
+  }
+
+  scan (source, end) {
+    while (this.depth) {
+      if (this.position > end) {
+        this.neededLength = this.position;
+        return false
+      }
+      const frame = this.frames[this.depth - 1];
+      if (frame.kind === 'bundle') {
+        if (frame.stage === 0) {
+          if (!this.header(source, end, true)) return false
+          frame.remaining = Math.max(0, this.argument - 2);
+          frame.stage = 1;
+        }
+        if (frame.stage === 1) {
+          const offsetStart = this.position;
+          if (!this.header(source, end)) return false
+          if (this.major > 1 || this.info === 31) throw new Error('Invalid bundled string offset')
+          frame.target = offsetStart + (this.major === 1 ? -1 - this.argument : this.argument);
+          if (!Number.isSafeInteger(frame.target) || frame.target < 0) throw new Error('Invalid bundled string offset')
+          frame.stage = 2;
+        }
+        if (frame.stage === 2) {
+          if (frame.remaining) {
+            if (!this.header(source, end, true)) return false
+            this.position += this.argument;
+            frame.remaining--;
+            continue
+          }
+          frame.resume = this.position;
+          this.position = frame.target;
+          frame.remaining = 2;
+          frame.stage = 3;
+          continue
+        }
+        if (frame.stage === 3) {
+          if (frame.remaining) {
+            if (!this.header(source, end, true)) return false
+            this.position += this.argument;
+            frame.remaining--;
+            continue
+          }
+          this.postBundlePosition = this.position;
+          this.position = frame.resume;
+          frame.kind = 'items';
+          frame.remaining = 1;
+          continue
+        }
+      }
+      if (frame.kind === 'record') {
+        if (!this.header(source, end, true)) return false
+        if (this.info > 26) throw new Error('Expected array header, but got ' + source[this.position - 1])
+        frame.kind = 'items';
+        frame.remaining = this.argument;
+        const reader = frame.reader;
+        if (reader.compiled.has(this.argument)) frame.remaining = Math.min(this.argument, reader.length);
+        else if (reader.slowReads++ >= _stream.readThreshold) {
+          reader.compiled.add(this.argument);
+          frame.remaining = Math.min(this.argument, reader.length);
+        }
+        continue
+      }
+      if (frame.kind === 'definition' && frame.stage === 0) {
+        const start = this.position;
+        if (!this.header(source, end, !frame.legacy)) return false
+        if (frame.legacy && this.major !== 4) {
+          this.position = start;
+          this.headers--;
+          frame.kind = 'items';
+          frame.remaining = 1;
+          continue
+        }
+        frame.remaining = frame.legacy ? (this.info === 31 ? -1 : this.argument) : Math.max(2, this.argument);
+        if (frame.legacy) {
+          if (frame.remaining >= 0) _stream.checkContainer(4, frame.remaining);
+          else frame.limitMajor = 4;
+          frame.index = 0;
+        }
+        frame.total = frame.remaining;
+        frame.stage = 1;
+        continue
+      }
+      if (frame.remaining === 0) {
+        if (frame.definition) this.records.set(frame.id - 0xe000, frame.definition);
+        if (frame.restoreMap && this.restoreMap) {
+          this.mapsAsObjects = true;
+          this.restoreMap = false;
+        }
+        this.depth--;
+        continue
+      }
+      if (!this.header(source, end)) return false
+      let { major, argument, info } = this;
+      if (frame.kind === 'definition') {
+        const index = frame.legacy ? frame.index++ : frame.total - frame.remaining;
+        if (index === 0 && major === 0) frame.id = argument;
+        if ((frame.multiple ? index >= 1 && index < frame.total - 1 : index === 1) && major === 4 && info !== 31 && frame.id !== undefined) {
+          const definition = { length: argument, slowReads: 0, compiled: new Set() };
+          if (frame.legacy) frame.definition = definition;
+          else this.records.set(frame.id - 0xe000 + (frame.multiple ? index - 1 : 0), definition);
+        }
+      }
+      if (major === 7 && info === 31 && (frame.remaining === -1 || frame.remaining === -2)) {
+        if (frame.definition) this.records.set(frame.id - 0xe000, frame.definition);
+        this.depth--;
+        continue
+      }
+      if (frame.limitMajor && (frame.remaining === -1 || frame.remaining === -2)) {
+        _stream.checkContainer(frame.limitMajor, ++frame.count, frame.mapsAsObjects);
+      }
+      if (frame.remaining > 0) frame.remaining--;
+      else if (frame.remaining === -2) frame.remaining = -3;
+      else if (frame.remaining === -3) frame.remaining = -2;
+      if (info === 31) {
+        if (major === 2 || major === 3) throw new Error('Indefinite length not supported for byte or text strings')
+        if (major === 4 || major === 5) {
+          const container = this.push('items', major === 4 ? -1 : -2);
+          container.limitMajor = major;
+          container.mapsAsObjects = this.mapsAsObjects;
+          if (major === 5 && this.restoreMap) {
+            this.mapsAsObjects = true;
+            this.restoreMap = false;
+          }
+        }
+        else if (major === 7) throw new Error('Unexpected break stop code outside of an indefinite-length item')
+        else throw new Error('Invalid major type for indefinite length ' + major)
+        continue
+      }
+      switch (major) {
+        case 2:
+        case 3:
+          this.position += argument;
+          break
+        case 4:
+        case 5:
+          _stream.checkContainer(major, argument, this.mapsAsObjects);
+          if (major === 5 && this.restoreMap) {
+            this.mapsAsObjects = true;
+            this.restoreMap = false;
+          }
+          if (argument) this.push('items', major === 5 ? argument * 2 : argument);
+          break
+        case 6: {
+          const structure = _stream.getTag(argument, this.decoder);
+          let reader = this.records.get(argument & 0x1fff);
+          if (argument >= 0xdff9 && (structure || reader)) {
+            if (!reader) {
+              reader = this.readers.get(structure);
+              if (!reader) {
+                reader = { length: structure.length, slowReads: structure.slowReads || 0, compiled: new Set() };
+                for (let compiled = structure.compiledReader; compiled; compiled = compiled.next) reader.compiled.add(compiled.propertyCount);
+                this.readers.set(structure, reader);
+              }
+            }
+            this.push('record').reader = reader;
+          } else if (argument === 0xdff9) {
+            this.push('bundle');
+          } else if (argument === 0xdfff || argument === 0xdffe) {
+            this.push('definition').multiple = argument === 0xdffe;
+          } else if (argument === 259 && _stream.isBuiltinTag(argument) && this.mapsAsObjects) {
+            this.push('items', 1).restoreMap = true;
+            this.mapsAsObjects = false;
+            this.restoreMap = true;
+          } else if (argument === 105 && _stream.isBuiltinTag(argument)) {
+            const definition = this.push('definition');
+            definition.multiple = false;
+            definition.legacy = true;
+          } else {
+            this.push('items', 1);
+          }
+          break
+        }
+      }
+    }
+    if (this.postBundlePosition) {
+      if (this.position >= this.postBundlePosition) throw new Error('Unexpected bundle position')
+      this.position = this.postBundlePosition;
+    }
+    if (this.frames.length > 256) this.frames.length = 256;
+    return true
+  }
 }
 
 /**
@@ -2608,7 +2953,7 @@ async function * encodeIterAsync (objectIterator, options) {
  * 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
+ * @param {object} [options] - Decoder options, and maxIncompleteBufferSize
  * @returns {IterableIterator|Promise.<AsyncIterableIterator}
  */
 function decodeIter (bufferIterator, options = {}) {
@@ -2617,26 +2962,15 @@ function decodeIter (bufferIterator, options = {}) {
   }
 
   const decoder = new Decoder(options);
-  let incomplete, fatalError;
+  const chunkDecoder = new ChunkDecoder(decoder, options.maxIncompleteBufferSize);
+  let fatalError;
   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) {
-      yields = err.values;
-      if (err.incomplete) {
-        incomplete = chunk.slice(err.lastPosition);
-      } else {
-        fatalError = err;
-      }
+      return chunkDecoder.buffer ? chunkDecoder.decodeAfterIncomplete(chunk) : decoder.decodeMultiple(chunk)
+    } catch (error) {
+      fatalError = chunkDecoder.keepIncomplete(error, chunk);
+      return (error && error.values) || []
     }
-    return yields || []
   };
 
   if (typeof bufferIterator[Symbol.iterator] === 'function') {
@@ -2645,6 +2979,8 @@ function decodeIter (bufferIterator, options = {}) {
         yield * parser(value);
         if (fatalError) throw fatalError
       }
+      const endError = chunkDecoder.end();
+      if (endError) throw endError
     })()
   } else if (typeof bufferIterator[Symbol.asyncIterator] === 'function') {
     return (async function * iter () {
@@ -2652,10 +2988,175 @@ function decodeIter (bufferIterator, options = {}) {
         yield * parser(value);
         if (fatalError) throw fatalError
       }
+      const endError = chunkDecoder.end();
+      if (endError) throw endError
     })()
   }
 }
 
+/**
+ * Keeps the bytes of a value that a chunk of a stream ends inside of, for DecoderStream and decodeIter, and decodes
+ * them again once enough have arrived to possibly complete it. Callers decode a chunk with decodeAfterIncomplete if
+ * buffer is set, or else directly with decodeMultiple, and pass any error to keepIncomplete, which returns the error
+ * to report, if any. end returns an error if the input ended inside a value.
+ */
+class ChunkDecoder {
+  constructor (decoder, maxIncompleteBufferSize) {
+    this.decoder = decoder;
+    if (maxIncompleteBufferSize === undefined) maxIncompleteBufferSize = 0x4000000;
+    if (typeof maxIncompleteBufferSize !== 'number' || !(maxIncompleteBufferSize >= 0)) {
+      throw new TypeError('maxIncompleteBufferSize must be a non-negative number')
+    }
+    this.maxIncompleteBufferSize = Math.floor(maxIncompleteBufferSize);
+    // buffer[0, bufferEnd) is the incomplete value; no decoded value is a view of buffer while it is kept here
+    this.buffer = null;
+    this.bufferEnd = 0;
+    this.appends = 0;
+    this.scanner = null;
+    this.scanned = false;
+    this.resetScanner = false;
+    this.neededLength = 0; // a lower bound on the incomplete value's length
+  }
+
+  decodeAfterIncomplete (chunk) {
+    if (!(ArrayBuffer.isView(chunk) && chunk.BYTES_PER_ELEMENT === 1)) {
+      throw new TypeError('Source must be a Uint8Array or Buffer')
+    }
+    const length = this.bufferEnd + chunk.length;
+    if (length < this.neededLength && length > this.maxIncompleteBufferSize) throw maxIncompleteBufferSizeError()
+    if (length > this.buffer.length) {
+      // Values usually complete within two appends, which are sized exactly. After that the buffer grows by at least
+      // the bytes already kept, so that they are copied a bounded number of times however small the chunks are.
+      const size = this.appends < 2 ? length
+        : Math.max(length, Math.min(length + this.bufferEnd, this.maxIncompleteBufferSize));
+      const buffer = Buffer.allocUnsafe(size);
+      if (size > length) buffer.fill(0, length); // decoded values are views of this buffer, so no uninitialized memory
+      buffer.set(this.buffer.subarray(0, this.bufferEnd));
+      this.buffer = buffer;
+    }
+    this.buffer.set(chunk, this.bufferEnd);
+    this.bufferEnd = length;
+    this.appends++;
+    if (length < this.neededLength) return []
+    if (!this.scanner) this.scanner = new StructureScanner(this.decoder);
+    if (this.resetScanner) {
+      this.scanner.reset();
+      this.resetScanner = false;
+    }
+    if (!this.scanner.scan(this.buffer, length)) {
+      this.neededLength = this.scanner.neededLength;
+      if (length > this.maxIncompleteBufferSize) throw maxIncompleteBufferSizeError()
+      return []
+    }
+    this.scanned = true;
+    const values = _stream.decode(this.decoder, this.buffer.subarray(0, length), this.scanner.position);
+    this.scanned = false;
+    this.buffer = null;
+    return values
+  }
+
+  keepIncomplete (error, chunk) {
+    // an extension may throw any value, and a falsy one would read as success
+    if (!error) return this.fail(new Error('Decoding failed: ' + error))
+    if (!error.incomplete) return this.fail(error)
+    if (this.scanned && error.lastPosition === 0) {
+      error.incomplete = false;
+      return this.fail(error)
+    }
+    const source = this.buffer ? this.buffer.subarray(0, this.bufferEnd) : chunk;
+    const length = source.length - error.lastPosition;
+    if (length > this.maxIncompleteBufferSize) return this.fail(maxIncompleteBufferSizeError())
+    if (!this.buffer || error.lastPosition > 0) {
+      if (length === 0) return
+      try {
+        // copied, so that the remainder does not keep in memory the chunk, or the buffer that the values before it
+        // are views of
+        this.buffer = Buffer.from(source.subarray(error.lastPosition));
+      } catch (copyError) {
+        return this.fail(copyError)
+      }
+      this.bufferEnd = length;
+      this.appends = 0;
+    }
+    this.scanned = false;
+    this.resetScanner = true;
+    this.neededLength = Math.max(length + 1, error.neededEnd ? error.neededEnd - error.lastPosition : 0);
+  }
+
+  end () {
+    if (this.buffer) {
+      const error = this.fail(new Error('Unexpected end of CBOR data'));
+      error.incomplete = true;
+      return error
+    }
+  }
+
+  fail (error) {
+    this.buffer = null;
+    this.scanner = null;
+    this.scanned = false;
+    this.resetScanner = false;
+    return error
+  }
+}
+
+function maxIncompleteBufferSizeError () {
+  return new Error('Maximum incomplete buffer size exceeded')
+}
+
+class EncoderStream extends stream.Transform {
+	constructor(options) {
+		if (!options)
+			options = {};
+		options.writableObjectMode = true;
+		super(options);
+		options.sequential = true;
+		this.encoder = options.encoder || new Encoder(options);
+	}
+	async _transform(value, encoding, callback) {
+		try {
+			for await (let chunk of this.encoder.encodeAsAsyncIterable(value)) {
+				this.push(chunk);
+			}
+			callback();
+		} catch(error) { callback (error); }
+	}
+}
+
+class DecoderStream extends stream.Transform {
+	constructor(options) {
+		if (!options)
+			options = {};
+		options.objectMode = true;
+		super(options);
+		options.structures = [];
+		this.decoder = options.decoder || new Decoder(options);
+		this.chunkDecoder = new ChunkDecoder(this.decoder, options.maxIncompleteBufferSize);
+	}
+	_transform(chunk, encoding, callback) {
+		let values, fatalError;
+		try {
+			// decodeMultiple is called directly, since another call level here measurably slows small writes
+			values = this.chunkDecoder.buffer ? this.chunkDecoder.decodeAfterIncomplete(chunk) : this.decoder.decodeMultiple(chunk);
+		} catch(error) {
+			values = error && error.values;
+			fatalError = this.chunkDecoder.keepIncomplete(error, chunk);
+		}
+		for (let value of values || []) {
+			if (value === null)
+				value = this.getNullValue();
+			this.push(value);
+		}
+		callback(fatalError);
+	}
+	_flush(callback) {
+		callback(this.chunkDecoder.end());
+	}
+	getNullValue() {
+		return Symbol.for(null)
+	}
+}
+
 const useRecords = false;
 const mapsAsObjects = true;