msgpackr 1.11.1 → 1.11.3

package/pack.js

@@ -523,11 +523,11 @@ export class Packr extends Unpackr {
 			} 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)
@@ -538,22 +538,46 @@ export class Packr extends Unpackr {
 						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) {
+								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' +
@@ -857,7 +881,7 @@ export class Packr extends Unpackr {
 	}
 }
 
-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
@@ -944,6 +968,13 @@ extensions = [{
 		else
 			writeBuffer(typedArray, allocateForWrite)
 	}
+}, {
+	pack(arrayBuffer, allocateForWrite) {
+		if (this.moreTypes)
+			writeExtBuffer(arrayBuffer, 0x11, allocateForWrite)
+		else
+			writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite)
+	}
 }, {
 	pack(c1, allocateForWrite) { // specific 0xC1 object
 		let { target, position} = allocateForWrite(1)
@@ -986,7 +1017,7 @@ function writeBuffer(buffer, allocateForWrite) {
 		target[position++] = length >> 8
 		target[position++] = length & 0xff
 	} else {
-		let { target, position, targetView } = allocateForWrite(length + 5)
+		var { target, position, targetView } = allocateForWrite(length + 5)
 		target[position++] = 0xc6
 		targetView.setUint32(position, length)
 		position += 4

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "msgpackr",
   "author": "Kris Zyp",
-  "version": "1.11.1",
+  "version": "1.11.3",
   "description": "Ultra-fast MessagePack implementation with extensions for records and structured cloning",
   "license": "MIT",
   "types": "./index.d.ts",
   "main": "./dist/node.cjs",
   "module": "./index.js",
+  "react-native": "./index.js",
   "keywords": [
     "MessagePack",
     "msgpack",
@@ -32,6 +33,7 @@
         "require": "./index.d.cts",
         "import": "./index.d.ts"
       },
+      "browser": "./index.js",
       "node": {
         "require": "./dist/node.cjs",
         "import": "./node-index.js"
@@ -47,6 +49,7 @@
         "require": "./pack.d.cts",
         "import": "./pack.d.ts"
       },
+      "browser": "./pack.js",
       "node": {
         "import": "./index.js",
         "require": "./dist/node.cjs"
@@ -62,6 +65,7 @@
         "require": "./unpack.d.cts",
         "import": "./unpack.d.ts"
       },
+      "browser": "./unpack.js",
       "node": {
         "import": "./index.js",
         "require": "./dist/node.cjs"

package/struct.js

@@ -515,10 +515,14 @@ function readStruct(src, position, srcEnd, unpackr) {
 			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;
@@ -719,12 +723,12 @@ function readStruct(src, position, srcEnd, unpackr) {
 				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]);

package/unpack.js

@@ -971,7 +971,10 @@ function asSafeString(property) {
 	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) => {
@@ -996,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]);
+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) => {
@@ -1021,20 +1050,33 @@ currentExtensions[0x69] = (data) => {
 		referenceMap = new Map()
 	let token = src[position]
 	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] === 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) => {
@@ -1053,18 +1095,16 @@ export const typedArrays = ['Int8','Uint8','Uint8Clamped','Int16','Uint16','Int3
 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()
@@ -1092,13 +1132,13 @@ currentExtensions[0xff] = (data) => {
 		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] = () =>