cbor-x 1.5.8 → 1.6.0

package/dist/node.cjs

@@ -17,6 +17,10 @@ const RECORD_INLINE_ID = 0xdfff; // temporary first-come first-serve tag // prop
 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 = {};
@@ -293,6 +297,7 @@ function read() {
 						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)
@@ -300,8 +305,19 @@ function read() {
 						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) {
@@ -309,8 +325,24 @@ function read() {
 								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:
@@ -341,12 +373,14 @@ function read() {
 			}
 			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();
@@ -448,6 +482,7 @@ function read() {
 }
 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++];
@@ -503,7 +538,8 @@ function createStructureReader(structure) {
 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);
 }
@@ -808,7 +844,7 @@ currentExtensions[2] = (buffer) => {
 	// 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
 };
@@ -923,6 +959,7 @@ currentExtensions[28] = (read) => {
 		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
@@ -935,8 +972,20 @@ currentExtensions[28] = (read) => {
 	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
 };
@@ -1018,7 +1067,7 @@ function registerTypedArray(TypedArray, tag) {
 	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)
@@ -1028,7 +1077,7 @@ function registerTypedArray(TypedArray, tag) {
 					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)
@@ -1145,6 +1194,12 @@ function addExtension$1(extension) {
 	currentExtensions[extension.tag] = extension.decode;
 }
 
+function setSizeLimits(limits) {
+	if (limits.maxMapSize) maxMapSize = limits.maxMapSize;
+	if (limits.maxArraySize) maxArraySize = limits.maxArraySize;
+	if (limits.maxObjectSize) limits.maxObjectSize;
+}
+
 const mult10 = new Array(147); // this is a table matching binary exponents to the multiplier to determine significant digit rounding
 for (let i = 0; i < 256; i++) {
 	mult10[i] = +('1e' + Math.floor(45.15 - i * 0.30103));
@@ -1632,7 +1687,7 @@ class Encoder extends Decoder {
 					}
 					let constructor = value.constructor;
 					if (constructor === Object) {
-						writeObject(value, true);
+						writeObject(value);
 					} else if (constructor === Array) {
 						length = value.length;
 						if (length < 0x18) {
@@ -1727,8 +1782,8 @@ class Encoder extends Decoder {
 								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') {
@@ -1748,7 +1803,19 @@ class Encoder extends Decoder {
 						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;
@@ -1790,19 +1857,19 @@ class Encoder extends Decoder {
 				}
 			}
 		} :
-		(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++;
@@ -1811,7 +1878,7 @@ class Encoder extends Decoder {
 			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;
@@ -1830,7 +1897,7 @@ class Encoder extends Decoder {
 					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
@@ -1890,9 +1957,9 @@ class Encoder extends Decoder {
 					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
 				}
@@ -1902,9 +1969,9 @@ class Encoder extends Decoder {
 			} 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) => {
@@ -1942,7 +2009,7 @@ class Encoder extends Decoder {
 			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) {
@@ -1967,7 +2034,7 @@ class Encoder extends Decoder {
 							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)) {
@@ -2557,5 +2624,6 @@ exports.encodeAsIterable = encodeAsIterable;
 exports.encodeIter = encodeIter;
 exports.mapsAsObjects = mapsAsObjects;
 exports.roundFloat32 = roundFloat32;
+exports.setSizeLimits = setSizeLimits;
 exports.useRecords = useRecords;
 //# sourceMappingURL=node.cjs.map