cbor-x 1.6.7 → 1.6.9

package/dist/test.js

@@ -15,7 +15,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;
 			stringPosition = 0;
 			srcStringEnd = 0;
@@ -175,18 +169,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
 						}
 					}
@@ -200,8 +204,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;
@@ -210,8 +216,10 @@
 		}
 	}
 	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)
@@ -253,9 +261,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 +327,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 +341,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 +353,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 +375,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 +385,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 +396,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 +411,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);
@@ -401,7 +429,9 @@
 				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 
@@ -410,7 +440,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();
@@ -421,7 +451,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());
@@ -934,6 +964,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)
@@ -1206,6 +1237,8 @@
 	}
 
 	function saveState(callback) {
+		let savedFragmentReader = fragmentReadString;
+		let savedReadFixedString = readFixedString;
 		let savedSrcEnd = srcEnd;
 		let savedPosition = position$1;
 		let savedStringPosition = stringPosition;
@@ -1215,6 +1248,7 @@
 		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
@@ -1222,10 +1256,21 @@
 		let savedDecoder = currentDecoder;
 		let savedSequentialMode = sequentialMode;
 		let savedRestoreMapsAsObject = restoreMapsAsObject;
+		let savedArrayAllocationBudget = arrayAllocationBudget;
+		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 {
+			fragmentReadString = savedFragmentReader;
+			readFixedString = savedReadFixedString;
 			srcEnd = savedSrcEnd;
 			position$1 = savedPosition;
 			stringPosition = savedStringPosition;
@@ -1235,11 +1280,13 @@
 			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);
 		}
 	}
@@ -1249,8 +1296,15 @@
 		currentStructures = null;
 	}
 
+	const registeredExtensions = new Map();
+	let fragmentReadString;
+
+	new Map([[LEGACY_RECORD_INLINE_ID, legacyRecordDefinition], [259, currentExtensions[259]]]);
+
 	function addExtension$2(extension) {
 		currentExtensions[extension.tag] = extension.decode;
+		if (typeof extension.decode === 'function') registeredExtensions.set(extension.tag, extension.decode);
+		else registeredExtensions.delete(extension.tag);
 	}
 
 	const mult10 = new Array(147); // this is a table matching binary exponents to the multiplier to determine significant digit rounding
@@ -1838,6 +1892,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);
 						}
@@ -1931,8 +1990,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));
@@ -2671,6 +2744,15 @@
 			assert.throws(() => decode$1(Buffer.from('7a10000000', 'hex')));
 		});
 
+		test('break stop code outside indefinite-length item', function() {
+			assert.throws(() => decode$1(Buffer.from('ff', 'hex')));
+			assert.throws(() => decode$1(Buffer.from('81ff', 'hex')));
+			assert.throws(() => decode$1(Buffer.from('a16161ff', 'hex')));
+			assert.throws(() => decode$1(Buffer.from('c0ff', 'hex')));
+			assert.deepEqual(decode$1(Buffer.from('9f01ff', 'hex')), [1]);
+			assert.deepEqual(decode$1(Buffer.from('bf616101ff', 'hex')), { a: 1 });
+		});
+
 		test('overlong encoding', function() {
 			const payload = Buffer.from([0x62, 0xc0, 0xaf]);
 			const result = decode$1(payload);
@@ -3010,6 +3092,24 @@
 			var decoded = decode(encoded);
 			assert.equal(decoded.length, 0);
 		});
+		test('fixed map size overflow (map-16 to map-32)', function() {
+			this.timeout(120000);
+			// issue #131: the default encode() serializes objects with a back-patched
+			// map-16 (uint16) header, so an object with >= 65536 keys overflowed the
+			// count and the decoder stopped early with "Data read, but end of buffer not
+			// reached". Verify the round-trip across the map-16 -> map-32 boundary.
+			function roundTripObjectWith(count) {
+				var data = {};
+				for (var i = 0; i < count; i++)
+					data['k' + i] = i;
+				var decoded = decode(encode(data));
+				assert.equal(Object.keys(decoded).length, count);
+				assert.deepEqual(decoded, data);
+			}
+			roundTripObjectWith(65535); // map-16 path, must stay unchanged
+			roundTripObjectWith(65536); // first size that needs map-32
+			roundTripObjectWith(70000); // well past the 16-bit boundary
+		});
 
 		test('random strings', function(){
 			var data = [];
@@ -3136,6 +3236,14 @@
 			var deserialized = encoder.decode(serialized);
 			assert.equal(deserialized, data);
 		});
+		test('negative int64 as number', function() {
+			let encoded = Buffer.from('3b0000000e96848f5f', 'hex');
+			assert.equal(new Decoder().decode(encoded), -62654812000n);
+
+			let decoder = new Decoder({ int64AsNumber: true });
+			assert.equal(decoder.decode(encoded), -62654812000);
+			assert.equal(decoder.decode(Buffer.from('3b001ffffffffffffe', 'hex')), Number.MIN_SAFE_INTEGER);
+		});
 		test('bigint to float', function() {
 			var data = {
 				a: 325283295382932843n
@@ -3180,6 +3288,21 @@
 			assert.equal(decoded[2], 5);
 			assert.equal(decoded.byteLength, 3);
 		});
+		test('encode DataView', function() {
+			let bytes = new Uint8Array(40).map((_, i) => i);
+			assert.equal(Buffer.from(encode(new DataView(bytes.buffer, 3, 4))).toString('hex'), '4403040506');
+			assert.equal(Buffer.from(encode(new DataView(bytes.buffer, 5, 30))).toString('hex'),
+				'581e' + Buffer.from(bytes.subarray(5, 35)).toString('hex'));
+			assert.equal(Buffer.from(encode(new DataView(bytes.buffer, 0, 0))).toString('hex'), '40');
+			assert.deepEqual(decode(encode({ v: new DataView(bytes.buffer, 1, 2) })), { v: Buffer.from([1, 2]) });
+			assert.equal(Buffer.from(encode(bytes.buffer.slice(1, 4))).toString('hex'), '43010203');
+			assert.equal(Buffer.from(encode(bytes.subarray(1, 4))).toString('hex'), 'd84043010203');
+			assert.equal(Buffer.from(encode(Buffer.from(bytes.subarray(1, 4)))).toString('hex'), '43010203');
+			assert.equal(Buffer.from(new Encoder({ tagUint8Array: false }).encode(bytes.subarray(1, 4))).toString('hex'), '43010203');
+			let uint16Tag = new Uint8Array(new Uint16Array([1]).buffer)[0] == 1 ? '45' : '41';
+			assert.equal(Buffer.from(encode(new Uint16Array(bytes.buffer, 2, 2))).toString('hex'), 'd8' + uint16Tag + '4402030405');
+			assert.equal(Buffer.from(encode(new Uint8ClampedArray(bytes.buffer, 2, 2))).toString('hex'), 'd844420203');
+		});
 
 		test('iterator/indefinite length array', function(){
 			class NotArray {