msgpackr 1.10.0 → 1.10.2

package/README.md

@@ -188,6 +188,7 @@ The following options properties can be provided to the Packr or Unpackr constru
 * `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). 
 * `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

@@ -859,7 +859,7 @@
 				return readFixedString(length)
 		} else { // not cacheable, go back and do a standard read
 			position$1--;
-			return read().toString()
+			return asSafeString(read())
 		}
 		let key = ((length << 5) ^ (length > 1 ? dataView.getUint16(position$1) : length > 0 ? src[position$1] : 0)) & 0xfff;
 		let entry = keyCache[key];
@@ -911,9 +911,17 @@
 		return entry.string = readFixedString(length)
 	}
 
+	function asSafeString(property) {
+		// protect against expensive (DoS) string conversions
+		if (typeof property === 'string') return property;
+		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")
 	const recordDefinition = (id, highByte) => {
-		let structure = read().map(property => property.toString()); // ensure that all keys are strings and that the array is mutable
+		let structure = read().map(asSafeString); // ensure that all keys are strings and
+		// that the array is mutable
 		let firstByte = id;
 		if (highByte !== undefined) {
 			id = id < 32 ? -((highByte << 5) + id) : ((highByte << 5) + id);
@@ -947,11 +955,12 @@
 	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) => {
 		// id extension (for structured clones)
+		if (currentUnpackr.structuredClone === false) throw new Error('Structured clone extension is disabled')
 		let id = dataView.getUint32(position$1 - 4);
 		if (!referenceMap)
 			referenceMap = new Map();
@@ -975,6 +984,7 @@
 
 	currentExtensions[0x70] = (data) => {
 		// pointer extension (for structured clones)
+		if (currentUnpackr.structuredClone === false) throw new Error('Structured clone extension is disabled')
 		let id = dataView.getUint32(position$1 - 4);
 		let refEntry = referenceMap.get(id);
 		refEntry.used = true;
@@ -989,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)
 	};
@@ -1286,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;
 				}
@@ -1512,7 +1533,7 @@
 						}
 						let constructor = value.constructor;
 						if (constructor === Object) {
-							writeObject(value, true);
+							writeObject(value);
 						} else if (constructor === Array) {
 							packArray(value);
 						} else if (constructor === Map) {
@@ -1608,8 +1629,8 @@
 								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);
 							}
 						}
 					}
@@ -1696,13 +1717,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++;
@@ -1714,12 +1735,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;
@@ -1758,10 +1779,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);
@@ -1781,7 +1802,7 @@
 				}
 				// 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]);
 					}
 			};
@@ -1789,8 +1810,8 @@
 			// craete 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) => {
@@ -1895,7 +1916,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;
@@ -1909,7 +1930,7 @@
 					return position;
 				}, this);
 				if (newPosition === 0) // bail and go to a msgpack object
-					return writeObject(object, true);
+					return writeObject(object);
 				position = newPosition;
 			};
 		}
@@ -1987,7 +2008,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) {
@@ -2040,6 +2061,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) {