msgpackr 1.11.12 → 2.0.1

package/dist/node.cjs

@@ -31,7 +31,6 @@ const C1 = new C1Type();
 C1.name = 'MessagePack 0xC1';
 var sequentialMode = false;
 var inlineObjectReadThreshold = 2;
-var readStruct$1, onLoadedStructures$1, onSaveState;
 
 class Unpackr {
 	constructor(options) {
@@ -61,10 +60,10 @@ class Unpackr {
 	unpack(source, options) {
 		if (src) {
 			// re-entrant execution, save the state and restore it after we do this unpack
-			return saveState$1(() => {
+			return saveState(() => {
 				clearSource();
-				return this ? this.unpack(source, options) : Unpackr.prototype.unpack.call(defaultOptions, source, options)
-			})
+				return this ? this.unpack(source, options) : Unpackr.prototype.unpack.call(defaultOptions, source, options);
+			});
 		}
 		if (!source.buffer && source.constructor === ArrayBuffer)
 			source = typeof Buffer !== 'undefined' ? Buffer.from(source) : new Uint8Array(source);
@@ -90,14 +89,14 @@ class Unpackr {
 			// if it doesn't have a buffer, maybe it is the wrong type of object
 			src = null;
 			if (source instanceof Uint8Array)
-				throw error
-			throw new Error('Source must be a Uint8Array or Buffer but was a ' + ((source && typeof source == 'object') ? source.constructor.name : typeof source))
+				throw error;
+			throw new Error('Source must be a Uint8Array or Buffer but was a ' + ((source && typeof source == 'object') ? source.constructor.name : typeof source));
 		}
 		if (this instanceof Unpackr) {
 			currentUnpackr = this;
 			if (this.structures) {
 				currentStructures = this.structures;
-				return checkedRead(options)
+				return checkedRead(options);
 			} else if (!currentStructures || currentStructures.length > 0) {
 				currentStructures = [];
 			}
@@ -106,7 +105,7 @@ class Unpackr {
 			if (!currentStructures || currentStructures.length > 0)
 				currentStructures = [];
 		}
-		return checkedRead(options)
+		return checkedRead(options);
 	}
 	unpackMultiple(source, forEach) {
 		let values, lastPosition = 0;
@@ -119,7 +118,7 @@ class Unpackr {
 				while(position$1 < size) {
 					lastPosition = position$1;
 					if (forEach(checkedRead(), lastPosition, position$1) === false) {
-						return
+						return;
 					}
 				}
 			}
@@ -129,20 +128,20 @@ class Unpackr {
 					lastPosition = position$1;
 					values.push(checkedRead());
 				}
-				return values
+				return values;
 			}
 		} catch(error) {
 			error.lastPosition = lastPosition;
 			error.values = values;
-			throw error
+			throw error;
 		} finally {
 			sequentialMode = false;
 			clearSource();
 		}
 	}
 	_mergeStructures(loadedStructures, existingStructures) {
-		if (onLoadedStructures$1)
-			loadedStructures = onLoadedStructures$1.call(this, loadedStructures);
+		if (this._onLoadedStructures)
+			loadedStructures = this._onLoadedStructures(loadedStructures);
 		loadedStructures = loadedStructures || [];
 		if (Object.isFrozen(loadedStructures))
 			loadedStructures = loadedStructures.map(structure => structure.slice(0));
@@ -166,10 +165,10 @@ class Unpackr {
 				}
 			}
 		}
-		return this.structures = loadedStructures
+		return this.structures = loadedStructures;
 	}
 	decode(source, options) {
-		return this.unpack(source, options)
+		return this.unpack(source, options);
 	}
 }
 function checkedRead(options) {
@@ -180,8 +179,8 @@ function checkedRead(options) {
 				currentStructures.length = sharedLength;
 		}
 		let result;
-		if (currentUnpackr.randomAccessStructure && src[position$1] < 0x40 && src[position$1] >= 0x20 && readStruct$1) {
-			result = readStruct$1(src, position$1, srcEnd, currentUnpackr);
+		if (currentUnpackr._readStruct && src[position$1] < 0x40 && src[position$1] >= 0x20) {
+			result = currentUnpackr._readStruct(src, position$1, srcEnd);
 			src = null; // dispose of this so that recursive unpack calls don't save state
 			if (!(options && options.lazy) && result)
 				result = result.toJSON();
@@ -207,7 +206,7 @@ function checkedRead(options) {
 				referenceMap = null;
 		} else if (position$1 > srcEnd) {
 			// over read
-			throw new Error('Unexpected end of MessagePack data')
+			throw new Error('Unexpected end of MessagePack data');
 		} else if (!sequentialMode) {
 			let jsonView;
 			try {
@@ -215,10 +214,10 @@ function checkedRead(options) {
 			} catch(error) {
 				jsonView = '(JSON view not available ' + error + ')';
 			}
-			throw new Error('Data read, but end of buffer not reached ' + jsonView)
+			throw new Error('Data read, but end of buffer not reached ' + jsonView);
 		}
 		// else more to read, but we are reading sequentially, so don't clear source yet
-		return result
+		return result;
 	} catch(error) {
 		if (currentStructures && currentStructures.restoreStructures)
 			restoreStructures();
@@ -226,7 +225,7 @@ function checkedRead(options) {
 		if (error instanceof RangeError || error.message.startsWith('Unexpected end of buffer') || position$1 > srcEnd) {
 			error.incomplete = true;
 		}
-		throw error
+		throw error;
 	}
 }
 
@@ -242,7 +241,7 @@ function read() {
 	if (token < 0xa0) {
 		if (token < 0x80) {
 			if (token < 0x40)
-				return token
+				return token;
 			else {
 				let structure = currentStructures[token & 0x3f] ||
 					currentUnpackr.getStructures && loadStructures()[token & 0x3f];
@@ -250,9 +249,9 @@ function read() {
 					if (!structure.read) {
 						structure.read = createStructureReader(structure, token & 0x3f);
 					}
-					return structure.read()
+					return structure.read();
 				} else
-					return token
+					return token;
 			}
 		} else if (token < 0x90) {
 			// map
@@ -265,13 +264,13 @@ function read() {
 						key = '__proto_';
 					object[key] = read();
 				}
-				return object
+				return object;
 			} else {
 				let map = new Map();
 				for (let i = 0; i < token; i++) {
 					map.set(read(), read());
 				}
-				return map
+				return map;
 			}
 		} else {
 			token -= 0x90;
@@ -280,91 +279,91 @@ function read() {
 				array[i] = read();
 			}
 			if (currentUnpackr.freezeData)
-				return Object.freeze(array)
-			return array
+				return Object.freeze(array);
+			return array;
 		}
 	} else if (token < 0xc0) {
 		// fixstr
 		let length = token - 0xa0;
 		if (srcStringEnd >= position$1) {
-			return srcString.slice(position$1 - srcStringStart, (position$1 += length) - srcStringStart)
+			return srcString.slice(position$1 - srcStringStart, (position$1 += length) - srcStringStart);
 		}
 		if (srcStringEnd == 0 && srcEnd < 140) {
 			// for small blocks, avoiding the overhead of the extract call is helpful
 			let string = length < 16 ? shortStringInJS(length) : longStringInJS(length);
 			if (string != null)
-				return string
+				return string;
 		}
-		return readFixedString(length)
+		return readFixedString(length);
 	} else {
 		let value;
 		switch (token) {
-			case 0xc0: return null
+			case 0xc0: return null;
 			case 0xc1:
 				if (bundledStrings$1) {
 					value = read(); // followed by the length of the string in characters (not bytes!)
 					if (value > 0)
-						return bundledStrings$1[1].slice(bundledStrings$1.position1, bundledStrings$1.position1 += value)
+						return bundledStrings$1[1].slice(bundledStrings$1.position1, bundledStrings$1.position1 += value);
 					else
-						return bundledStrings$1[0].slice(bundledStrings$1.position0, bundledStrings$1.position0 -= value)
+						return bundledStrings$1[0].slice(bundledStrings$1.position0, bundledStrings$1.position0 -= value);
 				}
 				return C1; // "never-used", return special object to denote that
-			case 0xc2: return false
-			case 0xc3: return true
+			case 0xc2: return false;
+			case 0xc3: return true;
 			case 0xc4:
 				// bin 8
 				value = src[position$1++];
 				if (value === undefined)
-					throw new Error('Unexpected end of buffer')
-				return readBin(value)
+					throw new Error('Unexpected end of buffer');
+				return readBin(value);
 			case 0xc5:
 				// bin 16
 				value = dataView.getUint16(position$1);
 				position$1 += 2;
-				return readBin(value)
+				return readBin(value);
 			case 0xc6:
 				// bin 32
 				value = dataView.getUint32(position$1);
 				position$1 += 4;
-				return readBin(value)
+				return readBin(value);
 			case 0xc7:
 				// ext 8
-				return readExt(src[position$1++])
+				return readExt(src[position$1++]);
 			case 0xc8:
 				// ext 16
 				value = dataView.getUint16(position$1);
 				position$1 += 2;
-				return readExt(value)
+				return readExt(value);
 			case 0xc9:
 				// ext 32
 				value = dataView.getUint32(position$1);
 				position$1 += 4;
-				return readExt(value)
+				return readExt(value);
 			case 0xca:
 				value = dataView.getFloat32(position$1);
 				if (currentUnpackr.useFloat32 > 2) {
 					// this does rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
 					let multiplier = mult10[((src[position$1] & 0x7f) << 1) | (src[position$1 + 1] >> 7)];
 					position$1 += 4;
-					return ((multiplier * value + (value > 0 ? 0.5 : -0.5)) >> 0) / multiplier
+					return ((multiplier * value + (value > 0 ? 0.5 : -0.5)) >> 0) / multiplier;
 				}
 				position$1 += 4;
-				return value
+				return value;
 			case 0xcb:
 				value = dataView.getFloat64(position$1);
 				position$1 += 8;
-				return value
+				return value;
 			// uint handlers
 			case 0xcc:
-				return src[position$1++]
+				return src[position$1++];
 			case 0xcd:
 				value = dataView.getUint16(position$1);
 				position$1 += 2;
-				return value
+				return value;
 			case 0xce:
 				value = dataView.getUint32(position$1);
 				position$1 += 4;
-				return value
+				return value;
 			case 0xcf:
 				if (currentUnpackr.int64AsType === 'number') {
 					value = dataView.getUint32(position$1) * 0x100000000;
@@ -377,19 +376,19 @@ function read() {
 				} else
 					value = dataView.getBigUint64(position$1);
 				position$1 += 8;
-				return value
+				return value;
 
 			// int handlers
 			case 0xd0:
-				return dataView.getInt8(position$1++)
+				return dataView.getInt8(position$1++);
 			case 0xd1:
 				value = dataView.getInt16(position$1);
 				position$1 += 2;
-				return value
+				return value;
 			case 0xd2:
 				value = dataView.getInt32(position$1);
 				position$1 += 4;
-				return value
+				return value;
 			case 0xd3:
 				if (currentUnpackr.int64AsType === 'number') {
 					value = dataView.getInt32(position$1) * 0x100000000;
@@ -402,96 +401,96 @@ function read() {
 				} else
 					value = dataView.getBigInt64(position$1);
 				position$1 += 8;
-				return value
+				return value;
 
 			case 0xd4:
 				// fixext 1
 				value = src[position$1++];
 				if (value == 0x72) {
-					return recordDefinition(src[position$1++] & 0x3f)
+					return recordDefinition(src[position$1++] & 0x3f);
 				} else {
 					let extension = currentExtensions[value];
 					if (extension) {
 						if (extension.read) {
 							position$1++; // skip filler byte
-							return extension.read(read())
+							return extension.read(read());
 						} else if (extension.noBuffer) {
 							position$1++; // skip filler byte
-							return extension()
+							return extension();
 						} else
-							return extension(src.subarray(position$1, ++position$1))
+							return extension(src.subarray(position$1, ++position$1));
 					} else
-						throw new Error('Unknown extension ' + value)
+						throw new Error('Unknown extension ' + value);
 				}
 			case 0xd5:
 				// fixext 2
 				value = src[position$1];
 				if (value == 0x72) {
 					position$1++;
-					return recordDefinition(src[position$1++] & 0x3f, src[position$1++])
+					return recordDefinition(src[position$1++] & 0x3f, src[position$1++]);
 				} else
-					return readExt(2)
+					return readExt(2);
 			case 0xd6:
 				// fixext 4
-				return readExt(4)
+				return readExt(4);
 			case 0xd7:
 				// fixext 8
-				return readExt(8)
+				return readExt(8);
 			case 0xd8:
 				// fixext 16
-				return readExt(16)
+				return readExt(16);
 			case 0xd9:
 			// str 8
 				value = src[position$1++];
 				if (srcStringEnd >= position$1) {
-					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart)
+					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart);
 				}
-				return readString8(value)
+				return readString8(value);
 			case 0xda:
 			// str 16
 				value = dataView.getUint16(position$1);
 				position$1 += 2;
 				if (srcStringEnd >= position$1) {
-					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart)
+					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart);
 				}
-				return readString16(value)
+				return readString16(value);
 			case 0xdb:
 			// str 32
 				value = dataView.getUint32(position$1);
 				position$1 += 4;
 				if (srcStringEnd >= position$1) {
-					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart)
+					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart);
 				}
-				return readString32(value)
+				return readString32(value);
 			case 0xdc:
 			// array 16
 				value = dataView.getUint16(position$1);
 				position$1 += 2;
-				return readArray(value)
+				return readArray(value);
 			case 0xdd:
 			// array 32
 				value = dataView.getUint32(position$1);
 				position$1 += 4;
-				return readArray(value)
+				return readArray(value);
 			case 0xde:
 			// map 16
 				value = dataView.getUint16(position$1);
 				position$1 += 2;
-				return readMap(value)
+				return readMap(value);
 			case 0xdf:
 			// map 32
 				value = dataView.getUint32(position$1);
 				position$1 += 4;
-				return readMap(value)
+				return readMap(value);
 			default: // negative int
 				if (token >= 0xe0)
-					return token - 0x100
+					return token - 0x100;
 				if (token === undefined) {
 					let error = new Error('Unexpected end of MessagePack data');
 					error.incomplete = true;
-					throw error
+					throw error;
 				}
-				throw new Error('Unknown MessagePack token ' + token)
+				throw new Error('Unknown MessagePack token ' + token);
 
 		}
 	}
@@ -512,7 +511,7 @@ function createStructureReader(structure, firstId) {
 			}
 			if (structure.highByte === 0)
 				structure.read = createSecondByteReader(firstId, structure.read);
-			return optimizedReadObject() // second byte is already read, if there is one so immediately read object
+			return optimizedReadObject(); // second byte is already read, if there is one so immediately read object
 		}
 		let object = {};
 		for (let i = 0, l = structure.length; i < l; i++) {
@@ -523,38 +522,38 @@ function createStructureReader(structure, firstId) {
 		}
 		if (currentUnpackr.freezeData)
 			return Object.freeze(object);
-		return object
+		return object;
 	}
 	readObject.count = 0;
 	if (structure.highByte === 0) {
-		return createSecondByteReader(firstId, readObject)
+		return createSecondByteReader(firstId, readObject);
 	}
-	return readObject
+	return readObject;
 }
 
 const createSecondByteReader = (firstId, read0) => {
 	return function() {
 		let highByte = src[position$1++];
 		if (highByte === 0)
-			return read0()
+			return read0();
 		let id = firstId < 32 ? -(firstId + (highByte << 5)) : firstId + (highByte << 5);
 		let structure = currentStructures[id] || loadStructures()[id];
 		if (!structure) {
-			throw new Error('Record id is not defined for ' + id)
+			throw new Error('Record id is not defined for ' + id);
 		}
 		if (!structure.read)
 			structure.read = createStructureReader(structure, firstId);
-		return structure.read()
-	}
+		return structure.read();
+	};
 };
 
 function loadStructures() {
-	let loadedStructures = saveState$1(() => {
+	let loadedStructures = saveState(() => {
 		// save the state in case getStructures modifies our buffer
 		src = null;
-		return currentUnpackr.getStructures()
+		return currentUnpackr.getStructures();
 	});
-	return currentStructures = currentUnpackr._mergeStructures(loadedStructures, currentStructures)
+	return currentStructures = currentUnpackr._mergeStructures(loadedStructures, currentStructures);
 }
 
 var readFixedString = readStringJS;
@@ -574,7 +573,7 @@ function setExtractor(extractStrings) {
 			let string = strings[stringPosition++];
 			if (string == null) {
 				if (bundledStrings$1)
-					return readStringJS(length)
+					return readStringJS(length);
 				let byteOffset = src.byteOffset;
 				let extraction = extractStrings(position$1 - headerLength + byteOffset, srcEnd + byteOffset, src.buffer);
 				if (typeof extraction == 'string') {
@@ -586,30 +585,30 @@ function setExtractor(extractStrings) {
 					srcStringEnd = 1; // even if a utf-8 string was decoded, must indicate we are in the midst of extracted strings and can't skip strings
 					string = strings[0];
 					if (string === undefined)
-						throw new Error('Unexpected end of buffer')
+						throw new Error('Unexpected end of buffer');
 				}
 			}
 			let srcStringLength = string.length;
 			if (srcStringLength <= length) {
 				position$1 += length;
-				return string
+				return string;
 			}
 			srcString = string;
 			srcStringStart = position$1;
 			srcStringEnd = position$1 + srcStringLength;
 			position$1 += length;
-			return string.slice(0, length) // we know we just want the beginning
-		}
+			return string.slice(0, length); // we know we just want the beginning
+		};
 	}
 }
 function readStringJS(length) {
 	let result;
 	if (length < 16) {
 		if (result = shortStringInJS(length))
-			return result
+			return result;
 	}
 	if (length > 64 && decoder)
-		return decoder.decode(src.subarray(position$1, position$1 += length))
+		return decoder.decode(src.subarray(position$1, position$1 += length));
 	const end = position$1 + length;
 	const units = [];
 	result = '';
@@ -672,17 +671,7 @@ function readStringJS(length) {
 		result += fromCharCode.apply(String, units);
 	}
 
-	return result
-}
-function readString(source, start, length) {
-	let existingSrc = src;
-	src = source;
-	position$1 = start;
-	try {
-		return readStringJS(length);
-	} finally {
-		src = existingSrc;
-	}
+	return result;
 }
 
 function readArray(length) {
@@ -691,8 +680,8 @@ function readArray(length) {
 		array[i] = read();
 	}
 	if (currentUnpackr.freezeData)
-		return Object.freeze(array)
-	return array
+		return Object.freeze(array);
+	return array;
 }
 
 function readMap(length) {
@@ -704,13 +693,13 @@ function readMap(length) {
 				key = '__proto_';
 			object[key] = read();
 		}
-		return object
+		return object;
 	} else {
 		let map = new Map();
 		for (let i = 0; i < length; i++) {
 			map.set(read(), read());
 		}
-		return map
+		return map;
 	}
 }
 
@@ -722,40 +711,40 @@ function longStringInJS(length) {
 		const byte = src[position$1++];
 		if ((byte & 0x80) > 0) {
 				position$1 = start;
-				return
+				return;
 			}
 			bytes[i] = byte;
 		}
-		return fromCharCode.apply(String, bytes)
+		return fromCharCode.apply(String, bytes);
 }
 function shortStringInJS(length) {
 	if (length < 4) {
 		if (length < 2) {
 			if (length === 0)
-				return ''
+				return '';
 			else {
 				let a = src[position$1++];
 				if ((a & 0x80) > 1) {
 					position$1 -= 1;
-					return
+					return;
 				}
-				return fromCharCode(a)
+				return fromCharCode(a);
 			}
 		} else {
 			let a = src[position$1++];
 			let b = src[position$1++];
 			if ((a & 0x80) > 0 || (b & 0x80) > 0) {
 				position$1 -= 2;
-				return
+				return;
 			}
 			if (length < 3)
-				return fromCharCode(a, b)
+				return fromCharCode(a, b);
 			let c = src[position$1++];
 			if ((c & 0x80) > 0) {
 				position$1 -= 3;
-				return
+				return;
 			}
-			return fromCharCode(a, b, c)
+			return fromCharCode(a, b, c);
 		}
 	} else {
 		let a = src[position$1++];
@@ -764,34 +753,34 @@ function shortStringInJS(length) {
 		let d = src[position$1++];
 		if ((a & 0x80) > 0 || (b & 0x80) > 0 || (c & 0x80) > 0 || (d & 0x80) > 0) {
 			position$1 -= 4;
-			return
+			return;
 		}
 		if (length < 6) {
 			if (length === 4)
-				return fromCharCode(a, b, c, d)
+				return fromCharCode(a, b, c, d);
 			else {
 				let e = src[position$1++];
 				if ((e & 0x80) > 0) {
 					position$1 -= 5;
-					return
+					return;
 				}
-				return fromCharCode(a, b, c, d, e)
+				return fromCharCode(a, b, c, d, e);
 			}
 		} else if (length < 8) {
 			let e = src[position$1++];
 			let f = src[position$1++];
 			if ((e & 0x80) > 0 || (f & 0x80) > 0) {
 				position$1 -= 6;
-				return
+				return;
 			}
 			if (length < 7)
-				return fromCharCode(a, b, c, d, e, f)
+				return fromCharCode(a, b, c, d, e, f);
 			let g = src[position$1++];
 			if ((g & 0x80) > 0) {
 				position$1 -= 7;
-				return
+				return;
 			}
-			return fromCharCode(a, b, c, d, e, f, g)
+			return fromCharCode(a, b, c, d, e, f, g);
 		} else {
 			let e = src[position$1++];
 			let f = src[position$1++];
@@ -799,34 +788,34 @@ function shortStringInJS(length) {
 			let h = src[position$1++];
 			if ((e & 0x80) > 0 || (f & 0x80) > 0 || (g & 0x80) > 0 || (h & 0x80) > 0) {
 				position$1 -= 8;
-				return
+				return;
 			}
 			if (length < 10) {
 				if (length === 8)
-					return fromCharCode(a, b, c, d, e, f, g, h)
+					return fromCharCode(a, b, c, d, e, f, g, h);
 				else {
 					let i = src[position$1++];
 					if ((i & 0x80) > 0) {
 						position$1 -= 9;
-						return
+						return;
 					}
-					return fromCharCode(a, b, c, d, e, f, g, h, i)
+					return fromCharCode(a, b, c, d, e, f, g, h, i);
 				}
 			} else if (length < 12) {
 				let i = src[position$1++];
 				let j = src[position$1++];
 				if ((i & 0x80) > 0 || (j & 0x80) > 0) {
 					position$1 -= 10;
-					return
+					return;
 				}
 				if (length < 11)
-					return fromCharCode(a, b, c, d, e, f, g, h, i, j)
+					return fromCharCode(a, b, c, d, e, f, g, h, i, j);
 				let k = src[position$1++];
 				if ((k & 0x80) > 0) {
 					position$1 -= 11;
-					return
+					return;
 				}
-				return fromCharCode(a, b, c, d, e, f, g, h, i, j, k)
+				return fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
 			} else {
 				let i = src[position$1++];
 				let j = src[position$1++];
@@ -834,34 +823,34 @@ function shortStringInJS(length) {
 				let l = src[position$1++];
 				if ((i & 0x80) > 0 || (j & 0x80) > 0 || (k & 0x80) > 0 || (l & 0x80) > 0) {
 					position$1 -= 12;
-					return
+					return;
 				}
 				if (length < 14) {
 					if (length === 12)
-						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l)
+						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l);
 					else {
 						let m = src[position$1++];
 						if ((m & 0x80) > 0) {
 							position$1 -= 13;
-							return
+							return;
 						}
-						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m)
+						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
 					}
 				} else {
 					let m = src[position$1++];
 					let n = src[position$1++];
 					if ((m & 0x80) > 0 || (n & 0x80) > 0) {
 						position$1 -= 14;
-						return
+						return;
 					}
 					if (length < 15)
-						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n)
+						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
 					let o = src[position$1++];
 					if ((o & 0x80) > 0) {
 						position$1 -= 15;
-						return
+						return;
 					}
-					return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
+					return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
 				}
 			}
 		}
@@ -879,22 +868,22 @@ function readOnlyJSString() {
 			case 0xd9:
 			// str 8
 				length = src[position$1++];
-				break
+				break;
 			case 0xda:
 			// str 16
 				length = dataView.getUint16(position$1);
 				position$1 += 2;
-				break
+				break;
 			case 0xdb:
 			// str 32
 				length = dataView.getUint32(position$1);
 				position$1 += 4;
-				break
+				break;
 			default:
-				throw new Error('Expected string')
+				throw new Error('Expected string');
 		}
 	}
-	return readStringJS(length)
+	return readStringJS(length);
 }
 
 
@@ -902,7 +891,7 @@ function readBin(length) {
 	return currentUnpackr.copyBuffers ?
 		// specifically use the copying slice (not the node one)
 		Uint8Array.prototype.slice.call(src, position$1, position$1 += length) :
-		src.subarray(position$1, position$1 += length)
+		src.subarray(position$1, position$1 += length);
 }
 function readExt(length) {
 	let type = src[position$1++];
@@ -915,10 +904,10 @@ function readExt(length) {
 			} finally {
 				position$1 = end;
 			}
-		})
+		});
 	}
 	else
-		throw new Error('Unknown extension type ' + type)
+		throw new Error('Unknown extension type ' + type);
 }
 
 var keyCache = new Array(4096);
@@ -928,12 +917,12 @@ function readKey() {
 		// fixstr, potentially use key cache
 		length = length - 0xa0;
 		if (srcStringEnd >= position$1) // if it has been extracted, must use it (and faster anyway)
-			return srcString.slice(position$1 - srcStringStart, (position$1 += length) - srcStringStart)
+			return srcString.slice(position$1 - srcStringStart, (position$1 += length) - srcStringStart);
 		else if (!(srcStringEnd == 0 && srcEnd < 180))
-			return readFixedString(length)
+			return readFixedString(length);
 	} else { // not cacheable, go back and do a standard read
 		position$1--;
-		return asSafeString(read())
+		return asSafeString(read());
 	}
 	let key = ((length << 5) ^ (length > 1 ? dataView.getUint16(position$1) : length > 0 ? src[position$1] : 0)) & 0xfff;
 	let entry = keyCache[key];
@@ -946,7 +935,7 @@ function readKey() {
 			chunk = dataView.getUint32(checkPosition);
 			if (chunk != entry[i++]) {
 				checkPosition = 0x70000000;
-				break
+				break;
 			}
 			checkPosition += 4;
 		}
@@ -955,12 +944,12 @@ function readKey() {
 			chunk = src[checkPosition++];
 			if (chunk != entry[i++]) {
 				checkPosition = 0x70000000;
-				break
+				break;
 			}
 		}
 		if (checkPosition === end) {
 			position$1 = checkPosition;
-			return entry.string
+			return entry.string;
 		}
 		end -= 3;
 		checkPosition = position$1;
@@ -981,8 +970,8 @@ function readKey() {
 	// for small blocks, avoiding the overhead of the extract call is helpful
 	let string = length < 16 ? shortStringInJS(length) : longStringInJS(length);
 	if (string != null)
-		return entry.string = string
-	return entry.string = readFixedString(length)
+		return entry.string = string;
+	return entry.string = readFixedString(length);
 }
 
 function asSafeString(property) {
@@ -1013,7 +1002,7 @@ const recordDefinition = (id, highByte) => {
 	}
 	currentStructures[id] = structure;
 	structure.read = createStructureReader(structure, firstByte);
-	return structure.read()
+	return structure.read();
 };
 currentExtensions[0] = () => {}; // notepack defines extension 0 to mean undefined, so use that as the default here
 currentExtensions[0].noBuffer = true;
@@ -1035,17 +1024,17 @@ currentExtensions[0x42] = data => {
 					out <<= BigInt(64);
 					out |= view.getBigUint64(i);
 				}
-				return out
+				return out;
 			}
 			// if (length === 8) return view.getBigUint64(start)
 			let middle = start + (length >> 4 << 3);
 			let left = decode(start, middle);
 			let right = decode(middle, end);
-			return (left << BigInt((end - middle) * 8)) | right
+			return (left << BigInt((end - middle) * 8)) | right;
 		};
 		head = (head << BigInt((view.byteLength - headLength) * 8)) | decode(headLength, view.byteLength);
 	}
-	return head
+	return head;
 };
 
 let errors = {
@@ -1056,14 +1045,14 @@ currentExtensions[0x65] = () => {
 	if (!errors[data[0]]) {
 		let error = Error(data[1], { cause: data[2] });
 		error.name = data[0];
-		return error
+		return error;
 	}
-	return errors[data[0]](data[1], { cause: data[2] })
+	return errors[data[0]](data[1], { cause: data[2] });
 };
 
 currentExtensions[0x69] = (data) => {
 	// id extension (for structured clones)
-	if (currentUnpackr.structuredClone === false) throw new Error('Structured clone extension is disabled')
+	if (currentUnpackr.structuredClone === false) throw new Error('Structured clone extension is disabled');
 	let id = dataView.getUint32(position$1 - 4);
 	if (!referenceMap)
 		referenceMap = new Map();
@@ -1084,7 +1073,7 @@ currentExtensions[0x69] = (data) => {
 	let targetProperties = read(); // read the next value as the target object to id
 	if (!refEntry.used) {
 		// no cycle, can just use the returned read object
-		return refEntry.target = targetProperties // replace the placeholder with the real one
+		return refEntry.target = targetProperties; // replace the placeholder with the real one
 	} else {
 		// there is a cycle, so we have to assign properties to original target
 		Object.assign(target, targetProperties);
@@ -1095,16 +1084,16 @@ currentExtensions[0x69] = (data) => {
 		for (let [k, v] of targetProperties.entries()) target.set(k, v);
 	if (target instanceof Set)
 		for (let i of Array.from(targetProperties)) target.add(i);
-	return target
+	return target;
 };
 
 currentExtensions[0x70] = (data) => {
 	// pointer extension (for structured clones)
-	if (currentUnpackr.structuredClone === false) throw new Error('Structured clone extension is disabled')
+	if (currentUnpackr.structuredClone === false) throw new Error('Structured clone extension is disabled');
 	let id = dataView.getUint32(position$1 - 4);
 	let refEntry = referenceMap.get(id);
 	refEntry.used = true;
-	return refEntry.target
+	return refEntry.target;
 };
 
 currentExtensions[0x73] = () => new Set(read());
@@ -1119,15 +1108,15 @@ currentExtensions[0x74] = (data) => {
 
 	let typedArrayName = typedArrays[typeCode];
 	if (!typedArrayName) {
-		if (typeCode === 16) return buffer
-		if (typeCode === 17) return new DataView(buffer)
-		throw new Error('Could not find typed array for code ' + typeCode)
+		if (typeCode === 16) return buffer;
+		if (typeCode === 17) return new DataView(buffer);
+		throw new Error('Could not find typed array for code ' + typeCode);
 	}
-	return new glbl[typedArrayName](buffer)
+	return new glbl[typedArrayName](buffer);
 };
 currentExtensions[0x78] = () => {
 	let data = read();
-	return new RegExp(data[0], data[1])
+	return new RegExp(data[0], data[1]);
 };
 const TEMP_BUNDLE = [];
 currentExtensions[0x62] = (data) => {
@@ -1140,30 +1129,30 @@ currentExtensions[0x62] = (data) => {
 	bundledStrings$1.position1 = 0;
 	bundledStrings$1.postBundlePosition = position$1;
 	position$1 = dataPosition;
-	return read()
+	return read();
 };
 
 currentExtensions[0xff] = (data) => {
 	// 32-bit date extension
 	if (data.length == 4)
-		return new Date((data[0] * 0x1000000 + (data[1] << 16) + (data[2] << 8) + data[3]) * 1000)
+		return new Date((data[0] * 0x1000000 + (data[1] << 16) + (data[2] << 8) + data[3]) * 1000);
 	else if (data.length == 8)
 		return new Date(
 			((data[0] << 22) + (data[1] << 14) + (data[2] << 6) + (data[3] >> 2)) / 1000000 +
-			((data[3] & 0x3) * 0x100000000 + data[4] * 0x1000000 + (data[5] << 16) + (data[6] << 8) + data[7]) * 1000)
+			((data[3] & 0x3) * 0x100000000 + data[4] * 0x1000000 + (data[5] << 16) + (data[6] << 8) + data[7]) * 1000);
 	else if (data.length == 12)
 		return new Date(
 			((data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3]) / 1000000 +
-			(((data[4] & 0x80) ? -0x1000000000000 : 0) + data[6] * 0x10000000000 + data[7] * 0x100000000 + data[8] * 0x1000000 + (data[9] << 16) + (data[10] << 8) + data[11]) * 1000)
+			(((data[4] & 0x80) ? -0x1000000000000 : 0) + data[6] * 0x10000000000 + data[7] * 0x100000000 + data[8] * 0x1000000 + (data[9] << 16) + (data[10] << 8) + data[11]) * 1000);
 	else
-		return new Date('invalid')
+		return new Date('invalid');
 };
 // registration of bulk record definition?
 // currentExtensions[0x52] = () =>
 
-function saveState$1(callback) {
-	if (onSaveState)
-		onSaveState();
+function saveState(callback) {
+	if (currentUnpackr && currentUnpackr._onSaveState)
+		currentUnpackr._onSaveState();
 	let savedSrcEnd = srcEnd;
 	let savedPosition = position$1;
 	let savedStringPosition = stringPosition;
@@ -1196,7 +1185,7 @@ function saveState$1(callback) {
 	currentStructures.splice(0, currentStructures.length, ...savedStructuresContents);
 	currentUnpackr = savedPackr;
 	dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
-	return value
+	return value;
 }
 function clearSource() {
 	src = null;
@@ -1231,30 +1220,28 @@ let u8Array = new Uint8Array(f32Array.buffer, 0, 4);
 function roundFloat32(float32Number) {
 	f32Array[0] = float32Number;
 	let multiplier = mult10[((u8Array[3] & 0x7f) << 1) | (u8Array[2] >> 7)];
-	return ((multiplier * float32Number + (float32Number > 0 ? 0.5 : -0.5)) >> 0) / multiplier
-}
-function setReadStruct(updatedReadStruct, loadedStructs, saveState) {
-	readStruct$1 = updatedReadStruct;
-	onLoadedStructures$1 = loadedStructs;
-	onSaveState = saveState;
+	return ((multiplier * float32Number + (float32Number > 0 ? 0.5 : -0.5)) >> 0) / multiplier;
 }
+// Marker for downstream libraries (e.g. structon) to detect per-instance
+// struct-decoding hooks (this._readStruct, this._onLoadedStructures,
+// this._onSaveState).  See `checkedRead` for the dispatch.
+Unpackr.SUPPORTS_STRUCT_HOOKS = true;
 
-let textEncoder$1;
+let textEncoder;
 try {
-	textEncoder$1 = new TextEncoder();
+	textEncoder = new TextEncoder();
 } catch (error) {}
 let extensions, extensionClasses;
-const hasNodeBuffer$1 = typeof Buffer !== 'undefined';
-const ByteArrayAllocate = hasNodeBuffer$1 ?
-	function(length) { return Buffer.allocUnsafeSlow(length) } : Uint8Array;
-const ByteArray = hasNodeBuffer$1 ? Buffer : Uint8Array;
-const MAX_BUFFER_SIZE = hasNodeBuffer$1 ? 0x100000000 : 0x7fd00000;
+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]/;
 const RECORD_SYMBOL = Symbol('record-id');
@@ -1267,10 +1254,10 @@ class Packr extends Unpackr {
 		let structures;
 		let referenceMap;
 		let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position) {
-			return target.utf8Write(string, position, target.byteLength - position)
-		} : (textEncoder$1 && textEncoder$1.encodeInto) ?
+			return target.utf8Write(string, position, target.byteLength - position);
+		} : (textEncoder && textEncoder.encodeInto) ?
 			function(string, position) {
-				return textEncoder$1.encodeInto(string, target.subarray(position)).written
+				return textEncoder.encodeInto(string, target.subarray(position)).written;
 			} : false;
 
 		let packr = this;
@@ -1282,7 +1269,7 @@ class Packr extends Unpackr {
 		if (maxSharedStructures == null)
 			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;
 		}
@@ -1296,7 +1283,7 @@ class Packr extends Unpackr {
 		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;
@@ -1332,7 +1319,7 @@ class Packr extends Unpackr {
 				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
@@ -1340,7 +1327,7 @@ class Packr extends Unpackr {
 					for (let i = 0; i < sharedLength; i++) {
 						let keys = structures[i];
 						if (!keys)
-							continue
+							continue;
 						let nextTransition, transition = structures.transitions;
 						for (let j = 0, l = keys.length; j < l; j++) {
 							let key = keys[j];
@@ -1362,7 +1349,7 @@ class Packr extends Unpackr {
 				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)
@@ -1406,15 +1393,15 @@ class Packr extends Unpackr {
 					packr.offset = position;
 					let serialized = insertIds(target.subarray(start, position), idsToInsert);
 					referenceMap = null;
-					return serialized
+					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
 				if (encodeOptions & REUSE_BUFFER_MODE) {
 					target.start = start;
 					target.end = position;
-					return target
+					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;
@@ -1425,16 +1412,16 @@ class Packr extends Unpackr {
 						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$1(structures, packr);
+						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;
 							// don't keep large buffers around
 							if (target.length > 0x40000000) target = null;
-							return returnBuffer
+							return returnBuffer;
 						}
 					}
 				}
@@ -1520,7 +1507,7 @@ class Packr extends Unpackr {
 					bundledStrings[twoByte ? 0 : 1] += value;
 					target[position++] = 0xc1;
 					pack(twoByte ? -strLength : strLength);
-					return
+					return;
 				}
 				let headerSize;
 				// first we estimate the header size, so we can write to the correct location
@@ -1594,7 +1581,7 @@ class Packr extends Unpackr {
 			} 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)) {
+					if (value < 0x20 || (value < 0x80 && this.useRecords === false) || (value < 0x40 && !this._writeStruct)) {
 						target[position++] = value;
 					} else if (value < 0x100) {
 						target[position++] = 0xcc;
@@ -1633,7 +1620,7 @@ class Packr extends Unpackr {
 								// 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
+							return;
 						} else
 							position--; // move back into position for writing a double
 					}
@@ -1656,7 +1643,7 @@ class Packr extends Unpackr {
 							target[position++] = 0x70; // "p" for pointer
 							targetView.setUint32(position, referee.id);
 							position += 4;
-							return
+							return;
 						} else
 							referenceMap.set(value, { offset: position - start });
 					}
@@ -1706,7 +1693,7 @@ class Packr extends Unpackr {
 									} else {
 										pack(writeResult);
 									}
-									return
+									return;
 								}
 								let currentTarget = target;
 								let currentTargetView = targetView;
@@ -1723,7 +1710,7 @@ class Packr extends Unpackr {
 											makeRoom(position);
 										return {
 											target, targetView, position: position - size
-										}
+										};
 									}, pack);
 								} finally {
 									// restore current target information (unless already restored)
@@ -1739,7 +1726,7 @@ class Packr extends Unpackr {
 										makeRoom(result.length + position);
 									position = writeExtensionData(result, target, position, extension.type);
 								}
-								return
+								return;
 							}
 						}
 						// check isArray after extensions, because extensions can extend Array
@@ -1751,7 +1738,7 @@ class Packr extends Unpackr {
 								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
@@ -1790,7 +1777,7 @@ class Packr extends Unpackr {
 							let chunks = [];
 							while (true) {
 								chunks.push(value & mask);
-								if ((value >> BigInt(63)) === empty) break
+								if ((value >> BigInt(63)) === empty) break;
 								value >>= BigInt(64);
 							}
 
@@ -1805,7 +1792,7 @@ class Packr extends Unpackr {
 								string = '00' + string;
 							}
 
-							if (hasNodeBuffer$1) {
+							if (hasNodeBuffer) {
 								array = Buffer.from(string, 'hex');
 							} else {
 								array = new Uint8Array(string.length / 2);
@@ -1822,11 +1809,11 @@ class Packr extends Unpackr {
 						if (array.length + position > safeEnd)
 							makeRoom(array.length + position);
 						position = writeExtensionData(array, target, position, 0x42);
-						return
+						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;
@@ -1839,7 +1826,7 @@ class Packr extends Unpackr {
 					target[position++] = 0;
 				}
 			} else {
-				throw new Error('Unknown type: ' + type)
+				throw new Error('Unknown type: ' + type);
 			}
 		};
 
@@ -1985,12 +1972,30 @@ class Packr extends Unpackr {
 			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;
 			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);
 			} else // faster handling for smaller buffers
@@ -2005,7 +2010,7 @@ class Packr extends Unpackr {
 			position -= start;
 			start = 0;
 			safeEnd = newBuffer.length - 10;
-			return target = newBuffer
+			return target = newBuffer;
 		};
 		const newRecord = (transition, keys, newTransitions) => {
 			let recordId = structures.nextId;
@@ -2087,23 +2092,6 @@ class Packr extends Unpackr {
 				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
@@ -2146,7 +2134,7 @@ extensions = [{
 		} else if (isNaN(seconds)) {
 			if (this.onInvalidDate) {
 				allocateForWrite(0);
-				return pack(this.onInvalidDate())
+				return pack(this.onInvalidDate());
 			}
 			// Intentionally invalid timestamp
 			let { target, targetView, position} = allocateForWrite(3);
@@ -2167,7 +2155,7 @@ extensions = [{
 	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);
@@ -2203,7 +2191,7 @@ extensions = [{
 		if (this.moreTypes)
 			writeExtBuffer(arrayBuffer, 0x10, allocateForWrite);
 		else
-			writeBuffer(hasNodeBuffer$1 ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
+			writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
 	}
 }, {
 	pack(typedArray, allocateForWrite) {
@@ -2218,7 +2206,7 @@ extensions = [{
 		if (this.moreTypes)
 			writeExtBuffer(arrayBuffer, 0x11, allocateForWrite);
 		else
-			writeBuffer(hasNodeBuffer$1 ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
+			writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
 	}
 }, {
 	pack(c1, allocateForWrite) { // specific 0xC1 object
@@ -2275,19 +2263,19 @@ function writeExtensionData(result, target, position, type) {
 	switch (length) {
 		case 1:
 			target[position++] = 0xd4;
-			break
+			break;
 		case 2:
 			target[position++] = 0xd5;
-			break
+			break;
 		case 4:
 			target[position++] = 0xd6;
-			break
+			break;
 		case 8:
 			target[position++] = 0xd7;
-			break
+			break;
 		case 16:
 			target[position++] = 0xd8;
-			break
+			break;
 		default:
 			if (length < 0x100) {
 				target[position++] = 0xc7;
@@ -2307,7 +2295,7 @@ function writeExtensionData(result, target, position, type) {
 	target[position++] = type;
 	target.set(result, position);
 	position += length;
-	return position
+	return position;
 }
 
 function insertIds(serialized, idsToInsert) {
@@ -2329,7 +2317,7 @@ function insertIds(serialized, idsToInsert) {
 		serialized[position++] = id & 0xff;
 		lastEnd = offset;
 	}
-	return serialized
+	return serialized;
 }
 
 function writeBundles(start, pack, incrementPosition) {
@@ -2346,28 +2334,29 @@ function writeBundles(start, pack, incrementPosition) {
 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)')
+			throw new Error('Extension has no type (numeric code to identify the extension)');
 		extensionClasses.unshift(extension.Class);
 		extensions.unshift(extension);
 	}
 	addExtension$1(extension);
 }
-function prepareStructures$1(structures, packr) {
+function prepareStructures(structures, packr) {
 	structures.isCompatible = (existingStructures) => {
 		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
-}
-function setWriteStructSlots(writeSlots, makeStructures) {
-	writeStructSlots = writeSlots;
-	prepareStructures$1 = makeStructures;
+	return structures;
 }
 
+// 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 });
 const pack = defaultPackr.pack;
 const encode = defaultPackr.pack;
@@ -2377,779 +2366,6 @@ const REUSE_BUFFER_MODE = 512;
 const RESET_BUFFER_MODE = 1024;
 const RESERVE_START_SPACE = 2048;
 
-const ASCII = 3; // the MIBenum from https://www.iana.org/assignments/character-sets/character-sets.xhtml (and other character encodings could be referenced by MIBenum)
-const NUMBER = 0;
-const UTF8 = 2;
-const OBJECT_DATA = 1;
-const DATE = 16;
-const TYPE_NAMES = ['num', 'object', 'string', 'ascii'];
-TYPE_NAMES[DATE] = 'date';
-const float32Headers = [false, true, true, false, false, true, true, false];
-let evalSupported;
-try {
-	new Function('');
-	evalSupported = true;
-} catch(error) {
-	// if eval variants are not supported, do not create inline object readers ever
-}
-
-let updatedPosition;
-const hasNodeBuffer = typeof Buffer !== 'undefined';
-let textEncoder, currentSource;
-try {
-	textEncoder = new TextEncoder();
-} catch (error) {}
-const encodeUtf8 = hasNodeBuffer ? function(target, string, position) {
-	return target.utf8Write(string, position, target.byteLength - position)
-} : (textEncoder && textEncoder.encodeInto) ?
-	function(target, string, position) {
-		return textEncoder.encodeInto(string, target.subarray(position)).written
-	} : false;
-setWriteStructSlots(writeStruct, prepareStructures);
-function writeStruct(object, target, encodingStart, position, structures, makeRoom, pack, packr) {
-	let typedStructs = packr.typedStructs || (packr.typedStructs = []);
-	// note that we rely on pack.js to load stored structures before we get to this point
-	let targetView = target.dataView;
-	let refsStartPosition = (typedStructs.lastStringStart || 100) + position;
-	let safeEnd = target.length - 10;
-	let start = position;
-	if (position > safeEnd) {
-		target = makeRoom(position);
-		targetView = target.dataView;
-		position -= encodingStart;
-		start -= encodingStart;
-		refsStartPosition -= encodingStart;
-		encodingStart = 0;
-		safeEnd = target.length - 10;
-	}
-
-	let refOffset, refPosition = refsStartPosition;
-
-	let transition = typedStructs.transitions || (typedStructs.transitions = Object.create(null));
-	let nextId = typedStructs.nextId || typedStructs.length;
-	let headerSize =
-		nextId < 0xf ? 1 :
-			nextId < 0xf0 ? 2 :
-				nextId < 0xf000 ? 3 :
-					nextId < 0xf00000 ? 4 : 0;
-	if (headerSize === 0)
-		return 0;
-	position += headerSize;
-	let queuedReferences = [];
-	let usedAscii0;
-	let keyIndex = 0;
-	for (let key in object) {
-		let value = object[key];
-		let nextTransition = transition[key];
-		if (!nextTransition) {
-			transition[key] = nextTransition = {
-				key,
-				parent: transition,
-				enumerationOffset: 0,
-				ascii0: null,
-				ascii8: null,
-				num8: null,
-				string16: null,
-				object16: null,
-				num32: null,
-				float64: null,
-				date64: null
-			};
-		}
-		if (position > safeEnd) {
-			target = makeRoom(position);
-			targetView = target.dataView;
-			position -= encodingStart;
-			start -= encodingStart;
-			refsStartPosition -= encodingStart;
-			refPosition -= encodingStart;
-			encodingStart = 0;
-			safeEnd = target.length - 10;
-		}
-		switch (typeof value) {
-			case 'number':
-				let number = value;
-				// first check to see if we are using a lot of ids and should default to wide/common format
-				if (nextId < 200 || !nextTransition.num64) {
-					if (number >> 0 === number && number < 0x20000000 && number > -0x1f000000) {
-						if (number < 0xf6 && number >= 0 && (nextTransition.num8 && !(nextId > 200 && nextTransition.num32) || number < 0x20 && !nextTransition.num32)) {
-							transition = nextTransition.num8 || createTypeTransition(nextTransition, NUMBER, 1);
-							target[position++] = number;
-						} else {
-							transition = nextTransition.num32 || createTypeTransition(nextTransition, NUMBER, 4);
-							targetView.setUint32(position, number, true);
-							position += 4;
-						}
-						break;
-					} else if (number < 0x100000000 && number >= -0x80000000) {
-						targetView.setFloat32(position, number, true);
-						if (float32Headers[target[position + 3] >>> 5]) {
-							let xShifted;
-							// this checks for rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
-							if (((xShifted = number * mult10[((target[position + 3] & 0x7f) << 1) | (target[position + 2] >> 7)]) >> 0) === xShifted) {
-								transition = nextTransition.num32 || createTypeTransition(nextTransition, NUMBER, 4);
-								position += 4;
-								break;
-							}
-						}
-					}
-				}
-				transition = nextTransition.num64 || createTypeTransition(nextTransition, NUMBER, 8);
-				targetView.setFloat64(position, number, true);
-				position += 8;
-				break;
-			case 'string':
-				let strLength = value.length;
-				refOffset = refPosition - refsStartPosition;
-				if ((strLength << 2) + refPosition > safeEnd) {
-					target = makeRoom((strLength << 2) + refPosition);
-					targetView = target.dataView;
-					position -= encodingStart;
-					start -= encodingStart;
-					refsStartPosition -= encodingStart;
-					refPosition -= encodingStart;
-					encodingStart = 0;
-					safeEnd = target.length - 10;
-				}
-				if (strLength > ((0xff00 + refOffset) >> 2)) {
-					queuedReferences.push(key, value, position - start);
-					break;
-				}
-				let isNotAscii;
-				let strStart = refPosition;
-				if (strLength < 0x40) {
-					let i, c1, c2;
-					for (i = 0; i < strLength; i++) {
-						c1 = value.charCodeAt(i);
-						if (c1 < 0x80) {
-							target[refPosition++] = c1;
-						} else if (c1 < 0x800) {
-							isNotAscii = true;
-							target[refPosition++] = c1 >> 6 | 0xc0;
-							target[refPosition++] = c1 & 0x3f | 0x80;
-						} else if (
-							(c1 & 0xfc00) === 0xd800 &&
-							((c2 = value.charCodeAt(i + 1)) & 0xfc00) === 0xdc00
-						) {
-							isNotAscii = true;
-							c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
-							i++;
-							target[refPosition++] = c1 >> 18 | 0xf0;
-							target[refPosition++] = c1 >> 12 & 0x3f | 0x80;
-							target[refPosition++] = c1 >> 6 & 0x3f | 0x80;
-							target[refPosition++] = c1 & 0x3f | 0x80;
-						} else {
-							isNotAscii = true;
-							target[refPosition++] = c1 >> 12 | 0xe0;
-							target[refPosition++] = c1 >> 6 & 0x3f | 0x80;
-							target[refPosition++] = c1 & 0x3f | 0x80;
-						}
-					}
-				} else {
-					refPosition += encodeUtf8(target, value, refPosition);
-					isNotAscii = refPosition - strStart > strLength;
-				}
-				if (refOffset < 0xa0 || (refOffset < 0xf6 && (nextTransition.ascii8 || nextTransition.string8))) {
-					// short strings
-					if (isNotAscii) {
-						if (!(transition = nextTransition.string8)) {
-							if (typedStructs.length > 10 && (transition = nextTransition.ascii8)) {
-								// we can safely change ascii to utf8 in place since they are compatible
-								transition.__type = UTF8;
-								nextTransition.ascii8 = null;
-								nextTransition.string8 = transition;
-								pack(null, 0, true); // special call to notify that structures have been updated
-							} else {
-								transition = createTypeTransition(nextTransition, UTF8, 1);
-							}
-						}
-					} else if (refOffset === 0 && !usedAscii0) {
-						usedAscii0 = true;
-						transition = nextTransition.ascii0 || createTypeTransition(nextTransition, ASCII, 0);
-						break; // don't increment position
-					}// else ascii:
-					else if (!(transition = nextTransition.ascii8) && !(typedStructs.length > 10 && (transition = nextTransition.string8)))
-						transition = createTypeTransition(nextTransition, ASCII, 1);
-					target[position++] = refOffset;
-				} else {
-					// TODO: Enable ascii16 at some point, but get the logic right
-					//if (isNotAscii)
-						transition = nextTransition.string16 || createTypeTransition(nextTransition, UTF8, 2);
-					//else
-						//transition = nextTransition.ascii16 || createTypeTransition(nextTransition, ASCII, 2);
-					targetView.setUint16(position, refOffset, true);
-					position += 2;
-				}
-				break;
-			case 'object':
-				if (value) {
-					if (value.constructor === Date) {
-						transition = nextTransition.date64 || createTypeTransition(nextTransition, DATE, 8);
-						targetView.setFloat64(position, value.getTime(), true);
-						position += 8;
-					} else {
-						queuedReferences.push(key, value, keyIndex);
-					}
-					break;
-				} else { // null
-					nextTransition = anyType(nextTransition, position, targetView, -10); // match CBOR with this
-					if (nextTransition) {
-						transition = nextTransition;
-						position = updatedPosition;
-					} else queuedReferences.push(key, value, keyIndex);
-				}
-				break;
-			case 'boolean':
-				transition = nextTransition.num8 || nextTransition.ascii8 || createTypeTransition(nextTransition, NUMBER, 1);
-				target[position++] = value ? 0xf9 : 0xf8; // match CBOR with these
-				break;
-			case 'undefined':
-				nextTransition = anyType(nextTransition, position, targetView, -9); // match CBOR with this
-				if (nextTransition) {
-					transition = nextTransition;
-					position = updatedPosition;
-				} else queuedReferences.push(key, value, keyIndex);
-				break;
-			default:
-				queuedReferences.push(key, value, keyIndex);
-		}
-		keyIndex++;
-	}
-
-	for (let i = 0, l = queuedReferences.length; i < l;) {
-		let key = queuedReferences[i++];
-		let value = queuedReferences[i++];
-		let propertyIndex = queuedReferences[i++];
-		let nextTransition = transition[key];
-		if (!nextTransition) {
-			transition[key] = nextTransition = {
-				key,
-				parent: transition,
-				enumerationOffset: propertyIndex - keyIndex,
-				ascii0: null,
-				ascii8: null,
-				num8: null,
-				string16: null,
-				object16: null,
-				num32: null,
-				float64: null
-			};
-		}
-		let newPosition;
-		if (value) {
-			/*if (typeof value === 'string') { // TODO: we could re-enable long strings
-				if (position + value.length * 3 > safeEnd) {
-					target = makeRoom(position + value.length * 3);
-					position -= start;
-					targetView = target.dataView;
-					start = 0;
-				}
-				newPosition = position + target.utf8Write(value, position, 0xffffffff);
-			} else { */
-			let size;
-			refOffset = refPosition - refsStartPosition;
-			if (refOffset < 0xff00) {
-				transition = nextTransition.object16;
-				if (transition)
-					size = 2;
-				else if ((transition = nextTransition.object32))
-					size = 4;
-				else {
-					transition = createTypeTransition(nextTransition, OBJECT_DATA, 2);
-					size = 2;
-				}
-			} else {
-				transition = nextTransition.object32 || createTypeTransition(nextTransition, OBJECT_DATA, 4);
-				size = 4;
-			}
-			newPosition = pack(value, refPosition);
-			//}
-			if (typeof newPosition === 'object') {
-				// re-allocated
-				refPosition = newPosition.position;
-				targetView = newPosition.targetView;
-				target = newPosition.target;
-				refsStartPosition -= encodingStart;
-				position -= encodingStart;
-				start -= encodingStart;
-				encodingStart = 0;
-			} else
-				refPosition = newPosition;
-			if (size === 2) {
-				targetView.setUint16(position, refOffset, true);
-				position += 2;
-			} else {
-				targetView.setUint32(position, refOffset, true);
-				position += 4;
-			}
-		} else { // null or undefined
-			transition = nextTransition.object16 || createTypeTransition(nextTransition, OBJECT_DATA, 2);
-			targetView.setInt16(position, value === null ? -10 : -9, true);
-			position += 2;
-		}
-		keyIndex++;
-	}
-
-
-	let recordId = transition[RECORD_SYMBOL];
-	if (recordId == null) {
-		recordId = packr.typedStructs.length;
-		let structure = [];
-		let nextTransition = transition;
-		let key, type;
-		while ((type = nextTransition.__type) !== undefined) {
-			let size = nextTransition.__size;
-			nextTransition = nextTransition.__parent;
-			key = nextTransition.key;
-			let property = [type, size, key];
-			if (nextTransition.enumerationOffset)
-				property.push(nextTransition.enumerationOffset);
-			structure.push(property);
-			nextTransition = nextTransition.parent;
-		}
-		structure.reverse();
-		transition[RECORD_SYMBOL] = recordId;
-		packr.typedStructs[recordId] = structure;
-		pack(null, 0, true); // special call to notify that structures have been updated
-	}
-
-
-	switch (headerSize) {
-		case 1:
-			if (recordId >= 0x10) return 0;
-			target[start] = recordId + 0x20;
-			break;
-		case 2:
-			if (recordId >= 0x100) return 0;
-			target[start] = 0x38;
-			target[start + 1] = recordId;
-			break;
-		case 3:
-			if (recordId >= 0x10000) return 0;
-			target[start] = 0x39;
-			targetView.setUint16(start + 1, recordId, true);
-			break;
-		case 4:
-			if (recordId >= 0x1000000) return 0;
-			targetView.setUint32(start, (recordId << 8) + 0x3a, true);
-			break;
-	}
-
-	if (position < refsStartPosition) {
-		if (refsStartPosition === refPosition)
-			return position; // no refs
-		// adjust positioning
-		target.copyWithin(position, refsStartPosition, refPosition);
-		refPosition += position - refsStartPosition;
-		typedStructs.lastStringStart = position - start;
-	} else if (position > refsStartPosition) {
-		if (refsStartPosition === refPosition)
-			return position; // no refs
-		typedStructs.lastStringStart = position - start;
-		return writeStruct(object, target, encodingStart, start, structures, makeRoom, pack, packr);
-	}
-	return refPosition;
-}
-function anyType(transition, position, targetView, value) {
-	let nextTransition;
-	if ((nextTransition = transition.ascii8 || transition.num8)) {
-		targetView.setInt8(position, value, true);
-		updatedPosition = position + 1;
-		return nextTransition;
-	}
-	if ((nextTransition = transition.string16 || transition.object16)) {
-		targetView.setInt16(position, value, true);
-		updatedPosition = position + 2;
-		return nextTransition;
-	}
-	if (nextTransition = transition.num32) {
-		targetView.setUint32(position, 0xe0000100 + value, true);
-		updatedPosition = position + 4;
-		return nextTransition;
-	}
-	// transition.float64
-	if (nextTransition = transition.num64) {
-		targetView.setFloat64(position, NaN, true);
-		targetView.setInt8(position, value);
-		updatedPosition = position + 8;
-		return nextTransition;
-	}
-	updatedPosition = position;
-	// TODO: can we do an "any" type where we defer the decision?
-	return;
-}
-function createTypeTransition(transition, type, size) {
-	let typeName = TYPE_NAMES[type] + (size << 3);
-	let newTransition = transition[typeName] || (transition[typeName] = Object.create(null));
-	newTransition.__type = type;
-	newTransition.__size = size;
-	newTransition.__parent = transition;
-	return newTransition;
-}
-function onLoadedStructures(sharedData) {
-	if (!(sharedData instanceof Map))
-		return sharedData;
-	let typed = sharedData.get('typed') || [];
-	if (Object.isFrozen(typed))
-		typed = typed.map(structure => structure.slice(0));
-	let named = sharedData.get('named');
-	let transitions = Object.create(null);
-	for (let i = 0, l = typed.length; i < l; i++) {
-		let structure = typed[i];
-		let transition = transitions;
-		for (let [type, size, key] of structure) {
-			let nextTransition = transition[key];
-			if (!nextTransition) {
-				transition[key] = nextTransition = {
-					key,
-					parent: transition,
-					enumerationOffset: 0,
-					ascii0: null,
-					ascii8: null,
-					num8: null,
-					string16: null,
-					object16: null,
-					num32: null,
-					float64: null,
-					date64: null,
-				};
-			}
-			transition = createTypeTransition(nextTransition, type, size);
-		}
-		transition[RECORD_SYMBOL] = i;
-	}
-	typed.transitions = transitions;
-	this.typedStructs = typed;
-	this.lastTypedStructuresLength = typed.length;
-	return named;
-}
-var sourceSymbol = Symbol.for('source');
-function readStruct(src, position, srcEnd, unpackr) {
-	let recordId = src[position++] - 0x20;
-	if (recordId >= 24) {
-		switch(recordId) {
-			case 24: recordId = src[position++]; break;
-			// little endian:
-			case 25: recordId = src[position++] + (src[position++] << 8); break;
-			case 26: recordId = src[position++] + (src[position++] << 8) + (src[position++] << 16); break;
-			case 27: recordId = src[position++] + (src[position++] << 8) + (src[position++] << 16) + (src[position++] << 24); break;
-		}
-	}
-	let structure = unpackr.typedStructs && unpackr.typedStructs[recordId];
-	if (!structure) {
-		// copy src buffer because getStructures will override it
-		src = Uint8Array.prototype.slice.call(src, position, srcEnd);
-		srcEnd -= position;
-		position = 0;
-		if (!unpackr.getStructures)
-			throw new Error(`Reference to shared structure ${recordId} without getStructures method`);
-		unpackr._mergeStructures(unpackr.getStructures());
-		if (!unpackr.typedStructs)
-			throw new Error('Could not find any shared typed structures');
-		unpackr.lastTypedStructuresLength = unpackr.typedStructs.length;
-		structure = unpackr.typedStructs[recordId];
-		if (!structure)
-			throw new Error('Could not find typed structure ' + recordId);
-	}
-	var construct = structure.construct;
-	var fullConstruct = structure.fullConstruct;
-	if (!construct) {
-		construct = structure.construct = function LazyObject() {
-		};
-		fullConstruct = structure.fullConstruct = function LoadedObject() {
-		};
-		fullConstruct.prototype = unpackr.structPrototype || {};
-		var prototype = construct.prototype = unpackr.structPrototype ? Object.create(unpackr.structPrototype) : {};
-		let properties = [];
-		let currentOffset = 0;
-		let lastRefProperty;
-		for (let i = 0, l = structure.length; i < l; i++) {
-			let definition = structure[i];
-			let [ type, size, key, enumerationOffset ] = definition;
-			if (key === '__proto__')
-				key = '__proto_';
-			let property = {
-				key,
-				offset: currentOffset,
-			};
-			if (enumerationOffset)
-				properties.splice(i + enumerationOffset, 0, property);
-			else
-				properties.push(property);
-			let getRef;
-			switch(size) { // TODO: Move into a separate function
-				case 0: getRef = () => 0; break;
-				case 1:
-					getRef = (source, position) => {
-						let ref = source.bytes[position + property.offset];
-						return ref >= 0xf6 ? toConstant(ref) : ref;
-					};
-					break;
-				case 2:
-					getRef = (source, position) => {
-						let src = source.bytes;
-						let dataView = src.dataView || (src.dataView = new DataView(src.buffer, src.byteOffset, src.byteLength));
-						let ref = dataView.getUint16(position + property.offset, true);
-						return ref >= 0xff00 ? toConstant(ref & 0xff) : ref;
-					};
-					break;
-				case 4:
-					getRef = (source, position) => {
-						let src = source.bytes;
-						let dataView = src.dataView || (src.dataView = new DataView(src.buffer, src.byteOffset, src.byteLength));
-						let ref = dataView.getUint32(position + property.offset, true);
-						return ref >= 0xffffff00 ? toConstant(ref & 0xff) : ref;
-					};
-					break;
-			}
-			property.getRef = getRef;
-			currentOffset += size;
-			let get;
-			switch(type) {
-				case ASCII:
-					if (lastRefProperty && !lastRefProperty.next)
-						lastRefProperty.next = property;
-					lastRefProperty = property;
-					property.multiGetCount = 0;
-					get = function(source) {
-						let src = source.bytes;
-						let position = source.position;
-						let refStart = currentOffset + position;
-						let ref = getRef(source, position);
-						if (typeof ref !== 'number') return ref;
-
-						let end, next = property.next;
-						while(next) {
-							end = next.getRef(source, position);
-							if (typeof end === 'number')
-								break;
-							else
-								end = null;
-							next = next.next;
-						}
-						if (end == null)
-							end = source.bytesEnd - refStart;
-						if (source.srcString) {
-							return source.srcString.slice(ref, end);
-						}
-						/*if (property.multiGetCount > 0) {
-							let asciiEnd;
-							next = firstRefProperty;
-							let dataView = src.dataView || (src.dataView = new DataView(src.buffer, src.byteOffset, src.byteLength));
-							do {
-								asciiEnd = dataView.getUint16(source.position + next.offset, true);
-								if (asciiEnd < 0xff00)
-									break;
-								else
-									asciiEnd = null;
-							} while((next = next.next));
-							if (asciiEnd == null)
-								asciiEnd = source.bytesEnd - refStart
-							source.srcString = src.toString('latin1', refStart, refStart + asciiEnd);
-							return source.srcString.slice(ref, end);
-						}
-						if (source.prevStringGet) {
-							source.prevStringGet.multiGetCount += 2;
-						} else {
-							source.prevStringGet = property;
-							property.multiGetCount--;
-						}*/
-						return readString(src, ref + refStart, end - ref);
-						//return src.toString('latin1', ref + refStart, end + refStart);
-					};
-					break;
-				case UTF8: case OBJECT_DATA:
-					if (lastRefProperty && !lastRefProperty.next)
-						lastRefProperty.next = property;
-					lastRefProperty = property;
-					get = function(source) {
-						let position = source.position;
-						let refStart = currentOffset + position;
-						let ref = getRef(source, position);
-						if (typeof ref !== 'number') return ref;
-						let src = source.bytes;
-						let end, next = property.next;
-						while(next) {
-							end = next.getRef(source, position);
-							if (typeof end === 'number')
-								break;
-							else
-								end = null;
-							next = next.next;
-						}
-						if (end == null)
-							end = source.bytesEnd - refStart;
-						if (type === UTF8) {
-							return src.toString('utf8', ref + refStart, end + refStart);
-						} else {
-							currentSource = source;
-							try {
-								return unpackr.unpack(src, { start: ref + refStart, end: end + refStart });
-							} finally {
-								currentSource = null;
-							}
-						}
-					};
-					break;
-				case NUMBER:
-					switch(size) {
-						case 4:
-							get = function (source) {
-								let src = source.bytes;
-								let dataView = src.dataView || (src.dataView = new DataView(src.buffer, src.byteOffset, src.byteLength));
-								let position = source.position + property.offset;
-								let value = dataView.getInt32(position, true);
-								if (value < 0x20000000) {
-									if (value > -0x1f000000)
-										return value;
-									if (value > -0x20000000)
-										return toConstant(value & 0xff);
-								}
-								let fValue = dataView.getFloat32(position, true);
-								// this does rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
-								let multiplier = mult10[((src[position + 3] & 0x7f) << 1) | (src[position + 2] >> 7)];
-								return ((multiplier * fValue + (fValue > 0 ? 0.5 : -0.5)) >> 0) / multiplier;
-							};
-							break;
-						case 8:
-							get = function (source) {
-								let src = source.bytes;
-								let dataView = src.dataView || (src.dataView = new DataView(src.buffer, src.byteOffset, src.byteLength));
-								let value = dataView.getFloat64(source.position + property.offset, true);
-								if (isNaN(value)) {
-									let byte = src[source.position + property.offset];
-									if (byte >= 0xf6)
-										return toConstant(byte);
-								}
-								return value;
-							};
-							break;
-						case 1:
-							get = function (source) {
-								let src = source.bytes;
-								let value = src[source.position + property.offset];
-								return value < 0xf6 ? value : toConstant(value);
-							};
-							break;
-					}
-					break;
-				case DATE:
-					get = function (source) {
-						let src = source.bytes;
-						let dataView = src.dataView || (src.dataView = new DataView(src.buffer, src.byteOffset, src.byteLength));
-						return new Date(dataView.getFloat64(source.position + property.offset, true));
-					};
-					break;
-
-			}
-			property.get = get;
-		}
-		// TODO: load the srcString for faster string decoding on toJSON
-		if (evalSupported) {
-			let objectLiteralProperties = [];
-			let args = [];
-			let i = 0;
-			let hasInheritedProperties;
-			for (let property of properties) { // assign in enumeration order
-				if (unpackr.alwaysLazyProperty && unpackr.alwaysLazyProperty(property.key)) {
-					// these properties are not eagerly evaluated and this can be used for creating properties
-					// that are not serialized as JSON
-					hasInheritedProperties = true;
-					continue;
-				}
-				Object.defineProperty(prototype, property.key, { get: withSource(property.get), enumerable: true });
-				let valueFunction = 'v' + i++;
-				args.push(valueFunction);
-				objectLiteralProperties.push('o[' + JSON.stringify(property.key) + ']=' + valueFunction + '(s)');
-			}
-			if (hasInheritedProperties) {
-				objectLiteralProperties.push('__proto__:this');
-			}
-			let toObject = (new Function(...args, 'var c=this;return function(s){var o=new c();' + objectLiteralProperties.join(';') + ';return o;}')).apply(fullConstruct, properties.map(prop => prop.get));
-			Object.defineProperty(prototype, 'toJSON', {
-				value(omitUnderscoredProperties) {
-					return toObject.call(this, this[sourceSymbol]);
-				}
-			});
-		} else {
-			Object.defineProperty(prototype, 'toJSON', {
-				value(omitUnderscoredProperties) {
-					// return an enumerable object with own properties to JSON stringify
-					let resolved = {};
-					for (let i = 0, l = properties.length; i < l; i++) {
-						// TODO: check alwaysLazyProperty
-						let key = properties[i].key;
-
-						resolved[key] = this[key];
-					}
-					return resolved;
-				},
-				// not enumerable or anything
-			});
-		}
-	}
-	var instance = new construct();
-	instance[sourceSymbol] = {
-		bytes: src,
-		position,
-		srcString: '',
-		bytesEnd: srcEnd
-	};
-	return instance;
-}
-function toConstant(code) {
-	switch(code) {
-		case 0xf6: return null;
-		case 0xf7: return undefined;
-		case 0xf8: return false;
-		case 0xf9: return true;
-	}
-	throw new Error('Unknown constant');
-}
-function withSource(get) {
-	return function() {
-		return get(this[sourceSymbol]);
-	}
-}
-
-function saveState() {
-	if (currentSource) {
-		currentSource.bytes = Uint8Array.prototype.slice.call(currentSource.bytes, currentSource.position, currentSource.bytesEnd);
-		currentSource.position = 0;
-		currentSource.bytesEnd = currentSource.bytes.length;
-	}
-}
-function prepareStructures(structures, packr) {
-	if (packr.typedStructs) {
-		let structMap = new Map();
-		structMap.set('named', structures);
-		structMap.set('typed', packr.typedStructs);
-		structures = structMap;
-	}
-	let lastTypedStructuresLength = packr.lastTypedStructuresLength || 0;
-	structures.isCompatible = existing => {
-		let compatible = true;
-		if (existing instanceof Map) {
-			let named = existing.get('named') || [];
-			if (named.length !== (packr.lastNamedStructuresLength || 0))
-				compatible = false;
-			let typed = existing.get('typed') || [];
-			if (typed.length !== lastTypedStructuresLength)
-				compatible = false;
-		} else if (existing instanceof Array || Array.isArray(existing)) {
-			if (existing.length !== (packr.lastNamedStructuresLength || 0))
-				compatible = false;
-		}
-		if (!compatible)
-			packr._mergeStructures(existing);
-		return compatible;
-	};
-	packr.lastTypedStructuresLength = packr.typedStructs && packr.typedStructs.length;
-	return structures;
-}
-
-setReadStruct(readStruct, onLoadedStructures, saveState);
-
 class PackrStream extends stream.Transform {
 	constructor(options) {
 		if (!options)
@@ -3188,12 +2404,12 @@ class UnpackrStream extends stream.Transform {
 				let incompleteBuffer = chunk.slice(error.lastPosition);
 				if (incompleteBuffer.length > this.maxIncompleteBufferSize) {
 					this.incompleteBuffer = null;
-					return callback(new Error('Maximum incomplete buffer size exceeded'))
+					return callback(new Error('Maximum incomplete buffer size exceeded'));
 				}
 				this.incompleteBuffer = incompleteBuffer;
 				values = error.values;
 			} else {
-				return callback(error)
+				return callback(error);
 			}
 		}
 		for (let value of values || []) {
@@ -3204,7 +2420,7 @@ class UnpackrStream extends stream.Transform {
 		callback();
 	}
 	getNullValue() {
-		return Symbol.for(null)
+		return Symbol.for(null);
 	}
 }
 
@@ -3217,13 +2433,13 @@ class UnpackrStream extends stream.Transform {
  */
 function packIter (objectIterator, options = {}) {
   if (!objectIterator || typeof objectIterator !== 'object') {
-    throw new Error('first argument must be an Iterable, Async Iterable, or a Promise for an Async Iterable')
+    throw new Error('first argument must be an Iterable, Async Iterable, or a Promise for an Async Iterable');
   } else if (typeof objectIterator[Symbol.iterator] === 'function') {
-    return packIterSync(objectIterator, options)
+    return packIterSync(objectIterator, options);
   } else if (typeof objectIterator.then === 'function' || typeof objectIterator[Symbol.asyncIterator] === 'function') {
-    return packIterAsync(objectIterator, options)
+    return packIterAsync(objectIterator, options);
   } else {
-    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a Promise')
+    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a Promise');
   }
 }
 
@@ -3250,7 +2466,7 @@ async function * packIterAsync (objectIterator, options) {
  */
 function unpackIter (bufferIterator, options = {}) {
   if (!bufferIterator || typeof bufferIterator !== 'object') {
-    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a promise')
+    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a promise');
   }
 
   const unpackr = new Unpackr(options);
@@ -3270,10 +2486,10 @@ function unpackIter (bufferIterator, options = {}) {
         incomplete = chunk.slice(err.lastPosition);
         yields = err.values;
       } else {
-        throw err
+        throw err;
       }
     }
-    return yields
+    return yields;
   };
 
   if (typeof bufferIterator[Symbol.iterator] === 'function') {
@@ -3281,13 +2497,13 @@ function unpackIter (bufferIterator, options = {}) {
       for (const value of bufferIterator) {
         yield * parser(value);
       }
-    })()
+    })();
   } else if (typeof bufferIterator[Symbol.asyncIterator] === 'function') {
     return (async function * iter () {
       for await (const value of bufferIterator) {
         yield * parser(value);
       }
-    })()
+    })();
   }
 }
 const decodeIter = unpackIter;