msgpackr 1.11.12 → 2.0.1

package/dist/unpack-no-eval.cjs

@@ -32,7 +32,6 @@
 	C1.name = 'MessagePack 0xC1';
 	var sequentialMode = false;
 	var inlineObjectReadThreshold = 2;
-	var readStruct, onLoadedStructures, onSaveState;
 	var BlockedFunction; // we use search and replace to change the next call to BlockedFunction to avoid CSP issues for
 
 	class Unpackr {
@@ -65,8 +64,8 @@
 				// re-entrant execution, save the state and restore it after we do this unpack
 				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);
@@ -92,14 +91,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) {
 				currentUnpackr = this;
 				if (this.structures) {
 					currentStructures = this.structures;
-					return checkedRead(options)
+					return checkedRead(options);
 				} else if (!currentStructures || currentStructures.length > 0) {
 					currentStructures = [];
 				}
@@ -108,7 +107,7 @@
 				if (!currentStructures || currentStructures.length > 0)
 					currentStructures = [];
 			}
-			return checkedRead(options)
+			return checkedRead(options);
 		}
 		unpackMultiple(source, forEach) {
 			let values, lastPosition = 0;
@@ -121,7 +120,7 @@
 					while(position < size) {
 						lastPosition = position;
 						if (forEach(checkedRead(), lastPosition, position) === false) {
-							return
+							return;
 						}
 					}
 				}
@@ -131,20 +130,20 @@
 						lastPosition = position;
 						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)
-				loadedStructures = onLoadedStructures.call(this, loadedStructures);
+			if (this._onLoadedStructures)
+				loadedStructures = this._onLoadedStructures(loadedStructures);
 			loadedStructures = loadedStructures || [];
 			if (Object.isFrozen(loadedStructures))
 				loadedStructures = loadedStructures.map(structure => structure.slice(0));
@@ -168,14 +167,14 @@
 					}
 				}
 			}
-			return this.structures = loadedStructures
+			return this.structures = loadedStructures;
 		}
 		decode(source, options) {
-			return this.unpack(source, options)
+			return this.unpack(source, options);
 		}
 	}
 	function getPosition() {
-		return position
+		return position;
 	}
 	function checkedRead(options) {
 		try {
@@ -185,8 +184,8 @@
 					currentStructures.length = sharedLength;
 			}
 			let result;
-			if (currentUnpackr.randomAccessStructure && src[position] < 0x40 && src[position] >= 0x20 && readStruct) {
-				result = readStruct(src, position, srcEnd, currentUnpackr);
+			if (currentUnpackr._readStruct && src[position] < 0x40 && src[position] >= 0x20) {
+				result = currentUnpackr._readStruct(src, position, srcEnd);
 				src = null; // dispose of this so that recursive unpack calls don't save state
 				if (!(options && options.lazy) && result)
 					result = result.toJSON();
@@ -212,7 +211,7 @@
 					referenceMap = null;
 			} else if (position > 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 {
@@ -220,10 +219,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();
@@ -231,7 +230,7 @@
 			if (error instanceof RangeError || error.message.startsWith('Unexpected end of buffer') || position > srcEnd) {
 				error.incomplete = true;
 			}
-			throw error
+			throw error;
 		}
 	}
 
@@ -247,7 +246,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];
@@ -255,9 +254,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
@@ -270,13 +269,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;
@@ -285,91 +284,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) {
-				return srcString.slice(position - srcStringStart, (position += length) - srcStringStart)
+				return srcString.slice(position - srcStringStart, (position += 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) {
 						value = read(); // followed by the length of the string in characters (not bytes!)
 						if (value > 0)
-							return bundledStrings[1].slice(bundledStrings.position1, bundledStrings.position1 += value)
+							return bundledStrings[1].slice(bundledStrings.position1, bundledStrings.position1 += value);
 						else
-							return bundledStrings[0].slice(bundledStrings.position0, bundledStrings.position0 -= value)
+							return bundledStrings[0].slice(bundledStrings.position0, bundledStrings.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++];
 					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);
 					position += 2;
-					return readBin(value)
+					return readBin(value);
 				case 0xc6:
 					// bin 32
 					value = dataView.getUint32(position);
 					position += 4;
-					return readBin(value)
+					return readBin(value);
 				case 0xc7:
 					// ext 8
-					return readExt(src[position++])
+					return readExt(src[position++]);
 				case 0xc8:
 					// ext 16
 					value = dataView.getUint16(position);
 					position += 2;
-					return readExt(value)
+					return readExt(value);
 				case 0xc9:
 					// ext 32
 					value = dataView.getUint32(position);
 					position += 4;
-					return readExt(value)
+					return readExt(value);
 				case 0xca:
 					value = dataView.getFloat32(position);
 					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] & 0x7f) << 1) | (src[position + 1] >> 7)];
 						position += 4;
-						return ((multiplier * value + (value > 0 ? 0.5 : -0.5)) >> 0) / multiplier
+						return ((multiplier * value + (value > 0 ? 0.5 : -0.5)) >> 0) / multiplier;
 					}
 					position += 4;
-					return value
+					return value;
 				case 0xcb:
 					value = dataView.getFloat64(position);
 					position += 8;
-					return value
+					return value;
 				// uint handlers
 				case 0xcc:
-					return src[position++]
+					return src[position++];
 				case 0xcd:
 					value = dataView.getUint16(position);
 					position += 2;
-					return value
+					return value;
 				case 0xce:
 					value = dataView.getUint32(position);
 					position += 4;
-					return value
+					return value;
 				case 0xcf:
 					if (currentUnpackr.int64AsType === 'number') {
 						value = dataView.getUint32(position) * 0x100000000;
@@ -382,19 +381,19 @@
 					} else
 						value = dataView.getBigUint64(position);
 					position += 8;
-					return value
+					return value;
 
 				// int handlers
 				case 0xd0:
-					return dataView.getInt8(position++)
+					return dataView.getInt8(position++);
 				case 0xd1:
 					value = dataView.getInt16(position);
 					position += 2;
-					return value
+					return value;
 				case 0xd2:
 					value = dataView.getInt32(position);
 					position += 4;
-					return value
+					return value;
 				case 0xd3:
 					if (currentUnpackr.int64AsType === 'number') {
 						value = dataView.getInt32(position) * 0x100000000;
@@ -407,96 +406,96 @@
 					} else
 						value = dataView.getBigInt64(position);
 					position += 8;
-					return value
+					return value;
 
 				case 0xd4:
 					// fixext 1
 					value = src[position++];
 					if (value == 0x72) {
-						return recordDefinition(src[position++] & 0x3f)
+						return recordDefinition(src[position++] & 0x3f);
 					} else {
 						let extension = currentExtensions[value];
 						if (extension) {
 							if (extension.read) {
 								position++; // skip filler byte
-								return extension.read(read())
+								return extension.read(read());
 							} else if (extension.noBuffer) {
 								position++; // skip filler byte
-								return extension()
+								return extension();
 							} else
-								return extension(src.subarray(position, ++position))
+								return extension(src.subarray(position, ++position));
 						} else
-							throw new Error('Unknown extension ' + value)
+							throw new Error('Unknown extension ' + value);
 					}
 				case 0xd5:
 					// fixext 2
 					value = src[position];
 					if (value == 0x72) {
 						position++;
-						return recordDefinition(src[position++] & 0x3f, src[position++])
+						return recordDefinition(src[position++] & 0x3f, src[position++]);
 					} 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++];
 					if (srcStringEnd >= position) {
-						return srcString.slice(position - srcStringStart, (position += value) - srcStringStart)
+						return srcString.slice(position - srcStringStart, (position += value) - srcStringStart);
 					}
-					return readString8(value)
+					return readString8(value);
 				case 0xda:
 				// str 16
 					value = dataView.getUint16(position);
 					position += 2;
 					if (srcStringEnd >= position) {
-						return srcString.slice(position - srcStringStart, (position += value) - srcStringStart)
+						return srcString.slice(position - srcStringStart, (position += value) - srcStringStart);
 					}
-					return readString16(value)
+					return readString16(value);
 				case 0xdb:
 				// str 32
 					value = dataView.getUint32(position);
 					position += 4;
 					if (srcStringEnd >= position) {
-						return srcString.slice(position - srcStringStart, (position += value) - srcStringStart)
+						return srcString.slice(position - srcStringStart, (position += value) - srcStringStart);
 					}
-					return readString32(value)
+					return readString32(value);
 				case 0xdc:
 				// array 16
 					value = dataView.getUint16(position);
 					position += 2;
-					return readArray(value)
+					return readArray(value);
 				case 0xdd:
 				// array 32
 					value = dataView.getUint32(position);
 					position += 4;
-					return readArray(value)
+					return readArray(value);
 				case 0xde:
 				// map 16
 					value = dataView.getUint16(position);
 					position += 2;
-					return readMap(value)
+					return readMap(value);
 				case 0xdf:
 				// map 32
 					value = dataView.getUint32(position);
 					position += 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);
 
 			}
 		}
@@ -517,7 +516,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++) {
@@ -528,38 +527,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++];
 			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(() => {
 			// 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;
@@ -579,7 +578,7 @@
 				let string = strings[stringPosition++];
 				if (string == null) {
 					if (bundledStrings)
-						return readStringJS(length)
+						return readStringJS(length);
 					let byteOffset = src.byteOffset;
 					let extraction = extractStrings(position - headerLength + byteOffset, srcEnd + byteOffset, src.buffer);
 					if (typeof extraction == 'string') {
@@ -591,30 +590,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 += length;
-					return string
+					return string;
 				}
 				srcString = string;
 				srcStringStart = position;
 				srcStringEnd = position + srcStringLength;
 				position += 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, position += length))
+			return decoder.decode(src.subarray(position, position += length));
 		const end = position + length;
 		const units = [];
 		result = '';
@@ -677,7 +676,7 @@
 			result += fromCharCode.apply(String, units);
 		}
 
-		return result
+		return result;
 	}
 	function readString(source, start, length) {
 		let existingSrc = src;
@@ -696,8 +695,8 @@
 			array[i] = read();
 		}
 		if (currentUnpackr.freezeData)
-			return Object.freeze(array)
-		return array
+			return Object.freeze(array);
+		return array;
 	}
 
 	function readMap(length) {
@@ -709,13 +708,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;
 		}
 	}
 
@@ -727,40 +726,40 @@
 			const byte = src[position++];
 			if ((byte & 0x80) > 0) {
 					position = 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++];
 					if ((a & 0x80) > 1) {
 						position -= 1;
-						return
+						return;
 					}
-					return fromCharCode(a)
+					return fromCharCode(a);
 				}
 			} else {
 				let a = src[position++];
 				let b = src[position++];
 				if ((a & 0x80) > 0 || (b & 0x80) > 0) {
 					position -= 2;
-					return
+					return;
 				}
 				if (length < 3)
-					return fromCharCode(a, b)
+					return fromCharCode(a, b);
 				let c = src[position++];
 				if ((c & 0x80) > 0) {
 					position -= 3;
-					return
+					return;
 				}
-				return fromCharCode(a, b, c)
+				return fromCharCode(a, b, c);
 			}
 		} else {
 			let a = src[position++];
@@ -769,34 +768,34 @@
 			let d = src[position++];
 			if ((a & 0x80) > 0 || (b & 0x80) > 0 || (c & 0x80) > 0 || (d & 0x80) > 0) {
 				position -= 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++];
 					if ((e & 0x80) > 0) {
 						position -= 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++];
 				let f = src[position++];
 				if ((e & 0x80) > 0 || (f & 0x80) > 0) {
 					position -= 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++];
 				if ((g & 0x80) > 0) {
 					position -= 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++];
 				let f = src[position++];
@@ -804,34 +803,34 @@
 				let h = src[position++];
 				if ((e & 0x80) > 0 || (f & 0x80) > 0 || (g & 0x80) > 0 || (h & 0x80) > 0) {
 					position -= 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++];
 						if ((i & 0x80) > 0) {
 							position -= 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++];
 					let j = src[position++];
 					if ((i & 0x80) > 0 || (j & 0x80) > 0) {
 						position -= 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++];
 					if ((k & 0x80) > 0) {
 						position -= 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++];
 					let j = src[position++];
@@ -839,34 +838,34 @@
 					let l = src[position++];
 					if ((i & 0x80) > 0 || (j & 0x80) > 0 || (k & 0x80) > 0 || (l & 0x80) > 0) {
 						position -= 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++];
 							if ((m & 0x80) > 0) {
 								position -= 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++];
 						let n = src[position++];
 						if ((m & 0x80) > 0 || (n & 0x80) > 0) {
 							position -= 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++];
 						if ((o & 0x80) > 0) {
 							position -= 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);
 					}
 				}
 			}
@@ -884,22 +883,22 @@
 				case 0xd9:
 				// str 8
 					length = src[position++];
-					break
+					break;
 				case 0xda:
 				// str 16
 					length = dataView.getUint16(position);
 					position += 2;
-					break
+					break;
 				case 0xdb:
 				// str 32
 					length = dataView.getUint32(position);
 					position += 4;
-					break
+					break;
 				default:
-					throw new Error('Expected string')
+					throw new Error('Expected string');
 			}
 		}
-		return readStringJS(length)
+		return readStringJS(length);
 	}
 
 
@@ -907,7 +906,7 @@
 		return currentUnpackr.copyBuffers ?
 			// specifically use the copying slice (not the node one)
 			Uint8Array.prototype.slice.call(src, position, position += length) :
-			src.subarray(position, position += length)
+			src.subarray(position, position += length);
 	}
 	function readExt(length) {
 		let type = src[position++];
@@ -920,10 +919,10 @@
 				} finally {
 					position = end;
 				}
-			})
+			});
 		}
 		else
-			throw new Error('Unknown extension type ' + type)
+			throw new Error('Unknown extension type ' + type);
 	}
 
 	var keyCache = new Array(4096);
@@ -933,12 +932,12 @@
 			// fixstr, potentially use key cache
 			length = length - 0xa0;
 			if (srcStringEnd >= position) // if it has been extracted, must use it (and faster anyway)
-				return srcString.slice(position - srcStringStart, (position += length) - srcStringStart)
+				return srcString.slice(position - srcStringStart, (position += 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--;
-			return asSafeString(read())
+			return asSafeString(read());
 		}
 		let key = ((length << 5) ^ (length > 1 ? dataView.getUint16(position) : length > 0 ? src[position] : 0)) & 0xfff;
 		let entry = keyCache[key];
@@ -951,7 +950,7 @@
 				chunk = dataView.getUint32(checkPosition);
 				if (chunk != entry[i++]) {
 					checkPosition = 0x70000000;
-					break
+					break;
 				}
 				checkPosition += 4;
 			}
@@ -960,12 +959,12 @@
 				chunk = src[checkPosition++];
 				if (chunk != entry[i++]) {
 					checkPosition = 0x70000000;
-					break
+					break;
 				}
 			}
 			if (checkPosition === end) {
 				position = checkPosition;
-				return entry.string
+				return entry.string;
 			}
 			end -= 3;
 			checkPosition = position;
@@ -986,8 +985,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) {
@@ -1018,7 +1017,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;
@@ -1040,17 +1039,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 = {
@@ -1061,14 +1060,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 - 4);
 		if (!referenceMap)
 			referenceMap = new Map();
@@ -1089,7 +1088,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);
@@ -1100,16 +1099,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 - 4);
 		let refEntry = referenceMap.get(id);
 		refEntry.used = true;
-		return refEntry.target
+		return refEntry.target;
 	};
 
 	currentExtensions[0x73] = () => new Set(read());
@@ -1124,15 +1123,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) => {
@@ -1145,30 +1144,30 @@
 		bundledStrings.position1 = 0;
 		bundledStrings.postBundlePosition = position;
 		position = 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(callback) {
-		if (onSaveState)
-			onSaveState();
+		if (currentUnpackr && currentUnpackr._onSaveState)
+			currentUnpackr._onSaveState();
 		let savedSrcEnd = srcEnd;
 		let savedPosition = position;
 		let savedStringPosition = stringPosition;
@@ -1201,7 +1200,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;
@@ -1236,13 +1235,12 @@
 	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 = updatedReadStruct;
-		onLoadedStructures = 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;
 
 	exports.C1 = C1;
 	exports.C1Type = C1Type;
@@ -1260,7 +1258,6 @@
 	exports.readString = readString;
 	exports.roundFloat32 = roundFloat32;
 	exports.setExtractor = setExtractor;
-	exports.setReadStruct = setReadStruct;
 	exports.typedArrays = typedArrays;
 	exports.unpack = unpack;
 	exports.unpackMultiple = unpackMultiple;