msgpackr 1.5.0 → 1.5.4

package/dist/str.cjs

@@ -0,0 +1,100 @@
+let utfz = require('../../msgpack-benchmark/node_modules/utfz-lib')
+
+var safeEnd = 1000000;
+var b = new Uint8Array(32768)
+function writeString(value, target, position) {
+			var length, strLength = value.length;
+			let headerSize;
+			// first we estimate the header size, so we can write to the correct location
+			if (strLength < 0x20) {
+				headerSize = 1;
+			} else if (strLength < 0x100) {
+				headerSize = 2;
+			} else if (strLength < 0x10000) {
+				headerSize = 3;
+			} else {
+				headerSize = 5;
+			}
+			let maxBytes = strLength * 3;
+			//if (position + maxBytes > safeEnd)
+			//	target = makeRoom(position + maxBytes);
+		for (let i = 0; i < 100; i++) {
+			length = pack(value, strLength, target, position + headerSize);
+		}
+			if (strLength < 0x40 || !encodeUtf8) {
+				var strPosition = position + headerSize;
+				var c2 = 0;
+				for (let i = 0; i < strLength; i++) {
+					const c1 = value.charCodeAt(i);
+					if (c1 < 0x80) {
+						target[strPosition++] = c1;
+					} else if (c1 < 0x800) {
+						target[strPosition++] = c1 >> 6 | 0xc0;
+						target[strPosition++] = c1 & 0x3f | 0x80;
+					} else if (
+						(c1 & 0xfc00) === 0xd800 &&
+						((c2 = value.charCodeAt(i + 1)) & 0xfc00) === 0xdc00
+					) {
+						c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
+						i++;
+						target[strPosition++] = c1 >> 18 | 0xf0;
+						target[strPosition++] = c1 >> 12 & 0x3f | 0x80;
+						target[strPosition++] = c1 >> 6 & 0x3f | 0x80;
+						target[strPosition++] = c1 & 0x3f | 0x80;
+					} else {
+						target[strPosition++] = c1 >> 12 | 0xe0;
+						target[strPosition++] = c1 >> 6 & 0x3f | 0x80;
+						target[strPosition++] = c1 & 0x3f | 0x80;
+					}
+				}
+				length = strPosition - position - headerSize;
+			} else {
+				length = encodeUtf8(value, position + headerSize, maxBytes);
+			}
+		
+		
+			if (length < 0x20) {
+				target[position++] = 0xa0 | length;
+			} else if (length < 0x100) {
+				if (headerSize < 2) {
+					target.copyWithin(position + 2, position + 1, position + 1 + length);
+				}
+				target[position++] = 0xd9;
+				target[position++] = length;
+			} else if (length < 0x10000) {
+				if (headerSize < 3) {
+					target.copyWithin(position + 3, position + 2, position + 2 + length);
+				}
+				target[position++] = 0xda;
+				target[position++] = length >> 8;
+				target[position++] = length & 0xff;
+			} else {
+				if (headerSize < 5) {
+					target.copyWithin(position + 5, position + 3, position + 3 + length);
+				}
+				target[position++] = 0xdb;
+				targetView.setUint32(position, length);
+				position += 4;
+			}
+			return position + length
+		};
+const pack = (str, length, buf, offset) => {
+  const start = offset;
+  let currHigh = 0;
+  for (let i = 0; i < length; i++) {
+    const code = str.charCodeAt(i);
+    const high = code >> 8;
+    if (high !== currHigh) {
+      buf[i + offset++] = 0;
+      buf[i + offset++] = high;
+      currHigh = high;
+    }
+    const low = code & 0xff;
+    buf[i + offset] = low;
+    if (!low) {
+      buf[i + ++offset] = currHigh;
+    }
+  }
+  return length + offset - start;
+};
+module.exports = writeString;

package/dist/test.js

@@ -634,10 +634,29 @@
 			let structures = [];
 			let packr = new Packr({ structures });
 			var serialized = packr.pack(data);
+			serialized = packr.pack(data);
+			serialized = packr.pack(data);
 			var deserialized = packr.unpack(serialized);
 			assert.deepEqual(deserialized, data);
 		});
 
+		test('mixed structures', function(){
+			let data1 = { a: 1, b: 2, c: 3 };
+			let data2 = { a: 1, b: 2, d: 4 };
+			let data3 = { a: 1, b: 2, e: 5 };
+			let structures = [];
+			let packr = new Packr({ structures });
+			var serialized = packr.pack(data1);
+			var deserialized = packr.unpack(serialized);
+			assert.deepEqual(deserialized, data1);
+			var serialized = packr.pack(data2);
+			var deserialized = packr.unpack(serialized);
+			assert.deepEqual(deserialized, data2);
+			var serialized = packr.pack(data3);
+			var deserialized = packr.unpack(serialized);
+			assert.deepEqual(deserialized, data3);
+		});
+
 		test('mixed array', function(){
 			var data = [
 				'one',
@@ -684,6 +703,13 @@
 			var deserialized = packr.unpack(serialized);
 			assert.deepEqual(deserialized, data);
 		});
+		test('pack/unpack sample data with bundled strings', function(){
+			var data = sampleData;
+			let packr = new Packr({ /*structures,*/ useRecords: false, bundleStrings: true });
+			var serialized = packr.pack(data);
+			var deserialized = packr.unpack(serialized);
+			assert.deepEqual(deserialized, data);
+		});
 		if (typeof Buffer != 'undefined')
 		test('replace data', function(){
 			var data1 = {
@@ -989,6 +1015,7 @@
 				date: new Date(1532219539733),
 				farFutureDate: new Date(3532219539133),
 				ancient: new Date(-3532219539133),
+				invalidDate: new Date('invalid')
 			};
 			let packr = new Packr();
 			var serialized = packr.pack(data);
@@ -998,6 +1025,7 @@
 			assert.equal(deserialized.date.getTime(), 1532219539733);
 			assert.equal(deserialized.farFutureDate.getTime(), 3532219539133);
 			assert.equal(deserialized.ancient.getTime(), -3532219539133);
+			assert.equal(deserialized.invalidDate.toString(), 'Invalid Date');
 		});
 		test('map/date with options', function(){
 			var map = new Map();
@@ -1008,16 +1036,19 @@
 			var data = {
 				map: map,
 				date: new Date(1532219539011),
+				invalidDate: new Date('invalid')
 			};
 			let packr = new Packr({
 				mapsAsObjects: true,
 				useTimestamp32: true,
+				onInvalidDate: () => 'Custom invalid date'
 			});
 			var serialized = packr.pack(data);
 			var deserialized = packr.unpack(serialized);
 			assert.equal(deserialized.map[4], 'four');
 			assert.equal(deserialized.map.three, 3);
 			assert.equal(deserialized.date.getTime(), 1532219539000);
+			assert.equal(deserialized.invalidDate, 'Custom invalid date');
 		});
 		test('key caching', function() {
 			var data = {
@@ -1197,7 +1228,7 @@
 			let structures = [];
 			var serialized = pack(data);
 			console.log('MessagePack size', serialized.length);
-			let packr = new Packr({ structures });
+			let packr = new Packr({ structures, bundleStrings: false });
 			var serialized = packr.pack(data);
 			console.log('msgpackr w/ record ext size', serialized.length);
 			for (var i = 0; i < ITERATIONS; i++) {
@@ -1208,7 +1239,7 @@
 			var data = sampleData;
 			this.timeout(10000);
 			let structures = [];
-			let packr = new Packr({ structures });
+			let packr = new Packr({ structures, bundleStrings: false });
 			let buffer = typeof Buffer != 'undefined' ? Buffer.alloc(0x10000) : new Uint8Array(0x10000);
 
 			for (var i = 0; i < ITERATIONS; i++) {

package/pack.js

@@ -9,10 +9,13 @@ const hasNodeBuffer = typeof Buffer !== 'undefined'
 const ByteArrayAllocate = hasNodeBuffer ? Buffer.allocUnsafeSlow : Uint8Array
 const ByteArray = hasNodeBuffer ? Buffer : Uint8Array
 const MAX_BUFFER_SIZE = hasNodeBuffer ? 0x100000000 : 0x7fd00000
-let target
+let target, keysTarget
 let targetView
 let position = 0
 let safeEnd
+let bundledStrings = null
+const MAX_BUNDLE_SIZE = 0xf000
+const hasNonLatin = /[\u0080-\uFFFF]/
 const RECORD_SYMBOL = Symbol('record-id')
 export class Packr extends Unpackr {
 	constructor(options) {
@@ -20,7 +23,6 @@ export class Packr extends Unpackr {
 		this.offset = 0
 		let typeBuffer
 		let start
-		let sharedStructures
 		let hasSharedUpdate
 		let structures
 		let referenceMap
@@ -45,7 +47,7 @@ export class Packr extends Unpackr {
 		let maxOwnStructures = options.maxOwnStructures
 		if (maxOwnStructures == null)
 			maxOwnStructures = hasSharedStructures ? 32 : 64
-		if (isSequential && !options.saveStructures)
+		if (!this.structures && options.useRecords != false)
 			this.structures = []
 		// two byte record ids for shared structures
 		let useTwoByteRecords = maxSharedStructures > 32 || (maxOwnStructures + maxSharedStructures > 64)		
@@ -75,23 +77,28 @@ export class Packr extends Unpackr {
 				position = (position + 7) & 0x7ffffff8 // Word align to make any future copying of this buffer faster
 			start = position
 			referenceMap = packr.structuredClone ? new Map() : null
-			sharedStructures = packr.structures
-			if (sharedStructures) {
-				if (sharedStructures.uninitialized)
-					sharedStructures = packr._mergeStructures(packr.getStructures())
-				let sharedLength = sharedStructures.sharedLength || 0
+			if (packr.bundleStrings && typeof value !== 'string') {
+				bundledStrings = []
+				bundledStrings.size = Infinity // force a new bundle start on first string
+			} else
+				bundledStrings = null
+			structures = packr.structures
+			if (structures) {
+				if (structures.uninitialized)
+					structures = packr._mergeStructures(packr.getStructures())
+				let sharedLength = structures.sharedLength || 0
 				if (sharedLength > maxSharedStructures) {
-					//if (maxSharedStructures <= 32 && sharedStructures.sharedLength > 32) // TODO: could support this, but would need to update the limit ids
-					throw new Error('Shared structures is larger than maximum shared structures, try increasing maxSharedStructures to ' + sharedStructures.sharedLength)
+					//if (maxSharedStructures <= 32 && structures.sharedLength > 32) // TODO: could support this, but would need to update the limit ids
+					throw new Error('Shared structures is larger than maximum shared structures, try increasing maxSharedStructures to ' + structures.sharedLength)
 				}
-				if (!sharedStructures.transitions) {
+				if (!structures.transitions) {
 					// rebuild our structure transitions
-					sharedStructures.transitions = Object.create(null)
+					structures.transitions = Object.create(null)
 					for (let i = 0; i < sharedLength; i++) {
-						let keys = sharedStructures[i]
+						let keys = structures[i]
 						if (!keys)
 							continue
-						let nextTransition, transition = sharedStructures.transitions
+						let nextTransition, transition = structures.transitions
 						for (let j = 0, l = keys.length; j < l; j++) {
 							let key = keys[j]
 							nextTransition = transition[key]
@@ -105,14 +112,16 @@ export class Packr extends Unpackr {
 					lastSharedStructuresLength = sharedLength
 				}
 				if (!isSequential) {
-					sharedStructures.nextId = sharedLength + 0x40
+					structures.nextId = sharedLength + 0x40
 				}
 			}
 			if (hasSharedUpdate)
 				hasSharedUpdate = false
-			structures = sharedStructures || []
 			try {
 				pack(value)
+				if (bundledStrings) {
+					writeBundles(start, pack)
+				}
 				packr.offset = position // update the offset so next serialization doesn't write over our buffer, but can continue writing to same buffer sequentially
 				if (referenceMap && referenceMap.idsToInsert) {
 					position += referenceMap.idsToInsert.length * 6
@@ -123,19 +132,22 @@ export class Packr extends Unpackr {
 					referenceMap = null
 					return serialized
 				}
-				if (encodeOptions === REUSE_BUFFER_MODE) {
+				if (encodeOptions & REUSE_BUFFER_MODE) {
 					target.start = start
 					target.end = position
 					return target
 				}
 				return target.subarray(start, position) // position can change if we call pack again in saveStructures, so we get the buffer now
 			} finally {
-				if (sharedStructures) {
+				if (structures) {
 					if (serializationsSinceTransitionRebuild < 10)
 						serializationsSinceTransitionRebuild++
+					let sharedLength = structures.sharedLength || maxSharedStructures
+					if (structures.length > sharedLength)
+						structures.length = sharedLength
 					if (transitionsCount > 10000) {
 						// force a rebuild occasionally after a lot of transitions so it can get cleaned up
-						sharedStructures.transitions = null
+						structures.transitions = null
 						serializationsSinceTransitionRebuild = 0
 						transitionsCount = 0
 						if (recordIdsToRemove.length > 0)
@@ -147,13 +159,9 @@ export class Packr extends Unpackr {
 						recordIdsToRemove = []
 					}
 					if (hasSharedUpdate && packr.saveStructures) {
-						let sharedLength = sharedStructures.sharedLength || maxSharedStructures
-						if (sharedStructures.length > sharedLength) {
-							sharedStructures = sharedStructures.slice(0, sharedLength)
-						}
 						// we can't rely on start/end with REUSE_BUFFER_MODE since they will (probably) change when we save
 						let returnBuffer = target.subarray(start, position)
-						if (packr.saveStructures(sharedStructures, lastSharedStructuresLength) === false) {
+						if (packr.saveStructures(structures, lastSharedStructuresLength) === false) {
 							// get updated structures and try again if the update failed
 							packr._mergeStructures(packr.getStructures())
 							return packr.pack(value)
@@ -162,6 +170,8 @@ export class Packr extends Unpackr {
 						return returnBuffer
 					}
 				}
+				if (encodeOptions & RESET_BUFFER_MODE)
+					position = start
 			}
 		}
 		const pack = (value) => {
@@ -172,6 +182,36 @@ export class Packr extends Unpackr {
 			var length
 			if (type === 'string') {
 				let strLength = value.length
+				if (bundledStrings && strLength >= 4 && strLength < 0x1000) {
+					if ((bundledStrings.size += strLength) > MAX_BUNDLE_SIZE) {
+						let extStart
+						let maxBytes = (bundledStrings[0] ? bundledStrings[0].length * 3 + bundledStrings[1].length : 0) + 10
+						if (position + maxBytes > safeEnd)
+							target = makeRoom(position + maxBytes)
+						if (bundledStrings.position) { // here we use the 0x62 extension to write the last bundle and reserve sapce for the reference pointer to the next/current bundle
+							target[position] = 0xc8 // ext 16
+							position += 3 // reserve for the writing bundle size
+							target[position++] = 0x62 // 'b'
+							extStart = position - start
+							position += 4 // reserve for writing bundle reference
+							writeBundles(start, pack) // write the last bundles
+							targetView.setUint16(extStart + start - 3, position - 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++] = 0xd6 // fixext 4
+							target[position++] = 0x62 // 'b'
+							extStart = position - start
+							position += 4 // reserve for writing bundle reference
+						}
+						bundledStrings = ['', ''] // create new ones
+						bundledStrings.size = 0
+						bundledStrings.position = extStart
+					}
+					let twoByte = hasNonLatin.test(value)
+					bundledStrings[twoByte ? 0 : 1] += value
+					target[position++] = 0xc1
+					pack(twoByte ? -strLength : strLength);
+					return
+				}
 				let headerSize
 				// first we estimate the header size, so we can write to the correct location
 				if (strLength < 0x20) {
@@ -470,8 +510,7 @@ export class Packr extends Unpackr {
 			target[objectOffset++ + start] = size >> 8
 			target[objectOffset + start] = size & 0xff
 		} :
-
-	/*	sharedStructures ?  // For highly stable structures, using for-in can a little bit faster
+		(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))
 			let objectOffset = position++ - start
@@ -479,44 +518,47 @@ export class Packr extends Unpackr {
 			for (let key in object) {
 				if (safePrototype || object.hasOwnProperty(key)) {
 					nextTransition = transition[key]
-					if (!nextTransition) {
-						nextTransition = transition[key] = Object.create(null)
-						nextTransition.__keys__ = (transition.__keys__ || []).concat([key])
-						/*let keys = Object.keys(object)
-						if 
-						let size = 0
-						let startBranch = transition.__keys__ ? transition.__keys__.length : 0
-						for (let i = 0, l = keys.length; i++) {
+					if (nextTransition)
+						transition = nextTransition
+					else {
+						// record doesn't exist, create full new record and insert it
+						let keys = Object.keys(object)
+						let lastTransition = transition
+						transition = structures.transitions
+						let newTransitions = 0
+						for (let i = 0, l = keys.length; i < l; i++) {
 							let key = keys[i]
-							size += key.length << 2
-							if (i >= startBranch) {
-								nextTransition = nextTransition[key] = Object.create(null)
-								nextTransition.__keys__ = keys.slice(0, i + 1)
+							nextTransition = transition[key]
+							if (!nextTransition) {
+								nextTransition = transition[key] = Object.create(null)
+								newTransitions++
 							}
+							transition = nextTransition
 						}
-						makeRoom(position + size)
-						nextTransition = transition[key]
-						target.copy(target, )
-						objectOffset
+						if (objectOffset + start + 1 == position) {
+							// first key, so we don't need to insert, we can just write record directly
+							position--
+							newRecord(transition, keys, newTransitions)
+						} else // otherwise we need to insert the record, moving existing data after the record
+							insertNewRecord(transition, keys, objectOffset, newTransitions)
+						wroteKeys = true
+						transition = lastTransition[key]
 					}
-					transition = nextTransition
 					pack(object[key])
 				}
 			}
-			let id = transition.id
-			if (!id) {
-				id = transition.id = structures.push(transition.__keys__) + 63
-				if (sharedStructures.onUpdate)
-					sharedStructures.onUpdate(id, transition.__keys__)
+			if (!wroteKeys) {
+				let recordId = transition[RECORD_SYMBOL]
+				if (recordId)
+					target[objectOffset + start] = recordId
+				else
+					insertNewRecord(transition, Object.keys(object), objectOffset, 0)
 			}
-			target[objectOffset + start] = id
-		}*/
-		(object) => {
-			let keys = Object.keys(object)
+		} :
+		(object, safePrototype) => {
 			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null))
 			let newTransitions = 0
-			for (let i = 0, l = keys.length; i < l; i++) {
-				let key = keys[i]
+			for (let key in object) if (safePrototype || object.hasOwnProperty(key)) {
 				nextTransition = transition[key]
 				if (!nextTransition) {
 					nextTransition = transition[key] = Object.create(null)
@@ -532,57 +574,12 @@ export class Packr extends Unpackr {
 				} else
 					target[position++] = recordId
 			} else {
-				recordId = structures.nextId
-				if (!recordId)
-					recordId = 0x40
-				if (recordId < sharedLimitId && this.shouldShareStructure && !this.shouldShareStructure(keys)) {
-					recordId = structures.nextOwnId
-					if (!(recordId < maxStructureId))
-						recordId = sharedLimitId
-					structures.nextOwnId = recordId + 1
-				} else {
-					if (recordId >= maxStructureId)// cycle back around
-						recordId = sharedLimitId
-					structures.nextId = recordId + 1
-				}
-				let highByte = keys.highByte = recordId >= 0x60 && useTwoByteRecords ? (recordId - 0x60) >> 5 : -1
-				transition[RECORD_SYMBOL] = recordId
-				structures[recordId - 0x40] = keys
-
-				if (recordId < sharedLimitId) {
-					keys.isShared = true
-					structures.sharedLength = recordId - 0x3f
-					hasSharedUpdate = true
-					if (highByte >= 0) {
-						target[position++] = (recordId & 0x1f) + 0x60
-						target[position++] = highByte
-					} else {
-						target[position++] = recordId
-					}
-				} else {
-					if (highByte >= 0) {
-						target[position++] = 0xd5 // fixext 2
-						target[position++] = 0x72 // "r" record defintion extension type
-						target[position++] = (recordId & 0x1f) + 0x60
-						target[position++] = highByte
-					} else {
-						target[position++] = 0xd4 // fixext 1
-						target[position++] = 0x72 // "r" record defintion extension type
-						target[position++] = recordId
-					}
-
-					if (newTransitions)
-						transitionsCount += serializationsSinceTransitionRebuild * newTransitions
-					// record the removal of the id, we can maintain our shared structure
-					if (recordIdsToRemove.length >= maxOwnStructures)
-						recordIdsToRemove.shift()[RECORD_SYMBOL] = 0 // we are cycling back through, and have to remove old ones
-					recordIdsToRemove.push(transition)
-					pack(keys)
-				}
+				newRecord(transition, transition.__keys__ || Object.keys(object), newTransitions)
 			}
 			// now write the values
-			for (let i = 0, l = keys.length; i < l; i++)
-				pack(object[keys[i]])
+			for (let key in object)
+				if (safePrototype || object.hasOwnProperty(key))
+					pack(object[key])
 		}
 		const makeRoom = (end) => {
 			let newSize
@@ -605,6 +602,86 @@ export class Packr extends Unpackr {
 			safeEnd = newBuffer.length - 10
 			return target = newBuffer
 		}
+		const newRecord = (transition, keys, newTransitions) => {
+			let recordId = structures.nextId
+			if (!recordId)
+				recordId = 0x40
+			if (recordId < sharedLimitId && this.shouldShareStructure && !this.shouldShareStructure(keys)) {
+				recordId = structures.nextOwnId
+				if (!(recordId < maxStructureId))
+					recordId = sharedLimitId
+				structures.nextOwnId = recordId + 1
+			} else {
+				if (recordId >= maxStructureId)// cycle back around
+					recordId = sharedLimitId
+				structures.nextId = recordId + 1
+			}
+			let highByte = keys.highByte = recordId >= 0x60 && useTwoByteRecords ? (recordId - 0x60) >> 5 : -1
+			transition[RECORD_SYMBOL] = recordId
+			transition.__keys__ = keys
+			structures[recordId - 0x40] = keys
+
+			if (recordId < sharedLimitId) {
+				keys.isShared = true
+				structures.sharedLength = recordId - 0x3f
+				hasSharedUpdate = true
+				if (highByte >= 0) {
+					target[position++] = (recordId & 0x1f) + 0x60
+					target[position++] = highByte
+				} else {
+					target[position++] = recordId
+				}
+			} else {
+				if (highByte >= 0) {
+					target[position++] = 0xd5 // fixext 2
+					target[position++] = 0x72 // "r" record defintion extension type
+					target[position++] = (recordId & 0x1f) + 0x60
+					target[position++] = highByte
+				} else {
+					target[position++] = 0xd4 // fixext 1
+					target[position++] = 0x72 // "r" record defintion extension type
+					target[position++] = recordId
+				}
+
+				if (newTransitions)
+					transitionsCount += serializationsSinceTransitionRebuild * newTransitions
+				// record the removal of the id, we can maintain our shared structure
+				if (recordIdsToRemove.length >= maxOwnStructures)
+					recordIdsToRemove.shift()[RECORD_SYMBOL] = 0 // we are cycling back through, and have to remove old ones
+				recordIdsToRemove.push(transition)
+				pack(keys)
+			}
+		}
+		const insertNewRecord = (transition, keys, insertionOffset, newTransitions) => {
+			let mainTarget = target
+			let mainPosition = position
+			let mainSafeEnd = safeEnd
+			let mainStart = start
+			target = keysTarget
+			position = 0
+			start = 0
+			if (!target)
+				keysTarget = target = new ByteArrayAllocate(8192)
+			safeEnd = target.length - 10
+			newRecord(transition, keys, newTransitions)
+			keysTarget = target
+			let keysPosition = position
+			target = mainTarget
+			position = mainPosition
+			safeEnd = mainSafeEnd
+			start = mainStart
+			if (keysPosition > 1) {
+				let newEnd = position + keysPosition - 1
+				if (newEnd > safeEnd)
+					makeRoom(newEnd)
+				let insertionPosition = insertionOffset + start
+				target.copyWithin(insertionPosition + keysPosition, insertionPosition + 1, position)
+				target.set(keysTarget.slice(0, keysPosition), insertionPosition)
+				position = newEnd
+			} else {
+				target[insertionOffset + start] = keysTarget[0]
+			}
+		}
 	}
 	useBuffer(buffer) {
 		// this means we are finished using our own buffer and we can write over it safely
@@ -612,6 +689,10 @@ export class Packr extends Unpackr {
 		targetView = new DataView(target.buffer, target.byteOffset, target.byteLength)
 		position = 0
 	}
+	clearSharedData() {
+		if (this.structures)
+			this.structures = []
+	}
 }
 
 function copyBinary(source, target, targetOffset, offset, endOffset) {
@@ -622,7 +703,7 @@ function copyBinary(source, target, targetOffset, offset, endOffset) {
 
 extensionClasses = [ Date, Set, Error, RegExp, ArrayBuffer, Object.getPrototypeOf(Uint8Array.prototype).constructor /*TypedArray*/, C1Type ]
 extensions = [{
-	pack(date, allocateForWrite) {
+	pack(date, allocateForWrite, pack) {
 		let seconds = date.getTime() / 1000
 		if ((this.useTimestamp32 || date.getMilliseconds() === 0) && seconds >= 0 && seconds < 0x100000000) {
 			// Timestamp 32
@@ -637,6 +718,16 @@ extensions = [{
 			target[position++] = 0xff
 			targetView.setUint32(position, date.getMilliseconds() * 4000000 + ((seconds / 1000 / 0x100000000) >> 0))
 			targetView.setUint32(position + 4, seconds)
+		} else if (isNaN(seconds)) {
+			if (this.onInvalidDate) {
+				allocateForWrite(0)
+				return pack(this.onInvalidDate())
+			}
+			// Intentionally invalid timestamp
+			let { target, targetView, position} = allocateForWrite(3)
+			target[position++] = 0xd4
+			target[position++] = 0xff
+			target[position++] = 0xff
 		} else {
 			// Timestamp 96
 			let { target, targetView, position} = allocateForWrite(15)
@@ -805,6 +896,15 @@ function insertIds(serialized, idsToInsert) {
 	return serialized
 }
 
+function writeBundles(start, pack) {
+	targetView.setUint32(bundledStrings.position + start, position - bundledStrings.position - start)
+	let writeStrings = bundledStrings
+	bundledStrings = null
+	let startPosition = position
+	pack(writeStrings[0])
+	pack(writeStrings[1])
+}
+
 export function addExtension(extension) {
 	if (extension.Class) {
 		if (!extension.pack && !extension.write)
@@ -824,4 +924,5 @@ export const Encoder = Packr
 export { FLOAT32_OPTIONS } from './unpack.js'
 import { FLOAT32_OPTIONS } from './unpack.js'
 export const { NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT } = FLOAT32_OPTIONS
-export const REUSE_BUFFER_MODE = 1000
+export const REUSE_BUFFER_MODE = 512
+export const RESET_BUFFER_MODE = 1024

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "msgpackr",
   "author": "Kris Zyp",
-  "version": "1.5.0",
+  "version": "1.5.4",
   "description": "Ultra-fast MessagePack implementation with extensions for records and structured cloning",
   "license": "MIT",
   "types": "./index.d.ts",
@@ -49,6 +49,12 @@
       "default": "./unpack.js"
     }
   },
+  "files": [
+    "/dist",
+    "*.md",
+    "/*.js",
+    "/*.ts"
+  ],
   "optionalDependencies": {
     "msgpackr-extract": "^1.0.14"
   },