cbor-x 1.5.9 → 1.6.3

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 = {};
@@ -263,6 +267,7 @@
 					}
 					token = dataView.getUint32(position$1);
 					position$1 += 4;
+					if (majorType === 1) return -1 - token; // can't safely use negation operator here
 					break
 				case 0x1b:
 					if (majorType == 7) {
@@ -277,8 +282,7 @@
 					} else if (currentDecoder.int64AsNumber) {
 						token = dataView.getUint32(position$1) * 0x100000000;
 						token += dataView.getUint32(position$1 + 4);
-					} else
-						token = dataView.getBigUint64(position$1);
+					} else token = dataView.getBigUint64(position$1);
 					position$1 += 8;
 					break
 				case 0x1f: 
@@ -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++];
@@ -804,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
 	};
@@ -1198,8 +1233,8 @@
 			let structures;
 			let referenceMap;
 			options = options || {};
-			let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position, maxBytes) {
-				return target.utf8Write(string, position, maxBytes)
+			let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position) {
+				return target.utf8Write(string, position, target.byteLength - position)
 			} : (textEncoder && textEncoder.encodeInto) ?
 				function(string, position) {
 					return textEncoder.encodeInto(string, target.subarray(position)).written
@@ -1580,7 +1615,7 @@
 							targetView.setUint32(position, value);
 							position += 4;
 						}
-					} else if (!this.alwaysUseFloat && value >> 0 === value) { // negative integer
+					} else if (!this.alwaysUseFloat && value >> 0 === value) { // negative integer, 31-bit or less
 						if (value >= -0x18) {
 							target[position++] = 0x1f - value;
 						} else if (value >= -0x100) {
@@ -1595,6 +1630,11 @@
 							targetView.setUint32(position, ~value);
 							position += 4;
 						}
+					} else if (!this.alwaysUseFloat && value < 0 && value >= -0x100000000 && Math.floor(value) === value) {
+						// negative integer, 32-bit or less
+						target[position++] = 0x3a;
+						targetView.setUint32(position, -1 - value);
+						position += 4;
 					} else {
 						let useFloat32;
 						if ((useFloat32 = this.useFloat32) > 0 && value < 0x100000000 && value >= -0x80000000) {
@@ -1636,6 +1676,9 @@
 						}
 						let constructor = value.constructor;
 						if (constructor === Object) {
+							if (this.skipFunction === true) {
+								value = Object.fromEntries([...Object.keys(value).filter(x => typeof value[x] !== "function").map(x => [x, value[x]])]);
+							}
 							writeObject(value);
 						} else if (constructor === Array) {
 							length = value.length;
@@ -1752,7 +1795,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;
@@ -1799,7 +1854,7 @@
 				let objectOffset = position - start;
 				position += 2;
 				let size = 0;
-				if (encoder.keyMap) { 
+				if (encoder.keyMap) {
 					for (let key in object) if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
 						encode(encoder.encodeKey(key));
 						encode(object[key]);
@@ -1971,7 +2026,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)) {
@@ -2548,6 +2603,10 @@
 			assert.equal(deserialized, data);
 		});
 
+		test('string overflow', function() {
+			assert.throws(() => decode$1(Buffer.from('7a10000000', 'hex')));
+		});
+
 		test('encode/decode sample data', function(){
 			var data = sampleData;
 			var serialized = encode$1(data);
@@ -3035,7 +3094,12 @@
 			var deserialized = decode(serialized);
 			assert.deepEqual(deserialized, data);
 		});
-
+		test('numbers are compact', function(){
+			assert.equal(encode(-256).length, 2);
+			let encoding = encode(-4294967296);
+			assert.equal(encoding.length, 5);
+			assert.equal(decode(encoding), -4294967296);
+		});
 		test('encode ArrayBuffer', function() {
 			let ua = new Uint8Array([3, 4, 5]);
 			let encoded = encode(ua.buffer);
@@ -3060,23 +3124,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() {
@@ -3130,6 +3198,20 @@
 			decodeMultiple(new Uint8Array([1, 2, 3, 4]), value => values.push(value));
 			assert.deepEqual(values, [1, 2, 3, 4]);
 		});
+		test('skipFunction', () => {
+			var data = {
+				a: 325283295382932843n,
+				f: () => {},
+			};
+			let encoder = new Encoder({
+				int64AsNumber: true,
+				skipFunction: true,
+			});
+			var serialized = encoder.encode(data);
+			var deserialized = encoder.decode(serialized);
+			assert.deepEqual(deserialized.a, 325283295382932843);
+			assert.equal(Object.hasOwn(deserialized, "f"), false);
+		});
 		test('bad input', function() {
 			let badInput = Buffer.from('7b2273657269616c6e6f223a2265343a30222c226970223a223139322e3136382e312e3335222c226b6579223a226770735f736563726574227d', 'hex');
 			assert.throws(function(){ decode(badInput); }); // should throw, not crash