msgpackr 1.10.1 → 1.11.0

package/dist/test.js

@@ -963,8 +963,10 @@
 	}
 
 	function asSafeString(property) {
+		// protect against expensive (DoS) string conversions
 		if (typeof property === 'string') return property;
-		if (typeof property === 'number') return property.toString();
+		if (typeof property === 'number' || typeof property === 'boolean' || typeof property === 'bigint') return property.toString();
+		if (property == null) return property + '';
 		throw new Error('Invalid property type for record', typeof property);
 	}
 	// the registration of the record definition extension (as "r")
@@ -1004,7 +1006,7 @@
 	let errors = { Error, TypeError, ReferenceError };
 	currentExtensions[0x65] = () => {
 		let data = read();
-		return (errors[data[0]] || Error)(data[1])
+		return (errors[data[0]] || Error)(data[1], { cause: data[2] })
 	};
 
 	currentExtensions[0x69] = (data) => {
@@ -1048,8 +1050,15 @@
 	currentExtensions[0x74] = (data) => {
 		let typeCode = data[0];
 		let typedArrayName = typedArrays[typeCode];
-		if (!typedArrayName)
+		if (!typedArrayName) {
+			if (typeCode === 16) {
+				let ab = new ArrayBuffer(data.length - 1);
+				let u8 = new Uint8Array(ab);
+				u8.set(data.subarray(1));
+				return ab;
+			}
 			throw new Error('Could not find typed array for code ' + typeCode)
+		}
 		// we have to always slice/copy here to get a new ArrayBuffer that is word/byte aligned
 		return new glbl[typedArrayName](Uint8Array.prototype.slice.call(data, 1).buffer)
 	};
@@ -1219,7 +1228,7 @@
 			if (!this.structures && options.useRecords != false)
 				this.structures = [];
 			// two byte record ids for shared structures
-			let useTwoByteRecords = maxSharedStructures > 32 || (maxOwnStructures + maxSharedStructures > 64);		
+			let useTwoByteRecords = maxSharedStructures > 32 || (maxOwnStructures + maxSharedStructures > 64);
 			let sharedLimitId = maxSharedStructures + 0x40;
 			let maxStructureId = maxSharedStructures + maxOwnStructures + 0x40;
 			if (maxStructureId > 8256) {
@@ -1237,7 +1246,7 @@
 				}
 				safeEnd = target.length - 10;
 				if (safeEnd - position < 0x800) {
-					// don't start too close to the end, 
+					// don't start too close to the end,
 					target = new ByteArrayAllocate(target.length);
 					targetView = target.dataView || (target.dataView = new DataView(target.buffer, 0, target.length));
 					safeEnd = target.length - 10;
@@ -1355,10 +1364,14 @@
 									return packr.pack(value, encodeOptions)
 								}
 								packr.lastNamedStructuresLength = sharedLength;
+								// don't keep large buffers around
+								if (target.length > 0x40000000) target = null;
 								return returnBuffer
 							}
 						}
 					}
+					// don't keep large buffers around, they take too much memory and cause problems (limit at 1GB)
+					if (target.length > 0x40000000) target = null;
 					if (encodeOptions & RESET_BUFFER_MODE)
 						position = start;
 				}
@@ -1576,12 +1589,12 @@
 								targetView.setUint32(position, referee.id);
 								position += 4;
 								return
-							} else 
+							} else
 								referenceMap.set(value, { offset: position - start });
 						}
 						let constructor = value.constructor;
 						if (constructor === Object) {
-							writeObject(value, true);
+							writeObject(value);
 						} else if (constructor === Array) {
 							packArray(value);
 						} else if (constructor === Map) {
@@ -1604,7 +1617,7 @@
 									pack(entryValue);
 								}
 							}
-						} else {	
+						} else {
 							for (let i = 0, l = extensions.length; i < l; i++) {
 								let extensionClass = extensionClasses[i];
 								if (value instanceof extensionClass) {
@@ -1672,13 +1685,13 @@
 									if (json !== value)
 										return pack(json)
 								}
-								
+
 								// if there is a writeFunction, use it, otherwise just encode as undefined
 								if (type === 'function')
 									return pack(this.writeFunction && this.writeFunction(value));
-								
-								// 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 plain object
+								writeObject(value);
 							}
 						}
 					}
@@ -1734,9 +1747,19 @@
 				}
 			};
 
-			const writePlainObject = (this.variableMapSize || this.coercibleKeyAsNumber) ? (object) => {
+			const writePlainObject = (this.variableMapSize || this.coercibleKeyAsNumber || this.skipValues) ? (object) => {
 				// this method is slightly slower, but generates "preferred serialization" (optimally small for smaller objects)
-				let keys = Object.keys(object);
+				let keys;
+				if (this.skipValues) {
+					keys = [];
+					for (let key in object) {
+						if ((typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) &&
+							!this.skipValues.includes(object[key]))
+							keys.push(key);
+					}
+				} else {
+					keys = Object.keys(object);
+				}
 				let length = keys.length;
 				if (length < 0x10) {
 					target[position++] = 0x80 | length;
@@ -1765,13 +1788,13 @@
 					}
 				}
 			} :
-			(object, safePrototype) => {
+			(object) => {
 				target[position++] = 0xde; // always using map 16, so we can preallocate and set the length afterwards
 				let objectOffset = position - start;
 				position += 2;
 				let size = 0;
 				for (let key in object) {
-					if (safePrototype || object.hasOwnProperty(key)) {
+					if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
 						pack(key);
 						pack(object[key]);
 						size++;
@@ -1783,12 +1806,12 @@
 
 			const writeRecord = this.useRecords === false ? writePlainObject :
 			(options.progressiveRecords && !useTwoByteRecords) ?  // this is about 2% faster for highly stable structures, since it only requires one for-in loop (but much more expensive when new structure needs to be written)
-			(object, safePrototype) => {
+			(object) => {
 				let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
 				let objectOffset = position++ - start;
 				let wroteKeys;
 				for (let key in object) {
-					if (safePrototype || object.hasOwnProperty(key)) {
+					if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
 						nextTransition = transition[key];
 						if (nextTransition)
 							transition = nextTransition;
@@ -1827,10 +1850,10 @@
 						insertNewRecord(transition, Object.keys(object), objectOffset, 0);
 				}
 			} :
-			(object, safePrototype) => {
+			(object) => {
 				let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
 				let newTransitions = 0;
-				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) {
 						nextTransition = transition[key] = Object.create(null);
@@ -1850,16 +1873,16 @@
 				}
 				// now write the values
 				for (let key in object)
-					if (safePrototype || object.hasOwnProperty(key)) {
+					if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
 						pack(object[key]);
 					}
 			};
 
-			// craete reference to useRecords if useRecords is a function
+			// create reference to useRecords if useRecords is a function
 			const checkUseRecords = typeof this.useRecords == 'function' && this.useRecords;
-			
-			const writeObject = checkUseRecords ? (object, safePrototype) => {
-				checkUseRecords(object) ? writeRecord(object,safePrototype) : writePlainObject(object,safePrototype);
+
+			const writeObject = checkUseRecords ? (object) => {
+				checkUseRecords(object) ? writeRecord(object) : writePlainObject(object);
 			} : writeRecord;
 
 			const makeRoom = (end) => {
@@ -1964,7 +1987,7 @@
 					target[insertionOffset + start] = keysTarget[0];
 				}
 			};
-			const writeStruct = (object, safePrototype) => {
+			const writeStruct = (object) => {
 				let newPosition = writeStructSlots(object, target, start, position, structures, makeRoom, (value, newPosition, notifySharedUpdate) => {
 					if (notifySharedUpdate)
 						return hasSharedUpdate = true;
@@ -1978,16 +2001,22 @@
 					return position;
 				}, this);
 				if (newPosition === 0) // bail and go to a msgpack object
-					return writeObject(object, true);
+					return writeObject(object);
 				position = newPosition;
 			};
 		}
 		useBuffer(buffer) {
 			// this means we are finished using our own buffer and we can write over it safely
 			target = buffer;
-			targetView = new DataView(target.buffer, target.byteOffset, target.byteLength);
+			target.dataView || (target.dataView = new DataView(target.buffer, target.byteOffset, target.byteLength));
 			position = 0;
 		}
+		set position (value) {
+			position = value;
+		}
+		get position() {
+			return position;
+		}
 		clearSharedData() {
 			if (this.structures)
 				this.structures = [];
@@ -2056,7 +2085,7 @@
 				target[position++] = 0x65; // 'e' for error
 				target[position++] = 0;
 			}
-			pack([ error.name, error.message ]);
+			pack([ error.name, error.message, error.cause ]);
 		}
 	}, {
 		pack(regex, allocateForWrite, pack) {
@@ -2109,6 +2138,7 @@
 		}
 		target[position++] = 0x74; // "t" for typed array
 		target[position++] = type;
+		if (!typedArray.buffer) typedArray = new Uint8Array(typedArray);
 		target.set(new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength), position);
 	}
 	function writeBuffer(buffer, allocateForWrite) {
@@ -2701,6 +2731,8 @@
 			src = Uint8Array.prototype.slice.call(src, position, srcEnd);
 			srcEnd -= position;
 			position = 0;
+			if (!unpackr.getStructures)
+				throw new Error(`Reference to shared structure ${recordId} without getStructures method`);
 			unpackr._mergeStructures(unpackr.getStructures());
 			if (!unpackr.typedStructs)
 				throw new Error('Could not find any shared typed structures');
@@ -3711,13 +3743,35 @@
 				}
 		});
 
+		test('moreTyesp: Error with causes', function() {
+			const object = {
+				error: new Error('test'),
+				errorWithCause: new Error('test-1', { cause: new Error('test-2')}),
+			};
+			const packr = new Packr({
+				moreTypes: true,
+			});
+
+			const serialized = packr.pack(object);
+			const deserialized = packr.unpack(serialized);
+			assert.equal(deserialized.error.message, object.error.message);
+			assert.equal(deserialized.error.cause, object.error.cause);
+			assert.equal(deserialized.errorWithCause.message, object.errorWithCause.message);
+			assert.equal(deserialized.errorWithCause.cause.message, object.errorWithCause.cause.message);
+			assert.equal(deserialized.errorWithCause.cause.cause, object.errorWithCause.cause.cause);
+		});
+
 		test('structured cloning: self reference', function() {
 			let object = {
 				test: 'string',
 				children: [
 					{ name: 'child' }
-				]
+				],
+				value: new ArrayBuffer(10)
 			};
+			let u8 = new Uint8Array(object.value);
+			u8[0] = 1;
+			u8[1] = 2;
 			object.self = object;
 			object.children[1] = object;
 			object.children[2] = object.children[0];
@@ -3733,6 +3787,10 @@
 			assert.equal(deserialized.children[1], deserialized);
 			assert.equal(deserialized.children[0], deserialized.children[2]);
 			assert.equal(deserialized.children, deserialized.childrenAgain);
+			assert.equal(deserialized.value.constructor.name, 'ArrayBuffer');
+			u8 = new Uint8Array(deserialized.value);
+			assert.equal(u8[0], 1);
+			assert.equal(u8[1], 2);
 		});
 
 		test('structured cloning: types', function() {
@@ -3813,6 +3871,13 @@
 			assert.deepEqual(deserialized, data);
 		});
 
+		test('object with __proto__', function(){
+			const data = { foo: 'bar', __proto__: { isAdmin: true } };
+			var serialized = pack(data);
+			var deserialized = unpack(serialized);
+			assert.deepEqual(deserialized, { foo: 'bar' });
+		});
+
 		test('separate instances', function() {
 			const packr = new Packr({
 				structures: [['m', 'e'], ['action', 'share']]
@@ -4200,6 +4265,54 @@
 			const deserialized = unpack(serialized);
 			assert.deepStrictEqual(deserialized, { someData: [1, 2, 3, 4] });
 		});
+		test('skip values', function () {
+			var data = {
+				data: [
+					{ a: 1, name: 'one', type: 'odd', isOdd: true },
+					{ a: 2, name: 'two', type: 'even', isOdd: undefined },
+					{ a: 3, name: 'three', type: 'odd', isOdd: true },
+					{ a: 4, name: 'four', type: 'even', isOdd: null},
+					{ a: 5, name: 'five', type: 'odd', isOdd: true },
+					{ a: 6, name: 'six', type: 'even', isOdd: null }
+				],
+				description: 'some names',
+				types: ['odd', 'even'],
+				convertEnumToNum: [
+					{ prop: 'test' },
+					{ prop: 'test' },
+					{ prop: 'test' },
+					{ prop: 1 },
+					{ prop: 2 },
+					{ prop: [undefined, null] },
+					{ prop: null }
+				]
+			};
+			var expected = {
+				data: [
+					{ a: 1, name: 'one', type: 'odd', isOdd: true },
+					{ a: 2, name: 'two', type: 'even' },
+					{ a: 3, name: 'three', type: 'odd', isOdd: true },
+					{ a: 4, name: 'four', type: 'even', },
+					{ a: 5, name: 'five', type: 'odd', isOdd: true },
+					{ a: 6, name: 'six', type: 'even' }
+				],
+				description: 'some names',
+				types: ['odd', 'even'],
+				convertEnumToNum: [
+					{ prop: 'test' },
+					{ prop: 'test' },
+					{ prop: 'test' },
+					{ prop: 1 },
+					{ prop: 2 },
+					{ prop: [undefined, null] },
+					{}
+				]
+			};
+			let packr = new Packr({ useRecords: false, skipValues: [undefined, null] });
+			var serialized = packr.pack(data);
+			var deserialized = packr.unpack(serialized);
+			assert.deepEqual(deserialized, expected);
+		});
 	});
 	suite('msgpackr performance tests', function(){
 		test('performance JSON.parse', function() {