msgpackr 1.10.2 → 1.11.1

package/dist/test.js

@@ -997,7 +997,7 @@
 		let length = data.length;
 		let value = BigInt(data[0] & 0x80 ? data[0] - 0x100 : data[0]);
 		for (let i = 1; i < length; i++) {
-			value <<= 8n;
+			value <<= BigInt(8);
 			value += BigInt(data[i]);
 		}
 		return value;
@@ -1203,7 +1203,7 @@
 			let structures;
 			let referenceMap;
 			let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position) {
-				return target.utf8Write(string, position, 0xffffffff)
+				return target.utf8Write(string, position, target.byteLength - position)
 			} : (textEncoder$1 && textEncoder$1.encodeInto) ?
 				function(string, position) {
 					return textEncoder$1.encodeInto(string, target.subarray(position)).written
@@ -1228,7 +1228,7 @@
 			if (!this.structures && options.useRecords != false)
 				this.structures = [];
 			// two byte record ids for shared structures
-			let useTwoByteRecords = maxSharedStructures > 32 || (maxOwnStructures + maxSharedStructures > 64);		
+			let useTwoByteRecords = maxSharedStructures > 32 || (maxOwnStructures + maxSharedStructures > 64);
 			let sharedLimitId = maxSharedStructures + 0x40;
 			let maxStructureId = maxSharedStructures + maxOwnStructures + 0x40;
 			if (maxStructureId > 8256) {
@@ -1246,7 +1246,7 @@
 				}
 				safeEnd = target.length - 10;
 				if (safeEnd - position < 0x800) {
-					// don't start too close to the end, 
+					// don't start too close to the end,
 					target = new ByteArrayAllocate(target.length);
 					targetView = target.dataView || (target.dataView = new DataView(target.buffer, 0, target.length));
 					safeEnd = target.length - 10;
@@ -1589,7 +1589,7 @@
 								targetView.setUint32(position, referee.id);
 								position += 4;
 								return
-							} else 
+							} else
 								referenceMap.set(value, { offset: position - start });
 						}
 						let constructor = value.constructor;
@@ -1617,7 +1617,7 @@
 									pack(entryValue);
 								}
 							}
-						} else {	
+						} else {
 							for (let i = 0, l = extensions.length; i < l; i++) {
 								let extensionClass = extensionClasses[i];
 								if (value instanceof extensionClass) {
@@ -1685,11 +1685,11 @@
 									if (json !== value)
 										return pack(json)
 								}
-								
+
 								// 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 plain object
 								writeObject(value);
 							}
@@ -1711,18 +1711,20 @@
 						if (this.largeBigIntToFloat) {
 							target[position++] = 0xcb;
 							targetView.setFloat64(position, Number(value));
-						} else if (this.useBigIntExtension && value < 2n**(1023n) && value > -(2n**(1023n))) {
+						} 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 & 0xffn;
-								alignedSign = (byte & 0x80n) === (value < 0n ? 0x80n : 0n);
+								let byte = value & BigInt(0xff);
+								alignedSign = (byte & BigInt(0x80)) === (value < BigInt(0) ? BigInt(0x80) : BigInt(0));
 								bytes.push(byte);
-								value >>= 8n;
-							} while (!((value === 0n || value === -1n) && alignedSign));
+								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]);
@@ -1730,7 +1732,8 @@
 							return
 						} else {
 							throw new RangeError(value + ' was too large to fit in MessagePack 64-bit integer format, use' +
-								' useBigIntExtension or set largeBigIntToFloat to convert to float-64')
+								' useBigIntExtension, or set largeBigIntToFloat to convert to float-64, or set' +
+								' largeBigIntToString to convert to string')
 						}
 					}
 					position += 8;
@@ -1747,9 +1750,19 @@
 				}
 			};
 
-			const writePlainObject = (this.variableMapSize || this.coercibleKeyAsNumber) ? (object) => {
+			const writePlainObject = (this.variableMapSize || this.coercibleKeyAsNumber || this.skipValues) ? (object) => {
 				// this method is slightly slower, but generates "preferred serialization" (optimally small for smaller objects)
-				let keys = Object.keys(object);
+				let keys;
+				if (this.skipValues) {
+					keys = [];
+					for (let key in object) {
+						if ((typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) &&
+							!this.skipValues.includes(object[key]))
+							keys.push(key);
+					}
+				} else {
+					keys = Object.keys(object);
+				}
 				let length = keys.length;
 				if (length < 0x10) {
 					target[position++] = 0x80 | length;
@@ -1790,6 +1803,10 @@
 						size++;
 					}
 				}
+				if (size > 0xffff) {
+					throw new Error('Object is too large to serialize with fast 16-bit map size,' +
+					' use the "variableMapSize" option to serialize this object');
+				}
 				target[objectOffset++ + start] = size >> 8;
 				target[objectOffset + start] = size & 0xff;
 			};
@@ -1868,9 +1885,9 @@
 					}
 			};
 
-			// craete reference to useRecords if useRecords is a function
+			// create reference to useRecords if useRecords is a function
 			const checkUseRecords = typeof this.useRecords == 'function' && this.useRecords;
-			
+
 			const writeObject = checkUseRecords ? (object) => {
 				checkUseRecords(object) ? writeRecord(object) : writePlainObject(object);
 			} : writeRecord;
@@ -1998,9 +2015,15 @@
 		useBuffer(buffer) {
 			// this means we are finished using our own buffer and we can write over it safely
 			target = buffer;
-			targetView = new DataView(target.buffer, target.byteOffset, target.byteLength);
+			target.dataView || (target.dataView = new DataView(target.buffer, target.byteOffset, target.byteLength));
 			position = 0;
 		}
+		set position (value) {
+			position = value;
+		}
+		get position() {
+			return position;
+		}
 		clearSharedData() {
 			if (this.structures)
 				this.structures = [];
@@ -2138,7 +2161,7 @@
 			target[position++] = length >> 8;
 			target[position++] = length & 0xff;
 		} else {
-			var { target, position, targetView } = allocateForWrite(length + 5);
+			let { target, position, targetView } = allocateForWrite(length + 5);
 			target[position++] = 0xc6;
 			targetView.setUint32(position, length);
 			position += 4;
@@ -2274,7 +2297,7 @@
 		textEncoder = new TextEncoder();
 	} catch (error) {}
 	const encodeUtf8 = hasNodeBuffer ? function(target, string, position) {
-		return target.utf8Write(string, position, 0xffffffff)
+		return target.utf8Write(string, position, target.byteLength - position)
 	} : (textEncoder && textEncoder.encodeInto) ?
 		function(target, string, position) {
 			return textEncoder.encodeInto(string, target.subarray(position)).written
@@ -2715,6 +2738,8 @@
 			src = Uint8Array.prototype.slice.call(src, position, srcEnd);
 			srcEnd -= position;
 			position = 0;
+			if (!unpackr.getStructures)
+				throw new Error(`Reference to shared structure ${recordId} without getStructures method`);
 			unpackr._mergeStructures(unpackr.getStructures());
 			if (!unpackr.typedStructs)
 				throw new Error('Could not find any shared typed structures');
@@ -4175,6 +4200,13 @@
 			serialized = packr.pack(tooBigInt);
 			deserialized = unpack(serialized);
 			assert.isTrue(deserialized.tooBig > 2n**65n);
+
+			packr = new Packr({
+				largeBigIntToString: true
+			});
+			serialized = packr.pack(tooBigInt);
+			deserialized = unpack(serialized);
+			assert.equal(deserialized.tooBig, (2n**66n).toString());
 		});
 
 		test('roundFloat32', function() {
@@ -4247,6 +4279,54 @@
 			const deserialized = unpack(serialized);
 			assert.deepStrictEqual(deserialized, { someData: [1, 2, 3, 4] });
 		});
+		test('skip values', function () {
+			var data = {
+				data: [
+					{ a: 1, name: 'one', type: 'odd', isOdd: true },
+					{ a: 2, name: 'two', type: 'even', isOdd: undefined },
+					{ a: 3, name: 'three', type: 'odd', isOdd: true },
+					{ a: 4, name: 'four', type: 'even', isOdd: null},
+					{ a: 5, name: 'five', type: 'odd', isOdd: true },
+					{ a: 6, name: 'six', type: 'even', isOdd: null }
+				],
+				description: 'some names',
+				types: ['odd', 'even'],
+				convertEnumToNum: [
+					{ prop: 'test' },
+					{ prop: 'test' },
+					{ prop: 'test' },
+					{ prop: 1 },
+					{ prop: 2 },
+					{ prop: [undefined, null] },
+					{ prop: null }
+				]
+			};
+			var expected = {
+				data: [
+					{ a: 1, name: 'one', type: 'odd', isOdd: true },
+					{ a: 2, name: 'two', type: 'even' },
+					{ a: 3, name: 'three', type: 'odd', isOdd: true },
+					{ a: 4, name: 'four', type: 'even', },
+					{ a: 5, name: 'five', type: 'odd', isOdd: true },
+					{ a: 6, name: 'six', type: 'even' }
+				],
+				description: 'some names',
+				types: ['odd', 'even'],
+				convertEnumToNum: [
+					{ prop: 'test' },
+					{ prop: 'test' },
+					{ prop: 'test' },
+					{ prop: 1 },
+					{ prop: 2 },
+					{ prop: [undefined, null] },
+					{}
+				]
+			};
+			let packr = new Packr({ useRecords: false, skipValues: [undefined, null] });
+			var serialized = packr.pack(data);
+			var deserialized = packr.unpack(serialized);
+			assert.deepEqual(deserialized, expected);
+		});
 	});
 	suite('msgpackr performance tests', function(){
 		test('performance JSON.parse', function() {