msgpackr 1.11.4 → 1.11.5

package/dist/node.cjs

@@ -999,21 +999,47 @@ const recordDefinition = (id, highByte) => {
 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]);
-	}
-	return value;
+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 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) => {
@@ -1732,22 +1758,47 @@ class Packr extends Unpackr {
 						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$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' +
@@ -2035,6 +2086,7 @@ class Packr extends Unpackr {
 		// 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) {
@@ -2783,7 +2835,7 @@ function readStruct(src, position, srcEnd, unpackr) {
 		};
 		fullConstruct = structure.fullConstruct = function LoadedObject() {
 		};
-		fullConstruct.prototype = unpackr.structPrototype ?? {};
+		fullConstruct.prototype = unpackr.structPrototype || {};
 		var prototype = construct.prototype = unpackr.structPrototype ? Object.create(unpackr.structPrototype) : {};
 		let properties = [];
 		let currentOffset = 0;