msgpackr 1.11.12 → 2.0.1

package/pack.js

@@ -1,139 +1,138 @@
-import { Unpackr, mult10, C1Type, typedArrays, addExtension as unpackAddExtension } from './unpack.js'
-let textEncoder
+import { Unpackr, mult10, C1Type, typedArrays, addExtension as unpackAddExtension } from './unpack.js';
+let textEncoder;
 try {
-	textEncoder = new TextEncoder()
+	textEncoder = new TextEncoder();
 } catch (error) {}
-let extensions, extensionClasses
-const hasNodeBuffer = typeof Buffer !== 'undefined'
+let extensions, extensionClasses;
+const hasNodeBuffer = typeof Buffer !== 'undefined';
 const ByteArrayAllocate = hasNodeBuffer ?
-	function(length) { return Buffer.allocUnsafeSlow(length) } : Uint8Array
-const ByteArray = hasNodeBuffer ? Buffer : Uint8Array
-const MAX_BUFFER_SIZE = hasNodeBuffer ? 0x100000000 : 0x7fd00000
-let target, keysTarget
-let targetView
-let position = 0
-let safeEnd
-let bundledStrings = null
-let writeStructSlots
-const MAX_BUNDLE_SIZE = 0x5500 // maximum characters such that the encoded bytes fits in 16 bits.
-const hasNonLatin = /[\u0080-\uFFFF]/
-export const RECORD_SYMBOL = Symbol('record-id')
+	function(length) { return Buffer.allocUnsafeSlow(length); } : Uint8Array;
+const ByteArray = hasNodeBuffer ? Buffer : Uint8Array;
+const MAX_BUFFER_SIZE = hasNodeBuffer ? 0x100000000 : 0x7fd00000;
+let target, keysTarget;
+let targetView;
+let position = 0;
+let safeEnd;
+let bundledStrings = null;
+const MAX_BUNDLE_SIZE = 0x5500; // maximum characters such that the encoded bytes fits in 16 bits.
+const hasNonLatin = /[\u0080-\uFFFF]/;
+export const RECORD_SYMBOL = Symbol('record-id');
 export class Packr extends Unpackr {
 	constructor(options) {
-		super(options)
-		this.offset = 0
-		let typeBuffer
-		let start
-		let hasSharedUpdate
-		let structures
-		let referenceMap
+		super(options);
+		this.offset = 0;
+		let typeBuffer;
+		let start;
+		let hasSharedUpdate;
+		let structures;
+		let referenceMap;
 		let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position) {
-			return target.utf8Write(string, position, target.byteLength - position)
+			return target.utf8Write(string, position, target.byteLength - position);
 		} : (textEncoder && textEncoder.encodeInto) ?
 			function(string, position) {
-				return textEncoder.encodeInto(string, target.subarray(position)).written
-			} : false
+				return textEncoder.encodeInto(string, target.subarray(position)).written;
+			} : false;
 
-		let packr = this
+		let packr = this;
 		if (!options)
-			options = {}
-		let isSequential = options && options.sequential
-		let hasSharedStructures = options.structures || options.saveStructures
-		let maxSharedStructures = options.maxSharedStructures
+			options = {};
+		let isSequential = options && options.sequential;
+		let hasSharedStructures = options.structures || options.saveStructures;
+		let maxSharedStructures = options.maxSharedStructures;
 		if (maxSharedStructures == null)
-			maxSharedStructures = hasSharedStructures ? 32 : 0
+			maxSharedStructures = hasSharedStructures ? 32 : 0;
 		if (maxSharedStructures > 8160)
-			throw new Error('Maximum maxSharedStructure is 8160')
+			throw new Error('Maximum maxSharedStructure is 8160');
 		if (options.structuredClone && options.moreTypes == undefined) {
-			this.moreTypes = true
+			this.moreTypes = true;
 		}
-		let maxOwnStructures = options.maxOwnStructures
+		let maxOwnStructures = options.maxOwnStructures;
 		if (maxOwnStructures == null)
-			maxOwnStructures = hasSharedStructures ? 32 : 64
+			maxOwnStructures = hasSharedStructures ? 32 : 64;
 		if (!this.structures && options.useRecords != false)
-			this.structures = []
+			this.structures = [];
 		// two byte record ids for shared structures
-		let useTwoByteRecords = maxSharedStructures > 32 || (maxOwnStructures + maxSharedStructures > 64)
-		let sharedLimitId = maxSharedStructures + 0x40
-		let maxStructureId = maxSharedStructures + maxOwnStructures + 0x40
+		let useTwoByteRecords = maxSharedStructures > 32 || (maxOwnStructures + maxSharedStructures > 64);
+		let sharedLimitId = maxSharedStructures + 0x40;
+		let maxStructureId = maxSharedStructures + maxOwnStructures + 0x40;
 		if (maxStructureId > 8256) {
-			throw new Error('Maximum maxSharedStructure + maxOwnStructure is 8192')
+			throw new Error('Maximum maxSharedStructure + maxOwnStructure is 8192');
 		}
-		let recordIdsToRemove = []
-		let transitionsCount = 0
-		let serializationsSinceTransitionRebuild = 0
+		let recordIdsToRemove = [];
+		let transitionsCount = 0;
+		let serializationsSinceTransitionRebuild = 0;
 
 		this.pack = this.encode = function(value, encodeOptions) {
 			if (!target) {
-				target = new ByteArrayAllocate(8192)
-				targetView = target.dataView || (target.dataView = new DataView(target.buffer, 0, 8192))
-				position = 0
+				target = new ByteArrayAllocate(8192);
+				targetView = target.dataView || (target.dataView = new DataView(target.buffer, 0, 8192));
+				position = 0;
 			}
-			safeEnd = target.length - 10
+			safeEnd = target.length - 10;
 			if (safeEnd - position < 0x800) {
 				// 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
-				position = 0
+				target = new ByteArrayAllocate(target.length);
+				targetView = target.dataView || (target.dataView = new DataView(target.buffer, 0, target.length));
+				safeEnd = target.length - 10;
+				position = 0;
 			} else
-				position = (position + 7) & 0x7ffffff8 // Word align to make any future copying of this buffer faster
-			start = position
-			if (encodeOptions & RESERVE_START_SPACE) position += (encodeOptions & 0xff)
-			referenceMap = packr.structuredClone ? new Map() : null
+				position = (position + 7) & 0x7ffffff8; // Word align to make any future copying of this buffer faster
+			start = position;
+			if (encodeOptions & RESERVE_START_SPACE) position += (encodeOptions & 0xff);
+			referenceMap = packr.structuredClone ? new Map() : null;
 			if (packr.bundleStrings && typeof value !== 'string') {
-				bundledStrings = []
-				bundledStrings.size = Infinity // force a new bundle start on first string
+				bundledStrings = [];
+				bundledStrings.size = Infinity; // force a new bundle start on first string
 			} else
-				bundledStrings = null
-			structures = packr.structures
+				bundledStrings = null;
+			structures = packr.structures;
 			if (structures) {
 				if (structures.uninitialized)
-					structures = packr._mergeStructures(packr.getStructures())
-				let sharedLength = structures.sharedLength || 0
+					structures = packr._mergeStructures(packr.getStructures());
+				let sharedLength = structures.sharedLength || 0;
 				if (sharedLength > maxSharedStructures) {
 					//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)
+					throw new Error('Shared structures is larger than maximum shared structures, try increasing maxSharedStructures to ' + structures.sharedLength);
 				}
 				if (!structures.transitions) {
 					// rebuild our structure transitions
-					structures.transitions = Object.create(null)
+					structures.transitions = Object.create(null);
 					for (let i = 0; i < sharedLength; i++) {
-						let keys = structures[i]
+						let keys = structures[i];
 						if (!keys)
-							continue
-						let nextTransition, transition = structures.transitions
+							continue;
+						let nextTransition, transition = structures.transitions;
 						for (let j = 0, l = keys.length; j < l; j++) {
-							let key = keys[j]
-							nextTransition = transition[key]
+							let key = keys[j];
+							nextTransition = transition[key];
 							if (!nextTransition) {
-								nextTransition = transition[key] = Object.create(null)
+								nextTransition = transition[key] = Object.create(null);
 							}
-							transition = nextTransition
+							transition = nextTransition;
 						}
-						transition[RECORD_SYMBOL] = i + 0x40
+						transition[RECORD_SYMBOL] = i + 0x40;
 					}
-					this.lastNamedStructuresLength = sharedLength
+					this.lastNamedStructuresLength = sharedLength;
 				}
 				if (!isSequential) {
-					structures.nextId = sharedLength + 0x40
+					structures.nextId = sharedLength + 0x40;
 				}
 			}
 			if (hasSharedUpdate)
-				hasSharedUpdate = false
+				hasSharedUpdate = false;
 			let encodingError;
 			try {
-				if (packr.randomAccessStructure && value && typeof value === 'object') {
+				if (packr._writeStruct && value && typeof value === 'object') {
 					if (value.constructor === Object) writeStruct(value); // simple object
 					else if (value.constructor !== Map && !Array.isArray(value) && !extensionClasses.some(extClass => value instanceof extClass)) {
 						// allow user classes, if they don't need special handling (but do use toJSON if available)
 						writeStruct(value.toJSON ? value.toJSON() : value);
-					} else pack(value)
+					} else pack(value);
 				} else
-					pack(value)
+					pack(value);
 				let lastBundle = bundledStrings;
 				if (bundledStrings)
-					writeBundles(start, pack, 0)
+					writeBundles(start, pack, 0);
 				if (referenceMap && referenceMap.idsToInsert) {
 					let idsToInsert = referenceMap.idsToInsert.sort((a, b) => a.offset > b.offset ? 1 : -1);
 					let i = idsToInsert.length;
@@ -149,7 +148,7 @@ export class Packr extends Unpackr {
 							if (incrementPosition >= 0) {
 								// update the bundle reference now
 								targetView.setUint32(lastBundle.position + start,
-									targetView.getUint32(lastBundle.position + start) + incrementPosition)
+									targetView.getUint32(lastBundle.position + start) + incrementPosition);
 								incrementPosition = -1; // reset
 							}
 							lastBundle = lastBundle.previous;
@@ -159,23 +158,23 @@ export class Packr extends Unpackr {
 					if (incrementPosition >= 0 && lastBundle) {
 						// update the bundle reference now
 						targetView.setUint32(lastBundle.position + start,
-							targetView.getUint32(lastBundle.position + start) + incrementPosition)
+							targetView.getUint32(lastBundle.position + start) + incrementPosition);
 					}
 					position += idsToInsert.length * 6;
 					if (position > safeEnd)
-						makeRoom(position)
-					packr.offset = position
-					let serialized = insertIds(target.subarray(start, position), idsToInsert)
-					referenceMap = null
-					return serialized
+						makeRoom(position);
+					packr.offset = position;
+					let serialized = insertIds(target.subarray(start, position), idsToInsert);
+					referenceMap = null;
+					return serialized;
 				}
-				packr.offset = position // update the offset so next serialization doesn't write over our buffer, but can continue writing to same buffer sequentially
+				packr.offset = position; // update the offset so next serialization doesn't write over our buffer, but can continue writing to same buffer sequentially
 				if (encodeOptions & REUSE_BUFFER_MODE) {
-					target.start = start
-					target.end = position
-					return target
+					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
+				return target.subarray(start, position); // position can change if we call pack again in saveStructures, so we get the buffer now
 			} catch(error) {
 				encodingError = error;
 				throw error;
@@ -183,336 +182,336 @@ export class Packr extends Unpackr {
 				if (structures) {
 					resetStructures();
 					if (hasSharedUpdate && packr.saveStructures) {
-						let sharedLength = structures.sharedLength || 0
+						let sharedLength = structures.sharedLength || 0;
 						// 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)
-						let newSharedData = prepareStructures(structures, packr);
+						let returnBuffer = target.subarray(start, position);
+						let newSharedData = (packr._prepareStructures || prepareStructures)(structures, packr);
 						if (!encodingError) { // TODO: If there is an encoding error, should make the structures as uninitialized so they get rebuilt next time
 							if (packr.saveStructures(newSharedData, newSharedData.isCompatible) === false) {
 								// get updated structures and try again if the update failed
-								return packr.pack(value, encodeOptions)
+								return packr.pack(value, encodeOptions);
 							}
-							packr.lastNamedStructuresLength = sharedLength
+							packr.lastNamedStructuresLength = sharedLength;
 							// don't keep large buffers around
-							if (target.length > 0x40000000) target = null
-							return returnBuffer
+							if (target.length > 0x40000000) target = null;
+							return returnBuffer;
 						}
 					}
 				}
 				// don't keep large buffers around, they take too much memory and cause problems (limit at 1GB)
-				if (target.length > 0x40000000) target = null
+				if (target.length > 0x40000000) target = null;
 				if (encodeOptions & RESET_BUFFER_MODE)
-					position = start
+					position = start;
 			}
-		}
+		};
 		const resetStructures = () => {
 			if (serializationsSinceTransitionRebuild < 10)
-				serializationsSinceTransitionRebuild++
-			let sharedLength = structures.sharedLength || 0
+				serializationsSinceTransitionRebuild++;
+			let sharedLength = structures.sharedLength || 0;
 			if (structures.length > sharedLength && !isSequential)
-				structures.length = sharedLength
+				structures.length = sharedLength;
 			if (transitionsCount > 10000) {
 				// force a rebuild occasionally after a lot of transitions so it can get cleaned up
-				structures.transitions = null
-				serializationsSinceTransitionRebuild = 0
-				transitionsCount = 0
+				structures.transitions = null;
+				serializationsSinceTransitionRebuild = 0;
+				transitionsCount = 0;
 				if (recordIdsToRemove.length > 0)
-					recordIdsToRemove = []
+					recordIdsToRemove = [];
 			} else if (recordIdsToRemove.length > 0 && !isSequential) {
 				for (let i = 0, l = recordIdsToRemove.length; i < l; i++) {
-					recordIdsToRemove[i][RECORD_SYMBOL] = 0
+					recordIdsToRemove[i][RECORD_SYMBOL] = 0;
 				}
-				recordIdsToRemove = []
+				recordIdsToRemove = [];
 			}
-		}
+		};
 		const packArray = (value) => {
-			var length = value.length
+			var length = value.length;
 			if (length < 0x10) {
-				target[position++] = 0x90 | length
+				target[position++] = 0x90 | length;
 			} else if (length < 0x10000) {
-				target[position++] = 0xdc
-				target[position++] = length >> 8
-				target[position++] = length & 0xff
+				target[position++] = 0xdc;
+				target[position++] = length >> 8;
+				target[position++] = length & 0xff;
 			} else {
-				target[position++] = 0xdd
-				targetView.setUint32(position, length)
-				position += 4
+				target[position++] = 0xdd;
+				targetView.setUint32(position, length);
+				position += 4;
 			}
 			for (let i = 0; i < length; i++) {
-				pack(value[i])
+				pack(value[i]);
 			}
-		}
+		};
 		const pack = (value) => {
 			if (position > safeEnd)
-				target = makeRoom(position)
+				target = makeRoom(position);
 
-			var type = typeof value
-			var length
+			var type = typeof value;
+			var length;
 			if (type === 'string') {
-				let strLength = value.length
+				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
+						let extStart;
+						let maxBytes = (bundledStrings[0] ? bundledStrings[0].length * 3 + bundledStrings[1].length : 0) + 10;
 						if (position + maxBytes > safeEnd)
-							target = makeRoom(position + maxBytes)
-						let lastBundle
+							target = makeRoom(position + maxBytes);
+						let lastBundle;
 						if (bundledStrings.position) { // here we use the 0x62 extension to write the last bundle and reserve space for the reference pointer to the next/current bundle
-							lastBundle = bundledStrings
-							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, 0) // write the last bundles
-							targetView.setUint16(extStart + start - 3, position - start - extStart)
+							lastBundle = bundledStrings;
+							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, 0); // 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
+							target[position++] = 0xd6; // fixext 4
+							target[position++] = 0x62; // 'b'
+							extStart = position - start;
+							position += 4; // reserve for writing bundle reference
 						}
-						bundledStrings = ['', ''] // create new ones
+						bundledStrings = ['', '']; // create new ones
 						bundledStrings.previous = lastBundle;
-						bundledStrings.size = 0
-						bundledStrings.position = extStart
+						bundledStrings.size = 0;
+						bundledStrings.position = extStart;
 					}
-					let twoByte = hasNonLatin.test(value)
-					bundledStrings[twoByte ? 0 : 1] += value
-					target[position++] = 0xc1
+					let twoByte = hasNonLatin.test(value);
+					bundledStrings[twoByte ? 0 : 1] += value;
+					target[position++] = 0xc1;
 					pack(twoByte ? -strLength : strLength);
-					return
+					return;
 				}
-				let headerSize
+				let headerSize;
 				// first we estimate the header size, so we can write to the correct location
 				if (strLength < 0x20) {
-					headerSize = 1
+					headerSize = 1;
 				} else if (strLength < 0x100) {
-					headerSize = 2
+					headerSize = 2;
 				} else if (strLength < 0x10000) {
-					headerSize = 3
+					headerSize = 3;
 				} else {
-					headerSize = 5
+					headerSize = 5;
 				}
-				let maxBytes = strLength * 3
+				let maxBytes = strLength * 3;
 				if (position + maxBytes > safeEnd)
-					target = makeRoom(position + maxBytes)
+					target = makeRoom(position + maxBytes);
 
 				if (strLength < 0x40 || !encodeUtf8) {
-					let i, c1, c2, strPosition = position + headerSize
+					let i, c1, c2, strPosition = position + headerSize;
 					for (i = 0; i < strLength; i++) {
-						c1 = value.charCodeAt(i)
+						c1 = value.charCodeAt(i);
 						if (c1 < 0x80) {
-							target[strPosition++] = c1
+							target[strPosition++] = c1;
 						} else if (c1 < 0x800) {
-							target[strPosition++] = c1 >> 6 | 0xc0
-							target[strPosition++] = c1 & 0x3f | 0x80
+							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
+							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
+							target[strPosition++] = c1 >> 12 | 0xe0;
+							target[strPosition++] = c1 >> 6 & 0x3f | 0x80;
+							target[strPosition++] = c1 & 0x3f | 0x80;
 						}
 					}
-					length = strPosition - position - headerSize
+					length = strPosition - position - headerSize;
 				} else {
-					length = encodeUtf8(value, position + headerSize)
+					length = encodeUtf8(value, position + headerSize);
 				}
 
 				if (length < 0x20) {
-					target[position++] = 0xa0 | length
+					target[position++] = 0xa0 | length;
 				} else if (length < 0x100) {
 					if (headerSize < 2) {
-						target.copyWithin(position + 2, position + 1, position + 1 + length)
+						target.copyWithin(position + 2, position + 1, position + 1 + length);
 					}
-					target[position++] = 0xd9
-					target[position++] = length
+					target[position++] = 0xd9;
+					target[position++] = length;
 				} else if (length < 0x10000) {
 					if (headerSize < 3) {
-						target.copyWithin(position + 3, position + 2, position + 2 + length)
+						target.copyWithin(position + 3, position + 2, position + 2 + length);
 					}
-					target[position++] = 0xda
-					target[position++] = length >> 8
-					target[position++] = length & 0xff
+					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.copyWithin(position + 5, position + 3, position + 3 + length);
 					}
-					target[position++] = 0xdb
-					targetView.setUint32(position, length)
-					position += 4
+					target[position++] = 0xdb;
+					targetView.setUint32(position, length);
+					position += 4;
 				}
-				position += length
+				position += length;
 			} else if (type === 'number') {
 				if (value >>> 0 === value) {// positive integer, 32-bit or less
 					// positive uint
-					if (value < 0x20 || (value < 0x80 && this.useRecords === false) || (value < 0x40 && !this.randomAccessStructure)) {
-						target[position++] = value
+					if (value < 0x20 || (value < 0x80 && this.useRecords === false) || (value < 0x40 && !this._writeStruct)) {
+						target[position++] = value;
 					} else if (value < 0x100) {
-						target[position++] = 0xcc
-						target[position++] = value
+						target[position++] = 0xcc;
+						target[position++] = value;
 					} else if (value < 0x10000) {
-						target[position++] = 0xcd
-						target[position++] = value >> 8
-						target[position++] = value & 0xff
+						target[position++] = 0xcd;
+						target[position++] = value >> 8;
+						target[position++] = value & 0xff;
 					} else {
-						target[position++] = 0xce
-						targetView.setUint32(position, value)
-						position += 4
+						target[position++] = 0xce;
+						targetView.setUint32(position, value);
+						position += 4;
 					}
 				} else if (value >> 0 === value) { // negative integer
 					if (value >= -0x20) {
-						target[position++] = 0x100 + value
+						target[position++] = 0x100 + value;
 					} else if (value >= -0x80) {
-						target[position++] = 0xd0
-						target[position++] = value + 0x100
+						target[position++] = 0xd0;
+						target[position++] = value + 0x100;
 					} else if (value >= -0x8000) {
-						target[position++] = 0xd1
-						targetView.setInt16(position, value)
-						position += 2
+						target[position++] = 0xd1;
+						targetView.setInt16(position, value);
+						position += 2;
 					} else {
-						target[position++] = 0xd2
-						targetView.setInt32(position, value)
-						position += 4
+						target[position++] = 0xd2;
+						targetView.setInt32(position, value);
+						position += 4;
 					}
 				} else {
-					let useFloat32
+					let useFloat32;
 					if ((useFloat32 = this.useFloat32) > 0 && value < 0x100000000 && value >= -0x80000000) {
-						target[position++] = 0xca
-						targetView.setFloat32(position, value)
-						let xShifted
+						target[position++] = 0xca;
+						targetView.setFloat32(position, value);
+						let xShifted;
 						if (useFloat32 < 4 ||
 								// this checks for rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
 								((xShifted = value * mult10[((target[position] & 0x7f) << 1) | (target[position + 1] >> 7)]) >> 0) === xShifted) {
-							position += 4
-							return
+							position += 4;
+							return;
 						} else
-							position-- // move back into position for writing a double
+							position--; // move back into position for writing a double
 					}
-					target[position++] = 0xcb
-					targetView.setFloat64(position, value)
-					position += 8
+					target[position++] = 0xcb;
+					targetView.setFloat64(position, value);
+					position += 8;
 				}
 			} else if (type === 'object' || type === 'function') {
 				if (!value)
-					target[position++] = 0xc0
+					target[position++] = 0xc0;
 				else {
 					if (referenceMap) {
-						let referee = referenceMap.get(value)
+						let referee = referenceMap.get(value);
 						if (referee) {
 							if (!referee.id) {
-								let idsToInsert = referenceMap.idsToInsert || (referenceMap.idsToInsert = [])
-								referee.id = idsToInsert.push(referee)
+								let idsToInsert = referenceMap.idsToInsert || (referenceMap.idsToInsert = []);
+								referee.id = idsToInsert.push(referee);
 							}
-							target[position++] = 0xd6 // fixext 4
-							target[position++] = 0x70 // "p" for pointer
-							targetView.setUint32(position, referee.id)
-							position += 4
-							return
+							target[position++] = 0xd6; // fixext 4
+							target[position++] = 0x70; // "p" for pointer
+							targetView.setUint32(position, referee.id);
+							position += 4;
+							return;
 						} else
-							referenceMap.set(value, { offset: position - start })
+							referenceMap.set(value, { offset: position - start });
 					}
-					let constructor = value.constructor
+					let constructor = value.constructor;
 					if (constructor === Object) {
-						writeObject(value)
+						writeObject(value);
 					} else if (constructor === Array) {
-						packArray(value)
+						packArray(value);
 					} else if (constructor === Map) {
-						if (this.mapAsEmptyObject) target[position++] = 0x80
+						if (this.mapAsEmptyObject) target[position++] = 0x80;
 						else {
-							length = value.size
+							length = value.size;
 							if (length < 0x10) {
-								target[position++] = 0x80 | length
+								target[position++] = 0x80 | length;
 							} else if (length < 0x10000) {
-								target[position++] = 0xde
-								target[position++] = length >> 8
-								target[position++] = length & 0xff
+								target[position++] = 0xde;
+								target[position++] = length >> 8;
+								target[position++] = length & 0xff;
 							} else {
-								target[position++] = 0xdf
-								targetView.setUint32(position, length)
-								position += 4
+								target[position++] = 0xdf;
+								targetView.setUint32(position, length);
+								position += 4;
 							}
 							for (let [key, entryValue] of value) {
-								pack(key)
-								pack(entryValue)
+								pack(key);
+								pack(entryValue);
 							}
 						}
 					} else {
 						for (let i = 0, l = extensions.length; i < l; i++) {
-							let extensionClass = extensionClasses[i]
+							let extensionClass = extensionClasses[i];
 							if (value instanceof extensionClass) {
-								let extension = extensions[i]
+								let extension = extensions[i];
 								if (extension.write) {
 									if (extension.type) {
-										target[position++] = 0xd4 // one byte "tag" extension
-										target[position++] = extension.type
-										target[position++] = 0
+										target[position++] = 0xd4; // one byte "tag" extension
+										target[position++] = extension.type;
+										target[position++] = 0;
 									}
-									let writeResult = extension.write.call(this, value)
+									let writeResult = extension.write.call(this, value);
 									if (writeResult === value) { // avoid infinite recursion
 										if (Array.isArray(value)) {
-											packArray(value)
+											packArray(value);
 										} else {
-											writeObject(value)
+											writeObject(value);
 										}
 									} else {
-										pack(writeResult)
+										pack(writeResult);
 									}
-									return
+									return;
 								}
-								let currentTarget = target
-								let currentTargetView = targetView
-								let currentPosition = position
-								target = null
-								let result
+								let currentTarget = target;
+								let currentTargetView = targetView;
+								let currentPosition = position;
+								target = null;
+								let result;
 								try {
 									result = extension.pack.call(this, value, (size) => {
 										// restore target and use it
-										target = currentTarget
-										currentTarget = null
-										position += size
+										target = currentTarget;
+										currentTarget = null;
+										position += size;
 										if (position > safeEnd)
-											makeRoom(position)
+											makeRoom(position);
 										return {
 											target, targetView, position: position - size
-										}
-									}, pack)
+										};
+									}, pack);
 								} finally {
 									// restore current target information (unless already restored)
 									if (currentTarget) {
-										target = currentTarget
-										targetView = currentTargetView
-										position = currentPosition
-										safeEnd = target.length - 10
+										target = currentTarget;
+										targetView = currentTargetView;
+										position = currentPosition;
+										safeEnd = target.length - 10;
 									}
 								}
 								if (result) {
 									if (result.length + position > safeEnd)
-										makeRoom(result.length + position)
-									position = writeExtensionData(result, target, position, extension.type)
+										makeRoom(result.length + position);
+									position = writeExtensionData(result, target, position, extension.type);
 								}
-								return
+								return;
 							}
 						}
 						// check isArray after extensions, because extensions can extend Array
 						if (Array.isArray(value)) {
-							packArray(value)
+							packArray(value);
 						} else {
 							// use this as an alternate mechanism for expressing how to serialize
 							if (value.toJSON) {
-								const json = value.toJSON()
+								const json = value.toJSON();
 								// if for some reason value.toJSON returns itself it'll loop forever
 								if (json !== value)
-									return pack(json)
+									return pack(json);
 							}
 
 							// if there is a writeFunction, use it, otherwise just encode as undefined
@@ -520,89 +519,89 @@ export class Packr extends Unpackr {
 								return pack(this.writeFunction && this.writeFunction(value));
 
 							// no extension found, write as plain object
-							writeObject(value)
+							writeObject(value);
 						}
 					}
 				}
 			} else if (type === 'boolean') {
-				target[position++] = value ? 0xc3 : 0xc2
+				target[position++] = value ? 0xc3 : 0xc2;
 			} else if (type === 'bigint') {
 				if (value < 0x8000000000000000 && value >= -0x8000000000000000) {
 					// use a signed int as long as it fits
-					target[position++] = 0xd3
-					targetView.setBigInt64(position, value)
+					target[position++] = 0xd3;
+					targetView.setBigInt64(position, value);
 				} else if (value < 0x10000000000000000 && value > 0) {
 					// if we can fit an unsigned int, use that
-					target[position++] = 0xcf
-					targetView.setBigUint64(position, value)
+					target[position++] = 0xcf;
+					targetView.setBigUint64(position, value);
 				} else {
 					// overflow
 					if (this.largeBigIntToFloat) {
-						target[position++] = 0xcb
-						targetView.setFloat64(position, Number(value))
+						target[position++] = 0xcb;
+						targetView.setFloat64(position, Number(value));
 					} else if (this.largeBigIntToString) {
 						return pack(value.toString());
 					} else if (this.useBigIntExtension || this.moreTypes) {
-						let empty = value < 0 ? BigInt(-1) : BigInt(0)
+						let empty = value < 0 ? BigInt(-1) : BigInt(0);
 
-						let array
+						let array;
 						if (value >> BigInt(0x10000) === empty) {
-							let mask = BigInt(0x10000000000000000) - BigInt(1) // literal would overflow
-							let chunks = []
+							let mask = BigInt(0x10000000000000000) - BigInt(1); // literal would overflow
+							let chunks = [];
 							while (true) {
-								chunks.push(value & mask)
-								if ((value >> BigInt(63)) === empty) break
-								value >>= BigInt(64)
+								chunks.push(value & mask);
+								if ((value >> BigInt(63)) === empty) break;
+								value >>= BigInt(64);
 							}
 
-							array = new Uint8Array(new BigUint64Array(chunks).buffer)
-							array.reverse()
+							array = new Uint8Array(new BigUint64Array(chunks).buffer);
+							array.reverse();
 						} else {
-							let invert = value < 0
-							let string = (invert ? ~value : value).toString(16)
+							let invert = value < 0;
+							let string = (invert ? ~value : value).toString(16);
 							if (string.length % 2) {
-								string = '0' + string
+								string = '0' + string;
 							} else if (parseInt(string.charAt(0), 16) >= 8) {
-								string = '00' + string
+								string = '00' + string;
 							}
 
 							if (hasNodeBuffer) {
-								array = Buffer.from(string, 'hex')
+								array = Buffer.from(string, 'hex');
 							} else {
-								array = new Uint8Array(string.length / 2)
+								array = new Uint8Array(string.length / 2);
 								for (let i = 0; i < array.length; i++) {
-									array[i] = parseInt(string.slice(i * 2, i * 2 + 2), 16)
+									array[i] = parseInt(string.slice(i * 2, i * 2 + 2), 16);
 								}
 							}
 
 							if (invert) {
-								for (let i = 0; i < array.length; i++) array[i] = ~array[i]
+								for (let i = 0; i < array.length; i++) array[i] = ~array[i];
 							}
 						}
 
 						if (array.length + position > safeEnd)
-							makeRoom(array.length + position)
-						position = writeExtensionData(array, target, position, 0x42)
-						return
+							makeRoom(array.length + position);
+						position = writeExtensionData(array, target, position, 0x42);
+						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, or set' +
-							' largeBigIntToString to convert to string')
+							' largeBigIntToString to convert to string');
 					}
 				}
-				position += 8
+				position += 8;
 			} else if (type === 'undefined') {
 				if (this.encodeUndefinedAsNil)
-					target[position++] = 0xc0
+					target[position++] = 0xc0;
 				else {
-					target[position++] = 0xd4 // a number of implementations use fixext1 with type 0, data 0 to denote undefined, so we follow suite
-					target[position++] = 0
-					target[position++] = 0
+					target[position++] = 0xd4; // a number of implementations use fixext1 with type 0, data 0 to denote undefined, so we follow suite
+					target[position++] = 0;
+					target[position++] = 0;
 				}
 			} else {
-				throw new Error('Unknown type: ' + type)
+				throw new Error('Unknown type: ' + type);
 			}
-		}
+		};
 
 		const writePlainObject = (this.variableMapSize || this.coercibleKeyAsNumber || this.skipValues) ? (object) => {
 			// this method is slightly slower, but generates "preferred serialization" (optimally small for smaller objects)
@@ -615,263 +614,264 @@ export class Packr extends Unpackr {
 						keys.push(key);
 				}
 			} else {
-				keys = Object.keys(object)
+				keys = Object.keys(object);
 			}
-			let length = keys.length
+			let length = keys.length;
 			if (length < 0x10) {
-				target[position++] = 0x80 | length
+				target[position++] = 0x80 | length;
 			} else if (length < 0x10000) {
-				target[position++] = 0xde
-				target[position++] = length >> 8
-				target[position++] = length & 0xff
+				target[position++] = 0xde;
+				target[position++] = length >> 8;
+				target[position++] = length & 0xff;
 			} else {
-				target[position++] = 0xdf
-				targetView.setUint32(position, length)
-				position += 4
+				target[position++] = 0xdf;
+				targetView.setUint32(position, length);
+				position += 4;
 			}
-			let key
+			let 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])
+					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])
+					pack(key = keys[i]);
+					pack(object[key]);
 				}
 			}
 		} :
 		(object) => {
-			target[position++] = 0xde // always using map 16, so we can preallocate and set the length afterwards
-			let objectOffset = position - start
-			position += 2
-			let size = 0
+			target[position++] = 0xde; // always using map 16, so we can preallocate and set the length afterwards
+			let objectOffset = position - start;
+			position += 2;
+			let size = 0;
 			for (let key in object) {
 				if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
-					pack(key)
-					pack(object[key])
-					size++
+					pack(key);
+					pack(object[key]);
+					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
-		}
+			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) => {
-			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null))
-			let objectOffset = position++ - start
-			let wroteKeys
+			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
+			let objectOffset = position++ - start;
+			let wroteKeys;
 			for (let key in object) {
 				if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
-					nextTransition = transition[key]
+					nextTransition = transition[key];
 					if (nextTransition)
-						transition = 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
+						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]
-							nextTransition = transition[key]
+							let key = keys[i];
+							nextTransition = transition[key];
 							if (!nextTransition) {
-								nextTransition = transition[key] = Object.create(null)
-								newTransitions++
+								nextTransition = transition[key] = Object.create(null);
+								newTransitions++;
 							}
-							transition = nextTransition
+							transition = nextTransition;
 						}
 						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)
+							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]
+							insertNewRecord(transition, keys, objectOffset, newTransitions);
+						wroteKeys = true;
+						transition = lastTransition[key];
 					}
-					pack(object[key])
+					pack(object[key]);
 				}
 			}
 			if (!wroteKeys) {
-				let recordId = transition[RECORD_SYMBOL]
+				let recordId = transition[RECORD_SYMBOL];
 				if (recordId)
-					target[objectOffset + start] = recordId
+					target[objectOffset + start] = recordId;
 				else
-					insertNewRecord(transition, Object.keys(object), objectOffset, 0)
+					insertNewRecord(transition, Object.keys(object), objectOffset, 0);
 			}
 		} :
 		(object) => {
-			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null))
-			let newTransitions = 0
+			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
+			let newTransitions = 0;
 			for (let key in object) if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
-				nextTransition = transition[key]
+				nextTransition = transition[key];
 				if (!nextTransition) {
-					nextTransition = transition[key] = Object.create(null)
-					newTransitions++
+					nextTransition = transition[key] = Object.create(null);
+					newTransitions++;
 				}
-				transition = nextTransition
+				transition = nextTransition;
 			}
-			let recordId = transition[RECORD_SYMBOL]
+			let recordId = transition[RECORD_SYMBOL];
 			if (recordId) {
 				if (recordId >= 0x60 && useTwoByteRecords) {
-					target[position++] = ((recordId -= 0x60) & 0x1f) + 0x60
-					target[position++] = recordId >> 5
+					target[position++] = ((recordId -= 0x60) & 0x1f) + 0x60;
+					target[position++] = recordId >> 5;
 				} else
-					target[position++] = recordId
+					target[position++] = recordId;
 			} else {
-				newRecord(transition, transition.__keys__ || Object.keys(object), newTransitions)
+				newRecord(transition, transition.__keys__ || Object.keys(object), newTransitions);
 			}
 			// now write the values
 			for (let key in object)
 				if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
-					pack(object[key])
+					pack(object[key]);
 				}
-		}
+		};
 
 		// 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
+			checkUseRecords(object) ? writeRecord(object) : writePlainObject(object);
+		} : writeRecord;
+
+		const writeStruct = (object) => {
+			let newPosition = packr._writeStruct(object, target, start, position, structures, makeRoom, (value, newPosition, notifySharedUpdate) => {
+				if (notifySharedUpdate)
+					return hasSharedUpdate = true;
+				position = newPosition;
+				let startTarget = target;
+				pack(value);
+				resetStructures();
+				if (startTarget !== target) {
+					return { position, targetView, target }; // indicate the buffer was re-allocated
+				}
+				return position;
+			});
+			if (newPosition === 0) // bail and go to a msgpack object
+				return writeObject(object);
+			position = newPosition;
+		};
 
 		const makeRoom = (end) => {
-			let newSize
+			let newSize;
 			if (end > 0x1000000) {
 				// special handling for really large buffers
 				if ((end - start) > MAX_BUFFER_SIZE)
-					throw new Error('Packed buffer would be larger than maximum buffer size')
+					throw new Error('Packed buffer would be larger than maximum buffer size');
 				newSize = Math.min(MAX_BUFFER_SIZE,
-					Math.round(Math.max((end - start) * (end > 0x4000000 ? 1.25 : 2), 0x400000) / 0x1000) * 0x1000)
+					Math.round(Math.max((end - start) * (end > 0x4000000 ? 1.25 : 2), 0x400000) / 0x1000) * 0x1000);
 			} else // faster handling for smaller buffers
-				newSize = ((Math.max((end - start) << 2, target.length - 1) >> 12) + 1) << 12
-			let newBuffer = new ByteArrayAllocate(newSize)
-			targetView = newBuffer.dataView || (newBuffer.dataView = new DataView(newBuffer.buffer, 0, newSize))
-			end = Math.min(end, target.length)
+				newSize = ((Math.max((end - start) << 2, target.length - 1) >> 12) + 1) << 12;
+			let newBuffer = new ByteArrayAllocate(newSize);
+			targetView = newBuffer.dataView || (newBuffer.dataView = new DataView(newBuffer.buffer, 0, newSize));
+			end = Math.min(end, target.length);
 			if (target.copy)
-				target.copy(newBuffer, 0, start, end)
+				target.copy(newBuffer, 0, start, end);
 			else
-				newBuffer.set(target.slice(start, end))
-			position -= start
-			start = 0
-			safeEnd = newBuffer.length - 10
-			return target = newBuffer
-		}
+				newBuffer.set(target.slice(start, end));
+			position -= start;
+			start = 0;
+			safeEnd = newBuffer.length - 10;
+			return target = newBuffer;
+		};
 		const newRecord = (transition, keys, newTransitions) => {
-			let recordId = structures.nextId
+			let recordId = structures.nextId;
 			if (!recordId)
-				recordId = 0x40
+				recordId = 0x40;
 			if (recordId < sharedLimitId && this.shouldShareStructure && !this.shouldShareStructure(keys)) {
-				recordId = structures.nextOwnId
+				recordId = structures.nextOwnId;
 				if (!(recordId < maxStructureId))
-					recordId = sharedLimitId
-				structures.nextOwnId = recordId + 1
+					recordId = sharedLimitId;
+				structures.nextOwnId = recordId + 1;
 			} else {
 				if (recordId >= maxStructureId)// cycle back around
-					recordId = sharedLimitId
-				structures.nextId = recordId + 1
+					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
+			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
+				keys.isShared = true;
+				structures.sharedLength = recordId - 0x3f;
+				hasSharedUpdate = true;
 				if (highByte >= 0) {
-					target[position++] = (recordId & 0x1f) + 0x60
-					target[position++] = highByte
+					target[position++] = (recordId & 0x1f) + 0x60;
+					target[position++] = highByte;
 				} else {
-					target[position++] = recordId
+					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
+					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
+					target[position++] = 0xd4; // fixext 1
+					target[position++] = 0x72; // "r" record defintion extension type
+					target[position++] = recordId;
 				}
 
 				if (newTransitions)
-					transitionsCount += serializationsSinceTransitionRebuild * 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)
+					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
+			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
+				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
+				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
+					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]
+				target[insertionOffset + start] = keysTarget[0];
 			}
-		}
-		const writeStruct = (object) => {
-			let newPosition = writeStructSlots(object, target, start, position, structures, makeRoom, (value, newPosition, notifySharedUpdate) => {
-				if (notifySharedUpdate)
-					return hasSharedUpdate = true;
-				position = newPosition;
-				let startTarget = target;
-				pack(value);
-				resetStructures();
-				if (startTarget !== target) {
-					return { position, targetView, target }; // indicate the buffer was re-allocated
-				}
-				return position;
-			}, this);
-			if (newPosition === 0) // bail and go to a msgpack object
-				return writeObject(object);
-			position = newPosition;
-		}
+		};
 	}
 	useBuffer(buffer) {
 		// this means we are finished using our own buffer and we can write over it safely
-		target = buffer
-		target.dataView || (target.dataView = new DataView(target.buffer, target.byteOffset, target.byteLength))
+		target = buffer;
+		target.dataView || (target.dataView = new DataView(target.buffer, target.byteOffset, target.byteLength));
 		targetView = target.dataView;
-		position = 0
+		position = 0;
 	}
 	set position (value) {
 		position = value;
@@ -881,261 +881,262 @@ export class Packr extends Unpackr {
 	}
 	clearSharedData() {
 		if (this.structures)
-			this.structures = []
+			this.structures = [];
 		if (this.typedStructs)
-			this.typedStructs = []
+			this.typedStructs = [];
 	}
 }
 
-extensionClasses = [ Date, Set, Error, RegExp, ArrayBuffer, Object.getPrototypeOf(Uint8Array.prototype).constructor /*TypedArray*/, DataView, C1Type ]
+extensionClasses = [ Date, Set, Error, RegExp, ArrayBuffer, Object.getPrototypeOf(Uint8Array.prototype).constructor /*TypedArray*/, DataView, C1Type ];
 extensions = [{
 	pack(date, allocateForWrite, pack) {
-		let seconds = date.getTime() / 1000
+		let seconds = date.getTime() / 1000;
 		if ((this.useTimestamp32 || date.getMilliseconds() === 0) && seconds >= 0 && seconds < 0x100000000) {
 			// Timestamp 32
-			let { target, targetView, position} = allocateForWrite(6)
-			target[position++] = 0xd6
-			target[position++] = 0xff
-			targetView.setUint32(position, seconds)
+			let { target, targetView, position} = allocateForWrite(6);
+			target[position++] = 0xd6;
+			target[position++] = 0xff;
+			targetView.setUint32(position, seconds);
 		} else if (seconds > 0 && seconds < 0x100000000) {
 			// Timestamp 64
-			let { target, targetView, position} = allocateForWrite(10)
-			target[position++] = 0xd7
-			target[position++] = 0xff
-			targetView.setUint32(position, date.getMilliseconds() * 4000000 + ((seconds / 1000 / 0x100000000) >> 0))
-			targetView.setUint32(position + 4, seconds)
+			let { target, targetView, position} = allocateForWrite(10);
+			target[position++] = 0xd7;
+			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())
+				allocateForWrite(0);
+				return pack(this.onInvalidDate());
 			}
 			// Intentionally invalid timestamp
-			let { target, targetView, position} = allocateForWrite(3)
-			target[position++] = 0xd4
-			target[position++] = 0xff
-			target[position++] = 0xff
+			let { target, targetView, position} = allocateForWrite(3);
+			target[position++] = 0xd4;
+			target[position++] = 0xff;
+			target[position++] = 0xff;
 		} else {
 			// Timestamp 96
-			let { target, targetView, position} = allocateForWrite(15)
-			target[position++] = 0xc7
-			target[position++] = 12
-			target[position++] = 0xff
-			targetView.setUint32(position, date.getMilliseconds() * 1000000)
-			targetView.setBigInt64(position + 4, BigInt(Math.floor(seconds)))
+			let { target, targetView, position} = allocateForWrite(15);
+			target[position++] = 0xc7;
+			target[position++] = 12;
+			target[position++] = 0xff;
+			targetView.setUint32(position, date.getMilliseconds() * 1000000);
+			targetView.setBigInt64(position + 4, BigInt(Math.floor(seconds)));
 		}
 	}
 }, {
 	pack(set, allocateForWrite, pack) {
 		if (this.setAsEmptyObject) {
 			allocateForWrite(0);
-			return pack({})
+			return pack({});
 		}
-		let array = Array.from(set)
-		let { target, position} = allocateForWrite(this.moreTypes ? 3 : 0)
+		let array = Array.from(set);
+		let { target, position} = allocateForWrite(this.moreTypes ? 3 : 0);
 		if (this.moreTypes) {
-			target[position++] = 0xd4
-			target[position++] = 0x73 // 's' for Set
-			target[position++] = 0
+			target[position++] = 0xd4;
+			target[position++] = 0x73; // 's' for Set
+			target[position++] = 0;
 		}
-		pack(array)
+		pack(array);
 	}
 }, {
 	pack(error, allocateForWrite, pack) {
-		let { target, position} = allocateForWrite(this.moreTypes ? 3 : 0)
+		let { target, position} = allocateForWrite(this.moreTypes ? 3 : 0);
 		if (this.moreTypes) {
-			target[position++] = 0xd4
-			target[position++] = 0x65 // 'e' for error
-			target[position++] = 0
+			target[position++] = 0xd4;
+			target[position++] = 0x65; // 'e' for error
+			target[position++] = 0;
 		}
-		pack([ error.name, error.message, error.cause ])
+		pack([ error.name, error.message, error.cause ]);
 	}
 }, {
 	pack(regex, allocateForWrite, pack) {
-		let { target, position} = allocateForWrite(this.moreTypes ? 3 : 0)
+		let { target, position} = allocateForWrite(this.moreTypes ? 3 : 0);
 		if (this.moreTypes) {
-			target[position++] = 0xd4
-			target[position++] = 0x78 // 'x' for regeXp
-			target[position++] = 0
+			target[position++] = 0xd4;
+			target[position++] = 0x78; // 'x' for regeXp
+			target[position++] = 0;
 		}
-		pack([ regex.source, regex.flags ])
+		pack([ regex.source, regex.flags ]);
 	}
 }, {
 	pack(arrayBuffer, allocateForWrite) {
 		if (this.moreTypes)
-			writeExtBuffer(arrayBuffer, 0x10, allocateForWrite)
+			writeExtBuffer(arrayBuffer, 0x10, allocateForWrite);
 		else
-			writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite)
+			writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
 	}
 }, {
 	pack(typedArray, allocateForWrite) {
-		let constructor = typedArray.constructor
+		let constructor = typedArray.constructor;
 		if (constructor !== ByteArray && this.moreTypes)
-			writeExtBuffer(typedArray, typedArrays.indexOf(constructor.name), allocateForWrite)
+			writeExtBuffer(typedArray, typedArrays.indexOf(constructor.name), allocateForWrite);
 		else
-			writeBuffer(typedArray, allocateForWrite)
+			writeBuffer(typedArray, allocateForWrite);
 	}
 }, {
 	pack(arrayBuffer, allocateForWrite) {
 		if (this.moreTypes)
-			writeExtBuffer(arrayBuffer, 0x11, allocateForWrite)
+			writeExtBuffer(arrayBuffer, 0x11, allocateForWrite);
 		else
-			writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite)
+			writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
 	}
 }, {
 	pack(c1, allocateForWrite) { // specific 0xC1 object
-		let { target, position} = allocateForWrite(1)
-		target[position] = 0xc1
+		let { target, position} = allocateForWrite(1);
+		target[position] = 0xc1;
 	}
-}]
+}];
 
 function writeExtBuffer(typedArray, type, allocateForWrite, encode) {
-	let length = typedArray.byteLength
+	let length = typedArray.byteLength;
 	if (length + 1 < 0x100) {
-		var { target, position } = allocateForWrite(4 + length)
-		target[position++] = 0xc7
-		target[position++] = length + 1
+		var { target, position } = allocateForWrite(4 + length);
+		target[position++] = 0xc7;
+		target[position++] = length + 1;
 	} else if (length + 1 < 0x10000) {
-		var { target, position } = allocateForWrite(5 + length)
-		target[position++] = 0xc8
-		target[position++] = (length + 1) >> 8
-		target[position++] = (length + 1) & 0xff
+		var { target, position } = allocateForWrite(5 + length);
+		target[position++] = 0xc8;
+		target[position++] = (length + 1) >> 8;
+		target[position++] = (length + 1) & 0xff;
 	} else {
-		var { target, position, targetView } = allocateForWrite(7 + length)
-		target[position++] = 0xc9
-		targetView.setUint32(position, length + 1) // plus one for the type byte
-		position += 4
+		var { target, position, targetView } = allocateForWrite(7 + length);
+		target[position++] = 0xc9;
+		targetView.setUint32(position, length + 1); // plus one for the type byte
+		position += 4;
 	}
-	target[position++] = 0x74 // "t" for typed array
-	target[position++] = type
-	if (!typedArray.buffer) typedArray = new Uint8Array(typedArray)
-	target.set(new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength), position)
+	target[position++] = 0x74; // "t" for typed array
+	target[position++] = type;
+	if (!typedArray.buffer) typedArray = new Uint8Array(typedArray);
+	target.set(new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength), position);
 }
 function writeBuffer(buffer, allocateForWrite) {
-	let length = buffer.byteLength
-	var target, position
+	let length = buffer.byteLength;
+	var target, position;
 	if (length < 0x100) {
-		var { target, position } = allocateForWrite(length + 2)
-		target[position++] = 0xc4
-		target[position++] = length
+		var { target, position } = allocateForWrite(length + 2);
+		target[position++] = 0xc4;
+		target[position++] = length;
 	} else if (length < 0x10000) {
-		var { target, position } = allocateForWrite(length + 3)
-		target[position++] = 0xc5
-		target[position++] = length >> 8
-		target[position++] = length & 0xff
+		var { target, position } = allocateForWrite(length + 3);
+		target[position++] = 0xc5;
+		target[position++] = length >> 8;
+		target[position++] = length & 0xff;
 	} else {
-		var { target, position, targetView } = allocateForWrite(length + 5)
-		target[position++] = 0xc6
-		targetView.setUint32(position, length)
-		position += 4
+		var { target, position, targetView } = allocateForWrite(length + 5);
+		target[position++] = 0xc6;
+		targetView.setUint32(position, length);
+		position += 4;
 	}
-	target.set(buffer, position)
+	target.set(buffer, position);
 }
 
 function writeExtensionData(result, target, position, type) {
-	let length = result.length
+	let length = result.length;
 	switch (length) {
 		case 1:
-			target[position++] = 0xd4
-			break
+			target[position++] = 0xd4;
+			break;
 		case 2:
-			target[position++] = 0xd5
-			break
+			target[position++] = 0xd5;
+			break;
 		case 4:
-			target[position++] = 0xd6
-			break
+			target[position++] = 0xd6;
+			break;
 		case 8:
-			target[position++] = 0xd7
-			break
+			target[position++] = 0xd7;
+			break;
 		case 16:
-			target[position++] = 0xd8
-			break
+			target[position++] = 0xd8;
+			break;
 		default:
 			if (length < 0x100) {
-				target[position++] = 0xc7
-				target[position++] = length
+				target[position++] = 0xc7;
+				target[position++] = length;
 			} else if (length < 0x10000) {
-				target[position++] = 0xc8
-				target[position++] = length >> 8
-				target[position++] = length & 0xff
+				target[position++] = 0xc8;
+				target[position++] = length >> 8;
+				target[position++] = length & 0xff;
 			} else {
-				target[position++] = 0xc9
-				target[position++] = length >> 24
-				target[position++] = (length >> 16) & 0xff
-				target[position++] = (length >> 8) & 0xff
-				target[position++] = length & 0xff
+				target[position++] = 0xc9;
+				target[position++] = length >> 24;
+				target[position++] = (length >> 16) & 0xff;
+				target[position++] = (length >> 8) & 0xff;
+				target[position++] = length & 0xff;
 			}
 	}
-	target[position++] = type
-	target.set(result, position)
-	position += length
-	return position
+	target[position++] = type;
+	target.set(result, position);
+	position += length;
+	return position;
 }
 
 function insertIds(serialized, idsToInsert) {
 	// insert the ids that need to be referenced for structured clones
-	let nextId
-	let distanceToMove = idsToInsert.length * 6
-	let lastEnd = serialized.length - distanceToMove
+	let nextId;
+	let distanceToMove = idsToInsert.length * 6;
+	let lastEnd = serialized.length - distanceToMove;
 	while (nextId = idsToInsert.pop()) {
-		let offset = nextId.offset
-		let id = nextId.id
-		serialized.copyWithin(offset + distanceToMove, offset, lastEnd)
-		distanceToMove -= 6
-		let position = offset + distanceToMove
-		serialized[position++] = 0xd6
-		serialized[position++] = 0x69 // 'i'
-		serialized[position++] = id >> 24
-		serialized[position++] = (id >> 16) & 0xff
-		serialized[position++] = (id >> 8) & 0xff
-		serialized[position++] = id & 0xff
-		lastEnd = offset
+		let offset = nextId.offset;
+		let id = nextId.id;
+		serialized.copyWithin(offset + distanceToMove, offset, lastEnd);
+		distanceToMove -= 6;
+		let position = offset + distanceToMove;
+		serialized[position++] = 0xd6;
+		serialized[position++] = 0x69; // 'i'
+		serialized[position++] = id >> 24;
+		serialized[position++] = (id >> 16) & 0xff;
+		serialized[position++] = (id >> 8) & 0xff;
+		serialized[position++] = id & 0xff;
+		lastEnd = offset;
 	}
-	return serialized
+	return serialized;
 }
 
 function writeBundles(start, pack, incrementPosition) {
 	if (bundledStrings.length > 0) {
-		targetView.setUint32(bundledStrings.position + start, position + incrementPosition - bundledStrings.position - start)
+		targetView.setUint32(bundledStrings.position + start, position + incrementPosition - bundledStrings.position - start);
 		bundledStrings.stringsPosition = position - start;
-		let writeStrings = bundledStrings
-		bundledStrings = null
-		pack(writeStrings[0])
-		pack(writeStrings[1])
+		let writeStrings = bundledStrings;
+		bundledStrings = null;
+		pack(writeStrings[0]);
+		pack(writeStrings[1]);
 	}
 }
 
 export function addExtension(extension) {
 	if (extension.Class) {
 		if (!extension.pack && !extension.write)
-			throw new Error('Extension has no pack or write function')
+			throw new Error('Extension has no pack or write function');
 		if (extension.pack && !extension.type)
-			throw new Error('Extension has no type (numeric code to identify the extension)')
-		extensionClasses.unshift(extension.Class)
-		extensions.unshift(extension)
+			throw new Error('Extension has no type (numeric code to identify the extension)');
+		extensionClasses.unshift(extension.Class);
+		extensions.unshift(extension);
 	}
-	unpackAddExtension(extension)
+	unpackAddExtension(extension);
 }
 function prepareStructures(structures, packr) {
 	structures.isCompatible = (existingStructures) => {
-		let compatible = !existingStructures || ((packr.lastNamedStructuresLength || 0) === existingStructures.length)
+		let compatible = !existingStructures || ((packr.lastNamedStructuresLength || 0) === existingStructures.length);
 		if (!compatible) // we want to merge these existing structures immediately since we already have it and we are in the right transaction
 			packr._mergeStructures(existingStructures);
 		return compatible;
-	}
-	return structures
-}
-export function setWriteStructSlots(writeSlots, makeStructures) {
-	writeStructSlots = writeSlots;
-	prepareStructures = makeStructures;
+	};
+	return structures;
 }
 
-let defaultPackr = new Packr({ useRecords: false })
-export const pack = defaultPackr.pack
-export const encode = defaultPackr.pack
-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 = 512
-export const RESET_BUFFER_MODE = 1024
-export const RESERVE_START_SPACE = 2048
+// Marker for downstream libraries (e.g. structon) to detect that this Packr
+// supports per-instance struct-encoding hooks (this._writeStruct,
+// this._prepareStructures).  See `pack` for the dispatch.
+Packr.SUPPORTS_STRUCT_HOOKS = true;
+
+let defaultPackr = new Packr({ useRecords: false });
+export const pack = defaultPackr.pack;
+export const encode = defaultPackr.pack;
+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 = 512;
+export const RESET_BUFFER_MODE = 1024;
+export const RESERVE_START_SPACE = 2048;