msgpackr 1.9.1 → 1.9.3

package/dist/node.cjs

@@ -122,10 +122,10 @@ class Unpackr {
 			let size = source.length;
 			let value = this ? this.unpack(source, size) : defaultUnpackr.unpack(source, size);
 			if (forEach) {
-				if (forEach(value) === false) return;
+				if (forEach(value, lastPosition, position$1) === false) return;
 				while(position$1 < size) {
 					lastPosition = position$1;
-					if (forEach(checkedRead()) === false) {
+					if (forEach(checkedRead(), lastPosition, position$1) === false) {
 						return
 					}
 				}
@@ -199,6 +199,10 @@ function checkedRead(options) {
 			position$1 = bundledStrings$1.postBundlePosition;
 			bundledStrings$1 = null;
 		}
+		if (sequentialMode)
+			// we only need to restore the structures if there was an error, but if we completed a read,
+			// we can clear this out and keep the structures we read
+			currentStructures.restoreStructures = null;
 
 		if (position$1 == srcEnd) {
 			// finished reading this source, cleanup references
@@ -971,7 +975,10 @@ const recordDefinition = (id, highByte) => {
 		structure.highByte = highByte;
 	}
 	let existingStructure = currentStructures[id];
-	if (existingStructure && existingStructure.isShared) {
+	// If it is a shared structure, we need to restore any changes after reading.
+	// Also in sequential mode, we may get incomplete reads and thus errors, and we need to restore
+	// to the state prior to an incomplete read in order to properly resume.
+	if (existingStructure && (existingStructure.isShared || sequentialMode)) {
 		(currentStructures.restoreStructures || (currentStructures.restoreStructures = []))[id] = existingStructure;
 	}
 	currentStructures[id] = structure;
@@ -981,10 +988,10 @@ const recordDefinition = (id, highByte) => {
 currentExtensions[0] = () => {}; // notepack defines extension 0 to mean undefined, so use that as the default here
 currentExtensions[0].noBuffer = true;
 
-let glbl = typeof globalThis === 'object' ? globalThis : window;
+let errors = { Error, TypeError, ReferenceError };
 currentExtensions[0x65] = () => {
 	let data = read();
-	return (glbl[data[0]] || Error)(data[1])
+	return (errors[data[0]] || Error)(data[1])
 };
 
 currentExtensions[0x69] = (data) => {
@@ -1022,6 +1029,7 @@ currentExtensions[0x73] = () => new Set(read());
 
 const typedArrays = ['Int8','Uint8','Uint8Clamped','Int16','Uint16','Int32','Uint32','Float32','Float64','BigInt64','BigUint64'].map(type => type + 'Array');
 
+let glbl = typeof globalThis === 'object' ? globalThis : window;
 currentExtensions[0x74] = (data) => {
 	let typeCode = data[0];
 	let typedArrayName = typedArrays[typeCode];
@@ -1319,7 +1327,7 @@ class Packr extends Unpackr {
 					if (serializationsSinceTransitionRebuild < 10)
 						serializationsSinceTransitionRebuild++;
 					let sharedLength = structures.sharedLength || 0;
-					if (structures.length > sharedLength)
+					if (structures.length > sharedLength && !isSequential)
 						structures.length = sharedLength;
 					if (transitionsCount > 10000) {
 						// force a rebuild occasionally after a lot of transitions so it can get cleaned up
@@ -1527,7 +1535,7 @@ class Packr extends Unpackr {
 					targetView.setFloat64(position, value);
 					position += 8;
 				}
-			} else if (type === 'object') {
+			} else if (type === 'object' || type === 'function') {
 				if (!value)
 					target[position++] = 0xc0;
 				else {
@@ -1634,6 +1642,11 @@ class Packr extends Unpackr {
 						} else {
 							if (value.toJSON) // use this as an alternate mechanism for expressing how to serialize
 								return pack(value.toJSON());
+							
+							// if there is a writeFunction, use it, otherwise just encode as undefined
+							if (type === 'function')
+								return pack(this.writeFunction && this.writeFunction(value));
+							
 							// no extension found, write as object
 							writeObject(value, !value.hasOwnProperty); // if it doesn't have hasOwnProperty, don't do hasOwnProperty checks
 						}
@@ -1668,14 +1681,12 @@ class Packr extends Unpackr {
 					target[position++] = 0;
 					target[position++] = 0;
 				}
-			} else if (type === 'function') {
-				pack(this.writeFunction && this.writeFunction()); // if there is a writeFunction, use it, otherwise just encode as undefined
 			} else {
 				throw new Error('Unknown type: ' + type)
 			}
 		};
 
-		const writeObject = this.useRecords === false ? this.variableMapSize ? (object) => {
+		const writePlainObject = this.variableMapSize ? (object) => {
 			// this method is slightly slower, but generates "preferred serialization" (optimally small for smaller objects)
 			let keys = Object.keys(object);
 			let length = keys.length;
@@ -1710,7 +1721,9 @@ class Packr extends Unpackr {
 			}
 			target[objectOffset++ + start] = size >> 8;
 			target[objectOffset + start] = size & 0xff;
-		} :
+		};
+
+		const writeRecord = this.useRecords === false ? writePlainObject :
 		(options.progressiveRecords && !useTwoByteRecords) ?  // this is about 2% faster for highly stable structures, since it only requires one for-in loop (but much more expensive when new structure needs to be written)
 		(object, safePrototype) => {
 			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
@@ -1782,6 +1795,14 @@ class Packr extends Unpackr {
 				if (safePrototype || object.hasOwnProperty(key))
 					pack(object[key]);
 		};
+
+		// craete reference to useRecords if useRecords is a function
+		const checkUseRecords = typeof this.useRecords == 'function' && this.useRecords;
+		
+		const writeObject = checkUseRecords ? (object, safePrototype) => {
+			checkUseRecords(object) ? writeRecord(object,safePrototype) : writePlainObject(object,safePrototype);
+		} : writeRecord;
+
 		const makeRoom = (end) => {
 			let newSize;
 			if (end > 0x1000000) {
@@ -1954,7 +1975,10 @@ extensions = [{
 	}
 }, {
 	pack(set, allocateForWrite, pack) {
-		if (this.setAsEmptyObject) return pack({})
+		if (this.setAsEmptyObject) {
+			allocateForWrite(0);
+			return pack({})
+		}
 		let array = Array.from(set);
 		let { target, position} = allocateForWrite(this.moreTypes ? 3 : 0);
 		if (this.moreTypes) {