msgpackr 1.10.1 → 1.11.0

package/README.md

@@ -186,8 +186,10 @@ The following options properties can be provided to the Packr or Unpackr constru
 * `largeBigIntToFloat` - If a bigint needs to be encoded that is larger than will fit in 64-bit integers, it will be encoded as a float-64 (otherwise will throw a RangeError).
 * `useBigIntExtension` - If a bigint needs to be encoded that is larger than will fit in 64-bit integers, it will be encoded using a custom extension that supports up to about 1000-bits of integer precision.
 * `encodeUndefinedAsNil` - Encodes a value of `undefined` as a MessagePack `nil`, the same as a `null`.
-* `int64AsType` - This will decode uint64 and int64 numbers as the specified type. The type can be `bigint` (default), `number`,  `string`, or `auto` (where range [-2^53...2^53] is represented by number and everything else by a bigint). 
+* `int64AsType` - This will decode uint64 and int64 numbers as the specified type. The type can be `bigint` (default), `number`,  `string`, or `auto` (where range [-2^53...2^53] is represented by number and everything else by a bigint).
+* `skipValues` - This can be an array of property values that will indicate properties that should be skipped when serializing objects. For example, to mimic `JSON.stringify`'s behavior of skipping properties with a value of `undefined`, you can provide `skipValues: [undefined]`. Note, that this will only apply to serializing objects as standard MessagePack maps, not to records. Also, the array is checked by calling the `include` method, so you can provide an object with an `includes` if you want a custom function to skip values. 
 * `onInvalidDate` - This can be provided as function that will be called when an invalid date is provided. The function can throw an error, or return a value that will be encoded in place of the invalid date. If not provided, an invalid date will be encoded as an invalid timestamp (which decodes with msgpackr back to an invalid date).
+* `writeFunction` - This can be provided as function that will be called when a function is encountered. The function can throw an error, or return a value that will be encoded in place of the function. If not provided, a function will be encoded as undefined (similar to `JSON.stringify`).
 * `mapAsEmptyObject` - Encodes JS `Map`s as empty objects (for back-compat with older libraries).
 * `setAsEmptyObject` - Encodes JS `Set`s as empty objects (for back-compat with older libraries).
 

package/dist/index-no-eval.cjs

@@ -912,8 +912,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")
@@ -953,7 +955,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) => {
@@ -997,8 +999,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)
 	};
@@ -1158,7 +1167,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) {
@@ -1176,7 +1185,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;
@@ -1294,10 +1303,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;
 				}
@@ -1515,12 +1528,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) {
@@ -1543,7 +1556,7 @@
 									pack(entryValue);
 								}
 							}
-						} else {	
+						} else {
 							for (let i = 0, l = extensions.length; i < l; i++) {
 								let extensionClass = extensionClasses[i];
 								if (value instanceof extensionClass) {
@@ -1611,13 +1624,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);
 							}
 						}
 					}
@@ -1673,9 +1686,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;
@@ -1704,13 +1727,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++;
@@ -1722,12 +1745,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;
@@ -1766,10 +1789,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);
@@ -1789,16 +1812,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) => {
@@ -1903,7 +1926,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;
@@ -1917,16 +1940,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 = [];
@@ -1995,7 +2024,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) {
@@ -2048,6 +2077,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) {
@@ -2271,6 +2301,8 @@
 	exports.FLOAT32_OPTIONS = FLOAT32_OPTIONS;
 	exports.NEVER = NEVER;
 	exports.Packr = Packr;
+	exports.RESERVE_START_SPACE = RESERVE_START_SPACE;
+	exports.RESET_BUFFER_MODE = RESET_BUFFER_MODE;
 	exports.REUSE_BUFFER_MODE = REUSE_BUFFER_MODE;
 	exports.Unpackr = Unpackr;
 	exports.addExtension = addExtension;