msgpackr 1.9.8 → 1.10.0

package/README.md

@@ -184,6 +184,7 @@ The following options properties can be provided to the Packr or Unpackr constru
 * `useTimestamp32` - Encode JS `Date`s in 32-bit format when possible by dropping the milliseconds. This is a more efficient encoding of dates. You can also cause dates to use 32-bit format by manually setting the milliseconds to zero (`date.setMilliseconds(0)`).
 * `sequential` - Encode structures in serialized data, and reference previously encoded structures with expectation that decoder will read the encoded structures in the same order as encoded, with `unpackMultiple`.
 * `largeBigIntToFloat` - If a bigint needs to be encoded that is larger than will fit in 64-bit integers, it will be encoded as a float-64 (otherwise will throw a RangeError).
+* `useBigIntExtension` - If a bigint needs to be encoded that is larger than will fit in 64-bit integers, it will be encoded using a custom extension that supports up to about 1000-bits of integer precision.
 * `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).

package/dist/index-no-eval.cjs

@@ -933,6 +933,17 @@
 	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 <<= 8n;
+			value += BigInt(data[i]);
+		}
+		return value;
+	};
+
 	let errors = { Error, TypeError, ReferenceError };
 	currentExtensions[0x65] = () => {
 		let data = read();
@@ -1207,6 +1218,7 @@
 				}
 				if (hasSharedUpdate)
 					hasSharedUpdate = false;
+				let encodingError;
 				try {
 					if (packr.randomAccessStructure && value && value.constructor && value.constructor === Object)
 						writeStruct(value);
@@ -1257,6 +1269,9 @@
 						return target
 					}
 					return target.subarray(start, position) // position can change if we call pack again in saveStructures, so we get the buffer now
+				} catch(error) {
+					encodingError = error;
+					throw error;
 				} finally {
 					if (structures) {
 						resetStructures();
@@ -1265,12 +1280,14 @@
 							// we can't rely on start/end with REUSE_BUFFER_MODE since they will (probably) change when we save
 							let returnBuffer = target.subarray(start, position);
 							let newSharedData = prepareStructures(structures, packr);
-							if (packr.saveStructures(newSharedData, newSharedData.isCompatible) === false) {
-								// get updated structures and try again if the update failed
-								return packr.pack(value)
+							if (!encodingError) { // TODO: If there is an encoding error, should make the structures as uninitialized so they get rebuilt next time
+								if (packr.saveStructures(newSharedData, newSharedData.isCompatible) === false) {
+									// get updated structures and try again if the update failed
+									return packr.pack(value, encodeOptions)
+								}
+								packr.lastNamedStructuresLength = sharedLength;
+								return returnBuffer
 							}
-							packr.lastNamedStructuresLength = sharedLength;
-							return returnBuffer
 						}
 					}
 					if (encodeOptions & RESET_BUFFER_MODE)
@@ -1612,8 +1629,26 @@
 						if (this.largeBigIntToFloat) {
 							target[position++] = 0xcb;
 							targetView.setFloat64(position, Number(value));
+						} else if (this.useBigIntExtension && value < 2n**(1023n) && value > -(2n**(1023n))) {
+							target[position++] = 0xc7;
+							position++;
+							target[position++] = 0x42; // "B" for BigInt
+							let bytes = [];
+							let alignedSign;
+							do {
+								let byte = value & 0xffn;
+								alignedSign = (byte & 0x80n) === (value < 0n ? 0x80n : 0n);
+								bytes.push(byte);
+								value >>= 8n;
+							} while (!((value === 0n || value === -1n) && alignedSign));
+							target[position-2] = bytes.length;
+							for (let i = bytes.length; i > 0;) {
+								target[position++] = Number(bytes[--i]);
+							}
+							return
 						} else {
-							throw new RangeError(value + ' was too large to fit in MessagePack 64-bit integer format, set largeBigIntToFloat to convert to float-64')
+							throw new RangeError(value + ' was too large to fit in MessagePack 64-bit integer format, use' +
+								' useBigIntExtension or set largeBigIntToFloat to convert to float-64')
 						}
 					}
 					position += 8;
@@ -1861,7 +1896,7 @@
 				}
 			};
 			const writeStruct = (object, safePrototype) => {
-				let newPosition = writeStructSlots(object, target, position, structures, makeRoom, (value, newPosition, notifySharedUpdate) => {
+				let newPosition = writeStructSlots(object, target, start, position, structures, makeRoom, (value, newPosition, notifySharedUpdate) => {
 					if (notifySharedUpdate)
 						return hasSharedUpdate = true;
 					position = newPosition;