msgpackr 1.9.1 → 1.9.3

package/README.md

@@ -157,10 +157,22 @@ unpackMultiple(data, (value) => {
 })
 ```
 
+If you need to know the start and end offsets of the unpacked values, these are
+provided as optional parameters in the callback:
+```js
+let data = new Uint8Array([1, 2, 3]) // encodings of values 1, 2, and 3
+unpackMultiple(data, (value,start,end) => {
+	// called for each value
+	// `start` is the data buffer offset where the value was read from
+	// `end` is `start` plus the byte length of the encoded value
+	// return false if you wish to end the parsing
+})
+```
+
 ## Options
 The following options properties can be provided to the Packr or Unpackr constructor:
 
-* `useRecords` - Setting this to `false` disables the record extension and stores JavaScript objects as MessagePack maps, and unpacks maps as JavaScript `Object`s, which ensures compatibilty with other decoders.
+* `useRecords` - Setting this to `false` disables the record extension and stores JavaScript objects as MessagePack maps, and unpacks maps as JavaScript `Object`s, which ensures compatibilty with other decoders. Setting this to a function will use records for objects where `useRecords(object)` returns `true`.
 * `structures` - Provides the array of structures that is to be used for record extension, if you want the structures saved and used again. This array will be modified in place with new record structures that are serialized (if less than 32 structures are in the array).
 * `moreTypes` - Enable serialization of additional built-in types/classes including typed arrays, `Set`s, `Map`s, and `Error`s.
 * `structuredClone` - This enables the structured cloning extensions that will encode object/cyclic references. `moreTypes` is enabled by default when this is enabled.

package/dist/index-no-eval.cjs

@@ -119,10 +119,10 @@
 				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
 						}
 					}
@@ -194,6 +194,10 @@
 				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
@@ -916,7 +920,10 @@
 			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;
@@ -926,10 +933,10 @@
 	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) => {
@@ -967,6 +974,7 @@
 
 	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];
@@ -1253,7 +1261,7 @@
 						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
@@ -1461,7 +1469,7 @@
 						targetView.setFloat64(position, value);
 						position += 8;
 					}
-				} else if (type === 'object') {
+				} else if (type === 'object' || type === 'function') {
 					if (!value)
 						target[position++] = 0xc0;
 					else {
@@ -1568,6 +1576,11 @@
 							} 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
 							}
@@ -1602,14 +1615,12 @@
 						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;
@@ -1644,7 +1655,9 @@
 				}
 				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));
@@ -1716,6 +1729,14 @@
 					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) {
@@ -1888,7 +1909,10 @@
 		}
 	}, {
 		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) {