cbor-x 1.6.8 → 1.6.9

package/dist/index-no-eval.cjs

@@ -16,7 +16,6 @@
 	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,
@@ -126,16 +125,11 @@
 				// 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;
 			srcStringEnd = 0;
 			srcString = null;
@@ -173,18 +167,28 @@
 			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
 						}
 					}
@@ -198,8 +202,10 @@
 					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;
@@ -253,9 +259,21 @@
 		}
 	}
 
-	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
 	}
 
@@ -307,6 +325,9 @@
 					} 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
@@ -318,10 +339,10 @@
 							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
@@ -330,13 +351,15 @@
 								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();
 									}
@@ -350,7 +373,8 @@
 								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}`);
 										}
@@ -359,7 +383,8 @@
 								}
 								else {
 									let i = 0;
-									while ((key = read()) != STOP_CODE) {
+									while (!readBreak()) {
+										key = read();
 										if (i++ >= maxMapSize) {
 											throw new Error(`Map size exceeds ${maxMapSize}`);
 										}
@@ -369,7 +394,8 @@
 								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)
 					}
@@ -383,13 +409,13 @@
 			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 +429,7 @@
 				// never be satisfied; check before allocating so a tiny header can not force a huge allocation
 				// 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()
+				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 +438,7 @@
 			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 +449,7 @@
 						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());
@@ -904,6 +930,7 @@
 		}
 		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)
@@ -1176,6 +1203,9 @@
 	}
 
 	function saveState(callback) {
+		let savedFragmentEnd = fragmentEnd;
+		let savedFragmentReader = fragmentReadString;
+		let savedReadFixedString = readFixedString;
 		let savedSrcEnd = srcEnd;
 		let savedPosition = position$1;
 		let savedSrcStringStart = srcStringStart;
@@ -1183,6 +1213,7 @@
 		let savedSrcString = srcString;
 		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
@@ -1191,10 +1222,22 @@
 		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;
 			srcStringStart = savedSrcStringStart;
@@ -1202,6 +1245,7 @@
 			srcString = savedSrcString;
 			referenceMap = savedReferenceMap;
 			bundledStrings$1 = savedBundledStrings;
+			packedValues = savedPackedValues;
 			src = savedSrc;
 			sequentialMode = savedSequentialMode;
 			currentStructures = savedStructures;
@@ -1217,8 +1261,82 @@
 		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 = isNativeAccelerationEnabled ;
+		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) ;
+			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) {
@@ -1818,6 +1936,11 @@
 									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);
 						}
@@ -1911,8 +2034,22 @@
 						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));
@@ -2479,6 +2616,258 @@
 	const RESET_BUFFER_MODE = 1024;
 	const THROW_ON_ITERABLE = 2048;
 
+	// 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();
+	  }
+
+	  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
+	  }
+	}
+
 	/**
 	 * 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.
@@ -2516,7 +2905,7 @@
 	 * 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 = {}) {
@@ -2525,26 +2914,15 @@
 	  }
 
 	  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') {
@@ -2553,6 +2931,8 @@
 	        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 () {
@@ -2560,10 +2940,122 @@
 	        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')
+	}
+
 	exports.ALWAYS = ALWAYS;
 	exports.DECIMAL_FIT = DECIMAL_FIT;
 	exports.DECIMAL_ROUND = DECIMAL_ROUND;