cbor-x 1.5.8 → 1.5.9

package/dist/test.js

@@ -501,7 +501,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);
 	}
@@ -918,6 +919,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 +932,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 +1027,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 +1037,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 +1636,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 +1731,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') {
@@ -1780,19 +1794,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)) {
+					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 +1815,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 +1834,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 +1894,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 +1906,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 +1946,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) {
@@ -2649,22 +2663,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 +2688,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 +2860,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;
@@ -3092,6 +3134,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 +3231,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() {