msgpackr 1.9.2 → 1.9.4

package/dist/index.js

@@ -932,10 +932,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) => {
@@ -973,6 +973,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];
@@ -1467,7 +1468,7 @@
 						targetView.setFloat64(position, value);
 						position += 8;
 					}
-				} else if (type === 'object') {
+				} else if (type === 'object' || type === 'function') {
 					if (!value)
 						target[position++] = 0xc0;
 					else {
@@ -1574,6 +1575,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
 							}
@@ -1608,14 +1614,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 || this.coercibleKeyAsNumber) ? (object) => {
 				// this method is slightly slower, but generates "preferred serialization" (optimally small for smaller objects)
 				let keys = Object.keys(object);
 				let length = keys.length;
@@ -1631,9 +1635,19 @@
 					position += 4;
 				}
 				let key;
-				for (let i = 0; i < length; i++) {
-					pack(key = keys[i]);
-					pack(object[key]);
+				if (this.coercibleKeyAsNumber) {
+					for (let i = 0; i < length; i++) {
+						key = keys[i];
+						let num = Number(key);
+						pack(isNaN(num) ? key : num);
+						pack(object[key]);
+					}
+
+				} else {
+					for (let i = 0; i < length; i++) {
+						pack(key = keys[i]);
+						pack(object[key]);
+					}
 				}
 			} :
 			(object, safePrototype) => {
@@ -1650,7 +1664,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));
@@ -1722,6 +1738,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) {