cbor-x 1.5.8 → 1.6.0

package/dist/test.js

@@ -15,6 +15,10 @@
 	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,
+	// many keys in an object, so also probably a reasonable choice there.
 	let strings = EMPTY_ARRAY;
 	let stringPosition = 0;
 	let currentDecoder = {};
@@ -291,6 +295,7 @@
 							let array = [];
 							let value, i = 0;
 							while ((value = read()) != STOP_CODE) {
+								if (i >= maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`)
 								array[i++] = value;
 							}
 							return majorType == 4 ? array : majorType == 3 ? array.join('') : Buffer.concat(array)
@@ -298,8 +303,19 @@
 							let key;
 							if (currentDecoder.mapsAsObjects) {
 								let object = {};
-								if (currentDecoder.keyMap) while((key = read()) != STOP_CODE) object[safeKey(currentDecoder.decodeKey(key))] = read();
-								else while ((key = read()) != STOP_CODE) object[safeKey(key)] = read();
+								let i = 0;
+								if (currentDecoder.keyMap) {
+									while((key = read()) != STOP_CODE) {
+										if (i++ >= maxMapSize) throw new Error(`Property count exceeds ${maxMapSize}`)
+										object[safeKey(currentDecoder.decodeKey(key))] = read();
+									}
+								}
+								else {
+									while ((key = read()) != STOP_CODE) {
+										if (i++ >= maxMapSize) throw new Error(`Property count exceeds ${maxMapSize}`)
+										object[safeKey(key)] = read();
+									}
+								}
 								return object
 							} else {
 								if (restoreMapsAsObject) {
@@ -307,8 +323,24 @@
 									restoreMapsAsObject = false;
 								}
 								let map = new Map();
-								if (currentDecoder.keyMap) while((key = read()) != STOP_CODE) map.set(currentDecoder.decodeKey(key), read());
-								else while ((key = read()) != STOP_CODE) map.set(key, read());
+								if (currentDecoder.keyMap) {
+									let i = 0;
+									while((key = read()) != STOP_CODE) {
+										if (i++ >= maxMapSize) {
+											throw new Error(`Map size exceeds ${maxMapSize}`);
+										}
+										map.set(currentDecoder.decodeKey(key), read());
+									}
+								}
+								else {
+									let i = 0;
+									while ((key = read()) != STOP_CODE) {
+										if (i++ >= maxMapSize) {
+											throw new Error(`Map size exceeds ${maxMapSize}`);
+										}
+										map.set(key, read());
+									}
+								}
 								return map
 							}
 						case 7:
@@ -339,12 +371,14 @@
 				}
 				return readFixedString(token)
 			case 4: // array
+				if (token >= maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`)
 				let array = new Array(token);
 			  //if (currentDecoder.keyMap) for (let i = 0; i < token; i++) array[i] = currentDecoder.decodeKey(read())	
 				//else 
 				for (let i = 0; i < token; i++) array[i] = read();
 				return array
 			case 5: // map
+				if (token >= maxMapSize) throw new Error(`Map size exceeds ${maxArraySize}`)
 				if (currentDecoder.mapsAsObjects) {
 					let object = {};
 					if (currentDecoder.keyMap) for (let i = 0; i < token; i++) object[safeKey(currentDecoder.decodeKey(read()))] = read();
@@ -446,6 +480,7 @@
 	}
 	const validName = /^[a-zA-Z_$][a-zA-Z\d_$]*$/;
 	function createStructureReader(structure) {
+		if (!structure) throw new Error('Structure is required in record definition');
 		function readObject() {
 			// get the array size from the header
 			let length = src[position$1++];
@@ -501,7 +536,8 @@
 	function safeKey(key) {
 		// protect against prototype pollution
 		if (typeof key === 'string') return key === '__proto__' ? '__proto_' : key
-		if (typeof key !== 'object') return key.toString()
+		if (typeof key === 'number' || typeof key === 'boolean' || typeof key === 'bigint') return key.toString();
+		if (key == null) return key + '';
 		// protect against expensive (DoS) string conversions
 		throw new Error('Invalid property name type ' + typeof key);
 	}
@@ -803,7 +839,7 @@
 		// bigint extension
 		let value = BigInt(0);
 		for (let i = 0, l = buffer.byteLength; i < l; i++) {
-			value = BigInt(buffer[i]) + value << BigInt(8);
+			value = BigInt(buffer[i]) + (value << BigInt(8));
 		}
 		return value
 	};
@@ -918,6 +954,7 @@
 			referenceMap.id = 0;
 		}
 		let id = referenceMap.id++;
+		let startingPosition = position$1;
 		let token = src[position$1];
 		let target;
 		// TODO: handle Maps, Sets, and other types that can cycle; this is complicated, because you potentially need to read
@@ -930,8 +967,20 @@
 		let refEntry = { target }; // a placeholder object
 		referenceMap.set(id, refEntry);
 		let targetProperties = read(); // read the next value as the target object to id
-		if (refEntry.used) // there is a cycle, so we have to assign properties to original target
+		if (refEntry.used) {// there is a cycle, so we have to assign properties to original target
+			if (Object.getPrototypeOf(target) !== Object.getPrototypeOf(targetProperties)) {
+				// this means that the returned target does not match the targetProperties, so we need rerun the read to
+				// have the correctly create instance be assigned as a reference, then we do the copy the properties back to the
+				// target
+				// reset the position so that the read can be repeated
+				position$1 = startingPosition;
+				// the returned instance is our new target for references
+				target = targetProperties;
+				referenceMap.set(id, { target });
+				targetProperties = read();
+			}
 			return Object.assign(target, targetProperties)
+		}
 		refEntry.target = targetProperties; // the placeholder wasn't used, replace with the deserialized one
 		return targetProperties // no cycle, can just use the returned read object
 	};
@@ -1013,7 +1062,7 @@
 		for (let littleEndian = 0; littleEndian < 2; littleEndian++) {
 			if (!littleEndian && bytesPerElement == 1)
 				continue
-			let sizeShift = bytesPerElement == 2 ? 1 : bytesPerElement == 4 ? 2 : 3;
+			let sizeShift = bytesPerElement == 2 ? 1 : bytesPerElement == 4 ? 2 : bytesPerElement == 8 ? 3 : 0;
 			currentExtensions[littleEndian ? tag : (tag - 4)] = (bytesPerElement == 1 || littleEndian == isLittleEndianMachine$1) ? (buffer) => {
 				if (!TypedArray)
 					throw new Error('Could not find typed array for code ' + tag)
@@ -1023,7 +1072,7 @@
 						bytesPerElement === 2 && !(buffer.byteOffset & 1) ||
 						bytesPerElement === 4 && !(buffer.byteOffset & 3) ||
 						bytesPerElement === 8 && !(buffer.byteOffset & 7))
-						return new TypedArray(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+						return new TypedArray(buffer.buffer, buffer.byteOffset, buffer.byteLength >> sizeShift);
 				}
 				// we have to slice/copy here to get a new ArrayBuffer, if we are not word/byte aligned
 				return new TypedArray(Uint8Array.prototype.slice.call(buffer, 0).buffer)
@@ -1622,7 +1671,7 @@
 						}
 						let constructor = value.constructor;
 						if (constructor === Object) {
-							writeObject(value, true);
+							writeObject(value);
 						} else if (constructor === Array) {
 							length = value.length;
 							if (length < 0x18) {
@@ -1717,8 +1766,8 @@
 									return encode(json)
 							}
 
-							// no extension found, write as object
-							writeObject(value, !value.hasOwnProperty); // if it doesn't have hasOwnProperty, don't do hasOwnProperty checks
+							// no extension found, write as a plain object
+							writeObject(value);
 						}
 					}
 				} else if (type === 'boolean') {
@@ -1738,7 +1787,19 @@
 							target[position++] = 0xfb;
 							targetView.setFloat64(position, Number(value));
 						} else {
-							throw new RangeError(value + ' was too large to fit in CBOR 64-bit integer format, set largeBigIntToFloat to convert to float-64')
+							if (value >= BigInt(0))
+								target[position++] = 0xc2; // tag 2
+							else {
+								target[position++] = 0xc3; // tag 2
+								value = BigInt(-1) - value;
+							}
+							let bytes = [];
+							while (value) {
+								bytes.push(Number(value & BigInt(0xff)));
+								value >>= BigInt(8);
+							}
+							writeBuffer(new Uint8Array(bytes.reverse()), makeRoom);
+							return;
 						}
 					}
 					position += 8;
@@ -1780,19 +1841,19 @@
 					}
 				}
 			} :
-			(object, safePrototype) => {
+			(object) => {
 				target[position++] = 0xb9; // always use map 16, so we can preallocate and set the length afterwards
 				let objectOffset = position - start;
 				position += 2;
 				let size = 0;
-				if (encoder.keyMap) { 
-					for (let key in object) if (safePrototype || object.hasOwnProperty(key)) {
+				if (encoder.keyMap) {
+					for (let key in object) if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
 						encode(encoder.encodeKey(key));
 						encode(object[key]);
 						size++;
 					}
 				} else { 
-					for (let key in object) if (safePrototype || object.hasOwnProperty(key)) {
+					for (let key in object) if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
 							encode(key);
 							encode(object[key]);
 						size++;
@@ -1801,7 +1862,7 @@
 				target[objectOffset++ + start] = size >> 8;
 				target[objectOffset + start] = size & 0xff;
 			} :
-			(object, safePrototype) => {
+			(object, skipValues) => {
 				let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
 				let newTransitions = 0;
 				let length = 0;
@@ -1820,7 +1881,7 @@
 						transition = nextTransition;
 					}				
 				} else {
-					for (let key in object) if (safePrototype || object.hasOwnProperty(key)) {
+					for (let key in object) if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
 						nextTransition = transition[key];
 						if (!nextTransition) {
 							if (transition[RECORD_SYMBOL] & 0x100000) {// this indicates it is a brancheable/extendable terminal node, so we will use this record id and extend it
@@ -1880,9 +1941,9 @@
 						writeArrayHeader(length + 2);
 						encode(0xe000 + recordId);
 						encode(keys);
-						if (safePrototype === null) return; // special exit for iterator
+						if (skipValues) return; // special exit for iterator
 						for (let key in object)
-							if (safePrototype || object.hasOwnProperty(key))
+							if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key))
 								encode(object[key]);
 						return
 					}
@@ -1892,9 +1953,9 @@
 				} else {
 					writeArrayHeader(length);
 				}
-				if (safePrototype === null) return; // special exit for iterator
+				if (skipValues) return; // special exit for iterator
 				for (let key in object)
-					if (safePrototype || object.hasOwnProperty(key))
+					if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key))
 						encode(object[key]);
 			};
 			const makeRoom = (end) => {
@@ -1932,7 +1993,7 @@
 				if (constructor === Object) {
 					let useRecords = encoder.useRecords !== false;
 					if (useRecords)
-						writeObject(object, null); // write the record identifier
+						writeObject(object, true); // write the record identifier
 					else
 						writeEntityLength(Object.keys(object).length, 0xa0);
 					for (let key in object) {
@@ -1957,7 +2018,7 @@
 								yield* tryEncode(value, iterateProperties, 'element');
 						} else encode(value);
 					}
-				} else if (object[Symbol.iterator]) {
+				} else if (object[Symbol.iterator] && !object.buffer) { // iterator, but exclude typed arrays
 					target[position++] = 0x9f; // start indefinite array
 					for (let value of object) {
 						if (value && (typeof value === 'object' || position - start > chunkThreshold)) {
@@ -2649,22 +2710,17 @@
 			assert.deepEqual(deserialized1, data1);
 			assert.deepEqual(deserialized2, data2);
 		});
-		test('extended class encode/decode', function(){
+		test('extended class encode/decode', function() {
 			function Extended() {
 
 			}
+
 			Extended.prototype.getDouble = function() {
 				return this.value * 2
 			};
 			var instance = new Extended();
 			instance.value = 4;
 			instance.string = 'decode this: ᾜ';
-			var data = {
-				prop1: 'has multi-byte: ᾜ',
-				extendedInstance: instance,
-				prop2: 'more string',
-				num: 3,
-			};
 			let encoder = new Encoder();
 			addExtension({
 				Class: Extended,
@@ -2679,10 +2735,37 @@
 					return encoder.encode([instance.value, instance.string])
 				}
 			});
-			var serialized = encode(data);
-			var deserialized = decode(serialized);
-			assert.deepEqual(data, deserialized);
-			assert.equal(deserialized.extendedInstance.getDouble(), 8);
+		});
+		test('extended class encode/decode with self reference in structered clone', function(){
+			function Extended() {
+
+			}
+			addExtension({
+				Class: Extended,
+				tag: 301,
+				decode: function(data) {
+					let e = new Extended();
+					e.value = data[0];
+					e.string = data[1];
+					return e
+				},
+				encode: function(instance, encode) {
+					return encode([instance.value, instance.string])
+				}
+			});
+			var instance = new Extended();
+			instance.value = instance;
+			instance.string = 'hi';
+			let data = {
+				extended: instance
+			};
+			let encoder = new Encoder({
+				structuredClone: true,
+			});
+			let serialized = encoder.encode(data);
+			encoder.decode(serialized);
+			assert(data.extended.value.value === data.extended);
+			assert(data.extended instanceof Extended);
 		});
 
 		test('addExtension with map', function(){
@@ -2824,6 +2907,12 @@
 			var deserialized = decode(serialized);
 			assert.deepEqual(deserialized, data);
 		});
+		test('object with __proto__', function(){
+			const data = { foo: 'bar', __proto__: { isAdmin: true } };
+			var serialized = encode(data);
+			var deserialized = decode(serialized);
+			assert.deepEqual(deserialized, { foo: 'bar' });
+		});
 
 		test('big buffer', function() {
 			var size = 100000000;
@@ -3018,23 +3107,27 @@
 			var data = {
 				bigintSmall: 352n,
 				bigintSmallNegative: -333335252n,
-				bigintBig: 2n**64n - 1n, // biggest possible
+				bigintBig: 2n**64n - 1n, // biggest 64-bit possible
 				bigintBigNegative: -(2n**63n), // largest negative
 				mixedWithNormal: 44,
 			};
 			var serialized = encode(data);
 			var deserialized = decode(serialized);
 			assert.deepEqual(deserialized, data);
-			var tooBigInt = {
-				tooBig: 2n**66n
+			var evenBiggerInt = {
+				big: 2n**66n,
+				bigger: 53285732853728573289573289573289573289583725892358732859532n,
+				negBig: -93025879203578903275903285903285903289502n,
 			};
-			assert.throws(function(){ serialized = encode(tooBigInt); });
+			var serialized = encode(evenBiggerInt);
+			var deserialized = decode(serialized);
+			assert.deepEqual(deserialized, evenBiggerInt);
 			let encoder = new Encoder({
 				largeBigIntToFloat: true
 			});
-			serialized = encoder.encode(tooBigInt);
+			serialized = encoder.encode(evenBiggerInt);
 			deserialized = decode(serialized);
-			assert.isTrue(deserialized.tooBig > 2n**65n);
+			assert.isTrue(deserialized.bigger > 2n**65n);
 		});
 
 		test('buffers', function() {
@@ -3092,6 +3185,11 @@
 			let badInput = Buffer.from('7b2273657269616c6e6f223a2265343a30222c226970223a223139322e3136382e312e3335222c226b6579223a226770735f736563726574227d', 'hex');
 			assert.throws(function(){ decode(badInput); }); // should throw, not crash
 		});
+		test('buffer key', function() {
+			let encoder = new Encoder({ mapsAsObjects: false });
+			let test = encoder.decode(Buffer.from('D87982A1446E616D654361626301', 'hex'));
+			console.log(test);
+		});
 		test('encode as iterator', function() {
 			let hasIterables = {
 				a: 1,
@@ -3184,6 +3282,15 @@
 			decode(Buffer.concat(result));
 			console.log(performance.now() - start, result.length);
 		});
+
+		test('little-endian typed array with aligned data', function() {
+		    // array[1] { uint32-little-endian-typed-array { bytes <00 00 00 00> } }
+		    let data = new Uint8Array([ 129, 216, 70, 68, 0, 0, 0, 0 ]);
+		    assert.deepEqual(decode(data), [new Uint32Array([0])]);
+
+		    let value = {x: new Float32Array([1, 2, 3])};
+		    assert.deepEqual(decode(encode(value)), value);
+		});
 	});
 	suite('CBOR performance tests', function(){
 		test('performance JSON.parse', function() {