msgpackr 1.11.4 → 1.11.6

package/dist/index.js

@@ -943,21 +943,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) => {
@@ -1250,7 +1276,8 @@
 					hasSharedUpdate = false;
 				let encodingError;
 				try {
-					if (packr.randomAccessStructure && value && value.constructor && value.constructor === Object)
+					if (packr.randomAccessStructure && value && value.constructor && (value.constructor === Object ||
+							(value.constructor !== Map && !Array.isArray(value) && !extensionClasses.some(extClass => value instanceof extClass))))
 						writeStruct(value);
 					else
 						pack(value);
@@ -1665,22 +1692,47 @@
 							targetView.setFloat64(position, Number(value));
 						} else if (this.largeBigIntToString) {
 							return pack(value.toString());
-						} else if ((this.useBigIntExtension || this.moreTypes) && 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 = [];
+								while (true) {
+									chunks.push(value & mask);
+									if ((value >> BigInt(63)) === empty) break
+									value >>= BigInt(64);
+								}
+
+								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' +
@@ -1968,6 +2020,7 @@
 			// this means we are finished using our own buffer and we can write over it safely
 			target = buffer;
 			target.dataView || (target.dataView = new DataView(target.buffer, target.byteOffset, target.byteLength));
+			targetView = target.dataView;
 			position = 0;
 		}
 		set position (value) {