webpack 5.107.2 → 5.108.0

package/lib/serialization/BinaryMiddleware.js

@@ -84,6 +84,7 @@ const NULL3_HEADER = 0x12;
 const NULLS8_HEADER = 0x13;
 const NULLS32_HEADER = 0x14;
 const NULL_AND_I8_HEADER = 0x15;
+const NULL_AND_I16_HEADER = 0x19;
 const NULL_AND_I32_HEADER = 0x16;
 const NULL_AND_TRUE_HEADER = 0x17;
 const NULL_AND_FALSE_HEADER = 0x18;
@@ -104,6 +105,7 @@ const SHORT_STRING_LENGTH_MASK = 0x7f; // 0b0111_1111
 
 const HEADER_SIZE = 1;
 const I8_SIZE = 1;
+const I16_SIZE = 2;
 const I32_SIZE = 4;
 const F64_SIZE = 8;
 
@@ -148,6 +150,521 @@ const identifyBigInt = (n) => {
  * @typedef {import("./SerializerMiddleware").LazyFunction<LazyInputValue, LazyOutputValue, BinaryMiddleware, undefined>} LazyFunction
  */
 
+/**
+ * Mutable read state of one `_deserialize` run; the module-level dispatch
+ * table operates on this instead of per-call closures.
+ */
+class ReadState {
+	/**
+	 * @param {SerializedType} data data
+	 * @param {Context} context context object
+	 * @param {BinaryMiddleware} middleware binary middleware
+	 */
+	constructor(data, context, middleware) {
+		/** @type {SerializedType} */
+		this.data = data;
+		/** @type {Context} */
+		this.context = context;
+		/** @type {BinaryMiddleware} */
+		this.middleware = middleware;
+		this.retainedBuffer = context.retainedBuffer || ((x) => x);
+		/** @type {number} */
+		this.currentDataItem = 0;
+		/** @type {BufferSerializableType | null} */
+		this.currentBuffer = data[0];
+		/** @type {boolean} */
+		this.currentIsBuffer = Buffer.isBuffer(this.currentBuffer);
+		/** @type {number} */
+		this.currentPosition = 0;
+		/** @type {DeserializedType} */
+		this.result = [];
+	}
+
+	/** Advances to the next data item (does not reset the position). */
+	nextDataItem() {
+		this.currentDataItem++;
+		this.currentBuffer =
+			this.currentDataItem < this.data.length
+				? this.data[this.currentDataItem]
+				: null;
+		this.currentIsBuffer = Buffer.isBuffer(this.currentBuffer);
+	}
+
+	checkOverflow() {
+		if (
+			this.currentPosition >= /** @type {Buffer} */ (this.currentBuffer).length
+		) {
+			this.currentPosition = 0;
+			this.nextDataItem();
+		}
+	}
+
+	/**
+	 * Checks whether n bytes are available in the current buffer.
+	 * @param {number} n n
+	 * @returns {boolean} true when in current buffer, otherwise false
+	 */
+	isInCurrentBuffer(n) {
+		return (
+			this.currentIsBuffer &&
+			n + this.currentPosition <=
+				/** @type {Buffer} */ (this.currentBuffer).length
+		);
+	}
+
+	ensureBuffer() {
+		if (!this.currentIsBuffer) {
+			throw new Error(
+				this.currentBuffer === null
+					? "Unexpected end of stream"
+					: "Unexpected lazy element in stream"
+			);
+		}
+	}
+
+	/**
+	 * Returns buffer with bytes.
+	 * @param {number} n amount of bytes to read
+	 * @returns {Buffer} buffer with bytes
+	 */
+	read(n) {
+		this.ensureBuffer();
+		const rem =
+			/** @type {Buffer} */ (this.currentBuffer).length - this.currentPosition;
+		if (rem < n) {
+			const buffers = [this.read(rem)];
+			n -= rem;
+			this.ensureBuffer();
+			while (/** @type {Buffer} */ (this.currentBuffer).length < n) {
+				const b = /** @type {Buffer} */ (this.currentBuffer);
+				buffers.push(b);
+				n -= b.length;
+				this.nextDataItem();
+				this.ensureBuffer();
+			}
+			buffers.push(this.read(n));
+			return Buffer.concat(buffers);
+		}
+		const b = /** @type {Buffer} */ (this.currentBuffer);
+		const res = Buffer.from(b.buffer, b.byteOffset + this.currentPosition, n);
+		this.currentPosition += n;
+		this.checkOverflow();
+		return res;
+	}
+
+	/**
+	 * Reads up to n bytes.
+	 * @param {number} n amount of bytes to read
+	 * @returns {Buffer} buffer with bytes
+	 */
+	readUpTo(n) {
+		this.ensureBuffer();
+		const rem =
+			/** @type {Buffer} */ (this.currentBuffer).length - this.currentPosition;
+		if (rem < n) {
+			n = rem;
+		}
+		const b = /** @type {Buffer} */ (this.currentBuffer);
+		const res = Buffer.from(b.buffer, b.byteOffset + this.currentPosition, n);
+		this.currentPosition += n;
+		this.checkOverflow();
+		return res;
+	}
+
+	/**
+	 * Returns u8.
+	 * @returns {number} U8
+	 */
+	readU8() {
+		this.ensureBuffer();
+		/**
+		 * There is no need to check remaining buffer size here
+		 * since {@link ReadState#checkOverflow} guarantees at least one byte remaining
+		 */
+		const byte =
+			/** @type {Buffer} */
+			(this.currentBuffer).readUInt8(this.currentPosition);
+		this.currentPosition += I8_SIZE;
+		this.checkOverflow();
+		return byte;
+	}
+
+	/**
+	 * Returns u32.
+	 * @returns {number} U32
+	 */
+	readU32() {
+		// fast path avoids allocating a 4-byte view per length read
+		if (this.isInCurrentBuffer(I32_SIZE)) {
+			const value =
+				/** @type {Buffer} */
+				(this.currentBuffer).readUInt32LE(this.currentPosition);
+			this.currentPosition += I32_SIZE;
+			this.checkOverflow();
+			return value;
+		}
+		return this.read(I32_SIZE).readUInt32LE(0);
+	}
+
+	/**
+	 * Pushes the lowest n bits of data as booleans.
+	 * @param {number} data data
+	 * @param {number} n n
+	 */
+	readBits(data, n) {
+		let mask = 1;
+		while (n !== 0) {
+			this.result.push((data & mask) !== 0);
+			mask <<= 1;
+			n--;
+		}
+	}
+}
+
+/**
+ * Deserialize handlers indexed by header byte; built once so each
+ * `_deserialize` call doesn't rebuild 256 closures (hot on cache restore).
+ * @type {((s: ReadState) => void)[]}
+ */
+const dispatchTable = Array.from({ length: 256 }, (_, header) => {
+	switch (header) {
+		case LAZY_HEADER:
+			return (s) => {
+				const count = s.readU32();
+				/** @type {number[]} */
+				const lengths = [];
+				for (let i = 0; i < count; i++) lengths.push(s.readU32());
+				/** @type {(Buffer | LazyFunction<SerializedType, DeserializedType>)[]} */
+				const content = [];
+				for (let l of lengths) {
+					if (l === 0) {
+						if (typeof s.currentBuffer !== "function") {
+							throw new Error("Unexpected non-lazy element in stream");
+						}
+						content.push(s.currentBuffer);
+						s.nextDataItem();
+					} else {
+						do {
+							const buf = s.readUpTo(l);
+							l -= buf.length;
+							content.push(s.retainedBuffer(buf));
+						} while (l > 0);
+					}
+				}
+				s.result.push(s.middleware._createLazyDeserialized(content, s.context));
+			};
+		case BUFFER_HEADER:
+			return (s) => {
+				const len = s.readU32();
+				s.result.push(s.retainedBuffer(s.read(len)));
+			};
+		case TRUE_HEADER:
+			return (s) => s.result.push(true);
+		case FALSE_HEADER:
+			return (s) => s.result.push(false);
+		case NULL3_HEADER:
+			return (s) => s.result.push(null, null, null);
+		case NULL2_HEADER:
+			return (s) => s.result.push(null, null);
+		case NULL_HEADER:
+			return (s) => s.result.push(null);
+		case NULL_AND_TRUE_HEADER:
+			return (s) => s.result.push(null, true);
+		case NULL_AND_FALSE_HEADER:
+			return (s) => s.result.push(null, false);
+		case NULL_AND_I8_HEADER:
+			return (s) => {
+				if (s.currentIsBuffer) {
+					s.result.push(
+						null,
+						/** @type {Buffer} */ (s.currentBuffer).readInt8(s.currentPosition)
+					);
+					s.currentPosition += I8_SIZE;
+					s.checkOverflow();
+				} else {
+					s.result.push(null, s.read(I8_SIZE).readInt8(0));
+				}
+			};
+		case NULL_AND_I16_HEADER:
+			return (s) => {
+				s.result.push(null);
+				if (s.isInCurrentBuffer(I16_SIZE)) {
+					s.result.push(
+						/** @type {Buffer} */ (s.currentBuffer).readInt16LE(
+							s.currentPosition
+						)
+					);
+					s.currentPosition += I16_SIZE;
+					s.checkOverflow();
+				} else {
+					s.result.push(s.read(I16_SIZE).readInt16LE(0));
+				}
+			};
+		case NULL_AND_I32_HEADER:
+			return (s) => {
+				s.result.push(null);
+				if (s.isInCurrentBuffer(I32_SIZE)) {
+					s.result.push(
+						/** @type {Buffer} */ (s.currentBuffer).readInt32LE(
+							s.currentPosition
+						)
+					);
+					s.currentPosition += I32_SIZE;
+					s.checkOverflow();
+				} else {
+					s.result.push(s.read(I32_SIZE).readInt32LE(0));
+				}
+			};
+		case NULLS8_HEADER:
+			return (s) => {
+				const len = s.readU8() + 4;
+				for (let i = 0; i < len; i++) {
+					s.result.push(null);
+				}
+			};
+		case NULLS32_HEADER:
+			return (s) => {
+				const len = s.readU32() + 260;
+				for (let i = 0; i < len; i++) {
+					s.result.push(null);
+				}
+			};
+		case BOOLEANS_HEADER:
+			return (s) => {
+				const innerHeader = s.readU8();
+				if ((innerHeader & 0xf0) === 0) {
+					s.readBits(innerHeader, 3);
+				} else if ((innerHeader & 0xe0) === 0) {
+					s.readBits(innerHeader, 4);
+				} else if ((innerHeader & 0xc0) === 0) {
+					s.readBits(innerHeader, 5);
+				} else if ((innerHeader & 0x80) === 0) {
+					s.readBits(innerHeader, 6);
+				} else if (innerHeader !== 0xff) {
+					let count = (innerHeader & 0x7f) + 7;
+					while (count > 8) {
+						s.readBits(s.readU8(), 8);
+						count -= 8;
+					}
+					s.readBits(s.readU8(), count);
+				} else {
+					let count = s.readU32();
+					while (count > 8) {
+						s.readBits(s.readU8(), 8);
+						count -= 8;
+					}
+					s.readBits(s.readU8(), count);
+				}
+			};
+		case STRING_HEADER:
+			return (s) => {
+				const len = s.readU32();
+				if (s.isInCurrentBuffer(len) && s.currentPosition + len < 0x7fffffff) {
+					s.result.push(
+						/** @type {Buffer} */
+						(s.currentBuffer).toString(
+							undefined,
+							s.currentPosition,
+							s.currentPosition + len
+						)
+					);
+					s.currentPosition += len;
+					s.checkOverflow();
+				} else {
+					s.result.push(s.read(len).toString());
+				}
+			};
+		case SHORT_STRING_HEADER:
+			return (s) => s.result.push("");
+		case SHORT_STRING_HEADER | 1:
+			return (s) => {
+				if (s.currentIsBuffer && s.currentPosition < 0x7ffffffe) {
+					s.result.push(
+						/** @type {Buffer} */
+						(s.currentBuffer).toString(
+							"latin1",
+							s.currentPosition,
+							s.currentPosition + 1
+						)
+					);
+					s.currentPosition++;
+					s.checkOverflow();
+				} else {
+					s.result.push(s.read(1).toString("latin1"));
+				}
+			};
+		case I8_HEADER:
+			return (s) => {
+				if (s.currentIsBuffer) {
+					s.result.push(
+						/** @type {Buffer} */ (s.currentBuffer).readInt8(s.currentPosition)
+					);
+					s.currentPosition++;
+					s.checkOverflow();
+				} else {
+					s.result.push(s.read(1).readInt8(0));
+				}
+			};
+		case BIGINT_I8_HEADER: {
+			const len = 1;
+			return (s) => {
+				const need = I8_SIZE * len;
+
+				if (s.isInCurrentBuffer(need)) {
+					for (let i = 0; i < len; i++) {
+						const value =
+							/** @type {Buffer} */
+							(s.currentBuffer).readInt8(s.currentPosition);
+						s.result.push(BigInt(value));
+						s.currentPosition += I8_SIZE;
+					}
+					s.checkOverflow();
+				} else {
+					const buf = s.read(need);
+					for (let i = 0; i < len; i++) {
+						const value = buf.readInt8(i * I8_SIZE);
+						s.result.push(BigInt(value));
+					}
+				}
+			};
+		}
+		case BIGINT_I32_HEADER: {
+			const len = 1;
+			return (s) => {
+				const need = I32_SIZE * len;
+				if (s.isInCurrentBuffer(need)) {
+					for (let i = 0; i < len; i++) {
+						const value = /** @type {Buffer} */ (s.currentBuffer).readInt32LE(
+							s.currentPosition
+						);
+						s.result.push(BigInt(value));
+						s.currentPosition += I32_SIZE;
+					}
+					s.checkOverflow();
+				} else {
+					const buf = s.read(need);
+					for (let i = 0; i < len; i++) {
+						const value = buf.readInt32LE(i * I32_SIZE);
+						s.result.push(BigInt(value));
+					}
+				}
+			};
+		}
+		case BIGINT_HEADER: {
+			return (s) => {
+				const len = s.readU32();
+				if (s.isInCurrentBuffer(len) && s.currentPosition + len < 0x7fffffff) {
+					const value =
+						/** @type {Buffer} */
+						(s.currentBuffer).toString(
+							undefined,
+							s.currentPosition,
+							s.currentPosition + len
+						);
+
+					s.result.push(BigInt(value));
+					s.currentPosition += len;
+					s.checkOverflow();
+				} else {
+					const value = s.read(len).toString();
+					s.result.push(BigInt(value));
+				}
+			};
+		}
+		default:
+			if (header <= 10) {
+				return (s) => s.result.push(header);
+			} else if ((header & SHORT_STRING_HEADER) === SHORT_STRING_HEADER) {
+				const len = header & SHORT_STRING_LENGTH_MASK;
+				return (s) => {
+					if (
+						s.isInCurrentBuffer(len) &&
+						s.currentPosition + len < 0x7fffffff
+					) {
+						s.result.push(
+							/** @type {Buffer} */
+							(s.currentBuffer).toString(
+								"latin1",
+								s.currentPosition,
+								s.currentPosition + len
+							)
+						);
+						s.currentPosition += len;
+						s.checkOverflow();
+					} else {
+						s.result.push(s.read(len).toString("latin1"));
+					}
+				};
+			} else if ((header & NUMBERS_HEADER_MASK) === F64_HEADER) {
+				const len = (header & NUMBERS_COUNT_MASK) + 1;
+				return (s) => {
+					const need = F64_SIZE * len;
+					if (s.isInCurrentBuffer(need)) {
+						for (let i = 0; i < len; i++) {
+							s.result.push(
+								/** @type {Buffer} */ (s.currentBuffer).readDoubleLE(
+									s.currentPosition
+								)
+							);
+							s.currentPosition += F64_SIZE;
+						}
+						s.checkOverflow();
+					} else {
+						const buf = s.read(need);
+						for (let i = 0; i < len; i++) {
+							s.result.push(buf.readDoubleLE(i * F64_SIZE));
+						}
+					}
+				};
+			} else if ((header & NUMBERS_HEADER_MASK) === I32_HEADER) {
+				const len = (header & NUMBERS_COUNT_MASK) + 1;
+				return (s) => {
+					const need = I32_SIZE * len;
+					if (s.isInCurrentBuffer(need)) {
+						for (let i = 0; i < len; i++) {
+							s.result.push(
+								/** @type {Buffer} */ (s.currentBuffer).readInt32LE(
+									s.currentPosition
+								)
+							);
+							s.currentPosition += I32_SIZE;
+						}
+						s.checkOverflow();
+					} else {
+						const buf = s.read(need);
+						for (let i = 0; i < len; i++) {
+							s.result.push(buf.readInt32LE(i * I32_SIZE));
+						}
+					}
+				};
+			} else if ((header & NUMBERS_HEADER_MASK) === I8_HEADER) {
+				const len = (header & NUMBERS_COUNT_MASK) + 1;
+				return (s) => {
+					const need = I8_SIZE * len;
+					if (s.isInCurrentBuffer(need)) {
+						for (let i = 0; i < len; i++) {
+							s.result.push(
+								/** @type {Buffer} */ (s.currentBuffer).readInt8(
+									s.currentPosition
+								)
+							);
+							s.currentPosition += I8_SIZE;
+						}
+						s.checkOverflow();
+					} else {
+						const buf = s.read(need);
+						for (let i = 0; i < len; i++) {
+							s.result.push(buf.readInt8(i * I8_SIZE));
+						}
+					}
+				};
+			}
+			return (s) => {
+				throw new Error(`Unexpected header byte 0x${header.toString(16)}`);
+			};
+	}
+});
+
 /**
  * Represents BinaryMiddleware.
  * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
@@ -582,10 +1099,19 @@ class BinaryMiddleware extends SerializerMiddleware {
 										currentPosition += I8_SIZE;
 										i++;
 									} else if (type === 1) {
-										allocate(HEADER_SIZE + I32_SIZE);
-										writeU8(NULL_AND_I32_HEADER);
-										currentBuffer.writeInt32LE(next, currentPosition);
-										currentPosition += I32_SIZE;
+										// `null` + i32 is 5 bytes; if the value also fits an
+										// i16, fuse it as 3 bytes instead (helps back-references)
+										if (next >= -32768 && next <= 32767) {
+											allocate(HEADER_SIZE + I16_SIZE);
+											writeU8(NULL_AND_I16_HEADER);
+											currentBuffer.writeInt16LE(next, currentPosition);
+											currentPosition += I16_SIZE;
+										} else {
+											allocate(HEADER_SIZE + I32_SIZE);
+											writeU8(NULL_AND_I32_HEADER);
+											currentBuffer.writeInt32LE(next, currentPosition);
+											currentPosition += I32_SIZE;
+										}
 										i++;
 									} else {
 										allocate(HEADER_SIZE);
@@ -674,8 +1200,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 	}
 
 	/**
-	 * Create lazy deserialized.
-	 * @private
+	 * Create lazy deserialized. Internal, but called from the dispatch table.
 	 * @param {SerializedType} content content
 	 * @param {Context} context context object
 	 * @returns {LazyFunction<DeserializedType, SerializedType>} lazy function
@@ -709,471 +1234,16 @@ class BinaryMiddleware extends SerializerMiddleware {
 	 * @returns {DeserializedType} deserialized data
 	 */
 	_deserialize(data, context) {
-		let currentDataItem = 0;
-		/** @type {BufferSerializableType | null} */
-		let currentBuffer = data[0];
-		let currentIsBuffer = Buffer.isBuffer(currentBuffer);
-		let currentPosition = 0;
-
-		const retainedBuffer = context.retainedBuffer || ((x) => x);
-
-		const checkOverflow = () => {
-			if (currentPosition >= /** @type {Buffer} */ (currentBuffer).length) {
-				currentPosition = 0;
-				currentDataItem++;
-				currentBuffer =
-					currentDataItem < data.length ? data[currentDataItem] : null;
-				currentIsBuffer = Buffer.isBuffer(currentBuffer);
-			}
-		};
-		/**
-		 * Checks whether this binary middleware is in current buffer.
-		 * @param {number} n n
-		 * @returns {boolean} true when in current buffer, otherwise false
-		 */
-		const isInCurrentBuffer = (n) =>
-			currentIsBuffer &&
-			n + currentPosition <= /** @type {Buffer} */ (currentBuffer).length;
-		const ensureBuffer = () => {
-			if (!currentIsBuffer) {
-				throw new Error(
-					currentBuffer === null
-						? "Unexpected end of stream"
-						: "Unexpected lazy element in stream"
-				);
-			}
-		};
-		/**
-		 * Returns buffer with bytes.
-		 * @param {number} n amount of bytes to read
-		 * @returns {Buffer} buffer with bytes
-		 */
-		const read = (n) => {
-			ensureBuffer();
-			const rem =
-				/** @type {Buffer} */ (currentBuffer).length - currentPosition;
-			if (rem < n) {
-				const buffers = [read(rem)];
-				n -= rem;
-				ensureBuffer();
-				while (/** @type {Buffer} */ (currentBuffer).length < n) {
-					const b = /** @type {Buffer} */ (currentBuffer);
-					buffers.push(b);
-					n -= b.length;
-					currentDataItem++;
-					currentBuffer =
-						currentDataItem < data.length ? data[currentDataItem] : null;
-					currentIsBuffer = Buffer.isBuffer(currentBuffer);
-					ensureBuffer();
-				}
-				buffers.push(read(n));
-				return Buffer.concat(buffers);
-			}
-			const b = /** @type {Buffer} */ (currentBuffer);
-			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
-			currentPosition += n;
-			checkOverflow();
-			return res;
-		};
-		/**
-		 * Reads up to n bytes
-		 * @param {number} n amount of bytes to read
-		 * @returns {Buffer} buffer with bytes
-		 */
-		const readUpTo = (n) => {
-			ensureBuffer();
-			const rem =
-				/** @type {Buffer} */
-				(currentBuffer).length - currentPosition;
-			if (rem < n) {
-				n = rem;
-			}
-			const b = /** @type {Buffer} */ (currentBuffer);
-			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
-			currentPosition += n;
-			checkOverflow();
-			return res;
-		};
-		/**
-		 * Returns u8.
-		 * @returns {number} U8
-		 */
-		const readU8 = () => {
-			ensureBuffer();
-			/**
-			 * There is no need to check remaining buffer size here
-			 * since {@link checkOverflow} guarantees at least one byte remaining
-			 */
-			const byte =
-				/** @type {Buffer} */
-				(currentBuffer).readUInt8(currentPosition);
-			currentPosition += I8_SIZE;
-			checkOverflow();
-			return byte;
-		};
-		/**
-		 * Returns u32.
-		 * @returns {number} U32
-		 */
-		const readU32 = () => read(I32_SIZE).readUInt32LE(0);
-		/**
-		 * Processes the provided data.
-		 * @param {number} data data
-		 * @param {number} n n
-		 */
-		const readBits = (data, n) => {
-			let mask = 1;
-			while (n !== 0) {
-				result.push((data & mask) !== 0);
-				mask <<= 1;
-				n--;
-			}
-		};
-		const dispatchTable = Array.from({ length: 256 }).map((_, header) => {
-			switch (header) {
-				case LAZY_HEADER:
-					return () => {
-						const count = readU32();
-						const lengths = Array.from({ length: count }).map(() => readU32());
-						/** @type {(Buffer | LazyFunction<SerializedType, DeserializedType>)[]} */
-						const content = [];
-						for (let l of lengths) {
-							if (l === 0) {
-								if (typeof currentBuffer !== "function") {
-									throw new Error("Unexpected non-lazy element in stream");
-								}
-								content.push(currentBuffer);
-								currentDataItem++;
-								currentBuffer =
-									currentDataItem < data.length ? data[currentDataItem] : null;
-								currentIsBuffer = Buffer.isBuffer(currentBuffer);
-							} else {
-								do {
-									const buf = readUpTo(l);
-									l -= buf.length;
-									content.push(retainedBuffer(buf));
-								} while (l > 0);
-							}
-						}
-						result.push(this._createLazyDeserialized(content, context));
-					};
-				case BUFFER_HEADER:
-					return () => {
-						const len = readU32();
-						result.push(retainedBuffer(read(len)));
-					};
-				case TRUE_HEADER:
-					return () => result.push(true);
-				case FALSE_HEADER:
-					return () => result.push(false);
-				case NULL3_HEADER:
-					return () => result.push(null, null, null);
-				case NULL2_HEADER:
-					return () => result.push(null, null);
-				case NULL_HEADER:
-					return () => result.push(null);
-				case NULL_AND_TRUE_HEADER:
-					return () => result.push(null, true);
-				case NULL_AND_FALSE_HEADER:
-					return () => result.push(null, false);
-				case NULL_AND_I8_HEADER:
-					return () => {
-						if (currentIsBuffer) {
-							result.push(
-								null,
-								/** @type {Buffer} */ (currentBuffer).readInt8(currentPosition)
-							);
-							currentPosition += I8_SIZE;
-							checkOverflow();
-						} else {
-							result.push(null, read(I8_SIZE).readInt8(0));
-						}
-					};
-				case NULL_AND_I32_HEADER:
-					return () => {
-						result.push(null);
-						if (isInCurrentBuffer(I32_SIZE)) {
-							result.push(
-								/** @type {Buffer} */ (currentBuffer).readInt32LE(
-									currentPosition
-								)
-							);
-							currentPosition += I32_SIZE;
-							checkOverflow();
-						} else {
-							result.push(read(I32_SIZE).readInt32LE(0));
-						}
-					};
-				case NULLS8_HEADER:
-					return () => {
-						const len = readU8() + 4;
-						for (let i = 0; i < len; i++) {
-							result.push(null);
-						}
-					};
-				case NULLS32_HEADER:
-					return () => {
-						const len = readU32() + 260;
-						for (let i = 0; i < len; i++) {
-							result.push(null);
-						}
-					};
-				case BOOLEANS_HEADER:
-					return () => {
-						const innerHeader = readU8();
-						if ((innerHeader & 0xf0) === 0) {
-							readBits(innerHeader, 3);
-						} else if ((innerHeader & 0xe0) === 0) {
-							readBits(innerHeader, 4);
-						} else if ((innerHeader & 0xc0) === 0) {
-							readBits(innerHeader, 5);
-						} else if ((innerHeader & 0x80) === 0) {
-							readBits(innerHeader, 6);
-						} else if (innerHeader !== 0xff) {
-							let count = (innerHeader & 0x7f) + 7;
-							while (count > 8) {
-								readBits(readU8(), 8);
-								count -= 8;
-							}
-							readBits(readU8(), count);
-						} else {
-							let count = readU32();
-							while (count > 8) {
-								readBits(readU8(), 8);
-								count -= 8;
-							}
-							readBits(readU8(), count);
-						}
-					};
-				case STRING_HEADER:
-					return () => {
-						const len = readU32();
-						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
-							result.push(
-								/** @type {Buffer} */
-								(currentBuffer).toString(
-									undefined,
-									currentPosition,
-									currentPosition + len
-								)
-							);
-							currentPosition += len;
-							checkOverflow();
-						} else {
-							result.push(read(len).toString());
-						}
-					};
-				case SHORT_STRING_HEADER:
-					return () => result.push("");
-				case SHORT_STRING_HEADER | 1:
-					return () => {
-						if (currentIsBuffer && currentPosition < 0x7ffffffe) {
-							result.push(
-								/** @type {Buffer} */
-								(currentBuffer).toString(
-									"latin1",
-									currentPosition,
-									currentPosition + 1
-								)
-							);
-							currentPosition++;
-							checkOverflow();
-						} else {
-							result.push(read(1).toString("latin1"));
-						}
-					};
-				case I8_HEADER:
-					return () => {
-						if (currentIsBuffer) {
-							result.push(
-								/** @type {Buffer} */ (currentBuffer).readInt8(currentPosition)
-							);
-							currentPosition++;
-							checkOverflow();
-						} else {
-							result.push(read(1).readInt8(0));
-						}
-					};
-				case BIGINT_I8_HEADER: {
-					const len = 1;
-					return () => {
-						const need = I8_SIZE * len;
-
-						if (isInCurrentBuffer(need)) {
-							for (let i = 0; i < len; i++) {
-								const value =
-									/** @type {Buffer} */
-									(currentBuffer).readInt8(currentPosition);
-								result.push(BigInt(value));
-								currentPosition += I8_SIZE;
-							}
-							checkOverflow();
-						} else {
-							const buf = read(need);
-							for (let i = 0; i < len; i++) {
-								const value = buf.readInt8(i * I8_SIZE);
-								result.push(BigInt(value));
-							}
-						}
-					};
-				}
-				case BIGINT_I32_HEADER: {
-					const len = 1;
-					return () => {
-						const need = I32_SIZE * len;
-						if (isInCurrentBuffer(need)) {
-							for (let i = 0; i < len; i++) {
-								const value = /** @type {Buffer} */ (currentBuffer).readInt32LE(
-									currentPosition
-								);
-								result.push(BigInt(value));
-								currentPosition += I32_SIZE;
-							}
-							checkOverflow();
-						} else {
-							const buf = read(need);
-							for (let i = 0; i < len; i++) {
-								const value = buf.readInt32LE(i * I32_SIZE);
-								result.push(BigInt(value));
-							}
-						}
-					};
-				}
-				case BIGINT_HEADER: {
-					return () => {
-						const len = readU32();
-						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
-							const value =
-								/** @type {Buffer} */
-								(currentBuffer).toString(
-									undefined,
-									currentPosition,
-									currentPosition + len
-								);
-
-							result.push(BigInt(value));
-							currentPosition += len;
-							checkOverflow();
-						} else {
-							const value = read(len).toString();
-							result.push(BigInt(value));
-						}
-					};
-				}
-				default:
-					if (header <= 10) {
-						return () => result.push(header);
-					} else if ((header & SHORT_STRING_HEADER) === SHORT_STRING_HEADER) {
-						const len = header & SHORT_STRING_LENGTH_MASK;
-						return () => {
-							if (
-								isInCurrentBuffer(len) &&
-								currentPosition + len < 0x7fffffff
-							) {
-								result.push(
-									/** @type {Buffer} */
-									(currentBuffer).toString(
-										"latin1",
-										currentPosition,
-										currentPosition + len
-									)
-								);
-								currentPosition += len;
-								checkOverflow();
-							} else {
-								result.push(read(len).toString("latin1"));
-							}
-						};
-					} else if ((header & NUMBERS_HEADER_MASK) === F64_HEADER) {
-						const len = (header & NUMBERS_COUNT_MASK) + 1;
-						return () => {
-							const need = F64_SIZE * len;
-							if (isInCurrentBuffer(need)) {
-								for (let i = 0; i < len; i++) {
-									result.push(
-										/** @type {Buffer} */ (currentBuffer).readDoubleLE(
-											currentPosition
-										)
-									);
-									currentPosition += F64_SIZE;
-								}
-								checkOverflow();
-							} else {
-								const buf = read(need);
-								for (let i = 0; i < len; i++) {
-									result.push(buf.readDoubleLE(i * F64_SIZE));
-								}
-							}
-						};
-					} else if ((header & NUMBERS_HEADER_MASK) === I32_HEADER) {
-						const len = (header & NUMBERS_COUNT_MASK) + 1;
-						return () => {
-							const need = I32_SIZE * len;
-							if (isInCurrentBuffer(need)) {
-								for (let i = 0; i < len; i++) {
-									result.push(
-										/** @type {Buffer} */ (currentBuffer).readInt32LE(
-											currentPosition
-										)
-									);
-									currentPosition += I32_SIZE;
-								}
-								checkOverflow();
-							} else {
-								const buf = read(need);
-								for (let i = 0; i < len; i++) {
-									result.push(buf.readInt32LE(i * I32_SIZE));
-								}
-							}
-						};
-					} else if ((header & NUMBERS_HEADER_MASK) === I8_HEADER) {
-						const len = (header & NUMBERS_COUNT_MASK) + 1;
-						return () => {
-							const need = I8_SIZE * len;
-							if (isInCurrentBuffer(need)) {
-								for (let i = 0; i < len; i++) {
-									result.push(
-										/** @type {Buffer} */ (currentBuffer).readInt8(
-											currentPosition
-										)
-									);
-									currentPosition += I8_SIZE;
-								}
-								checkOverflow();
-							} else {
-								const buf = read(need);
-								for (let i = 0; i < len; i++) {
-									result.push(buf.readInt8(i * I8_SIZE));
-								}
-							}
-						};
-					}
-					return () => {
-						throw new Error(`Unexpected header byte 0x${header.toString(16)}`);
-					};
-			}
-		});
-
-		/** @type {DeserializedType} */
-		let result = [];
-		while (currentBuffer !== null) {
-			if (typeof currentBuffer === "function") {
-				result.push(this._deserializeLazy(currentBuffer, context));
-				currentDataItem++;
-				currentBuffer =
-					currentDataItem < data.length ? data[currentDataItem] : null;
-				currentIsBuffer = Buffer.isBuffer(currentBuffer);
+		const state = new ReadState(data, context, this);
+		while (state.currentBuffer !== null) {
+			if (typeof state.currentBuffer === "function") {
+				state.result.push(this._deserializeLazy(state.currentBuffer, context));
+				state.nextDataItem();
 			} else {
-				const header = readU8();
-				dispatchTable[header]();
+				dispatchTable[state.readU8()](state);
 			}
 		}
-
-		// avoid leaking memory in context
-		// eslint-disable-next-line prefer-const
-		let _result = result;
-		result = /** @type {EXPECTED_ANY} */ (undefined);
-		return _result;
+		return state.result;
 	}
 }