msgpackr 1.11.1 → 1.11.3

package/README.md

@@ -193,6 +193,7 @@ The following options properties can be provided to the Packr or Unpackr constru
 * `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).
+* `allowArraysInMapKeys` - Allows arrays to be used as keys in Maps, as long as all elements are strings, numbers, booleans, or bigints. When enabled, such arrays are flattened and converted to a string representation.
 
 ### 32-bit Float Options
 By default all non-integer numbers are serialized as 64-bit float (double). This is fast, and ensures maximum precision. However, often real-world data doesn't not need 64-bits of precision, and using 32-bit encoding can be much more space efficient. There are several options that provide more efficient encodings. Using the decimal rounding options for encoding and decoding provides lossless storage of common decimal representations like 7.99, in more efficient 32-bit format (rather than 64-bit). The `useFloat32` property has several possible options, available from the module as constants:

package/dist/index-no-eval.cjs

@@ -916,7 +916,10 @@
 		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);
+		if (currentUnpackr.allowArraysInMapKeys && Array.isArray(property) && property.flat().every(item => ['string', 'number', 'boolean', 'bigint'].includes(typeof item))) {
+			return property.flat().toString();
+		}
+		throw new Error(`Invalid property type for record: ${typeof property}`);
 	}
 	// the registration of the record definition extension (as "r")
 	const recordDefinition = (id, highByte) => {
@@ -941,21 +944,47 @@
 	currentExtensions[0] = () => {}; // notepack defines extension 0 to mean undefined, so use that as the default here
 	currentExtensions[0].noBuffer = true;
 
-	currentExtensions[0x42] = (data) => {
-		// decode bigint
-		let length = data.length;
-		let value = BigInt(data[0] & 0x80 ? data[0] - 0x100 : data[0]);
-		for (let i = 1; i < length; i++) {
-			value <<= BigInt(8);
-			value += BigInt(data[i]);
+	currentExtensions[0x42] = data => {
+		let headLength = (data.byteLength % 8) || 8;
+		let head = BigInt(data[0] & 0x80 ? data[0] - 0x100 : data[0]);
+		for (let i = 1; i < headLength; i++) {
+			head <<= BigInt(8);
+			head += BigInt(data[i]);
 		}
-		return value;
+		if (data.byteLength !== headLength) {
+			let view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+			let decode = (start, end) => {
+				let length = end - start;
+				if (length <= 40) {
+					let out = view.getBigUint64(start);
+					for (let i = start + 8; i < end; i += 8) {
+						out <<= BigInt(64n);
+						out |= view.getBigUint64(i);
+					}
+					return out
+				}
+				// if (length === 8) return view.getBigUint64(start)
+				let middle = start + (length >> 4 << 3);
+				let left = decode(start, middle);
+				let right = decode(middle, end);
+				return (left << BigInt((end - middle) * 8)) | right
+			};
+			head = (head << BigInt((view.byteLength - headLength) * 8)) | decode(headLength, view.byteLength);
+		}
+		return head
 	};
 
-	let errors = { Error, TypeError, ReferenceError };
+	let errors = {
+		Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError, AggregateError: typeof AggregateError === 'function' ? AggregateError : null,
+	};
 	currentExtensions[0x65] = () => {
 		let data = read();
-		return (errors[data[0]] || Error)(data[1], { cause: data[2] })
+		if (!errors[data[0]]) {
+			let error = Error(data[1], { cause: data[2] });
+			error.name = data[0];
+			return error
+		}
+		return errors[data[0]](data[1], { cause: data[2] })
 	};
 
 	currentExtensions[0x69] = (data) => {
@@ -966,20 +995,33 @@
 			referenceMap = new Map();
 		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
-		// ahead past references to record structure definitions
+		// TODO: handle any other types that can cycle and make the code more robust if there are other extensions
 		if (token >= 0x90 && token < 0xa0 || token == 0xdc || token == 0xdd)
 			target = [];
+		else if (token >= 0x80 && token < 0x90 || token == 0xde || token == 0xdf)
+			target = new Map();
+		else if ((token >= 0xc7 && token <= 0xc9 || token >= 0xd4 && token <= 0xd8) && src[position$1 + 1] === 0x73)
+			target = new Set();
 		else
 			target = {};
 
 		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
-			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
+		if (!refEntry.used) {
+			// no cycle, can just use the returned read object
+			return refEntry.target = targetProperties // replace the placeholder with the real one
+		} else {
+			// there is a cycle, so we have to assign properties to original target
+			Object.assign(target, targetProperties);
+		}
+
+		// copy over map/set entries if we're able to
+		if (target instanceof Map)
+			for (let [k, v] of targetProperties.entries()) target.set(k, v);
+		if (target instanceof Set)
+			for (let i of Array.from(targetProperties)) target.add(i);
+		return target
 	};
 
 	currentExtensions[0x70] = (data) => {
@@ -998,18 +1040,16 @@
 	let glbl = typeof globalThis === 'object' ? globalThis : window;
 	currentExtensions[0x74] = (data) => {
 		let typeCode = data[0];
+		// we always have to slice to get a new ArrayBuffer that is aligned
+		let buffer = Uint8Array.prototype.slice.call(data, 1).buffer;
+
 		let typedArrayName = typedArrays[typeCode];
 		if (!typedArrayName) {
-			if (typeCode === 16) {
-				let ab = new ArrayBuffer(data.length - 1);
-				let u8 = new Uint8Array(ab);
-				u8.set(data.subarray(1));
-				return ab;
-			}
+			if (typeCode === 16) return buffer
+			if (typeCode === 17) return new DataView(buffer)
 			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)
+		return new glbl[typedArrayName](buffer)
 	};
 	currentExtensions[0x78] = () => {
 		let data = read();
@@ -1037,13 +1077,13 @@
 			return new Date(
 				((data[0] << 22) + (data[1] << 14) + (data[2] << 6) + (data[3] >> 2)) / 1000000 +
 				((data[3] & 0x3) * 0x100000000 + data[4] * 0x1000000 + (data[5] << 16) + (data[6] << 8) + data[7]) * 1000)
-		else if (data.length == 12)// TODO: Implement support for negative
+		else if (data.length == 12)
 			return new Date(
 				((data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3]) / 1000000 +
 				(((data[4] & 0x80) ? -0x1000000000000 : 0) + data[6] * 0x10000000000 + data[7] * 0x100000000 + data[8] * 0x1000000 + (data[9] << 16) + (data[10] << 8) + data[11]) * 1000)
 		else
 			return new Date('invalid')
-	}; // notepack defines extension 0 to mean undefined, so use that as the default here
+	};
 	// registration of bulk record definition?
 	// currentExtensions[0x52] = () =>
 
@@ -1637,11 +1677,11 @@
 				} else if (type === 'boolean') {
 					target[position++] = value ? 0xc3 : 0xc2;
 				} else if (type === 'bigint') {
-					if (value < (BigInt(1)<<BigInt(63)) && value >= -(BigInt(1)<<BigInt(63))) {
+					if (value < 0x8000000000000000 && value >= -0x8000000000000000) {
 						// use a signed int as long as it fits
 						target[position++] = 0xd3;
 						targetView.setBigInt64(position, value);
-					} else if (value < (BigInt(1)<<BigInt(64)) && value > 0) {
+					} else if (value < 0x10000000000000000 && value > 0) {
 						// if we can fit an unsigned int, use that
 						target[position++] = 0xcf;
 						targetView.setBigUint64(position, value);
@@ -1652,22 +1692,46 @@
 							targetView.setFloat64(position, Number(value));
 						} else if (this.largeBigIntToString) {
 							return pack(value.toString());
-						} else if (this.useBigIntExtension && value < BigInt(2)**BigInt(1023) && value > -(BigInt(2)**BigInt(1023))) {
-							target[position++] = 0xc7;
-							position++;
-							target[position++] = 0x42; // "B" for BigInt
-							let bytes = [];
-							let alignedSign;
-							do {
-								let byte = value & BigInt(0xff);
-								alignedSign = (byte & BigInt(0x80)) === (value < BigInt(0) ? BigInt(0x80) : BigInt(0));
-								bytes.push(byte);
-								value >>= BigInt(8);
-							} while (!((value === BigInt(0) || value === BigInt(-1)) && alignedSign));
-							target[position-2] = bytes.length;
-							for (let i = bytes.length; i > 0;) {
-								target[position++] = Number(bytes[--i]);
+						} else if (this.useBigIntExtension || this.moreTypes) {
+							let empty = value < 0 ? BigInt(-1) : BigInt(0);
+
+							let array;
+							if (value >> BigInt(0x10000) === empty) {
+								let mask = BigInt(0x10000000000000000) - BigInt(1); // literal would overflow
+								let chunks = [];
+								do {
+									chunks.push(value & mask);
+									value >>= BigInt(64);
+								} while (value !== empty)
+
+								array = new Uint8Array(new BigUint64Array(chunks).buffer);
+								array.reverse();
+							} else {
+								let invert = value < 0;
+								let string = (invert ? ~value : value).toString(16);
+								if (string.length % 2) {
+									string = '0' + string;
+								} else if (parseInt(string.charAt(0), 16) >= 8) {
+									string = '00' + string;
+								}
+
+								if (hasNodeBuffer) {
+									array = Buffer.from(string, 'hex');
+								} else {
+									array = new Uint8Array(string.length / 2);
+									for (let i = 0; i < array.length; i++) {
+										array[i] = parseInt(string.slice(i * 2, i * 2 + 2), 16);
+									}
+								}
+
+								if (invert) {
+									for (let i = 0; i < array.length; i++) array[i] = ~array[i];
+								}
 							}
+
+							if (array.length + position > safeEnd)
+								makeRoom(array.length + position);
+							position = writeExtensionData(array, target, position, 0x42);
 							return
 						} else {
 							throw new RangeError(value + ' was too large to fit in MessagePack 64-bit integer format, use' +
@@ -1971,7 +2035,7 @@
 		}
 	}
 
-	extensionClasses = [ Date, Set, Error, RegExp, ArrayBuffer, Object.getPrototypeOf(Uint8Array.prototype).constructor /*TypedArray*/, C1Type ];
+	extensionClasses = [ Date, Set, Error, RegExp, ArrayBuffer, Object.getPrototypeOf(Uint8Array.prototype).constructor /*TypedArray*/, DataView, C1Type ];
 	extensions = [{
 		pack(date, allocateForWrite, pack) {
 			let seconds = date.getTime() / 1000;
@@ -2058,6 +2122,13 @@
 			else
 				writeBuffer(typedArray, allocateForWrite);
 		}
+	}, {
+		pack(arrayBuffer, allocateForWrite) {
+			if (this.moreTypes)
+				writeExtBuffer(arrayBuffer, 0x11, allocateForWrite);
+			else
+				writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
+		}
 	}, {
 		pack(c1, allocateForWrite) { // specific 0xC1 object
 			let { target, position} = allocateForWrite(1);
@@ -2100,7 +2171,7 @@
 			target[position++] = length >> 8;
 			target[position++] = length & 0xff;
 		} else {
-			let { target, position, targetView } = allocateForWrite(length + 5);
+			var { target, position, targetView } = allocateForWrite(length + 5);
 			target[position++] = 0xc6;
 			targetView.setUint32(position, length);
 			position += 4;