msgpackr 1.11.12 → 2.0.1

package/dist/test.js

@@ -29,7 +29,6 @@
 	C1.name = 'MessagePack 0xC1';
 	var sequentialMode = false;
 	var inlineObjectReadThreshold = 2;
-	var readStruct$1, onLoadedStructures$1, onSaveState;
 
 	let Unpackr$1 = class Unpackr {
 		constructor(options) {
@@ -59,10 +58,10 @@
 		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$1.prototype.unpack.call(defaultOptions, source, options)
-				})
+					return this ? this.unpack(source, options) : Unpackr$1.prototype.unpack.call(defaultOptions, source, options);
+				});
 			}
 			if (!source.buffer && source.constructor === ArrayBuffer)
 				source = typeof Buffer !== 'undefined' ? Buffer.from(source) : new Uint8Array(source);
@@ -88,14 +87,14 @@
 				// 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$1) {
 				currentUnpackr = this;
 				if (this.structures) {
 					currentStructures = this.structures;
-					return checkedRead(options)
+					return checkedRead(options);
 				} else if (!currentStructures || currentStructures.length > 0) {
 					currentStructures = [];
 				}
@@ -104,7 +103,7 @@
 				if (!currentStructures || currentStructures.length > 0)
 					currentStructures = [];
 			}
-			return checkedRead(options)
+			return checkedRead(options);
 		}
 		unpackMultiple(source, forEach) {
 			let values, lastPosition = 0;
@@ -117,7 +116,7 @@
 					while(position$1 < size) {
 						lastPosition = position$1;
 						if (forEach(checkedRead(), lastPosition, position$1) === false) {
-							return
+							return;
 						}
 					}
 				}
@@ -127,20 +126,20 @@
 						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));
@@ -164,10 +163,10 @@
 					}
 				}
 			}
-			return this.structures = loadedStructures
+			return this.structures = loadedStructures;
 		}
 		decode(source, options) {
-			return this.unpack(source, options)
+			return this.unpack(source, options);
 		}
 	};
 	function checkedRead(options) {
@@ -178,8 +177,8 @@
 					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();
@@ -205,7 +204,7 @@
 					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 {
@@ -213,10 +212,10 @@
 				} 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();
@@ -224,7 +223,7 @@
 			if (error instanceof RangeError || error.message.startsWith('Unexpected end of buffer') || position$1 > srcEnd) {
 				error.incomplete = true;
 			}
-			throw error
+			throw error;
 		}
 	}
 
@@ -240,7 +239,7 @@
 		if (token < 0xa0) {
 			if (token < 0x80) {
 				if (token < 0x40)
-					return token
+					return token;
 				else {
 					let structure = currentStructures[token & 0x3f] ||
 						currentUnpackr.getStructures && loadStructures()[token & 0x3f];
@@ -248,9 +247,9 @@
 						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
@@ -263,13 +262,13 @@
 							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;
@@ -278,91 +277,91 @@
 					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;
@@ -375,19 +374,19 @@
 					} 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;
@@ -400,96 +399,96 @@
 					} 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);
 
 			}
 		}
@@ -510,7 +509,7 @@
 				}
 				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++) {
@@ -521,38 +520,38 @@
 			}
 			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;
@@ -570,7 +569,7 @@
 				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') {
@@ -582,30 +581,30 @@
 						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 = '';
@@ -668,17 +667,7 @@
 			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) {
@@ -687,8 +676,8 @@
 			array[i] = read();
 		}
 		if (currentUnpackr.freezeData)
-			return Object.freeze(array)
-		return array
+			return Object.freeze(array);
+		return array;
 	}
 
 	function readMap(length) {
@@ -700,13 +689,13 @@
 					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;
 		}
 	}
 
@@ -718,40 +707,40 @@
 			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++];
@@ -760,34 +749,34 @@
 			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++];
@@ -795,34 +784,34 @@
 				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++];
@@ -830,34 +819,34 @@
 					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);
 					}
 				}
 			}
@@ -875,22 +864,22 @@
 				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);
 	}
 
 
@@ -898,7 +887,7 @@
 		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++];
@@ -911,10 +900,10 @@
 				} finally {
 					position$1 = end;
 				}
-			})
+			});
 		}
 		else
-			throw new Error('Unknown extension type ' + type)
+			throw new Error('Unknown extension type ' + type);
 	}
 
 	var keyCache = new Array(4096);
@@ -924,12 +913,12 @@
 			// 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];
@@ -942,7 +931,7 @@
 				chunk = dataView.getUint32(checkPosition);
 				if (chunk != entry[i++]) {
 					checkPosition = 0x70000000;
-					break
+					break;
 				}
 				checkPosition += 4;
 			}
@@ -951,12 +940,12 @@
 				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;
@@ -977,8 +966,8 @@
 		// 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) {
@@ -1009,7 +998,7 @@
 		}
 		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;
@@ -1031,17 +1020,17 @@
 						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 = {
@@ -1052,14 +1041,14 @@
 		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();
@@ -1080,7 +1069,7 @@
 		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);
@@ -1091,16 +1080,16 @@
 			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());
@@ -1115,15 +1104,15 @@
 
 		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) => {
@@ -1136,30 +1125,30 @@
 		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;
@@ -1192,7 +1181,7 @@
 		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;
@@ -1226,30 +1215,28 @@
 	function roundFloat32$1(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$1.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');
@@ -1262,10 +1249,10 @@
 			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;
@@ -1277,7 +1264,7 @@
 			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;
 			}
@@ -1291,7 +1278,7 @@
 			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;
@@ -1327,7 +1314,7 @@
 					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
@@ -1335,7 +1322,7 @@
 						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];
@@ -1357,7 +1344,7 @@
 					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)
@@ -1401,15 +1388,15 @@
 						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;
@@ -1420,16 +1407,16 @@
 							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;
 							}
 						}
 					}
@@ -1515,7 +1502,7 @@
 						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
@@ -1589,7 +1576,7 @@
 				} 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;
@@ -1628,7 +1615,7 @@
 									// 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
 						}
@@ -1651,7 +1638,7 @@
 								target[position++] = 0x70; // "p" for pointer
 								targetView.setUint32(position, referee.id);
 								position += 4;
-								return
+								return;
 							} else
 								referenceMap.set(value, { offset: position - start });
 						}
@@ -1701,7 +1688,7 @@
 										} else {
 											pack(writeResult);
 										}
-										return
+										return;
 									}
 									let currentTarget = target;
 									let currentTargetView = targetView;
@@ -1718,7 +1705,7 @@
 												makeRoom(position);
 											return {
 												target, targetView, position: position - size
-											}
+											};
 										}, pack);
 									} finally {
 										// restore current target information (unless already restored)
@@ -1734,7 +1721,7 @@
 											makeRoom(result.length + position);
 										position = writeExtensionData(result, target, position, extension.type);
 									}
-									return
+									return;
 								}
 							}
 							// check isArray after extensions, because extensions can extend Array
@@ -1746,7 +1733,7 @@
 									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
@@ -1785,7 +1772,7 @@
 								let chunks = [];
 								while (true) {
 									chunks.push(value & mask);
-									if ((value >> BigInt(63)) === empty) break
+									if ((value >> BigInt(63)) === empty) break;
 									value >>= BigInt(64);
 								}
 
@@ -1800,7 +1787,7 @@
 									string = '00' + string;
 								}
 
-								if (hasNodeBuffer$1) {
+								if (hasNodeBuffer) {
 									array = Buffer.from(string, 'hex');
 								} else {
 									array = new Uint8Array(string.length / 2);
@@ -1817,11 +1804,11 @@
 							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;
@@ -1834,7 +1821,7 @@
 						target[position++] = 0;
 					}
 				} else {
-					throw new Error('Unknown type: ' + type)
+					throw new Error('Unknown type: ' + type);
 				}
 			};
 
@@ -1980,12 +1967,30 @@
 				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
@@ -2000,7 +2005,7 @@
 				position -= start;
 				start = 0;
 				safeEnd = newBuffer.length - 10;
-				return target = newBuffer
+				return target = newBuffer;
 			};
 			const newRecord = (transition, keys, newTransitions) => {
 				let recordId = structures.nextId;
@@ -2082,23 +2087,6 @@
 					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
@@ -2141,7 +2129,7 @@
 			} 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);
@@ -2162,7 +2150,7 @@
 		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);
@@ -2198,7 +2186,7 @@
 			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) {
@@ -2213,7 +2201,7 @@
 			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
@@ -2270,19 +2258,19 @@
 		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;
@@ -2302,7 +2290,7 @@
 		target[position++] = type;
 		target.set(result, position);
 		position += length;
-		return position
+		return position;
 	}
 
 	function insertIds(serialized, idsToInsert) {
@@ -2324,7 +2312,7 @@
 			serialized[position++] = id & 0xff;
 			lastEnd = offset;
 		}
-		return serialized
+		return serialized;
 	}
 
 	function writeBundles(start, pack, incrementPosition) {
@@ -2341,28 +2329,29 @@
 	function addExtension$1(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$2(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$1.SUPPORTS_STRUCT_HOOKS = true;
+
 	let defaultPackr = new Packr$1({ useRecords: false });
 	const pack$1 = defaultPackr.pack;
 	defaultPackr.pack;
@@ -2370,779 +2359,6 @@
 	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);
-
 	const nativeAccelerationDisabled = process.env.MSGPACKR_NATIVE_ACCELERATION_DISABLED !== undefined && process.env.MSGPACKR_NATIVE_ACCELERATION_DISABLED.toLowerCase() === 'true';
 
 	if (!nativeAccelerationDisabled) {
@@ -3171,18 +2387,11 @@
 	const sampleData = allSampleData[3];
 	function tryRequire(module) {
 		try {
-			return require(module)
+			return require(module);
 		} catch(error) {
-			return {}
+			return {};
 		}
 	}
-
-	let seed = 0;
-	function random() {
-		seed++;
-		let a = seed * 15485863;
-		return (a * a * a % 2038074743) / 2038074743;
-	}
 	//if (typeof chai === 'undefined') { chai = require('chai') }
 	var assert = chai.assert;
 	//if (typeof msgpackr === 'undefined') { msgpackr = require('..') }
@@ -3312,39 +2521,6 @@
 			var deserialized = unpack(ab);
 			assert.deepEqual(deserialized, data);
 		});
-		test('pack/unpack varying data with random access structures', function () {
-			let structures = [];
-			let packr = new Packr({
-				structures, useRecords: true, randomAccessStructure: true, freezeData: true, saveStructures(structures) {
-				}, getStructures() {
-					console.log('getStructures');
-				}
-			});
-			for (let i = 0; i < 2000; i++) {
-				let data = {};
-				let props = ['foo', 'bar', 'a', 'b', 'c', 'name', 'age', 'd'];
-
-				function makeString() {
-					let str = '';
-					while (random() < 0.9) {
-						str += random() < 0.8 ? 'hello world' : String.fromCharCode(300);
-					}
-					return str;
-				}
-
-				for (let i = 0; i < random() * 20; i++) {
-					data[props[Math.floor(random() * 8)]] =
-						random() < 0.3 ? Math.floor(random() * 400) / 2 :
-							random() < 0.3 ? makeString() : random() < 0.3 ? true : random() < 0.3 ? sampleData : null;
-				}
-				var serialized = packr.pack(data);
-				var deserialized = packr.unpack(serialized);
-				for (let key in deserialized) {
-					deserialized[key];
-				}
-				assert.deepEqual(deserialized, data);
-			}
-		});
 
 		for (let sampleData of allSampleData) {
 			let snippet = JSON.stringify(sampleData).slice(0, 20) + '...';
@@ -3367,25 +2543,6 @@
 				var deserialized = unpack(serialized);
 				assert.deepEqual(deserialized, data);
 			});
-			test('pack/unpack sample data with random access structures ' + snippet, function () {
-				var data = sampleData;
-				let structures = [];
-				let packr = new Packr({
-					structures, useRecords: true, randomAccessStructure: true, freezeData: true, saveStructures(structures) {
-					}, getStructures() {
-						console.log('getStructures');
-					}
-				});
-				for (let i = 0; i < 20; i++) {
-					var serialized = packr.pack(data);
-					var deserialized = packr.unpack(serialized, {lazy: true});
-					var copied = {};
-					for (let key in deserialized) {
-						copied[key] = deserialized[key];
-					}
-					assert.deepEqual(copied, data);
-				}
-			});
 			test('pack/unpack sample data with bundled strings ' + snippet, function () {
 				var data = sampleData;
 				let packr = new Packr({ /*structures,*/ useRecords: false, bundleStrings: true});
@@ -3576,7 +2733,7 @@
 
 			}
 			Extended.prototype.getDouble = function() {
-				return this.value * 2
+				return this.value * 2;
 			};
 			var instance = new Extended();
 			instance.value = 4;
@@ -3596,10 +2753,10 @@
 					let data = packr.unpack(buffer);
 					e.value = data[0];
 					e.string = data[1];
-					return e
+					return e;
 				},
 				pack: function(instance) {
-					return packr.pack([instance.value, instance.string])
+					return packr.pack([instance.value, instance.string]);
 				}
 			});
 			var serialized = pack(data);
@@ -3625,10 +2782,10 @@
 				type: 12,
 				read: function(data) {
 					Object.setPrototypeOf(data, ExtendArray.prototype);
-					return data
+					return data;
 				},
 				write: function(instance) {
-					return [...instance]
+					return [...instance];
 				}
 			});
 			var serialized = pack(data);
@@ -3681,10 +2838,10 @@
 				Class: TestClass,
 				type: 0x01,
 				pack() {
-					return typeof Buffer != 'undefined' ? Buffer.alloc(256) : new Uint8Array(256)
+					return typeof Buffer != 'undefined' ? Buffer.alloc(256) : new Uint8Array(256);
 				},
 				unpack(data) {
-					return data.length
+					return data.length;
 				}
 			});
 			let result = unpack(pack(new TestClass()));
@@ -3696,7 +2853,7 @@
 
 			}
 			Extended.prototype.getDouble = function() {
-				return this.value * 2
+				return this.value * 2;
 			};
 			var instance = new Extended();
 			instance.value = 4;
@@ -3715,10 +2872,10 @@
 					let e = new Extended();
 					e.value = data[0];
 					e.string = data[1];
-					return e
+					return e;
 				},
 				write: function(instance) {
-					return [instance.value, instance.string]
+					return [instance.value, instance.string];
 				}
 			});
 			var serialized = pack(data);
@@ -3731,7 +2888,7 @@
 
 			}
 			Extended.prototype.getDouble = function() {
-				return this.value * 2
+				return this.value * 2;
 			};
 			var instance = new Extended();
 			instance.value = 4;
@@ -3748,10 +2905,10 @@
 				type: 13,
 				read: function(data) {
 					Object.setPrototypeOf(data, Extended.prototype);
-					return data
+					return data;
 				},
 				write: function(data) {
-					return data
+					return data;
 				}
 			});
 			var serialized = pack(data);
@@ -3776,10 +2933,10 @@
 				type: 14,
 				read: function(data) {
 					Object.setPrototypeOf(data, ExtendArray3.prototype);
-					return data
+					return data;
 				},
 				write: function(data) {
-					return data
+					return data;
 				}
 			});
 			var serialized = pack(data);
@@ -3794,10 +2951,10 @@
 
 			}
 			Extended.prototype.__call__ = function(){
-				return this.value * 4
+				return this.value * 4;
 			};
 			Extended.prototype.getDouble = function() {
-				return this.value * 2
+				return this.value * 2;
 			};
 
 			var instance = function() { instance.__call__();/* callable stuff */ };
@@ -3814,10 +2971,10 @@
 					var e = function() { e.__call__(); };
 					Object.setPrototypeOf(e,Extended.prototype);
 					e.value = packr.unpack(buffer);
-					return e
+					return e;
 				},
 				pack: function(instance) {
-					return packr.pack(instance.value)
+					return packr.pack(instance.value);
 				}
 			});
 			var serialized = pack(data);
@@ -3833,7 +2990,7 @@
 			addExtension({
 				Class: Date,
 				write(date) {
-					return date.toString()
+					return date.toString();
 				}
 			});
 			var serialized = pack(data);
@@ -4130,7 +3287,7 @@
 			const structures2 = [...structures];
 			const packr = new Packr({
 				getStructures() {
-					return structures
+					return structures;
 				},
 				saveStructures(structures) {
 				},
@@ -4138,7 +3295,7 @@
 			});
 			const packr2 = new Packr({
 				getStructures() {
-					return structures2
+					return structures2;
 				},
 				saveStructures(structures) {
 				},
@@ -4459,9 +3616,9 @@
 
 		test('pack toJSON returning this', () => {
 			class Serializable {
-				someData = [1, 2, 3, 4]
+				someData = [1, 2, 3, 4];
 				toJSON() {
-					return this
+					return this;
 				}
 			}
 			const serialized = pack(new Serializable);