msgpackr 1.11.2 → 1.11.3

package/dist/test.js

@@ -967,7 +967,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) => {
@@ -992,21 +995,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]);
+		}
+		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 value;
+		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) => {
@@ -1017,20 +1046,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) => {
@@ -1049,18 +1091,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();
@@ -1088,13 +1128,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] = () =>
 
@@ -1698,11 +1738,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);
@@ -1713,22 +1753,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$1) {
+									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' +
@@ -2032,7 +2096,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;
@@ -2119,6 +2183,13 @@
 			else
 				writeBuffer(typedArray, allocateForWrite);
 		}
+	}, {
+		pack(arrayBuffer, allocateForWrite) {
+			if (this.moreTypes)
+				writeExtBuffer(arrayBuffer, 0x11, allocateForWrite);
+			else
+				writeBuffer(hasNodeBuffer$1 ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
+		}
 	}, {
 		pack(c1, allocateForWrite) { // specific 0xC1 object
 			let { target, position} = allocateForWrite(1);
@@ -2749,10 +2820,14 @@
 				throw new Error('Could not find typed structure ' + recordId);
 		}
 		var construct = structure.construct;
+		var fullConstruct = structure.fullConstruct;
 		if (!construct) {
 			construct = structure.construct = function LazyObject() {
 			};
-			var prototype = construct.prototype;
+			fullConstruct = structure.fullConstruct = function LoadedObject() {
+			};
+			fullConstruct.prototype = unpackr.structPrototype ?? {};
+			var prototype = construct.prototype = unpackr.structPrototype ? Object.create(unpackr.structPrototype) : {};
 			let properties = [];
 			let currentOffset = 0;
 			let lastRefProperty;
@@ -2953,12 +3028,12 @@
 					Object.defineProperty(prototype, property.key, { get: withSource(property.get), enumerable: true });
 					let valueFunction = 'v' + i++;
 					args.push(valueFunction);
-					objectLiteralProperties.push('[' + JSON.stringify(property.key) + ']:' + valueFunction + '(s)');
+					objectLiteralProperties.push('o[' + JSON.stringify(property.key) + ']=' + valueFunction + '(s)');
 				}
 				if (hasInheritedProperties) {
 					objectLiteralProperties.push('__proto__:this');
 				}
-				let toObject = (new Function(...args, 'return function(s){return{' + objectLiteralProperties.join(',') + '}}')).apply(null, properties.map(prop => prop.get));
+				let toObject = (new Function(...args, 'var c=this;return function(s){var o=new c();' + objectLiteralProperties.join(';') + ';return o;}')).apply(fullConstruct, properties.map(prop => prop.get));
 				Object.defineProperty(prototype, 'toJSON', {
 					value(omitUnderscoredProperties) {
 						return toObject.call(this, this[sourceSymbol]);
@@ -3292,7 +3367,7 @@
 				{id: 2, type: 1, labels: {b: 1, c: 2}},
 				{id: 3, type: 1, labels: {d: 1, e: 2}}
 			];
-			
+
 			var alternatives = [
 				{useRecords: false}, // 88 bytes
 				{useRecords: true}, // 58 bytes
@@ -3304,7 +3379,7 @@
 				let packr = new Packr(o);
 				var serialized = packr.pack(data);
 				var deserialized = packr.unpack(serialized);
-				assert.deepEqual(deserialized, data);	
+				assert.deepEqual(deserialized, data);
 			}
 		});
 
@@ -3426,7 +3501,7 @@
 		});
 
 		test('BigInt', function() {
-			let packr = new Packr({useBigIntExtension: true});
+			let packr = new Packr({ useBigIntExtension: true });
 			let data = {
 				a: 3333333333333333333333333333n,
 				b: 1234567890123456789012345678901234567890n,
@@ -3434,7 +3509,21 @@
 				d: -352523523642364364364264264264264264262642642n,
 				e: 0xffffffffffffffffffffffffffn,
 				f: -0xffffffffffffffffffffffffffn,
+				g: (1234n << 123n) ^ (5678n << 56n) ^ 890n,
+				h: (-1234n << 123n) ^ (5678n << 56n) ^ 890n,
+				i: (1234n << 1234n) ^ (5678n << 567n) ^ 890n,
+				j: (-1234n << 1234n) ^ (5678n << 567n) ^ 890n,
+				k: 0xdeadn << 0xbeefn,
+				l: -0xdeadn << 0xbeefn,
+				m: 11n << 0x11111n ^ 111n,
+				n: -11n << 0x11111n ^ 111n,
+				array: [],
 			};
+
+			for (let n = 7n; n.toString(16).length * 4 < 150000; n *= n) {
+				data.array.push(n, -n);
+			}
+
 			let serialized = packr.pack(data);
 			let deserialized = packr.unpack(serialized);
 			assert.deepEqual(data, deserialized);
@@ -3661,7 +3750,7 @@
 
 		test('extended class pack/unpack proxied', function(){
 			function Extended() {
-				
+
 			}
 			Extended.prototype.__call__ = function(){
 				return this.value * 4
@@ -3672,7 +3761,7 @@
 
 			var instance = function() { instance.__call__();/* callable stuff */ };
 			Object.setPrototypeOf(instance,Extended.prototype);
-			
+
 			instance.value = 4;
 			var data = instance;
 
@@ -3750,10 +3839,12 @@
 				}
 		});
 
-		test('moreTyesp: Error with causes', function() {
+		test('moreTypes: Error with causes', function() {
 			const object = {
 				error: new Error('test'),
-				errorWithCause: new Error('test-1', { cause: new Error('test-2')}),
+				errorWithCause: new Error('test-1', { cause: new Error('test-2') }),
+				type: new TypeError(),
+				range: new RangeError('test', { cause: [1, 2] }),
 			};
 			const packr = new Packr({
 				moreTypes: true,
@@ -3766,6 +3857,12 @@
 			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);
+			assert.equal(deserialized.type.message, object.type.message);
+			assert.equal(deserialized.range.message, object.range.message);
+			assert.deepEqual(deserialized.range.cause, object.range.cause);
+			assert(deserialized.error instanceof Error);
+			assert(deserialized.type instanceof TypeError);
+			assert(deserialized.range instanceof RangeError);
 		});
 
 		test('structured cloning: self reference', function() {
@@ -3800,6 +3897,39 @@
 			assert.equal(u8[1], 2);
 		});
 
+		test('structured cloning: self reference with more types', function() {
+			let set = new Set();
+			set.add(['hello', 1, 2, { map: new Map([[set, set], ['a', 'b']]) }]);
+
+			let packr = new Packr({
+				moreTypes: true,
+				structuredClone: true,
+			});
+			let serialized = packr.pack(set);
+			let deserialized = packr.unpack(serialized);
+			assert.equal(deserialized.constructor.name, 'Set');
+			let map = Array.from(deserialized)[0][3].map;
+			assert.equal(map.get(deserialized), deserialized);
+
+			let sizeTestMap = new Map();
+			for (let i = 0; i < 50; i++) {
+				sizeTestMap.set(i || sizeTestMap, sizeTestMap);
+				let deserialized = packr.unpack(packr.pack(sizeTestMap));
+				assert.equal(deserialized.size, i + 1);
+				assert(deserialized.has(deserialized));
+				assert(deserialized.has(i || deserialized));
+			}
+
+			let sizeTestSet = new Set();
+			for (let i = 0; i < 50; i++) {
+				sizeTestSet.add(i || sizeTestSet);
+				let deserialized = packr.unpack(packr.pack(sizeTestSet));
+				assert.equal(deserialized.size, i + 1);
+				assert(deserialized.has(deserialized));
+				assert(deserialized.has(i || deserialized));
+			}
+		});
+
 		test('structured cloning: types', function() {
 			let b = typeof Buffer != 'undefined' ? Buffer.alloc(20) : new Uint8Array(20);
 			let fa = new Float32Array(b.buffer, 8, 2);
@@ -3810,7 +3940,9 @@
 				set: new Set(['a', 'b']),
 				regexp: /test/gi,
 				float32Array: fa,
-				uint16Array: new Uint16Array([3,4])
+				uint16Array: new Uint16Array([3, 4]),
+				arrayBuffer: new Uint8Array([0xde, 0xad]).buffer,
+				dataView: new DataView(new Uint8Array([0xbe, 0xef]).buffer),
 			};
 			let packr = new Packr({
 				moreTypes: true,
@@ -3827,6 +3959,10 @@
 			assert.equal(deserialized.uint16Array.constructor.name, 'Uint16Array');
 			assert.equal(deserialized.uint16Array[0], 3);
 			assert.equal(deserialized.uint16Array[1], 4);
+			assert.equal(deserialized.arrayBuffer.constructor.name, 'ArrayBuffer');
+			assert.equal(new DataView(deserialized.arrayBuffer).getUint16(), 0xdead);
+			assert.equal(deserialized.dataView.constructor.name, 'DataView');
+			assert.equal(deserialized.dataView.getUint16(), 0xbeef);
 		});
 		test('big bundledStrings', function() {
 			const MSGPACK_OPTIONS = {bundleStrings: true};
@@ -3955,7 +4091,7 @@
 				getStructures() {
 					return structures
 				},
-				saveStructures(structures) {		  
+				saveStructures(structures) {
 				},
 				maxSharedStructures: 100
 			});
@@ -3963,7 +4099,7 @@
 				getStructures() {
 					return structures2
 				},
-				saveStructures(structures) {		  
+				saveStructures(structures) {
 				},
 				maxSharedStructures: 100
 			});
@@ -4245,6 +4381,18 @@
 			assert.deepEqual(deserialized, data);
 		});
 
+		test('arrays in map keys', function() {
+			const msgpackr = new Packr({ mapsAsObjects: true, allowArraysInMapKeys: true });
+
+			const map = new Map();
+			map.set([1, 2, 3], 1);
+			map.set([1, 2, ['foo', 3.14]], 2);
+
+			const packed = msgpackr.pack(map);
+			const unpacked = msgpackr.unpack(packed);
+			assert.deepEqual(unpacked, { '1,2,3': 1, '1,2,foo,3.14': 2 });
+		});
+
 		test('utf16 causing expansion', function() {
 			this.timeout(10000);
 			let data = {fixstr: 'ᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝ', str8:'ᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝ'};