msgpackr 1.7.0 → 1.7.2

package/dist/node.cjs

@@ -196,7 +196,7 @@ function checkedRead(options) {
 
 		if (position == srcEnd) {
 			// finished reading this source, cleanup references
-			if (currentStructures?.restoreStructures)
+			if (currentStructures && currentStructures.restoreStructures)
 				restoreStructures();
 			currentStructures = null;
 			src = null;
@@ -211,7 +211,7 @@ function checkedRead(options) {
 		// else more to read, but we are reading sequentially, so don't clear source yet
 		return result
 	} catch(error) {
-		if (currentStructures?.restoreStructures)
+		if (currentStructures && currentStructures.restoreStructures)
 			restoreStructures();
 		clearSource();
 		if (error instanceof RangeError || error.message.startsWith('Unexpected end of buffer') || position > srcEnd) {
@@ -872,7 +872,7 @@ function readExt(length) {
 		})
 	}
 	else
-		throw new Error('Unknown extension type ' + type)
+		throw new Error('Unknown extension type ' + type)``
 }
 
 var keyCache = new Array(4096);
@@ -887,7 +887,7 @@ function readKey() {
 			return readFixedString(length)
 	} else { // not cacheable, go back and do a standard read
 		position--;
-		return read()
+		return read().toString()
 	}
 	let key = ((length << 5) ^ (length > 1 ? dataView.getUint16(position) : length > 0 ? src[position] : 0)) & 0xfff;
 	let entry = keyCache[key];
@@ -941,16 +941,7 @@ function readKey() {
 
 // the registration of the record definition extension (as "r")
 const recordDefinition = (id, highByte) => {
-	let structure;
-	if (currentUnpackr.freezeData) {
-		currentUnpackr.freezeData = false;
-		try {
-			structure = read();
-		} finally {
-			currentUnpackr.freezeData = true;
-		}
-	} else
-		structure = read();
+	let structure = read().map(property => property.toString()); // ensure that all keys are strings and that the array is mutable
 	let firstByte = id;
 	if (highByte !== undefined) {
 		id = id < 32 ? -((highByte << 5) + id) : ((highByte << 5) + id);
@@ -1254,19 +1245,45 @@ class Packr extends Unpackr {
 					writeStruct(value);
 				else
 					pack(value);
-				if (bundledStrings$1) {
-					writeBundles(start, pack);
-				}
-				packr.offset = position$1; // update the offset so next serialization doesn't write over our buffer, but can continue writing to same buffer sequentially
+				let lastBundle = bundledStrings$1;
+				if (bundledStrings$1)
+					writeBundles(start, pack, 0);
 				if (referenceMap && referenceMap.idsToInsert) {
-					position$1 += referenceMap.idsToInsert.length * 6;
+					let idsToInsert = referenceMap.idsToInsert.sort((a, b) => a.offset > b.offset ? 1 : -1);
+					let i = idsToInsert.length;
+					let incrementPosition = -1;
+					while (lastBundle && i > 0) {
+						let insertionPoint = idsToInsert[--i].offset + start;
+						if (insertionPoint < (lastBundle.stringsPosition + start) && incrementPosition === -1)
+							incrementPosition = 0;
+						if (insertionPoint > (lastBundle.position + start)) {
+							if (incrementPosition >= 0)
+								incrementPosition += 6;
+						} else {
+							if (incrementPosition >= 0) {
+								// update the bundle reference now
+								targetView.setUint32(lastBundle.position + start,
+									targetView.getUint32(lastBundle.position + start) + incrementPosition);
+								incrementPosition = -1; // reset
+							}
+							lastBundle = lastBundle.previous;
+							i++;
+						}
+					}
+					if (incrementPosition >= 0 && lastBundle) {
+						// update the bundle reference now
+						targetView.setUint32(lastBundle.position + start,
+							targetView.getUint32(lastBundle.position + start) + incrementPosition);
+					}
+					position$1 += idsToInsert.length * 6;
 					if (position$1 > safeEnd)
 						makeRoom(position$1);
 					packr.offset = position$1;
-					let serialized = insertIds(target.subarray(start, position$1), referenceMap.idsToInsert);
+					let serialized = insertIds(target.subarray(start, position$1), idsToInsert);
 					referenceMap = null;
 					return serialized
 				}
+				packr.offset = position$1; // update the offset so next serialization doesn't write over our buffer, but can continue writing to same buffer sequentially
 				if (encodeOptions & REUSE_BUFFER_MODE) {
 					target.start = start;
 					target.end = position$1;
@@ -1323,13 +1340,15 @@ class Packr extends Unpackr {
 						let maxBytes = (bundledStrings$1[0] ? bundledStrings$1[0].length * 3 + bundledStrings$1[1].length : 0) + 10;
 						if (position$1 + maxBytes > safeEnd)
 							target = makeRoom(position$1 + maxBytes);
-						if (bundledStrings$1.position) { // here we use the 0x62 extension to write the last bundle and reserve sapce for the reference pointer to the next/current bundle
+						let lastBundle;
+						if (bundledStrings$1.position) { // here we use the 0x62 extension to write the last bundle and reserve space for the reference pointer to the next/current bundle
+							lastBundle = bundledStrings$1;
 							target[position$1] = 0xc8; // ext 16
 							position$1 += 3; // reserve for the writing bundle size
 							target[position$1++] = 0x62; // 'b'
 							extStart = position$1 - start;
 							position$1 += 4; // reserve for writing bundle reference
-							writeBundles(start, pack); // write the last bundles
+							writeBundles(start, pack, 0); // write the last bundles
 							targetView.setUint16(extStart + start - 3, position$1 - start - extStart);
 						} else { // here we use the 0x62 extension just to reserve the space for the reference pointer to the bundle (will be updated once the bundle is written)
 							target[position$1++] = 0xd6; // fixext 4
@@ -1338,6 +1357,7 @@ class Packr extends Unpackr {
 							position$1 += 4; // reserve for writing bundle reference
 						}
 						bundledStrings$1 = ['', '']; // create new ones
+						bundledStrings$1.previous = lastBundle;
 						bundledStrings$1.size = 0;
 						bundledStrings$1.position = extStart;
 					}
@@ -2027,7 +2047,6 @@ function insertIds(serialized, idsToInsert) {
 	let nextId;
 	let distanceToMove = idsToInsert.length * 6;
 	let lastEnd = serialized.length - distanceToMove;
-	idsToInsert.sort((a, b) => a.offset > b.offset ? 1 : -1);
 	while (nextId = idsToInsert.pop()) {
 		let offset = nextId.offset;
 		let id = nextId.id;
@@ -2045,9 +2064,10 @@ function insertIds(serialized, idsToInsert) {
 	return serialized
 }
 
-function writeBundles(start, pack) {
+function writeBundles(start, pack, incrementPosition) {
 	if (bundledStrings$1.length > 0) {
-		targetView.setUint32(bundledStrings$1.position + start, position$1 - bundledStrings$1.position - start);
+		targetView.setUint32(bundledStrings$1.position + start, position$1 + incrementPosition - bundledStrings$1.position - start);
+		bundledStrings$1.stringsPosition = position$1 - start;
 		let writeStrings = bundledStrings$1;
 		bundledStrings$1 = null;
 		pack(writeStrings[0]);
@@ -2540,7 +2560,7 @@ function readStruct$1(src, position, srcEnd, unpackr) {
 			case 27: recordId = src[position++] + (src[position++] << 8) + (src[position++] << 16) + (src[position++] << 24); break;
 		}
 	}
-	let structure = unpackr.typedStructs?.[recordId];
+	let structure = unpackr.typedStructs && unpackr.typedStructs[recordId];
 	if (!structure) {
 		// copy src buffer because getStructures will override it
 		src = Uint8Array.prototype.slice.call(src, position, srcEnd);
@@ -2832,7 +2852,7 @@ function prepareStructures$1(structures, packr) {
 			packr._mergeStructures(existing);
 		return compatible;
 	};
-	packr.lastTypedStructuresLength = packr.typedStructs?.length;
+	packr.lastTypedStructuresLength = packr.typedStructs && packr.typedStructs.length;
 	return structures;
 }