msgpackr 1.8.5 → 1.9.0

package/README.md

@@ -173,8 +173,10 @@ The following options properties can be provided to the Packr or Unpackr constru
 * `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).
 * `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`, or `string`. 
+* `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).
+* `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).
 
 ### 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

@@ -72,6 +72,8 @@
 					return this ? this.unpack(source, options) : Unpackr.prototype.unpack.call(defaultOptions, source, options)
 				})
 			}
+			if (!source.buffer && source.constructor === ArrayBuffer)
+				source = typeof Buffer !== 'undefined' ? Buffer.from(source) : new Uint8Array(source);
 			if (typeof options === 'object') {
 				srcEnd = options.end || source.length;
 				position$1 = options.start || 0;
@@ -205,7 +207,13 @@
 				// over read
 				throw new Error('Unexpected end of MessagePack data')
 			} else if (!sequentialMode) {
-				throw new Error('Data read, but end of buffer not reached ' + JSON.stringify(result).slice(0, 100))
+				let jsonView;
+				try {
+					jsonView = JSON.stringify(result, (_, value) => typeof value === "bigint" ? `${value}n` : value).slice(0, 100);
+				} catch(error) {
+					jsonView = '(JSON view not available ' + error + ')';
+				}
+				throw new Error('Data read, but end of buffer not reached ' + jsonView)
 			}
 			// else more to read, but we are reading sequentially, so don't clear source yet
 			return result
@@ -361,6 +369,9 @@
 						value += dataView.getUint32(position$1 + 4);
 					} else if (currentUnpackr.int64AsType === 'string') {
 						value = dataView.getBigUint64(position$1).toString();
+					} else if (currentUnpackr.int64AsType === 'auto') {
+						value = dataView.getBigUint64(position$1);
+						if (value<=BigInt(2)<<BigInt(52)) value=Number(value);
 					} else
 						value = dataView.getBigUint64(position$1);
 					position$1 += 8;
@@ -383,6 +394,9 @@
 						value += dataView.getUint32(position$1 + 4);
 					} else if (currentUnpackr.int64AsType === 'string') {
 						value = dataView.getBigInt64(position$1).toString();
+					} else if (currentUnpackr.int64AsType === 'auto') {
+						value = dataView.getBigInt64(position$1);
+						if (value>=BigInt(-2)<<BigInt(52)&&value<=BigInt(2)<<BigInt(52)) value=Number(value);
 					} else
 						value = dataView.getBigInt64(position$1);
 					position$1 += 8;
@@ -912,9 +926,10 @@
 	currentExtensions[0] = () => {}; // notepack defines extension 0 to mean undefined, so use that as the default here
 	currentExtensions[0].noBuffer = true;
 
+	let global = typeof globalThis === 'object' ? globalThis : window;
 	currentExtensions[0x65] = () => {
 		let data = read();
-		return (globalThis[data[0]] || Error)(data[1])
+		return (global[data[0]] || Error)(data[1])
 	};
 
 	currentExtensions[0x69] = (data) => {
@@ -958,7 +973,7 @@
 		if (!typedArrayName)
 			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 globalThis[typedArrayName](Uint8Array.prototype.slice.call(data, 1).buffer)
+		return new global[typedArrayName](Uint8Array.prototype.slice.call(data, 1).buffer)
 	};
 	currentExtensions[0x78] = () => {
 		let data = read();
@@ -1184,7 +1199,7 @@
 				if (hasSharedUpdate)
 					hasSharedUpdate = false;
 				try {
-					if (packr.randomAccessStructure && value.constructor && value.constructor === Object)
+					if (packr.randomAccessStructure && value && value.constructor && value.constructor === Object)
 						writeStruct(value);
 					else
 						pack(value);
@@ -1471,21 +1486,24 @@
 						} else if (constructor === Array) {
 							packArray(value);
 						} else if (constructor === Map) {
-							length = value.size;
-							if (length < 0x10) {
-								target[position++] = 0x80 | length;
-							} else if (length < 0x10000) {
-								target[position++] = 0xde;
-								target[position++] = length >> 8;
-								target[position++] = length & 0xff;
-							} else {
-								target[position++] = 0xdf;
-								targetView.setUint32(position, length);
-								position += 4;
-							}
-							for (let [ key, entryValue ] of value) {
-								pack(key);
-								pack(entryValue);
+							if (this.mapAsEmptyObject) target[position++] = 0x80;
+							else {
+								length = value.size;
+								if (length < 0x10) {
+									target[position++] = 0x80 | length;
+								} else if (length < 0x10000) {
+									target[position++] = 0xde;
+									target[position++] = length >> 8;
+									target[position++] = length & 0xff;
+								} else {
+									target[position++] = 0xdf;
+									targetView.setUint32(position, length);
+									position += 4;
+								}
+								for (let [key, entryValue] of value) {
+									pack(key);
+									pack(entryValue);
+								}
 							}
 						} else {	
 							for (let i = 0, l = extensions.length; i < l; i++) {
@@ -1548,6 +1566,8 @@
 							if (Array.isArray(value)) {
 								packArray(value);
 							} else {
+								if (value.toJSON) // use this as an alternate mechanism for expressing how to serialize
+									return pack(value.toJSON());
 								// no extension found, write as object
 								writeObject(value, !value.hasOwnProperty); // if it doesn't have hasOwnProperty, don't do hasOwnProperty checks
 							}
@@ -1868,6 +1888,7 @@
 		}
 	}, {
 		pack(set, allocateForWrite, pack) {
+			if (this.setAsEmptyObject) return pack({})
 			let array = Array.from(set);
 			let { target, position} = allocateForWrite(this.moreTypes ? 3 : 0);
 			if (this.moreTypes) {