msgpackr 1.7.1 → 1.8.0

package/dist/node.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var stream = require('stream');
 var module$1 = require('module');
 
@@ -11,7 +9,7 @@ try {
 } catch(error) {}
 var src;
 var srcEnd;
-var position = 0;
+var position$1 = 0;
 const EMPTY_ARRAY = [];
 var strings = EMPTY_ARRAY;
 var stringPosition = 0;
@@ -20,7 +18,7 @@ var currentStructures;
 var srcString;
 var srcStringStart = 0;
 var srcStringEnd = 0;
-var bundledStrings;
+var bundledStrings$1;
 var referenceMap;
 var currentExtensions = [];
 var dataView;
@@ -33,7 +31,8 @@ const C1 = new C1Type();
 C1.name = 'MessagePack 0xC1';
 var sequentialMode = false;
 var inlineObjectReadThreshold = 2;
-var readStruct, onLoadedStructures, onSaveState;
+var readStruct$1, onLoadedStructures$1, onSaveState;
+// no-eval build
 try {
 	new Function('');
 } catch(error) {
@@ -60,29 +59,32 @@ class Unpackr {
 				(options.structures = []).uninitialized = true; // this is what we use to denote an uninitialized structures
 				options.structures.sharedLength = 0;
 			}
+			if (options.int64AsNumber) {
+				options.int64AsType = 'number';
+			}
 		}
 		Object.assign(this, options);
 	}
 	unpack(source, options) {
 		if (src) {
 			// re-entrant execution, save the state and restore it after we do this unpack
-			return saveState(() => {
+			return saveState$1(() => {
 				clearSource();
 				return this ? this.unpack(source, options) : Unpackr.prototype.unpack.call(defaultOptions, source, options)
 			})
 		}
 		if (typeof options === 'object') {
 			srcEnd = options.end || source.length;
-			position = options.start || 0;
+			position$1 = options.start || 0;
 		} else {
-			position = 0;
+			position$1 = 0;
 			srcEnd = options > -1 ? options : source.length;
 		}
 		stringPosition = 0;
 		srcStringEnd = 0;
 		srcString = null;
 		strings = EMPTY_ARRAY;
-		bundledStrings = null;
+		bundledStrings$1 = null;
 		src = source;
 		// this provides cached access to the data view for a buffer if it is getting reused, which is a recommend
 		// technique for getting data from a database where it can be copied into an existing buffer instead of creating
@@ -119,8 +121,8 @@ class Unpackr {
 			let value = this ? this.unpack(source, size) : defaultUnpackr.unpack(source, size);
 			if (forEach) {
 				forEach(value);
-				while(position < size) {
-					lastPosition = position;
+				while(position$1 < size) {
+					lastPosition = position$1;
 					if (forEach(checkedRead()) === false) {
 						return
 					}
@@ -128,8 +130,8 @@ class Unpackr {
 			}
 			else {
 				values = [ value ];
-				while(position < size) {
-					lastPosition = position;
+				while(position$1 < size) {
+					lastPosition = position$1;
 					values.push(checkedRead());
 				}
 				return values
@@ -144,8 +146,8 @@ class Unpackr {
 		}
 	}
 	_mergeStructures(loadedStructures, existingStructures) {
-		if (onLoadedStructures)
-			loadedStructures = onLoadedStructures.call(this, loadedStructures);
+		if (onLoadedStructures$1)
+			loadedStructures = onLoadedStructures$1.call(this, loadedStructures);
 		loadedStructures = loadedStructures || [];
 		if (Object.isFrozen(loadedStructures))
 			loadedStructures = loadedStructures.map(structure => structure.slice(0));
@@ -183,18 +185,20 @@ function checkedRead(options) {
 				currentStructures.length = sharedLength;
 		}
 		let result;
-		if (currentUnpackr.randomAccessStructure && src[position] < 0x40 && src[position] >= 0x20 && readStruct) {
-			result = readStruct(src, position, srcEnd, currentUnpackr);
+		if (currentUnpackr.randomAccessStructure && src[position$1] < 0x40 && src[position$1] >= 0x20 && readStruct$1) {
+			result = readStruct$1(src, position$1, srcEnd, currentUnpackr);
 			src = null; // dispose of this so that recursive unpack calls don't save state
 			if (!(options && options.lazy) && result)
 				result = result.toJSON();
-			position = srcEnd;
+			position$1 = srcEnd;
 		} else
 			result = read();
-		if (bundledStrings) // bundled strings to skip past
-			position = bundledStrings.postBundlePosition;
+		if (bundledStrings$1) { // bundled strings to skip past
+			position$1 = bundledStrings$1.postBundlePosition;
+			bundledStrings$1 = null;
+		}
 
-		if (position == srcEnd) {
+		if (position$1 == srcEnd) {
 			// finished reading this source, cleanup references
 			if (currentStructures && currentStructures.restoreStructures)
 				restoreStructures();
@@ -202,7 +206,7 @@ function checkedRead(options) {
 			src = null;
 			if (referenceMap)
 				referenceMap = null;
-		} else if (position > srcEnd) {
+		} else if (position$1 > srcEnd) {
 			// over read
 			throw new Error('Unexpected end of MessagePack data')
 		} else if (!sequentialMode) {
@@ -214,7 +218,7 @@ function checkedRead(options) {
 		if (currentStructures && currentStructures.restoreStructures)
 			restoreStructures();
 		clearSource();
-		if (error instanceof RangeError || error.message.startsWith('Unexpected end of buffer') || position > srcEnd) {
+		if (error instanceof RangeError || error.message.startsWith('Unexpected end of buffer') || position$1 > srcEnd) {
 			error.incomplete = true;
 		}
 		throw error
@@ -229,7 +233,7 @@ function restoreStructures() {
 }
 
 function read() {
-	let token = src[position++];
+	let token = src[position$1++];
 	if (token < 0xa0) {
 		if (token < 0x80) {
 			if (token < 0x40)
@@ -277,8 +281,8 @@ function read() {
 	} else if (token < 0xc0) {
 		// fixstr
 		let length = token - 0xa0;
-		if (srcStringEnd >= position) {
-			return srcString.slice(position - srcStringStart, (position += length) - srcStringStart)
+		if (srcStringEnd >= position$1) {
+			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
@@ -292,124 +296,128 @@ function read() {
 		switch (token) {
 			case 0xc0: return null
 			case 0xc1:
-				if (bundledStrings) {
+				if (bundledStrings$1) {
 					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[1].slice(bundledStrings$1.position1, bundledStrings$1.position1 += value)
 					else
-						return bundledStrings[0].slice(bundledStrings.position0, bundledStrings.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 0xc4:
 				// bin 8
-				value = src[position++];
+				value = src[position$1++];
 				if (value === undefined)
 					throw new Error('Unexpected end of buffer')
 				return readBin(value)
 			case 0xc5:
 				// bin 16
-				value = dataView.getUint16(position);
-				position += 2;
+				value = dataView.getUint16(position$1);
+				position$1 += 2;
 				return readBin(value)
 			case 0xc6:
 				// bin 32
-				value = dataView.getUint32(position);
-				position += 4;
+				value = dataView.getUint32(position$1);
+				position$1 += 4;
 				return readBin(value)
 			case 0xc7:
 				// ext 8
-				return readExt(src[position++])
+				return readExt(src[position$1++])
 			case 0xc8:
 				// ext 16
-				value = dataView.getUint16(position);
-				position += 2;
+				value = dataView.getUint16(position$1);
+				position$1 += 2;
 				return readExt(value)
 			case 0xc9:
 				// ext 32
-				value = dataView.getUint32(position);
-				position += 4;
+				value = dataView.getUint32(position$1);
+				position$1 += 4;
 				return readExt(value)
 			case 0xca:
-				value = dataView.getFloat32(position);
+				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] & 0x7f) << 1) | (src[position + 1] >> 7)];
-					position += 4;
+					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
 				}
-				position += 4;
+				position$1 += 4;
 				return value
 			case 0xcb:
-				value = dataView.getFloat64(position);
-				position += 8;
+				value = dataView.getFloat64(position$1);
+				position$1 += 8;
 				return value
 			// uint handlers
 			case 0xcc:
-				return src[position++]
+				return src[position$1++]
 			case 0xcd:
-				value = dataView.getUint16(position);
-				position += 2;
+				value = dataView.getUint16(position$1);
+				position$1 += 2;
 				return value
 			case 0xce:
-				value = dataView.getUint32(position);
-				position += 4;
+				value = dataView.getUint32(position$1);
+				position$1 += 4;
 				return value
 			case 0xcf:
-				if (currentUnpackr.int64AsNumber) {
-					value = dataView.getUint32(position) * 0x100000000;
-					value += dataView.getUint32(position + 4);
+				if (currentUnpackr.int64AsType === 'number') {
+					value = dataView.getUint32(position$1) * 0x100000000;
+					value += dataView.getUint32(position$1 + 4);
+				} else if (currentUnpackr.int64AsType === 'string') {
+					value = dataView.getBigUint64(position$1).toString();
 				} else
-					value = dataView.getBigUint64(position);
-				position += 8;
+					value = dataView.getBigUint64(position$1);
+				position$1 += 8;
 				return value
 
 			// int handlers
 			case 0xd0:
-				return dataView.getInt8(position++)
+				return dataView.getInt8(position$1++)
 			case 0xd1:
-				value = dataView.getInt16(position);
-				position += 2;
+				value = dataView.getInt16(position$1);
+				position$1 += 2;
 				return value
 			case 0xd2:
-				value = dataView.getInt32(position);
-				position += 4;
+				value = dataView.getInt32(position$1);
+				position$1 += 4;
 				return value
 			case 0xd3:
-				if (currentUnpackr.int64AsNumber) {
-					value = dataView.getInt32(position) * 0x100000000;
-					value += dataView.getUint32(position + 4);
+				if (currentUnpackr.int64AsType === 'number') {
+					value = dataView.getInt32(position$1) * 0x100000000;
+					value += dataView.getUint32(position$1 + 4);
+				} else if (currentUnpackr.int64AsType === 'string') {
+					value = dataView.getBigInt64(position$1).toString();
 				} else
-					value = dataView.getBigInt64(position);
-				position += 8;
+					value = dataView.getBigInt64(position$1);
+				position$1 += 8;
 				return value
 
 			case 0xd4:
 				// fixext 1
-				value = src[position++];
+				value = src[position$1++];
 				if (value == 0x72) {
-					return recordDefinition(src[position++] & 0x3f)
+					return recordDefinition(src[position$1++] & 0x3f)
 				} else {
 					let extension = currentExtensions[value];
 					if (extension) {
 						if (extension.read) {
-							position++; // skip filler byte
+							position$1++; // skip filler byte
 							return extension.read(read())
 						} else if (extension.noBuffer) {
-							position++; // skip filler byte
+							position$1++; // skip filler byte
 							return extension()
 						} else
-							return extension(src.subarray(position, ++position))
+							return extension(src.subarray(position$1, ++position$1))
 					} else
 						throw new Error('Unknown extension ' + value)
 				}
 			case 0xd5:
 				// fixext 2
-				value = src[position];
+				value = src[position$1];
 				if (value == 0x72) {
-					position++;
-					return recordDefinition(src[position++] & 0x3f, src[position++])
+					position$1++;
+					return recordDefinition(src[position$1++] & 0x3f, src[position$1++])
 				} else
 					return readExt(2)
 			case 0xd6:
@@ -423,46 +431,46 @@ function read() {
 				return readExt(16)
 			case 0xd9:
 			// str 8
-				value = src[position++];
-				if (srcStringEnd >= position) {
-					return srcString.slice(position - srcStringStart, (position += value) - srcStringStart)
+				value = src[position$1++];
+				if (srcStringEnd >= position$1) {
+					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart)
 				}
 				return readString8(value)
 			case 0xda:
 			// str 16
-				value = dataView.getUint16(position);
-				position += 2;
-				if (srcStringEnd >= position) {
-					return srcString.slice(position - srcStringStart, (position += value) - srcStringStart)
+				value = dataView.getUint16(position$1);
+				position$1 += 2;
+				if (srcStringEnd >= position$1) {
+					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart)
 				}
 				return readString16(value)
 			case 0xdb:
 			// str 32
-				value = dataView.getUint32(position);
-				position += 4;
-				if (srcStringEnd >= position) {
-					return srcString.slice(position - srcStringStart, (position += value) - srcStringStart)
+				value = dataView.getUint32(position$1);
+				position$1 += 4;
+				if (srcStringEnd >= position$1) {
+					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart)
 				}
 				return readString32(value)
 			case 0xdc:
 			// array 16
-				value = dataView.getUint16(position);
-				position += 2;
+				value = dataView.getUint16(position$1);
+				position$1 += 2;
 				return readArray(value)
 			case 0xdd:
 			// array 32
-				value = dataView.getUint32(position);
-				position += 4;
+				value = dataView.getUint32(position$1);
+				position$1 += 4;
 				return readArray(value)
 			case 0xde:
 			// map 16
-				value = dataView.getUint16(position);
-				position += 2;
+				value = dataView.getUint16(position$1);
+				position$1 += 2;
 				return readMap(value)
 			case 0xdf:
 			// map 32
-				value = dataView.getUint32(position);
-				position += 4;
+				value = dataView.getUint32(position$1);
+				position$1 += 4;
 				return readMap(value)
 			default: // negative int
 				if (token >= 0xe0)
@@ -508,7 +516,7 @@ function createStructureReader(structure, firstId) {
 
 const createSecondByteReader = (firstId, read0) => {
 	return function() {
-		let highByte = src[position++];
+		let highByte = src[position$1++];
 		if (highByte === 0)
 			return read0()
 		let id = firstId < 32 ? -(firstId + (highByte << 5)) : firstId + (highByte << 5);
@@ -523,7 +531,7 @@ const createSecondByteReader = (firstId, read0) => {
 };
 
 function loadStructures() {
-	let loadedStructures = saveState(() => {
+	let loadedStructures = saveState$1(() => {
 		// save the state in case getStructures modifies our buffer
 		src = null;
 		return currentUnpackr.getStructures()
@@ -547,9 +555,9 @@ function setExtractor(extractStrings) {
 		return function readString(length) {
 			let string = strings[stringPosition++];
 			if (string == null) {
-				if (bundledStrings)
+				if (bundledStrings$1)
 					return readStringJS(length)
-				let extraction = extractStrings(position - headerLength, srcEnd, src);
+				let extraction = extractStrings(position$1 - headerLength, srcEnd, src);
 				if (typeof extraction == 'string') {
 					string = extraction;
 					strings = EMPTY_ARRAY;
@@ -564,13 +572,13 @@ function setExtractor(extractStrings) {
 			}
 			let srcStringLength = string.length;
 			if (srcStringLength <= length) {
-				position += length;
+				position$1 += length;
 				return string
 			}
 			srcString = string;
-			srcStringStart = position;
-			srcStringEnd = position + srcStringLength;
-			position += length;
+			srcStringStart = position$1;
+			srcStringEnd = position$1 + srcStringLength;
+			position$1 += length;
 			return string.slice(0, length) // we know we just want the beginning
 		}
 	}
@@ -582,29 +590,29 @@ function readStringJS(length) {
 			return result
 	}
 	if (length > 64 && decoder)
-		return decoder.decode(src.subarray(position, position += length))
-	const end = position + length;
+		return decoder.decode(src.subarray(position$1, position$1 += length))
+	const end = position$1 + length;
 	const units = [];
 	result = '';
-	while (position < end) {
-		const byte1 = src[position++];
+	while (position$1 < end) {
+		const byte1 = src[position$1++];
 		if ((byte1 & 0x80) === 0) {
 			// 1 byte
 			units.push(byte1);
 		} else if ((byte1 & 0xe0) === 0xc0) {
 			// 2 bytes
-			const byte2 = src[position++] & 0x3f;
+			const byte2 = src[position$1++] & 0x3f;
 			units.push(((byte1 & 0x1f) << 6) | byte2);
 		} else if ((byte1 & 0xf0) === 0xe0) {
 			// 3 bytes
-			const byte2 = src[position++] & 0x3f;
-			const byte3 = src[position++] & 0x3f;
+			const byte2 = src[position$1++] & 0x3f;
+			const byte3 = src[position$1++] & 0x3f;
 			units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
 		} else if ((byte1 & 0xf8) === 0xf0) {
 			// 4 bytes
-			const byte2 = src[position++] & 0x3f;
-			const byte3 = src[position++] & 0x3f;
-			const byte4 = src[position++] & 0x3f;
+			const byte2 = src[position$1++] & 0x3f;
+			const byte3 = src[position$1++] & 0x3f;
+			const byte4 = src[position$1++] & 0x3f;
 			let unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
 			if (unit > 0xffff) {
 				unit -= 0x10000;
@@ -631,7 +639,7 @@ function readStringJS(length) {
 function readString(source, start, length) {
 	let existingSrc = src;
 	src = source;
-	position = start;
+	position$1 = start;
 	try {
 		return readStringJS(length);
 	} finally {
@@ -670,12 +678,12 @@ function readMap(length) {
 
 var fromCharCode = String.fromCharCode;
 function longStringInJS(length) {
-	let start = position;
+	let start = position$1;
 	let bytes = new Array(length);
 	for (let i = 0; i < length; i++) {
-		const byte = src[position++];
+		const byte = src[position$1++];
 		if ((byte & 0x80) > 0) {
-				position = start;
+				position$1 = start;
 				return
 			}
 			bytes[i] = byte;
@@ -688,131 +696,131 @@ function shortStringInJS(length) {
 			if (length === 0)
 				return ''
 			else {
-				let a = src[position++];
+				let a = src[position$1++];
 				if ((a & 0x80) > 1) {
-					position -= 1;
+					position$1 -= 1;
 					return
 				}
 				return fromCharCode(a)
 			}
 		} else {
-			let a = src[position++];
-			let b = src[position++];
+			let a = src[position$1++];
+			let b = src[position$1++];
 			if ((a & 0x80) > 0 || (b & 0x80) > 0) {
-				position -= 2;
+				position$1 -= 2;
 				return
 			}
 			if (length < 3)
 				return fromCharCode(a, b)
-			let c = src[position++];
+			let c = src[position$1++];
 			if ((c & 0x80) > 0) {
-				position -= 3;
+				position$1 -= 3;
 				return
 			}
 			return fromCharCode(a, b, c)
 		}
 	} else {
-		let a = src[position++];
-		let b = src[position++];
-		let c = src[position++];
-		let d = src[position++];
+		let a = src[position$1++];
+		let b = src[position$1++];
+		let c = src[position$1++];
+		let d = src[position$1++];
 		if ((a & 0x80) > 0 || (b & 0x80) > 0 || (c & 0x80) > 0 || (d & 0x80) > 0) {
-			position -= 4;
+			position$1 -= 4;
 			return
 		}
 		if (length < 6) {
 			if (length === 4)
 				return fromCharCode(a, b, c, d)
 			else {
-				let e = src[position++];
+				let e = src[position$1++];
 				if ((e & 0x80) > 0) {
-					position -= 5;
+					position$1 -= 5;
 					return
 				}
 				return fromCharCode(a, b, c, d, e)
 			}
 		} else if (length < 8) {
-			let e = src[position++];
-			let f = src[position++];
+			let e = src[position$1++];
+			let f = src[position$1++];
 			if ((e & 0x80) > 0 || (f & 0x80) > 0) {
-				position -= 6;
+				position$1 -= 6;
 				return
 			}
 			if (length < 7)
 				return fromCharCode(a, b, c, d, e, f)
-			let g = src[position++];
+			let g = src[position$1++];
 			if ((g & 0x80) > 0) {
-				position -= 7;
+				position$1 -= 7;
 				return
 			}
 			return fromCharCode(a, b, c, d, e, f, g)
 		} else {
-			let e = src[position++];
-			let f = src[position++];
-			let g = src[position++];
-			let h = src[position++];
+			let e = src[position$1++];
+			let f = src[position$1++];
+			let g = src[position$1++];
+			let h = src[position$1++];
 			if ((e & 0x80) > 0 || (f & 0x80) > 0 || (g & 0x80) > 0 || (h & 0x80) > 0) {
-				position -= 8;
+				position$1 -= 8;
 				return
 			}
 			if (length < 10) {
 				if (length === 8)
 					return fromCharCode(a, b, c, d, e, f, g, h)
 				else {
-					let i = src[position++];
+					let i = src[position$1++];
 					if ((i & 0x80) > 0) {
-						position -= 9;
+						position$1 -= 9;
 						return
 					}
 					return fromCharCode(a, b, c, d, e, f, g, h, i)
 				}
 			} else if (length < 12) {
-				let i = src[position++];
-				let j = src[position++];
+				let i = src[position$1++];
+				let j = src[position$1++];
 				if ((i & 0x80) > 0 || (j & 0x80) > 0) {
-					position -= 10;
+					position$1 -= 10;
 					return
 				}
 				if (length < 11)
 					return fromCharCode(a, b, c, d, e, f, g, h, i, j)
-				let k = src[position++];
+				let k = src[position$1++];
 				if ((k & 0x80) > 0) {
-					position -= 11;
+					position$1 -= 11;
 					return
 				}
 				return fromCharCode(a, b, c, d, e, f, g, h, i, j, k)
 			} else {
-				let i = src[position++];
-				let j = src[position++];
-				let k = src[position++];
-				let l = src[position++];
+				let i = src[position$1++];
+				let j = src[position$1++];
+				let k = src[position$1++];
+				let l = src[position$1++];
 				if ((i & 0x80) > 0 || (j & 0x80) > 0 || (k & 0x80) > 0 || (l & 0x80) > 0) {
-					position -= 12;
+					position$1 -= 12;
 					return
 				}
 				if (length < 14) {
 					if (length === 12)
 						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l)
 					else {
-						let m = src[position++];
+						let m = src[position$1++];
 						if ((m & 0x80) > 0) {
-							position -= 13;
+							position$1 -= 13;
 							return
 						}
 						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m)
 					}
 				} else {
-					let m = src[position++];
-					let n = src[position++];
+					let m = src[position$1++];
+					let n = src[position$1++];
 					if ((m & 0x80) > 0 || (n & 0x80) > 0) {
-						position -= 14;
+						position$1 -= 14;
 						return
 					}
 					if (length < 15)
 						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n)
-					let o = src[position++];
+					let o = src[position$1++];
 					if ((o & 0x80) > 0) {
-						position -= 15;
+						position$1 -= 15;
 						return
 					}
 					return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
@@ -823,7 +831,7 @@ function shortStringInJS(length) {
 }
 
 function readOnlyJSString() {
-	let token = src[position++];
+	let token = src[position$1++];
 	let length;
 	if (token < 0xc0) {
 		// fixstr
@@ -832,17 +840,17 @@ function readOnlyJSString() {
 		switch(token) {
 			case 0xd9:
 			// str 8
-				length = src[position++];
+				length = src[position$1++];
 				break
 			case 0xda:
 			// str 16
-				length = dataView.getUint16(position);
-				position += 2;
+				length = dataView.getUint16(position$1);
+				position$1 += 2;
 				break
 			case 0xdb:
 			// str 32
-				length = dataView.getUint32(position);
-				position += 4;
+				length = dataView.getUint32(position$1);
+				position$1 += 4;
 				break
 			default:
 				throw new Error('Expected string')
@@ -855,19 +863,19 @@ function readOnlyJSString() {
 function readBin(length) {
 	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)
+		Uint8Array.prototype.slice.call(src, position$1, position$1 += length) :
+		src.subarray(position$1, position$1 += length)
 }
 function readExt(length) {
-	let type = src[position++];
+	let type = src[position$1++];
 	if (currentExtensions[type]) {
 		let end;
-		return currentExtensions[type](src.subarray(position, end = (position += length)), (readPosition) => {
-			position = readPosition;
+		return currentExtensions[type](src.subarray(position$1, end = (position$1 += length)), (readPosition) => {
+			position$1 = readPosition;
 			try {
 				return read();
 			} finally {
-				position = end;
+				position$1 = end;
 			}
 		})
 	}
@@ -877,22 +885,22 @@ function readExt(length) {
 
 var keyCache = new Array(4096);
 function readKey() {
-	let length = src[position++];
+	let length = src[position$1++];
 	if (length >= 0xa0 && length < 0xc0) {
 		// 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)
+		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)
 		else if (!(srcStringEnd == 0 && srcEnd < 180))
 			return readFixedString(length)
 	} else { // not cacheable, go back and do a standard read
-		position--;
-		return read()
+		position$1--;
+		return read().toString()
 	}
-	let key = ((length << 5) ^ (length > 1 ? dataView.getUint16(position) : length > 0 ? src[position] : 0)) & 0xfff;
+	let key = ((length << 5) ^ (length > 1 ? dataView.getUint16(position$1) : length > 0 ? src[position$1] : 0)) & 0xfff;
 	let entry = keyCache[key];
-	let checkPosition = position;
-	let end = position + length - 3;
+	let checkPosition = position$1;
+	let end = position$1 + length - 3;
 	let chunk;
 	let i = 0;
 	if (entry && entry.bytes == length) {
@@ -913,11 +921,11 @@ function readKey() {
 			}
 		}
 		if (checkPosition === end) {
-			position = checkPosition;
+			position$1 = checkPosition;
 			return entry.string
 		}
 		end -= 3;
-		checkPosition = position;
+		checkPosition = position$1;
 	}
 	entry = [];
 	keyCache[key] = entry;
@@ -941,16 +949,7 @@ function readKey() {
 
 // the registration of the record definition extension (as "r")
 const recordDefinition = (id, highByte) => {
-	let structure;
-	if (currentUnpackr.freezeData) {
-		currentUnpackr.freezeData = false;
-		try {
-			structure = read();
-		} finally {
-			currentUnpackr.freezeData = true;
-		}
-	} else
-		structure = read();
+	let structure = read().map(property => property.toString()); // ensure that all keys are strings and that the array is mutable
 	let firstByte = id;
 	if (highByte !== undefined) {
 		id = id < 32 ? -((highByte << 5) + id) : ((highByte << 5) + id);
@@ -974,10 +973,10 @@ currentExtensions[0x65] = () => {
 
 currentExtensions[0x69] = (data) => {
 	// id extension (for structured clones)
-	let id = dataView.getUint32(position - 4);
+	let id = dataView.getUint32(position$1 - 4);
 	if (!referenceMap)
 		referenceMap = new Map();
-	let token = src[position];
+	let token = src[position$1];
 	let target;
 	// TODO: handle Maps, Sets, and other types that can cycle; this is complicated, because you potentially need to read
 	// ahead past references to record structure definitions
@@ -997,7 +996,7 @@ currentExtensions[0x69] = (data) => {
 
 currentExtensions[0x70] = (data) => {
 	// pointer extension (for structured clones)
-	let id = dataView.getUint32(position - 4);
+	let id = dataView.getUint32(position$1 - 4);
 	let refEntry = referenceMap.get(id);
 	refEntry.used = true;
 	return refEntry.target
@@ -1022,14 +1021,14 @@ currentExtensions[0x78] = () => {
 const TEMP_BUNDLE = [];
 currentExtensions[0x62] = (data) => {
 	let dataSize = (data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3];
-	let dataPosition = position;
-	position += dataSize - data.length;
-	bundledStrings = TEMP_BUNDLE;
-	bundledStrings = [readOnlyJSString(), readOnlyJSString()];
-	bundledStrings.position0 = 0;
-	bundledStrings.position1 = 0;
-	bundledStrings.postBundlePosition = position;
-	position = dataPosition;
+	let dataPosition = position$1;
+	position$1 += dataSize - data.length;
+	bundledStrings$1 = TEMP_BUNDLE;
+	bundledStrings$1 = [readOnlyJSString(), readOnlyJSString()];
+	bundledStrings$1.position0 = 0;
+	bundledStrings$1.position1 = 0;
+	bundledStrings$1.postBundlePosition = position$1;
+	position$1 = dataPosition;
 	return read()
 };
 
@@ -1051,18 +1050,18 @@ currentExtensions[0xff] = (data) => {
 // registration of bulk record definition?
 // currentExtensions[0x52] = () =>
 
-function saveState(callback) {
+function saveState$1(callback) {
 	if (onSaveState)
 		onSaveState();
 	let savedSrcEnd = srcEnd;
-	let savedPosition = position;
+	let savedPosition = position$1;
 	let savedStringPosition = stringPosition;
 	let savedSrcStringStart = srcStringStart;
 	let savedSrcStringEnd = srcStringEnd;
 	let savedSrcString = srcString;
 	let savedStrings = strings;
 	let savedReferenceMap = referenceMap;
-	let savedBundledStrings = bundledStrings;
+	let savedBundledStrings = bundledStrings$1;
 
 	// TODO: We may need to revisit this if we do more external calls to user code (since it could be slow)
 	let savedSrc = new Uint8Array(src.slice(0, srcEnd)); // we copy the data in case it changes while external data is processed
@@ -1072,14 +1071,14 @@ function saveState(callback) {
 	let savedSequentialMode = sequentialMode;
 	let value = callback();
 	srcEnd = savedSrcEnd;
-	position = savedPosition;
+	position$1 = savedPosition;
 	stringPosition = savedStringPosition;
 	srcStringStart = savedSrcStringStart;
 	srcStringEnd = savedSrcStringEnd;
 	srcString = savedSrcString;
 	strings = savedStrings;
 	referenceMap = savedReferenceMap;
-	bundledStrings = savedBundledStrings;
+	bundledStrings$1 = savedBundledStrings;
 	src = savedSrc;
 	sequentialMode = savedSequentialMode;
 	currentStructures = savedStructures;
@@ -1094,7 +1093,7 @@ function clearSource() {
 	currentStructures = null;
 }
 
-function addExtension(extension) {
+function addExtension$1(extension) {
 	if (extension.unpack)
 		currentExtensions[extension.type] = extension.unpack;
 	else
@@ -1124,26 +1123,26 @@ function roundFloat32(float32Number) {
 	return ((multiplier * float32Number + (float32Number > 0 ? 0.5 : -0.5)) >> 0) / multiplier
 }
 function setReadStruct(updatedReadStruct, loadedStructs, saveState) {
-	readStruct = updatedReadStruct;
-	onLoadedStructures = loadedStructs;
+	readStruct$1 = updatedReadStruct;
+	onLoadedStructures$1 = loadedStructs;
 	onSaveState = saveState;
 }
 
-let textEncoder;
+let textEncoder$1;
 try {
-	textEncoder = new TextEncoder();
+	textEncoder$1 = new TextEncoder();
 } catch (error) {}
 let extensions, extensionClasses;
-const hasNodeBuffer = typeof Buffer !== 'undefined';
-const ByteArrayAllocate = hasNodeBuffer ?
+const hasNodeBuffer$1 = typeof Buffer !== 'undefined';
+const ByteArrayAllocate = hasNodeBuffer$1 ?
 	function(length) { return Buffer.allocUnsafeSlow(length) } : Uint8Array;
-const ByteArray = hasNodeBuffer ? Buffer : Uint8Array;
-const MAX_BUFFER_SIZE = hasNodeBuffer ? 0x100000000 : 0x7fd00000;
+const ByteArray = hasNodeBuffer$1 ? Buffer : Uint8Array;
+const MAX_BUFFER_SIZE = hasNodeBuffer$1 ? 0x100000000 : 0x7fd00000;
 let target, keysTarget;
 let targetView;
-let position$1 = 0;
+let position = 0;
 let safeEnd;
-let bundledStrings$1 = null;
+let bundledStrings = null;
 let writeStructSlots;
 const MAX_BUNDLE_SIZE = 0xf000;
 const hasNonLatin = /[\u0080-\uFFFF]/;
@@ -1158,9 +1157,9 @@ class Packr extends Unpackr {
 		let referenceMap;
 		let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position) {
 			return target.utf8Write(string, position, 0xffffffff)
-		} : (textEncoder && textEncoder.encodeInto) ?
+		} : (textEncoder$1 && textEncoder$1.encodeInto) ?
 			function(string, position) {
-				return textEncoder.encodeInto(string, target.subarray(position)).written
+				return textEncoder$1.encodeInto(string, target.subarray(position)).written
 			} : false;
 
 		let packr = this;
@@ -1195,25 +1194,25 @@ class Packr extends Unpackr {
 		this.pack = this.encode = function(value, encodeOptions) {
 			if (!target) {
 				target = new ByteArrayAllocate(8192);
-				targetView = target.dataView = new DataView(target.buffer, 0, 8192);
-				position$1 = 0;
+				targetView = target.dataView || (target.dataView = new DataView(target.buffer, 0, 8192));
+				position = 0;
 			}
 			safeEnd = target.length - 10;
-			if (safeEnd - position$1 < 0x800) {
+			if (safeEnd - position < 0x800) {
 				// don't start too close to the end, 
 				target = new ByteArrayAllocate(target.length);
-				targetView = target.dataView = new DataView(target.buffer, 0, target.length);
+				targetView = target.dataView || (target.dataView = new DataView(target.buffer, 0, target.length));
 				safeEnd = target.length - 10;
-				position$1 = 0;
+				position = 0;
 			} else
-				position$1 = (position$1 + 7) & 0x7ffffff8; // Word align to make any future copying of this buffer faster
-			start = position$1;
+				position = (position + 7) & 0x7ffffff8; // Word align to make any future copying of this buffer faster
+			start = position;
 			referenceMap = packr.structuredClone ? new Map() : null;
 			if (packr.bundleStrings && typeof value !== 'string') {
-				bundledStrings$1 = [];
-				bundledStrings$1.size = Infinity; // force a new bundle start on first string
+				bundledStrings = [];
+				bundledStrings.size = Infinity; // force a new bundle start on first string
 			} else
-				bundledStrings$1 = null;
+				bundledStrings = null;
 			structures = packr.structures;
 			if (structures) {
 				if (structures.uninitialized)
@@ -1254,27 +1253,51 @@ class Packr extends Unpackr {
 					writeStruct(value);
 				else
 					pack(value);
+				let lastBundle = bundledStrings;
+				if (bundledStrings)
+					writeBundles(start, pack, 0);
 				if (referenceMap && referenceMap.idsToInsert) {
-					let incrementPosition = referenceMap.idsToInsert.length * 6;
-					if (bundledStrings$1)
-						writeBundles(start, pack, incrementPosition);
-					position$1 += incrementPosition;
-					if (position$1 > safeEnd)
-						makeRoom(position$1);
-					packr.offset = position$1;
-					let serialized = insertIds(target.subarray(start, position$1), referenceMap.idsToInsert);
+					let idsToInsert = referenceMap.idsToInsert.sort((a, b) => a.offset > b.offset ? 1 : -1);
+					let i = idsToInsert.length;
+					let incrementPosition = -1;
+					while (lastBundle && i > 0) {
+						let insertionPoint = idsToInsert[--i].offset + start;
+						if (insertionPoint < (lastBundle.stringsPosition + start) && incrementPosition === -1)
+							incrementPosition = 0;
+						if (insertionPoint > (lastBundle.position + start)) {
+							if (incrementPosition >= 0)
+								incrementPosition += 6;
+						} else {
+							if (incrementPosition >= 0) {
+								// update the bundle reference now
+								targetView.setUint32(lastBundle.position + start,
+									targetView.getUint32(lastBundle.position + start) + incrementPosition);
+								incrementPosition = -1; // reset
+							}
+							lastBundle = lastBundle.previous;
+							i++;
+						}
+					}
+					if (incrementPosition >= 0 && lastBundle) {
+						// update the bundle reference now
+						targetView.setUint32(lastBundle.position + start,
+							targetView.getUint32(lastBundle.position + start) + incrementPosition);
+					}
+					position += idsToInsert.length * 6;
+					if (position > safeEnd)
+						makeRoom(position);
+					packr.offset = position;
+					let serialized = insertIds(target.subarray(start, position), idsToInsert);
 					referenceMap = null;
 					return serialized
 				}
-				if (bundledStrings$1)
-					writeBundles(start, pack, 0);
-				packr.offset = position$1; // update the offset so next serialization doesn't write over our buffer, but can continue writing to same buffer sequentially
+				packr.offset = position; // update the offset so next serialization doesn't write over our buffer, but can continue writing to same buffer sequentially
 				if (encodeOptions & REUSE_BUFFER_MODE) {
 					target.start = start;
-					target.end = position$1;
+					target.end = position;
 					return target
 				}
-				return target.subarray(start, position$1) // 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
 			} finally {
 				if (structures) {
 					if (serializationsSinceTransitionRebuild < 10)
@@ -1297,8 +1320,8 @@ class Packr extends Unpackr {
 					}
 					if (hasSharedUpdate && packr.saveStructures) {
 						// 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$1);
-						let newSharedData = prepareStructures(structures, packr);
+						let returnBuffer = target.subarray(start, position);
+						let newSharedData = prepareStructures$1(structures, packr);
 						if (packr.saveStructures(newSharedData, newSharedData.isCompatible) === false) {
 							// get updated structures and try again if the update failed
 							return packr.pack(value)
@@ -1308,44 +1331,47 @@ class Packr extends Unpackr {
 					}
 				}
 				if (encodeOptions & RESET_BUFFER_MODE)
-					position$1 = start;
+					position = start;
 			}
 		};
 		const pack = (value) => {
-			if (position$1 > safeEnd)
-				target = makeRoom(position$1);
+			if (position > safeEnd)
+				target = makeRoom(position);
 
 			var type = typeof value;
 			var length;
 			if (type === 'string') {
 				let strLength = value.length;
-				if (bundledStrings$1 && strLength >= 4 && strLength < 0x1000) {
-					if ((bundledStrings$1.size += strLength) > MAX_BUNDLE_SIZE) {
+				if (bundledStrings && strLength >= 4 && strLength < 0x1000) {
+					if ((bundledStrings.size += strLength) > MAX_BUNDLE_SIZE) {
 						let extStart;
-						let maxBytes = (bundledStrings$1[0] ? bundledStrings$1[0].length * 3 + bundledStrings$1[1].length : 0) + 10;
-						if (position$1 + maxBytes > safeEnd)
-							target = makeRoom(position$1 + maxBytes);
-						if (bundledStrings$1.position) { // here we use the 0x62 extension to write the last bundle and reserve sapce for the reference pointer to the next/current bundle
-							target[position$1] = 0xc8; // ext 16
-							position$1 += 3; // reserve for the writing bundle size
-							target[position$1++] = 0x62; // 'b'
-							extStart = position$1 - start;
-							position$1 += 4; // reserve for writing bundle reference
-							writeBundles(start, pack); // write the last bundles
-							targetView.setUint16(extStart + start - 3, position$1 - start - extStart);
+						let maxBytes = (bundledStrings[0] ? bundledStrings[0].length * 3 + bundledStrings[1].length : 0) + 10;
+						if (position + maxBytes > safeEnd)
+							target = makeRoom(position + maxBytes);
+						let lastBundle;
+						if (bundledStrings.position) { // here we use the 0x62 extension to write the last bundle and reserve space for the reference pointer to the next/current bundle
+							lastBundle = bundledStrings;
+							target[position] = 0xc8; // ext 16
+							position += 3; // reserve for the writing bundle size
+							target[position++] = 0x62; // 'b'
+							extStart = position - start;
+							position += 4; // reserve for writing bundle reference
+							writeBundles(start, pack, 0); // write the last bundles
+							targetView.setUint16(extStart + start - 3, position - start - extStart);
 						} else { // here we use the 0x62 extension just to reserve the space for the reference pointer to the bundle (will be updated once the bundle is written)
-							target[position$1++] = 0xd6; // fixext 4
-							target[position$1++] = 0x62; // 'b'
-							extStart = position$1 - start;
-							position$1 += 4; // reserve for writing bundle reference
+							target[position++] = 0xd6; // fixext 4
+							target[position++] = 0x62; // 'b'
+							extStart = position - start;
+							position += 4; // reserve for writing bundle reference
 						}
-						bundledStrings$1 = ['', '']; // create new ones
-						bundledStrings$1.size = 0;
-						bundledStrings$1.position = extStart;
+						bundledStrings = ['', '']; // create new ones
+						bundledStrings.previous = lastBundle;
+						bundledStrings.size = 0;
+						bundledStrings.position = extStart;
 					}
 					let twoByte = hasNonLatin.test(value);
-					bundledStrings$1[twoByte ? 0 : 1] += value;
-					target[position$1++] = 0xc1;
+					bundledStrings[twoByte ? 0 : 1] += value;
+					target[position++] = 0xc1;
 					pack(twoByte ? -strLength : strLength);
 					return
 				}
@@ -1361,11 +1387,11 @@ class Packr extends Unpackr {
 					headerSize = 5;
 				}
 				let maxBytes = strLength * 3;
-				if (position$1 + maxBytes > safeEnd)
-					target = makeRoom(position$1 + maxBytes);
+				if (position + maxBytes > safeEnd)
+					target = makeRoom(position + maxBytes);
 
 				if (strLength < 0x40 || !encodeUtf8) {
-					let i, c1, c2, strPosition = position$1 + headerSize;
+					let i, c1, c2, strPosition = position + headerSize;
 					for (i = 0; i < strLength; i++) {
 						c1 = value.charCodeAt(i);
 						if (c1 < 0x80) {
@@ -1389,88 +1415,88 @@ class Packr extends Unpackr {
 							target[strPosition++] = c1 & 0x3f | 0x80;
 						}
 					}
-					length = strPosition - position$1 - headerSize;
+					length = strPosition - position - headerSize;
 				} else {
-					length = encodeUtf8(value, position$1 + headerSize);
+					length = encodeUtf8(value, position + headerSize);
 				}
 
 				if (length < 0x20) {
-					target[position$1++] = 0xa0 | length;
+					target[position++] = 0xa0 | length;
 				} else if (length < 0x100) {
 					if (headerSize < 2) {
-						target.copyWithin(position$1 + 2, position$1 + 1, position$1 + 1 + length);
+						target.copyWithin(position + 2, position + 1, position + 1 + length);
 					}
-					target[position$1++] = 0xd9;
-					target[position$1++] = length;
+					target[position++] = 0xd9;
+					target[position++] = length;
 				} else if (length < 0x10000) {
 					if (headerSize < 3) {
-						target.copyWithin(position$1 + 3, position$1 + 2, position$1 + 2 + length);
+						target.copyWithin(position + 3, position + 2, position + 2 + length);
 					}
-					target[position$1++] = 0xda;
-					target[position$1++] = length >> 8;
-					target[position$1++] = length & 0xff;
+					target[position++] = 0xda;
+					target[position++] = length >> 8;
+					target[position++] = length & 0xff;
 				} else {
 					if (headerSize < 5) {
-						target.copyWithin(position$1 + 5, position$1 + 3, position$1 + 3 + length);
+						target.copyWithin(position + 5, position + 3, position + 3 + length);
 					}
-					target[position$1++] = 0xdb;
-					targetView.setUint32(position$1, length);
-					position$1 += 4;
+					target[position++] = 0xdb;
+					targetView.setUint32(position, length);
+					position += 4;
 				}
-				position$1 += length;
+				position += length;
 			} else if (type === 'number') {
 				if (value >>> 0 === value) {// positive integer, 32-bit or less
 					// positive uint
 					if (value < 0x20 || (value < 0x80 && this.useRecords === false) || (value < 0x40 && !this.randomAccessStructure)) {
-						target[position$1++] = value;
+						target[position++] = value;
 					} else if (value < 0x100) {
-						target[position$1++] = 0xcc;
-						target[position$1++] = value;
+						target[position++] = 0xcc;
+						target[position++] = value;
 					} else if (value < 0x10000) {
-						target[position$1++] = 0xcd;
-						target[position$1++] = value >> 8;
-						target[position$1++] = value & 0xff;
+						target[position++] = 0xcd;
+						target[position++] = value >> 8;
+						target[position++] = value & 0xff;
 					} else {
-						target[position$1++] = 0xce;
-						targetView.setUint32(position$1, value);
-						position$1 += 4;
+						target[position++] = 0xce;
+						targetView.setUint32(position, value);
+						position += 4;
 					}
 				} else if (value >> 0 === value) { // negative integer
 					if (value >= -0x20) {
-						target[position$1++] = 0x100 + value;
+						target[position++] = 0x100 + value;
 					} else if (value >= -0x80) {
-						target[position$1++] = 0xd0;
-						target[position$1++] = value + 0x100;
+						target[position++] = 0xd0;
+						target[position++] = value + 0x100;
 					} else if (value >= -0x8000) {
-						target[position$1++] = 0xd1;
-						targetView.setInt16(position$1, value);
-						position$1 += 2;
+						target[position++] = 0xd1;
+						targetView.setInt16(position, value);
+						position += 2;
 					} else {
-						target[position$1++] = 0xd2;
-						targetView.setInt32(position$1, value);
-						position$1 += 4;
+						target[position++] = 0xd2;
+						targetView.setInt32(position, value);
+						position += 4;
 					}
 				} else {
 					let useFloat32;
 					if ((useFloat32 = this.useFloat32) > 0 && value < 0x100000000 && value >= -0x80000000) {
-						target[position$1++] = 0xca;
-						targetView.setFloat32(position$1, value);
+						target[position++] = 0xca;
+						targetView.setFloat32(position, value);
 						let xShifted;
 						if (useFloat32 < 4 ||
 								// this checks for rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
-								((xShifted = value * mult10[((target[position$1] & 0x7f) << 1) | (target[position$1 + 1] >> 7)]) >> 0) === xShifted) {
-							position$1 += 4;
+								((xShifted = value * mult10[((target[position] & 0x7f) << 1) | (target[position + 1] >> 7)]) >> 0) === xShifted) {
+							position += 4;
 							return
 						} else
-							position$1--; // move back into position for writing a double
+							position--; // move back into position for writing a double
 					}
-					target[position$1++] = 0xcb;
-					targetView.setFloat64(position$1, value);
-					position$1 += 8;
+					target[position++] = 0xcb;
+					targetView.setFloat64(position, value);
+					position += 8;
 				}
 			} else if (type === 'object') {
 				if (!value)
-					target[position$1++] = 0xc0;
+					target[position++] = 0xc0;
 				else {
 					if (referenceMap) {
 						let referee = referenceMap.get(value);
@@ -1479,29 +1505,29 @@ class Packr extends Unpackr {
 								let idsToInsert = referenceMap.idsToInsert || (referenceMap.idsToInsert = []);
 								referee.id = idsToInsert.push(referee);
 							}
-							target[position$1++] = 0xd6; // fixext 4
-							target[position$1++] = 0x70; // "p" for pointer
-							targetView.setUint32(position$1, referee.id);
-							position$1 += 4;
+							target[position++] = 0xd6; // fixext 4
+							target[position++] = 0x70; // "p" for pointer
+							targetView.setUint32(position, referee.id);
+							position += 4;
 							return
 						} else 
-							referenceMap.set(value, { offset: position$1 - start });
+							referenceMap.set(value, { offset: position - start });
 					}
 					let constructor = value.constructor;
 					if (constructor === Object) {
 						writeObject(value, true);
-					} else if (constructor === Array) {
+					} else if (constructor === Array || Array.isArray(value)) {
 						length = value.length;
 						if (length < 0x10) {
-							target[position$1++] = 0x90 | length;
+							target[position++] = 0x90 | length;
 						} else if (length < 0x10000) {
-							target[position$1++] = 0xdc;
-							target[position$1++] = length >> 8;
-							target[position$1++] = length & 0xff;
+							target[position++] = 0xdc;
+							target[position++] = length >> 8;
+							target[position++] = length & 0xff;
 						} else {
-							target[position$1++] = 0xdd;
-							targetView.setUint32(position$1, length);
-							position$1 += 4;
+							target[position++] = 0xdd;
+							targetView.setUint32(position, length);
+							position += 4;
 						}
 						for (let i = 0; i < length; i++) {
 							pack(value[i]);
@@ -1509,15 +1535,15 @@ class Packr extends Unpackr {
 					} else if (constructor === Map) {
 						length = value.size;
 						if (length < 0x10) {
-							target[position$1++] = 0x80 | length;
+							target[position++] = 0x80 | length;
 						} else if (length < 0x10000) {
-							target[position$1++] = 0xde;
-							target[position$1++] = length >> 8;
-							target[position$1++] = length & 0xff;
+							target[position++] = 0xde;
+							target[position++] = length >> 8;
+							target[position++] = length & 0xff;
 						} else {
-							target[position$1++] = 0xdf;
-							targetView.setUint32(position$1, length);
-							position$1 += 4;
+							target[position++] = 0xdf;
+							targetView.setUint32(position, length);
+							position += 4;
 						}
 						for (let [ key, entryValue ] of value) {
 							pack(key);
@@ -1530,16 +1556,16 @@ class Packr extends Unpackr {
 								let extension = extensions[i];
 								if (extension.write) {
 									if (extension.type) {
-										target[position$1++] = 0xd4; // one byte "tag" extension
-										target[position$1++] = extension.type;
-										target[position$1++] = 0;
+										target[position++] = 0xd4; // one byte "tag" extension
+										target[position++] = extension.type;
+										target[position++] = 0;
 									}
 									pack(extension.write.call(this, value));
 									return
 								}
 								let currentTarget = target;
 								let currentTargetView = targetView;
-								let currentPosition = position$1;
+								let currentPosition = position;
 								target = null;
 								let result;
 								try {
@@ -1547,11 +1573,11 @@ class Packr extends Unpackr {
 										// restore target and use it
 										target = currentTarget;
 										currentTarget = null;
-										position$1 += size;
-										if (position$1 > safeEnd)
-											makeRoom(position$1);
+										position += size;
+										if (position > safeEnd)
+											makeRoom(position);
 										return {
-											target, targetView, position: position$1 - size
+											target, targetView, position: position - size
 										}
 									}, pack);
 								} finally {
@@ -1559,14 +1585,14 @@ class Packr extends Unpackr {
 									if (currentTarget) {
 										target = currentTarget;
 										targetView = currentTargetView;
-										position$1 = currentPosition;
+										position = currentPosition;
 										safeEnd = target.length - 10;
 									}
 								}
 								if (result) {
-									if (result.length + position$1 > safeEnd)
-										makeRoom(result.length + position$1);
-									position$1 = writeExtensionData(result, target, position$1, extension.type);
+									if (result.length + position > safeEnd)
+										makeRoom(result.length + position);
+									position = writeExtensionData(result, target, position, extension.type);
 								}
 								return
 							}
@@ -1576,33 +1602,33 @@ class Packr extends Unpackr {
 					}
 				}
 			} else if (type === 'boolean') {
-				target[position$1++] = value ? 0xc3 : 0xc2;
+				target[position++] = value ? 0xc3 : 0xc2;
 			} else if (type === 'bigint') {
 				if (value < (BigInt(1)<<BigInt(63)) && value >= -(BigInt(1)<<BigInt(63))) {
 					// use a signed int as long as it fits
-					target[position$1++] = 0xd3;
-					targetView.setBigInt64(position$1, value);
+					target[position++] = 0xd3;
+					targetView.setBigInt64(position, value);
 				} else if (value < (BigInt(1)<<BigInt(64)) && value > 0) {
 					// if we can fit an unsigned int, use that
-					target[position$1++] = 0xcf;
-					targetView.setBigUint64(position$1, value);
+					target[position++] = 0xcf;
+					targetView.setBigUint64(position, value);
 				} else {
 					// overflow
 					if (this.largeBigIntToFloat) {
-						target[position$1++] = 0xcb;
-						targetView.setFloat64(position$1, Number(value));
+						target[position++] = 0xcb;
+						targetView.setFloat64(position, Number(value));
 					} else {
 						throw new RangeError(value + ' was too large to fit in MessagePack 64-bit integer format, set largeBigIntToFloat to convert to float-64')
 					}
 				}
-				position$1 += 8;
+				position += 8;
 			} else if (type === 'undefined') {
 				if (this.encodeUndefinedAsNil)
-					target[position$1++] = 0xc0;
+					target[position++] = 0xc0;
 				else {
-					target[position$1++] = 0xd4; // a number of implementations use fixext1 with type 0, data 0 to denote undefined, so we follow suite
-					target[position$1++] = 0;
-					target[position$1++] = 0;
+					target[position++] = 0xd4; // a number of implementations use fixext1 with type 0, data 0 to denote undefined, so we follow suite
+					target[position++] = 0;
+					target[position++] = 0;
 				}
 			} else if (type === 'function') {
 				pack(this.writeFunction && this.writeFunction()); // if there is a writeFunction, use it, otherwise just encode as undefined
@@ -1616,15 +1642,15 @@ class Packr extends Unpackr {
 			let keys = Object.keys(object);
 			let length = keys.length;
 			if (length < 0x10) {
-				target[position$1++] = 0x80 | length;
+				target[position++] = 0x80 | length;
 			} else if (length < 0x10000) {
-				target[position$1++] = 0xde;
-				target[position$1++] = length >> 8;
-				target[position$1++] = length & 0xff;
+				target[position++] = 0xde;
+				target[position++] = length >> 8;
+				target[position++] = length & 0xff;
 			} else {
-				target[position$1++] = 0xdf;
-				targetView.setUint32(position$1, length);
-				position$1 += 4;
+				target[position++] = 0xdf;
+				targetView.setUint32(position, length);
+				position += 4;
 			}
 			let key;
 			for (let i = 0; i < length; i++) {
@@ -1633,9 +1659,9 @@ class Packr extends Unpackr {
 			}
 		} :
 		(object, safePrototype) => {
-			target[position$1++] = 0xde; // always using map 16, so we can preallocate and set the length afterwards
-			let objectOffset = position$1 - start;
-			position$1 += 2;
+			target[position++] = 0xde; // always using map 16, so we can preallocate and set the length afterwards
+			let objectOffset = position - start;
+			position += 2;
 			let size = 0;
 			for (let key in object) {
 				if (safePrototype || object.hasOwnProperty(key)) {
@@ -1650,7 +1676,7 @@ class Packr extends Unpackr {
 		(options.progressiveRecords && !useTwoByteRecords) ?  // this is about 2% faster for highly stable structures, since it only requires one for-in loop (but much more expensive when new structure needs to be written)
 		(object, safePrototype) => {
 			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
-			let objectOffset = position$1++ - start;
+			let objectOffset = position++ - start;
 			let wroteKeys;
 			for (let key in object) {
 				if (safePrototype || object.hasOwnProperty(key)) {
@@ -1672,9 +1698,9 @@ class Packr extends Unpackr {
 							}
 							transition = nextTransition;
 						}
-						if (objectOffset + start + 1 == position$1) {
+						if (objectOffset + start + 1 == position) {
 							// first key, so we don't need to insert, we can just write record directly
-							position$1--;
+							position--;
 							newRecord(transition, keys, newTransitions);
 						} else // otherwise we need to insert the record, moving existing data after the record
 							insertNewRecord(transition, keys, objectOffset, newTransitions);
@@ -1706,10 +1732,10 @@ class Packr extends Unpackr {
 			let recordId = transition[RECORD_SYMBOL];
 			if (recordId) {
 				if (recordId >= 0x60 && useTwoByteRecords) {
-					target[position$1++] = ((recordId -= 0x60) & 0x1f) + 0x60;
-					target[position$1++] = recordId >> 5;
+					target[position++] = ((recordId -= 0x60) & 0x1f) + 0x60;
+					target[position++] = recordId >> 5;
 				} else
-					target[position$1++] = recordId;
+					target[position++] = recordId;
 			} else {
 				newRecord(transition, transition.__keys__ || Object.keys(object), newTransitions);
 			}
@@ -1729,13 +1755,13 @@ class Packr extends Unpackr {
 			} else // faster handling for smaller buffers
 				newSize = ((Math.max((end - start) << 2, target.length - 1) >> 12) + 1) << 12;
 			let newBuffer = new ByteArrayAllocate(newSize);
-			targetView = newBuffer.dataView = new DataView(newBuffer.buffer, 0, newSize);
+			targetView = newBuffer.dataView || (newBuffer.dataView = new DataView(newBuffer.buffer, 0, newSize));
 			end = Math.min(end, target.length);
 			if (target.copy)
 				target.copy(newBuffer, 0, start, end);
 			else
 				newBuffer.set(target.slice(start, end));
-			position$1 -= start;
+			position -= start;
 			start = 0;
 			safeEnd = newBuffer.length - 10;
 			return target = newBuffer
@@ -1764,21 +1790,21 @@ class Packr extends Unpackr {
 				structures.sharedLength = recordId - 0x3f;
 				hasSharedUpdate = true;
 				if (highByte >= 0) {
-					target[position$1++] = (recordId & 0x1f) + 0x60;
-					target[position$1++] = highByte;
+					target[position++] = (recordId & 0x1f) + 0x60;
+					target[position++] = highByte;
 				} else {
-					target[position$1++] = recordId;
+					target[position++] = recordId;
 				}
 			} else {
 				if (highByte >= 0) {
-					target[position$1++] = 0xd5; // fixext 2
-					target[position$1++] = 0x72; // "r" record defintion extension type
-					target[position$1++] = (recordId & 0x1f) + 0x60;
-					target[position$1++] = highByte;
+					target[position++] = 0xd5; // fixext 2
+					target[position++] = 0x72; // "r" record defintion extension type
+					target[position++] = (recordId & 0x1f) + 0x60;
+					target[position++] = highByte;
 				} else {
-					target[position$1++] = 0xd4; // fixext 1
-					target[position$1++] = 0x72; // "r" record defintion extension type
-					target[position$1++] = recordId;
+					target[position++] = 0xd4; // fixext 1
+					target[position++] = 0x72; // "r" record defintion extension type
+					target[position++] = recordId;
 				}
 
 				if (newTransitions)
@@ -1792,57 +1818,57 @@ class Packr extends Unpackr {
 		};
 		const insertNewRecord = (transition, keys, insertionOffset, newTransitions) => {
 			let mainTarget = target;
-			let mainPosition = position$1;
+			let mainPosition = position;
 			let mainSafeEnd = safeEnd;
 			let mainStart = start;
 			target = keysTarget;
-			position$1 = 0;
+			position = 0;
 			start = 0;
 			if (!target)
 				keysTarget = target = new ByteArrayAllocate(8192);
 			safeEnd = target.length - 10;
 			newRecord(transition, keys, newTransitions);
 			keysTarget = target;
-			let keysPosition = position$1;
+			let keysPosition = position;
 			target = mainTarget;
-			position$1 = mainPosition;
+			position = mainPosition;
 			safeEnd = mainSafeEnd;
 			start = mainStart;
 			if (keysPosition > 1) {
-				let newEnd = position$1 + keysPosition - 1;
+				let newEnd = position + keysPosition - 1;
 				if (newEnd > safeEnd)
 					makeRoom(newEnd);
 				let insertionPosition = insertionOffset + start;
-				target.copyWithin(insertionPosition + keysPosition, insertionPosition + 1, position$1);
+				target.copyWithin(insertionPosition + keysPosition, insertionPosition + 1, position);
 				target.set(keysTarget.slice(0, keysPosition), insertionPosition);
-				position$1 = newEnd;
+				position = newEnd;
 			} else {
 				target[insertionOffset + start] = keysTarget[0];
 			}
 		};
 		const writeStruct = (object, safePrototype) => {
-			let newPosition = writeStructSlots(object, target, position$1, structures, makeRoom, (value, newPosition, notifySharedUpdate) => {
+			let newPosition = writeStructSlots(object, target, position, structures, makeRoom, (value, newPosition, notifySharedUpdate) => {
 				if (notifySharedUpdate)
 					return hasSharedUpdate = true;
-				position$1 = newPosition;
+				position = newPosition;
 				if (start > 0) {
 					pack(value);
 					if (start == 0)
-						return { position: position$1, targetView, target }; // indicate the buffer was re-allocated
+						return { position, targetView, target }; // indicate the buffer was re-allocated
 				} else
 					pack(value);
-				return position$1;
+				return position;
 			}, this);
 			if (newPosition === 0) // bail and go to a msgpack object
 				return writeObject(object, true);
-			position$1 = newPosition;
+			position = newPosition;
 		};
 	}
 	useBuffer(buffer) {
 		// this means we are finished using our own buffer and we can write over it safely
 		target = buffer;
 		targetView = new DataView(target.buffer, target.byteOffset, target.byteLength);
-		position$1 = 0;
+		position = 0;
 	}
 	clearSharedData() {
 		if (this.structures)
@@ -1925,7 +1951,7 @@ extensions = [{
 		if (this.moreTypes)
 			writeExtBuffer(arrayBuffer, 0x10, allocateForWrite);
 		else
-			writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
+			writeBuffer(hasNodeBuffer$1 ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
 	}
 }, {
 	pack(typedArray, allocateForWrite) {
@@ -2029,7 +2055,6 @@ function insertIds(serialized, idsToInsert) {
 	let nextId;
 	let distanceToMove = idsToInsert.length * 6;
 	let lastEnd = serialized.length - distanceToMove;
-	idsToInsert.sort((a, b) => a.offset > b.offset ? 1 : -1);
 	while (nextId = idsToInsert.pop()) {
 		let offset = nextId.offset;
 		let id = nextId.id;
@@ -2048,16 +2073,17 @@ function insertIds(serialized, idsToInsert) {
 }
 
 function writeBundles(start, pack, incrementPosition) {
-	if (bundledStrings$1.length > 0) {
-		targetView.setUint32(bundledStrings$1.position + start, position$1 + incrementPosition - bundledStrings$1.position - start);
-		let writeStrings = bundledStrings$1;
-		bundledStrings$1 = null;
+	if (bundledStrings.length > 0) {
+		targetView.setUint32(bundledStrings.position + start, position + incrementPosition - bundledStrings.position - start);
+		bundledStrings.stringsPosition = position - start;
+		let writeStrings = bundledStrings;
+		bundledStrings = null;
 		pack(writeStrings[0]);
 		pack(writeStrings[1]);
 	}
 }
 
-function addExtension$1(extension) {
+function addExtension(extension) {
 	if (extension.Class) {
 		if (!extension.pack && !extension.write)
 			throw new Error('Extension has no pack or write function')
@@ -2066,9 +2092,9 @@ function addExtension$1(extension) {
 		extensionClasses.unshift(extension.Class);
 		extensions.unshift(extension);
 	}
-	addExtension(extension);
+	addExtension$1(extension);
 }
-function prepareStructures(structures, packr) {
+function prepareStructures$1(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
@@ -2079,7 +2105,7 @@ function prepareStructures(structures, packr) {
 }
 function setWriteStructSlots(writeSlots, makeStructures) {
 	writeStructSlots = writeSlots;
-	prepareStructures = makeStructures;
+	prepareStructures$1 = makeStructures;
 }
 
 let defaultPackr = new Packr({ useRecords: false });
@@ -2107,18 +2133,18 @@ try {
 }
 
 let updatedPosition;
-const hasNodeBuffer$1 = typeof Buffer !== 'undefined';
-let textEncoder$1, currentSource;
+const hasNodeBuffer = typeof Buffer !== 'undefined';
+let textEncoder, currentSource;
 try {
-	textEncoder$1 = new TextEncoder();
+	textEncoder = new TextEncoder();
 } catch (error) {}
-const encodeUtf8 = hasNodeBuffer$1 ? function(target, string, position) {
+const encodeUtf8 = hasNodeBuffer ? function(target, string, position) {
 	return target.utf8Write(string, position, 0xffffffff)
-} : (textEncoder$1 && textEncoder$1.encodeInto) ?
+} : (textEncoder && textEncoder.encodeInto) ?
 	function(target, string, position) {
-		return textEncoder$1.encodeInto(string, target.subarray(position)).written
+		return textEncoder.encodeInto(string, target.subarray(position)).written
 	} : false;
-setWriteStructSlots(writeStruct, prepareStructures$1);
+setWriteStructSlots(writeStruct, prepareStructures);
 function writeStruct(object, target, 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
@@ -2211,9 +2237,9 @@ function writeStruct(object, target, position, structures, makeRoom, pack, packr
 			case 'string':
 				let strLength = value.length;
 				refOffset = refPosition - refsStartPosition;
-				if ((strLength << 2) + position > safeEnd) {
+				if ((strLength << 2) + refPosition > safeEnd) {
 					let lastStart = start;
-					target = makeRoom(refPosition);
+					target = makeRoom((strLength << 2) + refPosition);
 					targetView = target.dataView;
 					position -= lastStart;
 					refsStartPosition -= lastStart;
@@ -2493,7 +2519,7 @@ function createTypeTransition(transition, type, size) {
 	newTransition.__parent = transition;
 	return newTransition;
 }
-function onLoadedStructures$1(sharedData) {
+function onLoadedStructures(sharedData) {
 	if (!(sharedData instanceof Map))
 		return sharedData;
 	let typed = sharedData.get('typed') || [];
@@ -2531,7 +2557,7 @@ function onLoadedStructures$1(sharedData) {
 	return named;
 }
 var sourceSymbol = Symbol.for('source');
-function readStruct$1(src, position, srcEnd, unpackr) {
+function readStruct(src, position, srcEnd, unpackr) {
 	let recordId = src[position++] - 0x20;
 	if (recordId >= 24) {
 		switch(recordId) {
@@ -2802,14 +2828,14 @@ function withSource(get) {
 	}
 }
 
-function saveState$1() {
+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$1(structures, packr) {
+function prepareStructures(structures, packr) {
 	if (packr.typedStructs) {
 		let structMap = new Map();
 		structMap.set('named', structures);
@@ -2826,7 +2852,7 @@ function prepareStructures$1(structures, packr) {
 			let typed = existing.get('typed') || [];
 			if (typed.length !== lastTypedStructuresLength)
 				compatible = false;
-		} else if (existing instanceof Array) {
+		} else if (existing instanceof Array || Array.isArray(existing)) {
 			if (existing.length !== (packr.lastNamedStructuresLength || 0))
 				compatible = false;
 		}
@@ -2838,7 +2864,7 @@ function prepareStructures$1(structures, packr) {
 	return structures;
 }
 
-setReadStruct(readStruct$1, onLoadedStructures$1, saveState$1);
+setReadStruct(readStruct, onLoadedStructures, saveState);
 
 class PackrStream extends stream.Transform {
 	constructor(options) {
@@ -3011,7 +3037,7 @@ exports.Packr = Packr;
 exports.PackrStream = PackrStream;
 exports.Unpackr = Unpackr;
 exports.UnpackrStream = UnpackrStream;
-exports.addExtension = addExtension$1;
+exports.addExtension = addExtension;
 exports.clearSource = clearSource;
 exports.decode = decode;
 exports.decodeIter = decodeIter;