@jsprismarine/binaryutils 0.15.0-unstable-20261024002035

package/dist/BinaryStream.es.js

@@ -0,0 +1,831 @@
+import assert from "assert";
+//#region src/BinaryStream.ts
+/**
+* A high-performance binary stream for reading and writing binary data.
+*
+* Unlike Node.js native buffers which have fixed size, BinaryStream uses dynamic
+* buffers that grow automatically during write operations. This eliminates the need
+* for manual resizing or inefficient `Buffer.concat()` calls.
+*
+* @example Reading data
+* ```typescript
+* const stream = new BinaryStream(buffer);
+* const value = stream.readInt();
+* ```
+*
+* @example Writing data
+* ```typescript
+* const stream = new BinaryStream();
+* stream.writeInt(42);
+* stream.write(Buffer.from('Hello'));  // Buffer grows automatically
+* const buffer = stream.getWriteBuffer();
+* ```
+*
+* @example Encoding many packets without allocating
+* ```typescript
+* const stream = new BinaryStream(undefined, 0, 4096);
+* for (const packet of queue) {
+*     stream.resetWrite();
+*     packet.encode(stream);
+*     offset = stream.copyInto(arena, offset);
+* }
+* ```
+*/
+var BinaryStream = class {
+	writeBuffer = null;
+	readBuffer = null;
+	readIndex;
+	writeIndex = 0;
+	writeCapacity = 0;
+	/**
+	* Creates a new BinaryStream instance.
+	* @param {Buffer|null|undefined} buffer - The array or Buffer containing binary data.
+	* @param {number} offset - The initial pointer position.
+	* @param {number} initialCapacity - Pre-allocates the write buffer to this size. Use it when
+	* the encoded size is known up front: it skips the 256 -> 512 -> 1024 ... growth ladder, and
+	* with {@link resetWrite} it lets a long-lived encoder run without allocating at all.
+	*/
+	constructor(buffer, offset = 0, initialCapacity = 0) {
+		this.readBuffer = buffer ?? null;
+		this.readIndex = offset;
+		if (initialCapacity > 0) this.reserve(initialCapacity);
+	}
+	/**
+	* Reads a slice of buffer by the given length.
+	* @param {number} len
+	*/
+	read(len) {
+		this.doReadAssertions(len);
+		return this.readBuffer.subarray(this.readIndex, this.readIndex += len);
+	}
+	/**
+	* Appends a buffer to the main buffer.
+	* @param {Buffer|Uint8Array} buf
+	*/
+	write(buf) {
+		const len = buf.byteLength;
+		this.ensureCapacity(len);
+		this.writeBuffer.set(buf, this.writeIndex);
+		this.writeIndex += len;
+	}
+	/**
+	* Reads an unsigned byte (0 to 255).
+	* @returns {number}
+	*/
+	readByte() {
+		this.doReadAssertions(1);
+		return this.readBuffer[this.readIndex++];
+	}
+	/**
+	* Writes an unsigned byte (0 to 255).
+	* @param {number} v
+	*/
+	writeByte(v) {
+		this.ensureCapacity(1);
+		this.writeBuffer[this.writeIndex++] = v & 255;
+	}
+	/**
+	* Reads a signed byte (-128 to 127).
+	* @returns {number}
+	*/
+	readSignedByte() {
+		this.doReadAssertions(1);
+		return this.readBuffer[this.readIndex++] << 24 >> 24;
+	}
+	/**
+	* Writes a signed byte (-128 to 127).
+	* @param {number} v
+	*/
+	writeSignedByte(v) {
+		this.ensureCapacity(1);
+		this.writeBuffer[this.writeIndex++] = (v < 0 ? 255 + v + 1 : v) & 255;
+	}
+	/**
+	* Reads a boolean (true or false).
+	* @returns {boolean}
+	*/
+	readBoolean() {
+		this.doReadAssertions(1);
+		return this.readBuffer[this.readIndex++] !== 0;
+	}
+	/**
+	* Writes a boolean (true or false).
+	* @param {boolean} v
+	*/
+	writeBoolean(v) {
+		this.ensureCapacity(1);
+		this.writeBuffer[this.writeIndex++] = v ? 1 : 0;
+	}
+	/**
+	* Reads a 16 bit (2 bytes) signed big-endian number.
+	* @returns {number}
+	*/
+	readShort() {
+		this.doReadAssertions(2);
+		return this.readBuffer.readInt16BE(this.addOffset(2));
+	}
+	/**
+	* Writes a 16 bit (2 bytes) signed big-endian number.
+	* @param {number} v
+	*/
+	writeShort(v) {
+		this.doWriteAssertions(v, -32768, 32767);
+		this.ensureCapacity(2);
+		this.writeBuffer[this.writeIndex++] = v >> 8 & 255;
+		this.writeBuffer[this.writeIndex++] = v & 255;
+	}
+	/**
+	* Reads a 16 bit (2 bytes) signed little-endian number.
+	* @returns {number}
+	*/
+	readShortLE() {
+		this.doReadAssertions(2);
+		return this.readBuffer.readInt16LE(this.addOffset(2));
+	}
+	/**
+	* Writes a 16 bit (2 bytes) signed little-endian number.
+	* @param {number} v
+	*/
+	writeShortLE(v) {
+		this.doWriteAssertions(v, -32768, 32767);
+		this.ensureCapacity(2);
+		this.writeBuffer[this.writeIndex++] = v & 255;
+		this.writeBuffer[this.writeIndex++] = v >> 8 & 255;
+	}
+	/**
+	* Reads a 16 bit (2 bytes) unsigned big-endian number.
+	* @returns {number}
+	*/
+	readUnsignedShort() {
+		this.doReadAssertions(2);
+		return this.readBuffer.readUInt16BE(this.addOffset(2));
+	}
+	/**
+	* Writes a 16 bit (2 bytes) unsigned big-endian number.
+	* @param {number} v
+	*/
+	writeUnsignedShort(v) {
+		this.doWriteAssertions(v, 0, 65535);
+		this.ensureCapacity(2);
+		this.writeBuffer[this.writeIndex++] = v >>> 8 & 255;
+		this.writeBuffer[this.writeIndex++] = v & 255;
+	}
+	/**
+	* Reads a 16 bit (2 bytes) unsigned little-endian number.
+	* @returns {number}
+	*/
+	readUnsignedShortLE() {
+		this.doReadAssertions(2);
+		return this.readBuffer.readUInt16LE(this.addOffset(2));
+	}
+	/**
+	* Writes a 16 bit (2 bytes) unsigned little-endian number.
+	* @param {number} v
+	*/
+	writeUnsignedShortLE(v) {
+		this.doWriteAssertions(v, 0, 65535);
+		this.ensureCapacity(2);
+		this.writeBuffer[this.writeIndex++] = v & 255;
+		this.writeBuffer[this.writeIndex++] = v >>> 8 & 255;
+	}
+	/**
+	* Reads a 24 bit (3 bytes) signed big-endian number.
+	* @returns {number}
+	*/
+	readTriad() {
+		this.doReadAssertions(3);
+		return this.readBuffer.readIntBE(this.addOffset(3), 3);
+	}
+	/**
+	* Writes a 24 bit (3 bytes) signed big-endian number.
+	* @param {number} v
+	*/
+	writeTriad(v) {
+		this.doWriteAssertions(v, -8388608, 8388607);
+		this.ensureCapacity(3);
+		this.writeBuffer[this.writeIndex++] = v >> 16 & 255;
+		this.writeBuffer[this.writeIndex++] = v >> 8 & 255;
+		this.writeBuffer[this.writeIndex++] = v & 255;
+	}
+	/**
+	* Reads a 24 bit (3 bytes) little-endian number.
+	* @returns {number}
+	*/
+	readTriadLE() {
+		this.doReadAssertions(3);
+		return this.readBuffer.readIntLE(this.addOffset(3), 3);
+	}
+	/**
+	* Writes a 24 bit (3 bytes) signed little-endian number.
+	* @param {number} v
+	*/
+	writeTriadLE(v) {
+		this.doWriteAssertions(v, -8388608, 8388607);
+		this.ensureCapacity(3);
+		this.writeBuffer[this.writeIndex++] = v & 255;
+		this.writeBuffer[this.writeIndex++] = v >> 8 & 255;
+		this.writeBuffer[this.writeIndex++] = v >> 16 & 255;
+	}
+	/**
+	* Reads a 24 bit (3 bytes) unsigned big-endian number.
+	* @returns {number}
+	*/
+	readUnsignedTriad() {
+		this.doReadAssertions(3);
+		return this.readBuffer.readUIntBE(this.addOffset(3), 3);
+	}
+	/**
+	* Writes a 24 bit (3 bytes) unsigned big-endian number.
+	* @param {number} v
+	*/
+	writeUnsignedTriad(v) {
+		this.doWriteAssertions(v, 0, 16777215);
+		this.ensureCapacity(3);
+		this.writeBuffer[this.writeIndex++] = v >>> 16 & 255;
+		this.writeBuffer[this.writeIndex++] = v >>> 8 & 255;
+		this.writeBuffer[this.writeIndex++] = v & 255;
+	}
+	/**
+	* Reads a 24 bit (3 bytes) unsigned little-endian number.
+	* @returns {number}
+	*/
+	readUnsignedTriadLE() {
+		this.doReadAssertions(3);
+		return this.readBuffer.readUIntLE(this.addOffset(3), 3);
+	}
+	/**
+	* Writes a 24 bit (3 bytes) unsigned little-endian number.
+	* @param {number} v
+	*/
+	writeUnsignedTriadLE(v) {
+		this.doWriteAssertions(v, 0, 16777215);
+		this.ensureCapacity(3);
+		this.writeBuffer[this.writeIndex++] = v & 255;
+		this.writeBuffer[this.writeIndex++] = v >>> 8 & 255;
+		this.writeBuffer[this.writeIndex++] = v >>> 16 & 255;
+	}
+	/**
+	* Reads a 32 bit (4 bytes) big-endian signed number.
+	* @returns {number}
+	*/
+	readInt() {
+		this.doReadAssertions(4);
+		return this.readBuffer.readInt32BE(this.addOffset(4));
+	}
+	/**
+	* Writes a 32 bit (4 bytes) big-endian signed number.
+	* @param {number} v
+	*/
+	writeInt(v) {
+		this.doWriteAssertions(v, -2147483648, 2147483647);
+		this.ensureCapacity(4);
+		this.writeBuffer.writeInt32BE(v, this.writeIndex);
+		this.writeIndex += 4;
+	}
+	/**
+	* Reads a 32 bit (4 bytes) signed number.
+	* @returns {number}
+	*/
+	readIntLE() {
+		this.doReadAssertions(4);
+		return this.readBuffer.readIntLE(this.addOffset(4), 4);
+	}
+	/**
+	* Writes a 32 bit (4 bytes) little-endian signed number.
+	* @param {number} v
+	*/
+	writeIntLE(v) {
+		this.doWriteAssertions(v, -2147483648, 2147483647);
+		this.ensureCapacity(4);
+		this.writeBuffer.writeInt32LE(v, this.writeIndex);
+		this.writeIndex += 4;
+	}
+	/**
+	* Reads a 32 bit (4 bytes) big-endian unsigned number.
+	* @returns {number}
+	*/
+	readUnsignedInt() {
+		this.doReadAssertions(4);
+		return this.readBuffer.readUInt32BE(this.addOffset(4));
+	}
+	/**
+	* Writes a 32 bit (4 bytes) big-endian unsigned number.
+	* @param {number} v
+	*/
+	writeUnsignedInt(v) {
+		this.doWriteAssertions(v, 0, 4294967295);
+		this.ensureCapacity(4);
+		this.writeBuffer.writeUInt32BE(v, this.writeIndex);
+		this.writeIndex += 4;
+	}
+	/**
+	* Reads a 32 bit (4 bytes) little-endian unsigned number.
+	* @returns {number}
+	*/
+	readUnsignedIntLE() {
+		this.doReadAssertions(4);
+		return this.readBuffer.readUInt32LE(this.addOffset(4));
+	}
+	/**
+	* Writes a 32 bit (4 bytes) little-endian unsigned number.
+	* @param {number} v
+	*/
+	writeUnsignedIntLE(v) {
+		this.doWriteAssertions(v, 0, 4294967295);
+		this.ensureCapacity(4);
+		this.writeBuffer.writeUInt32LE(v, this.writeIndex);
+		this.writeIndex += 4;
+	}
+	/**
+	* Returns a 32 bit (4 bytes) big-endian flating point number.
+	* @returns {number}
+	*/
+	readFloat() {
+		this.doReadAssertions(4);
+		return this.readBuffer.readFloatBE(this.addOffset(4));
+	}
+	/**
+	* Writes a 32 bit (4 bytes) big-endian floating point number.
+	* @param {number} v
+	*/
+	writeFloat(v) {
+		this.doWriteAssertions(v, -34028234663852886e22, 34028234663852886e22);
+		this.ensureCapacity(4);
+		this.writeBuffer.writeFloatBE(v, this.writeIndex);
+		this.writeIndex += 4;
+	}
+	/**
+	* Returns a 32 bit (4 bytes) big-endian flating point number.
+	* @returns {number}
+	*/
+	readFloatLE() {
+		this.doReadAssertions(4);
+		return this.readBuffer.readFloatLE(this.addOffset(4));
+	}
+	/**
+	* Writes a 32 bit (4 bytes) little-endian floating point number.
+	* @param {number} v
+	*/
+	writeFloatLE(v) {
+		this.doWriteAssertions(v, -34028234663852886e22, 34028234663852886e22);
+		this.ensureCapacity(4);
+		this.writeBuffer.writeFloatLE(v, this.writeIndex);
+		this.writeIndex += 4;
+	}
+	/**
+	* Returns a 64 bit (8 bytes) big-endian flating point number.
+	* @returns {number}
+	*/
+	readDouble() {
+		this.doReadAssertions(8);
+		return this.readBuffer.readDoubleBE(this.addOffset(8));
+	}
+	/**
+	* Writes a 64 bit (8 bytes) big-endian floating point number.
+	* @param {number} v
+	*/
+	writeDouble(v) {
+		this.doWriteAssertions(v, -17976931348623157e292, 17976931348623157e292);
+		this.ensureCapacity(8);
+		this.writeBuffer.writeDoubleBE(v, this.writeIndex);
+		this.writeIndex += 8;
+	}
+	/**
+	* Returns a 64 bit (8 bytes) little-endian flating point number.
+	* @returns {number}
+	*/
+	readDoubleLE() {
+		this.doReadAssertions(8);
+		return this.readBuffer.readDoubleLE(this.addOffset(8));
+	}
+	/**
+	* Writes a 64 bit (8 bytes) little-endian floating point number.
+	* @param {number} v
+	*/
+	writeDoubleLE(v) {
+		this.doWriteAssertions(v, -17976931348623157e292, 17976931348623157e292);
+		this.ensureCapacity(8);
+		this.writeBuffer.writeDoubleLE(v, this.writeIndex);
+		this.writeIndex += 8;
+	}
+	/**
+	* Returns a 64 bit (8 bytes) signed big-endian number.
+	* @returns {bigint}
+	*/
+	readLong() {
+		this.doReadAssertions(8);
+		return this.readBuffer.readBigInt64BE(this.addOffset(8));
+	}
+	/**
+	* Writes a 64 bit (8 bytes) signed big-endian number.
+	* @param {bigint} v
+	*/
+	writeLong(v) {
+		this.ensureCapacity(8);
+		this.writeBuffer.writeBigInt64BE(v, this.writeIndex);
+		this.writeIndex += 8;
+	}
+	/**
+	* Returns a 64 bit (8 bytes) signed little-endian number.
+	* @returns {bigint}
+	*/
+	readLongLE() {
+		this.doReadAssertions(8);
+		return this.readBuffer.readBigInt64LE(this.addOffset(8));
+	}
+	/**
+	* Writes a 64 bit (8 bytes) signed little-endian number.
+	* @param {bigint} v
+	*/
+	writeLongLE(v) {
+		this.ensureCapacity(8);
+		this.writeBuffer.writeBigInt64LE(v, this.writeIndex);
+		this.writeIndex += 8;
+	}
+	/**
+	* Returns a 64 bit (8 bytes) unsigned big-endian number.
+	* @returns {bigint}
+	*/
+	readUnsignedLong() {
+		this.doReadAssertions(8);
+		return this.readBuffer.readBigUInt64BE(this.addOffset(8));
+	}
+	/**
+	* Writes a 64 bit (8 bytes) unsigned big-endian number.
+	* @param {bigint} v
+	*/
+	writeUnsignedLong(v) {
+		this.ensureCapacity(8);
+		this.writeBuffer.writeBigUInt64BE(v, this.writeIndex);
+		this.writeIndex += 8;
+	}
+	/**
+	* Returns a 64 bit (8 bytes) unsigned little-endian number.
+	* @returns {bigint}
+	*/
+	readUnsignedLongLE() {
+		this.doReadAssertions(8);
+		return this.readBuffer.readBigUInt64LE(this.addOffset(8));
+	}
+	/**
+	* Writes a 64 bit (8 bytes) unsigned little-endian number.
+	* @param {bigint} v
+	*/
+	writeUnsignedLongLE(v) {
+		this.ensureCapacity(8);
+		this.writeBuffer.writeBigUInt64LE(v, this.writeIndex);
+		this.writeIndex += 8;
+	}
+	/**
+	* Reads a 32 bit (4 bytes) zigzag-encoded number.
+	* @returns {number}
+	*/
+	readVarInt() {
+		const raw = this.readUnsignedVarInt();
+		return raw >>> 1 ^ -(raw & 1);
+	}
+	/**
+	* Writes a 32 bit (4 bytes) zigzag-encoded number.
+	* @param {number} v
+	*/
+	writeVarInt(v) {
+		return this.writeUnsignedVarInt(v << 1 ^ v >> 31);
+	}
+	/**
+	* Reads a 32 bit unsigned number.
+	* @returns {number}
+	*/
+	readUnsignedVarInt() {
+		const buf = this.readBuffer;
+		if (buf === null) assert.fail("Reading on empty buffer!");
+		const len = buf.byteLength;
+		let value = 0;
+		for (let i = 0; i <= 28; i += 7) {
+			if (this.readIndex >= len) throw new Error("No bytes left in buffer");
+			const b = buf[this.readIndex++];
+			value |= (b & 127) << i;
+			if ((b & 128) === 0) {
+				if (i === 28 && (b & 112) !== 0) throw new Error("VarInt overflows 32 bits!");
+				return value >>> 0;
+			}
+		}
+		throw new Error("VarInt did not terminate after 5 bytes!");
+	}
+	/**
+	* Writes a 32 bit unsigned number with variable-length.
+	* @param {number} v
+	*/
+	writeUnsignedVarInt(v) {
+		this.ensureCapacity(5);
+		const buf = this.writeBuffer;
+		let i = this.writeIndex;
+		while ((v & 4294967168) !== 0) {
+			buf[i++] = v & 127 | 128;
+			v >>>= 7;
+		}
+		buf[i++] = v & 127;
+		this.writeIndex = i;
+	}
+	/**
+	* Reads a 64 bit zigzag-encoded variable-length number.
+	* @returns {bigint}
+	*/
+	readVarLong() {
+		const raw = this.readUnsignedVarLong();
+		return raw >> 1n ^ -(raw & 1n);
+	}
+	/**
+	* Writes a 64 bit unsigned zigzag-encoded number.
+	* @param {bigint} v
+	*/
+	writeVarLong(v) {
+		const n = BigInt.asIntN(64, v);
+		return this.writeUnsignedVarLong(n << 1n ^ n >> 63n);
+	}
+	/**
+	* Reads a 64 bit unsigned variable-length number.
+	* @returns {bigint}
+	*/
+	readUnsignedVarLong() {
+		const buf = this.readBuffer;
+		if (buf === null) throw new Error("Buffer is write only!");
+		const len = buf.byteLength;
+		let lo = 0;
+		let hi = 0;
+		for (let i = 0; i <= 63; i += 7) {
+			if (this.readIndex >= len) throw new Error("No bytes left in buffer");
+			const b = buf[this.readIndex++];
+			if (i < 28) lo |= (b & 127) << i;
+			else if (i === 28) {
+				lo = (lo | (b & 15) << 28) >>> 0;
+				hi = (b & 127) >>> 4;
+			} else hi |= (b & 127) << i - 32;
+			if ((b & 128) === 0) {
+				if (i === 63 && (b & 126) !== 0) throw new Error("VarLong overflows 64 bits!");
+				return BigInt(hi >>> 0) << 32n | BigInt(lo >>> 0);
+			}
+		}
+		throw new Error("VarLong did not terminate after 10 bytes!");
+	}
+	/**
+	* Writes a 64 bit unsigned variable-length number.
+	* @param {bigint} v
+	*/
+	writeUnsignedVarLong(v) {
+		this.ensureCapacity(10);
+		const buf = this.writeBuffer;
+		let i = this.writeIndex;
+		const u = BigInt.asUintN(64, v);
+		let lo = Number(u & 4294967295n) >>> 0;
+		let hi = Number(u >> 32n) >>> 0;
+		while (hi !== 0 || lo > 127) {
+			buf[i++] = lo & 127 | 128;
+			lo = (lo >>> 7 | hi << 25) >>> 0;
+			hi >>>= 7;
+		}
+		buf[i++] = lo;
+		this.writeIndex = i;
+	}
+	/**
+	* Ensures write buffer has enough capacity, grows if needed.
+	* @param {number} needed
+	*/
+	ensureCapacity(needed) {
+		const required = this.writeIndex + needed;
+		if (required > this.writeCapacity) {
+			const newCapacity = this.writeCapacity === 0 ? Math.max(256, required) : Math.max(required, this.writeCapacity << 1);
+			const newBuffer = Buffer.allocUnsafe(newCapacity);
+			if (this.writeBuffer !== null && this.writeIndex > 0) this.writeBuffer.copy(newBuffer, 0, 0, this.writeIndex);
+			this.writeBuffer = newBuffer;
+			this.writeCapacity = newCapacity;
+		}
+	}
+	/**
+	* Grows the write buffer so that at least `capacity` bytes can be written without any
+	* further allocation, and returns this stream.
+	*
+	* Pre-sizing skips the 256 -> 512 -> 1024 ... growth ladder, each step of which copies the
+	* whole payload; a 3 KB packet starting from the 256-byte floor performs five allocations
+	* and memcpy's 1.25x its own size before it is done.
+	* @param {number} capacity
+	*/
+	reserve(capacity) {
+		if (capacity > this.writeCapacity) {
+			const newBuffer = Buffer.allocUnsafe(capacity);
+			if (this.writeBuffer !== null && this.writeIndex > 0) this.writeBuffer.copy(newBuffer, 0, 0, this.writeIndex);
+			this.writeBuffer = newBuffer;
+			this.writeCapacity = capacity;
+		}
+		return this;
+	}
+	/**
+	* Rewinds the write cursor while keeping the allocated capacity, so a long-lived encoder
+	* reaches a steady state where it never allocates again. This is the intended way to reuse
+	* a stream for many packets.
+	*
+	* Note the aliasing contract, which it shares with {@link clear} and {@link reuse}: any
+	* buffer previously handed out by {@link getWriteBuffer} is a *view* over this stream's
+	* memory and is invalidated by this call. Use {@link copyOut} or {@link copyInto} for
+	* output you intend to keep.
+	*/
+	resetWrite() {
+		this.writeIndex = 0;
+	}
+	/**
+	* Returns the encoded bytes as an exactly-sized, standalone Buffer.
+	*
+	* Unlike {@link getWriteBuffer} the result does not alias this stream, so it survives
+	* {@link resetWrite}, and it does not pin a pool chunk: because `Buffer.allocUnsafe` is
+	* pool-backed (`Buffer.poolSize` is 64 KB on current Node), holding on to a handful of
+	* small slices from {@link getWriteBuffer} can keep megabytes alive.
+	* @returns {Buffer}
+	*/
+	copyOut() {
+		const out = Buffer.allocUnsafeSlow(this.writeIndex);
+		if (this.writeIndex > 0) this.writeBuffer.copy(out, 0, 0, this.writeIndex);
+		return out;
+	}
+	/**
+	* Copies the encoded bytes into a caller-owned buffer at `offset` and returns the offset
+	* just past them. Lets many packets be encoded into one arena with no per-packet
+	* allocation at all.
+	* @param {Buffer} target
+	* @param {number} offset
+	* @returns {number} the new offset
+	*/
+	copyInto(target, offset = 0) {
+		if (this.writeIndex > 0) this.writeBuffer.copy(target, offset, 0, this.writeIndex);
+		return offset + this.writeIndex;
+	}
+	/**
+	* Increases the write offset by the given length.
+	* @param {number} length
+	*/
+	addOffset(length) {
+		return (this.readIndex += length) - length;
+	}
+	/**
+	* Returns whatever or not the read offset is at end of line.
+	* @returns {number}
+	*/
+	feof() {
+		const buf = this.readBuffer;
+		if (buf === null) throw new Error("Buffer is write only!");
+		return this.readIndex >= buf.byteLength;
+	}
+	/**
+	* Reads the remaining bytes and returns the buffer slice.
+	* @returns {Buffer}
+	*/
+	readRemaining() {
+		if (!this.readBuffer) throw new Error("Buffer is write only!");
+		const buf = this.readBuffer.subarray(this.readIndex);
+		this.readIndex = this.readBuffer.byteLength;
+		return buf;
+	}
+	/**
+	* Skips len bytes on the buffer.
+	* @param {number} len
+	*/
+	skip(len) {
+		assert(Number.isInteger(len), "Cannot skip a float amount of bytes");
+		this.readIndex += len;
+	}
+	/**
+	* Returns the encoded buffer.
+	*
+	* Beware: when a read buffer is present this returns *that*, discarding everything
+	* written. On a stream used for both reading and writing it never returns your output.
+	* @returns {Buffer}
+	* @deprecated See {@link getReadBuffer} and {@link getWriteBuffer}.
+	*/
+	getBuffer() {
+		return this.readBuffer !== null ? this.readBuffer : this.writeBuffer.subarray(0, this.writeIndex);
+	}
+	/**
+	* Returns the read buffer if available.
+	* @returns {Buffer}
+	*/
+	getReadBuffer() {
+		return this.readBuffer;
+	}
+	/**
+	* Returns the encoded bytes as a *view* over this stream's internal buffer.
+	*
+	* The view is only valid until the next write: {@link resetWrite}, {@link clear} and
+	* {@link reuse} all rewind the cursor without reallocating, so a previously returned
+	* buffer is silently overwritten by the next packet. If you queue the result - a send
+	* queue, a resend window - use {@link copyOut} or {@link copyInto} instead.
+	*
+	* It also keeps the whole pooled 64 KB chunk it was carved from alive; retaining a
+	* scattered handful of small packets this way can pin megabytes.
+	* @returns {Buffer}
+	*/
+	getWriteBuffer() {
+		return this.writeBuffer.subarray(0, this.writeIndex);
+	}
+	/**
+	* Sets the buffer for reading.
+	* make sure to reset the reading index!
+	* @param buf - The new Buffer.
+	* @deprecated See {@link setReadBuffer} and {@link setWriteBuffer}.
+	*/
+	setBuffer(buf) {
+		this.readBuffer = buf;
+	}
+	/**
+	* Sets the buffer for reading.
+	* @param buf - The new Buffer.
+	* @param rIndex - The new read index (default: 0, pass -1 to keep current).
+	*/
+	setReadBuffer(buf, rIndex = 0) {
+		this.readBuffer = buf;
+		if (rIndex >= 0) this.readIndex = rIndex;
+	}
+	/**
+	* Sets the buffer for writing.
+	* @param buf - The new Buffer.
+	* @param wIndex - The new write index (default: 0, pass -1 to keep current).
+	*/
+	setWriteBuffer(buf, wIndex = 0) {
+		this.writeBuffer = buf;
+		if (wIndex >= 0) this.writeIndex = wIndex;
+		this.writeCapacity = buf.byteLength;
+	}
+	/**
+	* Clears the whole BinaryStream instance.
+	*
+	* The write buffer and its capacity are kept, so any view previously returned by
+	* {@link getWriteBuffer} is invalidated. See {@link resetWrite}.
+	*/
+	clear() {
+		this.readBuffer = null;
+		this.readIndex = 0;
+		this.writeIndex = 0;
+	}
+	/**
+	* Conventional method to reuse the stream
+	* without having to create a new BinaryStream instance.
+	*
+	* The write buffer and its capacity are kept, so any view previously returned by
+	* {@link getWriteBuffer} is invalidated. See {@link resetWrite}.
+	* @param buf - The new buffer instance.
+	*/
+	reuse(buf) {
+		this.readBuffer = buf;
+		this.readIndex = 0;
+		this.writeIndex = 0;
+	}
+	/**
+	* Sets the reading index.
+	* @param index - The new read index.
+	*/
+	setReadIndex(index) {
+		assert(index >= 0, "Index must be non-negative");
+		this.readIndex = index;
+	}
+	/**
+	* Sets the new writing index.
+	* @param index - The new write index.
+	*/
+	setWriteIndex(index) {
+		assert(index >= 0, "Index must be non-negative");
+		this.writeIndex = index;
+	}
+	/**
+	* Retuns the read index.
+	* @returns {number}
+	*/
+	getReadIndex() {
+		return this.readIndex;
+	}
+	/**
+	* Returns the write index.
+	* @returns {number}
+	*/
+	getWriteIndex() {
+		return this.writeIndex;
+	}
+	/**
+	* Do read assertions, check if the read buffer is null.
+	* @param {number} byteLength
+	*/
+	doReadAssertions(byteLength) {
+		const buf = this.readBuffer;
+		if (buf === null) assert.fail("Cannot read without buffer data!");
+		if (this.readIndex + byteLength > buf.byteLength) assert.fail(`Cannot read ${byteLength} byte(s) at offset ${this.readIndex}: only ${Math.max(0, buf.byteLength - this.readIndex)} left in buffer`);
+	}
+	/**
+	* Do read assertions, check if the read buffer is null.
+	* @param {number|bigint} num
+	* @param {number|bigint} minVal
+	* @param {number|bigint} maxVal
+	*/
+	doWriteAssertions(num, minVal, maxVal) {
+		if (!(num >= minVal && num <= maxVal)) assert.fail(`Value out of bounds: value=${num}, min=${minVal}, max=${maxVal}`);
+	}
+};
+//#endregion
+export { BinaryStream, BinaryStream as default };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"BinaryStream.es.js","names":[],"sources":["../src/BinaryStream.ts"],"sourcesContent":["import assert from 'assert';\n\n/**\n * A high-performance binary stream for reading and writing binary data.\n *\n * Unlike Node.js native buffers which have fixed size, BinaryStream uses dynamic\n * buffers that grow automatically during write operations. This eliminates the need\n * for manual resizing or inefficient `Buffer.concat()` calls.\n *\n * @example Reading data\n * ```typescript\n * const stream = new BinaryStream(buffer);\n * const value = stream.readInt();\n * ```\n *\n * @example Writing data\n * ```typescript\n * const stream = new BinaryStream();\n * stream.writeInt(42);\n * stream.write(Buffer.from('Hello'));  // Buffer grows automatically\n * const buffer = stream.getWriteBuffer();\n * ```\n *\n * @example Encoding many packets without allocating\n * ```typescript\n * const stream = new BinaryStream(undefined, 0, 4096);\n * for (const packet of queue) {\n *     stream.resetWrite();\n *     packet.encode(stream);\n *     offset = stream.copyInto(arena, offset);\n * }\n * ```\n */\nexport class BinaryStream {\n    private writeBuffer: Buffer | null = null;\n    private readBuffer: Buffer | null = null;\n    private readIndex: number;\n    private writeIndex = 0;\n    private writeCapacity = 0;\n\n    /**\n     * Creates a new BinaryStream instance.\n     * @param {Buffer|null|undefined} buffer - The array or Buffer containing binary data.\n     * @param {number} offset - The initial pointer position.\n     * @param {number} initialCapacity - Pre-allocates the write buffer to this size. Use it when\n     * the encoded size is known up front: it skips the 256 -> 512 -> 1024 ... growth ladder, and\n     * with {@link resetWrite} it lets a long-lived encoder run without allocating at all.\n     */\n    public constructor(buffer?: Buffer, offset: number = 0, initialCapacity: number = 0) {\n        this.readBuffer = buffer ?? null; // Keep this instance for reading\n        this.readIndex = offset;\n        if (initialCapacity > 0) {\n            this.reserve(initialCapacity);\n        }\n    }\n\n    /**\n     * Reads a slice of buffer by the given length.\n     * @param {number} len\n     */\n    public read(len: number): Buffer {\n        this.doReadAssertions(len);\n        return this.readBuffer!.subarray(this.readIndex, (this.readIndex += len));\n    }\n\n    /**\n     * Appends a buffer to the main buffer.\n     * @param {Buffer|Uint8Array} buf\n     */\n    public write(buf: Uint8Array): void {\n        const len = buf.byteLength;\n        this.ensureCapacity(len);\n        // This used to call `buf.copy(...)`, which only exists on Buffer, so passing the plain\n        // Uint8Array this signature advertises threw `TypeError: buf.copy is not a function`.\n        // `set` accepts both, is spec-required to handle overlapping ranges, and is cheaper\n        // for the small payloads (UUIDs, short blobs) that dominate packet encoding.\n        this.writeBuffer!.set(buf, this.writeIndex);\n        this.writeIndex += len;\n    }\n\n    /**\n     * Reads an unsigned byte (0 to 255).\n     * @returns {number}\n     */\n    public readByte(): number {\n        this.doReadAssertions(1);\n        return this.readBuffer![this.readIndex++]!;\n    }\n\n    /**\n     * Writes an unsigned byte (0 to 255).\n     * @param {number} v\n     */\n    public writeByte(v: number): void {\n        this.ensureCapacity(1);\n        this.writeBuffer![this.writeIndex++] = v & 0xff;\n    }\n\n    /**\n     * Reads a signed byte (-128 to 127).\n     * @returns {number}\n     */\n    public readSignedByte(): number {\n        this.doReadAssertions(1);\n        return (this.readBuffer![this.readIndex++]! << 24) >> 24;\n    }\n\n    /**\n     * Writes a signed byte (-128 to 127).\n     * @param {number} v\n     */\n    public writeSignedByte(v: number): void {\n        this.ensureCapacity(1);\n        this.writeBuffer![this.writeIndex++] = (v < 0 ? 0xff + v + 1 : v) & 0xff;\n    }\n\n    /**\n     * Reads a boolean (true or false).\n     * @returns {boolean}\n     */\n    public readBoolean(): boolean {\n        this.doReadAssertions(1);\n        return this.readBuffer![this.readIndex++] !== 0;\n    }\n\n    /**\n     * Writes a boolean (true or false).\n     * @param {boolean} v\n     */\n    public writeBoolean(v: boolean): void {\n        this.ensureCapacity(1);\n        this.writeBuffer![this.writeIndex++] = v ? 1 : 0;\n    }\n\n    /**\n     * Reads a 16 bit (2 bytes) signed big-endian number.\n     * @returns {number}\n     */\n    public readShort(): number {\n        this.doReadAssertions(2);\n        return this.readBuffer!.readInt16BE(this.addOffset(2));\n    }\n\n    /**\n     * Writes a 16 bit (2 bytes) signed big-endian number.\n     * @param {number} v\n     */\n    public writeShort(v: number): void {\n        this.doWriteAssertions(v, -32_768, 32_767);\n        this.ensureCapacity(2);\n        this.writeBuffer![this.writeIndex++] = (v >> 8) & 0xff;\n        this.writeBuffer![this.writeIndex++] = v & 0xff;\n    }\n\n    /**\n     * Reads a 16 bit (2 bytes) signed little-endian number.\n     * @returns {number}\n     */\n    public readShortLE(): number {\n        this.doReadAssertions(2);\n        return this.readBuffer!.readInt16LE(this.addOffset(2));\n    }\n\n    /**\n     * Writes a 16 bit (2 bytes) signed little-endian number.\n     * @param {number} v\n     */\n    public writeShortLE(v: number): void {\n        this.doWriteAssertions(v, -32_768, 32_767);\n        this.ensureCapacity(2);\n        this.writeBuffer![this.writeIndex++] = v & 0xff;\n        this.writeBuffer![this.writeIndex++] = (v >> 8) & 0xff;\n    }\n\n    /**\n     * Reads a 16 bit (2 bytes) unsigned big-endian number.\n     * @returns {number}\n     */\n    public readUnsignedShort(): number {\n        this.doReadAssertions(2);\n        return this.readBuffer!.readUInt16BE(this.addOffset(2));\n    }\n\n    /**\n     * Writes a 16 bit (2 bytes) unsigned big-endian number.\n     * @param {number} v\n     */\n    public writeUnsignedShort(v: number): void {\n        this.doWriteAssertions(v, 0, 65_535);\n        this.ensureCapacity(2);\n        this.writeBuffer![this.writeIndex++] = (v >>> 8) & 0xff;\n        this.writeBuffer![this.writeIndex++] = v & 0xff;\n    }\n\n    /**\n     * Reads a 16 bit (2 bytes) unsigned little-endian number.\n     * @returns {number}\n     */\n    public readUnsignedShortLE(): number {\n        this.doReadAssertions(2);\n        return this.readBuffer!.readUInt16LE(this.addOffset(2));\n    }\n\n    /**\n     * Writes a 16 bit (2 bytes) unsigned little-endian number.\n     * @param {number} v\n     */\n    public writeUnsignedShortLE(v: number): void {\n        this.doWriteAssertions(v, 0, 65_535);\n        this.ensureCapacity(2);\n        this.writeBuffer![this.writeIndex++] = v & 0xff;\n        this.writeBuffer![this.writeIndex++] = (v >>> 8) & 0xff;\n    }\n\n    /**\n     * Reads a 24 bit (3 bytes) signed big-endian number.\n     * @returns {number}\n     */\n    public readTriad(): number {\n        this.doReadAssertions(3);\n        return this.readBuffer!.readIntBE(this.addOffset(3), 3);\n    }\n\n    /**\n     * Writes a 24 bit (3 bytes) signed big-endian number.\n     * @param {number} v\n     */\n    public writeTriad(v: number): void {\n        this.doWriteAssertions(v, -8_388_608, 8_388_607);\n        this.ensureCapacity(3);\n        this.writeBuffer![this.writeIndex++] = (v >> 16) & 0xff;\n        this.writeBuffer![this.writeIndex++] = (v >> 8) & 0xff;\n        this.writeBuffer![this.writeIndex++] = v & 0xff;\n    }\n\n    /**\n     * Reads a 24 bit (3 bytes) little-endian number.\n     * @returns {number}\n     */\n    public readTriadLE(): number {\n        this.doReadAssertions(3);\n        return this.readBuffer!.readIntLE(this.addOffset(3), 3);\n    }\n\n    /**\n     * Writes a 24 bit (3 bytes) signed little-endian number.\n     * @param {number} v\n     */\n    public writeTriadLE(v: number): void {\n        this.doWriteAssertions(v, -8_388_608, 8_388_607);\n        this.ensureCapacity(3);\n        this.writeBuffer![this.writeIndex++] = v & 0xff;\n        this.writeBuffer![this.writeIndex++] = (v >> 8) & 0xff;\n        this.writeBuffer![this.writeIndex++] = (v >> 16) & 0xff;\n    }\n\n    /**\n     * Reads a 24 bit (3 bytes) unsigned big-endian number.\n     * @returns {number}\n     */\n    public readUnsignedTriad(): number {\n        this.doReadAssertions(3);\n        return this.readBuffer!.readUIntBE(this.addOffset(3), 3);\n    }\n\n    /**\n     * Writes a 24 bit (3 bytes) unsigned big-endian number.\n     * @param {number} v\n     */\n    public writeUnsignedTriad(v: number): void {\n        this.doWriteAssertions(v, 0, 16_777_215);\n        this.ensureCapacity(3);\n        this.writeBuffer![this.writeIndex++] = (v >>> 16) & 0xff;\n        this.writeBuffer![this.writeIndex++] = (v >>> 8) & 0xff;\n        this.writeBuffer![this.writeIndex++] = v & 0xff;\n    }\n\n    /**\n     * Reads a 24 bit (3 bytes) unsigned little-endian number.\n     * @returns {number}\n     */\n    public readUnsignedTriadLE(): number {\n        this.doReadAssertions(3);\n        return this.readBuffer!.readUIntLE(this.addOffset(3), 3);\n    }\n\n    /**\n     * Writes a 24 bit (3 bytes) unsigned little-endian number.\n     * @param {number} v\n     */\n    public writeUnsignedTriadLE(v: number): void {\n        this.doWriteAssertions(v, 0, 16_777_215);\n        this.ensureCapacity(3);\n        this.writeBuffer![this.writeIndex++] = v & 0xff;\n        this.writeBuffer![this.writeIndex++] = (v >>> 8) & 0xff;\n        this.writeBuffer![this.writeIndex++] = (v >>> 16) & 0xff;\n    }\n\n    /**\n     * Reads a 32 bit (4 bytes) big-endian signed number.\n     * @returns {number}\n     */\n    public readInt(): number {\n        this.doReadAssertions(4);\n        return this.readBuffer!.readInt32BE(this.addOffset(4));\n    }\n\n    /**\n     * Writes a 32 bit (4 bytes) big-endian signed number.\n     * @param {number} v\n     */\n    public writeInt(v: number): void {\n        this.doWriteAssertions(v, -2_147_483_648, 2_147_483_647);\n        this.ensureCapacity(4);\n        this.writeBuffer!.writeInt32BE(v, this.writeIndex);\n        this.writeIndex += 4;\n    }\n\n    /**\n     * Reads a 32 bit (4 bytes) signed number.\n     * @returns {number}\n     */\n    public readIntLE(): number {\n        this.doReadAssertions(4);\n        return this.readBuffer!.readIntLE(this.addOffset(4), 4);\n    }\n\n    /**\n     * Writes a 32 bit (4 bytes) little-endian signed number.\n     * @param {number} v\n     */\n    public writeIntLE(v: number) {\n        this.doWriteAssertions(v, -2_147_483_648, 2_147_483_647);\n        this.ensureCapacity(4);\n        this.writeBuffer!.writeInt32LE(v, this.writeIndex);\n        this.writeIndex += 4;\n    }\n\n    /**\n     * Reads a 32 bit (4 bytes) big-endian unsigned number.\n     * @returns {number}\n     */\n    public readUnsignedInt(): number {\n        this.doReadAssertions(4);\n        return this.readBuffer!.readUInt32BE(this.addOffset(4));\n    }\n\n    /**\n     * Writes a 32 bit (4 bytes) big-endian unsigned number.\n     * @param {number} v\n     */\n    public writeUnsignedInt(v: number): void {\n        this.doWriteAssertions(v, 0, 4_294_967_295);\n        this.ensureCapacity(4);\n        this.writeBuffer!.writeUInt32BE(v, this.writeIndex);\n        this.writeIndex += 4;\n    }\n\n    /**\n     * Reads a 32 bit (4 bytes) little-endian unsigned number.\n     * @returns {number}\n     */\n    public readUnsignedIntLE(): number {\n        this.doReadAssertions(4);\n        return this.readBuffer!.readUInt32LE(this.addOffset(4));\n    }\n\n    /**\n     * Writes a 32 bit (4 bytes) little-endian unsigned number.\n     * @param {number} v\n     */\n    public writeUnsignedIntLE(v: number): void {\n        this.doWriteAssertions(v, 0, 4_294_967_295);\n        this.ensureCapacity(4);\n        this.writeBuffer!.writeUInt32LE(v, this.writeIndex);\n        this.writeIndex += 4;\n    }\n\n    /**\n     * Returns a 32 bit (4 bytes) big-endian flating point number.\n     * @returns {number}\n     */\n    public readFloat(): number {\n        this.doReadAssertions(4);\n        return this.readBuffer!.readFloatBE(this.addOffset(4));\n    }\n\n    /**\n     * Writes a 32 bit (4 bytes) big-endian floating point number.\n     * @param {number} v\n     */\n    public writeFloat(v: number): void {\n        this.doWriteAssertions(v, -3.4028234663852886e38, +3.4028234663852886e38);\n        this.ensureCapacity(4);\n        this.writeBuffer!.writeFloatBE(v, this.writeIndex);\n        this.writeIndex += 4;\n    }\n\n    /**\n     * Returns a 32 bit (4 bytes) big-endian flating point number.\n     * @returns {number}\n     */\n    public readFloatLE(): number {\n        this.doReadAssertions(4);\n        return this.readBuffer!.readFloatLE(this.addOffset(4));\n    }\n\n    /**\n     * Writes a 32 bit (4 bytes) little-endian floating point number.\n     * @param {number} v\n     */\n    public writeFloatLE(v: number): void {\n        this.doWriteAssertions(v, -3.4028234663852886e38, +3.4028234663852886e38);\n        this.ensureCapacity(4);\n        this.writeBuffer!.writeFloatLE(v, this.writeIndex);\n        this.writeIndex += 4;\n    }\n\n    /**\n     * Returns a 64 bit (8 bytes) big-endian flating point number.\n     * @returns {number}\n     */\n    public readDouble(): number {\n        this.doReadAssertions(8);\n        return this.readBuffer!.readDoubleBE(this.addOffset(8));\n    }\n\n    /**\n     * Writes a 64 bit (8 bytes) big-endian floating point number.\n     * @param {number} v\n     */\n    public writeDouble(v: number): void {\n        this.doWriteAssertions(v, -1.7976931348623157e308, +1.7976931348623157e308);\n        this.ensureCapacity(8);\n        this.writeBuffer!.writeDoubleBE(v, this.writeIndex);\n        this.writeIndex += 8;\n    }\n\n    /**\n     * Returns a 64 bit (8 bytes) little-endian flating point number.\n     * @returns {number}\n     */\n    public readDoubleLE(): number {\n        this.doReadAssertions(8);\n        return this.readBuffer!.readDoubleLE(this.addOffset(8));\n    }\n\n    /**\n     * Writes a 64 bit (8 bytes) little-endian floating point number.\n     * @param {number} v\n     */\n    public writeDoubleLE(v: number): void {\n        this.doWriteAssertions(v, -1.7976931348623157e308, +1.7976931348623157e308);\n        this.ensureCapacity(8);\n        this.writeBuffer!.writeDoubleLE(v, this.writeIndex);\n        this.writeIndex += 8;\n    }\n\n    /**\n     * Returns a 64 bit (8 bytes) signed big-endian number.\n     * @returns {bigint}\n     */\n    public readLong(): bigint {\n        this.doReadAssertions(8);\n        return this.readBuffer!.readBigInt64BE(this.addOffset(8));\n    }\n\n    /**\n     * Writes a 64 bit (8 bytes) signed big-endian number.\n     * @param {bigint} v\n     */\n    public writeLong(v: bigint): void {\n        this.ensureCapacity(8);\n        this.writeBuffer!.writeBigInt64BE(v, this.writeIndex);\n        this.writeIndex += 8;\n    }\n\n    /**\n     * Returns a 64 bit (8 bytes) signed little-endian number.\n     * @returns {bigint}\n     */\n    public readLongLE(): bigint {\n        this.doReadAssertions(8);\n        return this.readBuffer!.readBigInt64LE(this.addOffset(8));\n    }\n\n    /**\n     * Writes a 64 bit (8 bytes) signed little-endian number.\n     * @param {bigint} v\n     */\n    public writeLongLE(v: bigint): void {\n        this.ensureCapacity(8);\n        this.writeBuffer!.writeBigInt64LE(v, this.writeIndex);\n        this.writeIndex += 8;\n    }\n\n    /**\n     * Returns a 64 bit (8 bytes) unsigned big-endian number.\n     * @returns {bigint}\n     */\n    public readUnsignedLong(): bigint {\n        this.doReadAssertions(8);\n        return this.readBuffer!.readBigUInt64BE(this.addOffset(8));\n    }\n\n    /**\n     * Writes a 64 bit (8 bytes) unsigned big-endian number.\n     * @param {bigint} v\n     */\n    public writeUnsignedLong(v: bigint): void {\n        this.ensureCapacity(8);\n        this.writeBuffer!.writeBigUInt64BE(v, this.writeIndex);\n        this.writeIndex += 8;\n    }\n\n    /**\n     * Returns a 64 bit (8 bytes) unsigned little-endian number.\n     * @returns {bigint}\n     */\n    public readUnsignedLongLE(): bigint {\n        this.doReadAssertions(8);\n        return this.readBuffer!.readBigUInt64LE(this.addOffset(8));\n    }\n\n    /**\n     * Writes a 64 bit (8 bytes) unsigned little-endian number.\n     * @param {bigint} v\n     */\n    public writeUnsignedLongLE(v: bigint): void {\n        this.ensureCapacity(8);\n        this.writeBuffer!.writeBigUInt64LE(v, this.writeIndex);\n        this.writeIndex += 8;\n    }\n\n    /**\n     * Reads a 32 bit (4 bytes) zigzag-encoded number.\n     * @returns {number}\n     */\n    public readVarInt(): number {\n        const raw = this.readUnsignedVarInt();\n        // The previous expression was `(((raw << 63) >> 63) ^ raw) >> 1 ^ (raw & (1 << 63))`,\n        // a Java port that relied on JS shift counts being taken mod 32. It was verified\n        // correct over 7.2M values, but this is the same function written legibly.\n        return (raw >>> 1) ^ -(raw & 1);\n    }\n\n    /**\n     * Writes a 32 bit (4 bytes) zigzag-encoded number.\n     * @param {number} v\n     */\n    public writeVarInt(v: number): void {\n        // The `v = (v << 32) >> 32` that used to sit here was a no-op: JS shift counts are\n        // taken mod 32, so it shifted by 0. The `<< 1` below already coerces to int32.\n        return this.writeUnsignedVarInt((v << 1) ^ (v >> 31));\n    }\n\n    /**\n     * Reads a 32 bit unsigned number.\n     * @returns {number}\n     */\n    public readUnsignedVarInt(): number {\n        const buf = this.readBuffer;\n        if (buf === null) {\n            assert.fail('Reading on empty buffer!');\n        }\n        const len = buf.byteLength;\n        let value = 0;\n        for (let i = 0; i <= 28; i += 7) {\n            // A numeric compare rather than `typeof buf[idx] === 'undefined'`: the latter is an\n            // out-of-bounds element load, which makes V8 discard the optimized code for this\n            // function the first time a stream is read to its end.\n            if (this.readIndex >= len) {\n                throw new Error('No bytes left in buffer');\n            }\n            const b = buf[this.readIndex++]!;\n            value |= (b & 0x7f) << i;\n\n            if ((b & 0x80) === 0) {\n                if (i === 28 && (b & 0x70) !== 0) {\n                    // Bits above the 32nd used to be shifted off and discarded, so an\n                    // over-long encoding such as `ff ff ff ff 7f` silently decoded to the\n                    // same value as the canonical `ff ff ff ff 0f`.\n                    throw new Error('VarInt overflows 32 bits!');\n                }\n                // `>>> 0` because the accumulator above is int32: without it every value\n                // from 2^31 up came back negative, so writeUnsignedVarInt(0xffffffff)\n                // round-tripped to -1.\n                return value >>> 0;\n            }\n        }\n\n        throw new Error('VarInt did not terminate after 5 bytes!');\n    }\n\n    /**\n     * Writes a 32 bit unsigned number with variable-length.\n     * @param {number} v\n     */\n    public writeUnsignedVarInt(v: number): void {\n        // One capacity check for the whole varint instead of one per byte (via writeByte),\n        // with the buffer and cursor hoisted into locals so each byte is a plain store.\n        this.ensureCapacity(5);\n        const buf = this.writeBuffer!;\n        let i = this.writeIndex;\n        while ((v & 0xffffff80) !== 0) {\n            buf[i++] = (v & 0x7f) | 0x80;\n            v >>>= 7;\n        }\n        buf[i++] = v & 0x7f;\n        this.writeIndex = i;\n    }\n\n    /**\n     * Reads a 64 bit zigzag-encoded variable-length number.\n     * @returns {bigint}\n     */\n    public readVarLong(): bigint {\n        const raw = this.readUnsignedVarLong();\n        // The zigzag sign XOR was missing, so this used to return `raw >> 1n`: every negative\n        // value decoded wrong (-20n came back as 19n, -1n as 0n) and anything at or above\n        // 2^54 collapsed to 0n. Positive small values were unaffected, which is why the\n        // shipped test suite never caught it.\n        return (raw >> 1n) ^ -(raw & 1n);\n    }\n\n    /**\n     * Writes a 64 bit unsigned zigzag-encoded number.\n     * @param {bigint} v\n     */\n    public writeVarLong(v: bigint) {\n        const n = BigInt.asIntN(64, v);\n        return this.writeUnsignedVarLong((n << 1n) ^ (n >> 63n));\n    }\n\n    /**\n     * Reads a 64 bit unsigned variable-length number.\n     * @returns {bigint}\n     */\n    public readUnsignedVarLong(): bigint {\n        const buf = this.readBuffer;\n        if (buf === null) {\n            throw new Error('Buffer is write only!');\n        }\n        const len = buf.byteLength;\n        // The accumulator is kept in two int32 halves and materialised as a single BigInt at\n        // the end. The previous version allocated five BigInts per decoded byte\n        // (BigInt(b), the mask, BigInt(i), the shift and the or).\n        let lo = 0;\n        let hi = 0;\n        for (let i = 0; i <= 63; i += 7) {\n            if (this.readIndex >= len) {\n                throw new Error('No bytes left in buffer');\n            }\n            const b = buf[this.readIndex++]!;\n            if (i < 28) {\n                lo |= (b & 0x7f) << i;\n            } else if (i === 28) {\n                lo = (lo | ((b & 0x0f) << 28)) >>> 0;\n                hi = (b & 0x7f) >>> 4;\n            } else {\n                hi |= (b & 0x7f) << (i - 32);\n            }\n\n            if ((b & 0x80) === 0) {\n                if (i === 63 && (b & 0x7e) !== 0) {\n                    throw new Error('VarLong overflows 64 bits!');\n                }\n                return (BigInt(hi >>> 0) << 32n) | BigInt(lo >>> 0);\n            }\n        }\n\n        throw new Error('VarLong did not terminate after 10 bytes!');\n    }\n\n    /**\n     * Writes a 64 bit unsigned variable-length number.\n     * @param {bigint} v\n     */\n    public writeUnsignedVarLong(v: bigint) {\n        // The value is split into two uint32 halves once, then the shift/mask loop runs\n        // entirely in int32 space. The previous version did three BigInt allocations plus a\n        // Number() conversion per emitted byte, and computed `v >> 7n` twice per byte.\n        //\n        // It was also wrong: `Number(v | 0x80n)` converted to a double *before* writeByte's\n        // `& 0xff` mask, so above 2^54 the low bits were already rounded away.\n        // writeUnsignedVarLong(9007199254741119n) emitted a leading 0x00 - a terminator -\n        // and the value read back as 0n. Negative inputs emitted ten unterminated bytes;\n        // they are now well-defined as their two's complement, matching protobuf.\n        this.ensureCapacity(10);\n        const buf = this.writeBuffer!;\n        let i = this.writeIndex;\n        const u = BigInt.asUintN(64, v);\n        let lo = Number(u & 0xffffffffn) >>> 0;\n        let hi = Number(u >> 32n) >>> 0;\n        while (hi !== 0 || lo > 0x7f) {\n            buf[i++] = (lo & 0x7f) | 0x80;\n            lo = ((lo >>> 7) | (hi << 25)) >>> 0;\n            hi >>>= 7;\n        }\n        buf[i++] = lo;\n        this.writeIndex = i;\n    }\n\n    /**\n     * Ensures write buffer has enough capacity, grows if needed.\n     * @param {number} needed\n     */\n    private ensureCapacity(needed: number): void {\n        const required = this.writeIndex + needed;\n        if (required > this.writeCapacity) {\n            // Initial allocation or growth\n            const newCapacity =\n                this.writeCapacity === 0\n                    ? Math.max(256, required) // Initial: 256 or required size\n                    : Math.max(required, this.writeCapacity << 1); // Growth: 2x\n            const newBuffer = Buffer.allocUnsafe(newCapacity);\n\n            // Copy existing data if any\n            if (this.writeBuffer !== null && this.writeIndex > 0) {\n                this.writeBuffer!.copy(newBuffer, 0, 0, this.writeIndex);\n            }\n\n            this.writeBuffer = newBuffer;\n            this.writeCapacity = newCapacity;\n        }\n    }\n\n    /**\n     * Grows the write buffer so that at least `capacity` bytes can be written without any\n     * further allocation, and returns this stream.\n     *\n     * Pre-sizing skips the 256 -> 512 -> 1024 ... growth ladder, each step of which copies the\n     * whole payload; a 3 KB packet starting from the 256-byte floor performs five allocations\n     * and memcpy's 1.25x its own size before it is done.\n     * @param {number} capacity\n     */\n    public reserve(capacity: number): this {\n        if (capacity > this.writeCapacity) {\n            const newBuffer = Buffer.allocUnsafe(capacity);\n            if (this.writeBuffer !== null && this.writeIndex > 0) {\n                this.writeBuffer.copy(newBuffer, 0, 0, this.writeIndex);\n            }\n            this.writeBuffer = newBuffer;\n            this.writeCapacity = capacity;\n        }\n        return this;\n    }\n\n    /**\n     * Rewinds the write cursor while keeping the allocated capacity, so a long-lived encoder\n     * reaches a steady state where it never allocates again. This is the intended way to reuse\n     * a stream for many packets.\n     *\n     * Note the aliasing contract, which it shares with {@link clear} and {@link reuse}: any\n     * buffer previously handed out by {@link getWriteBuffer} is a *view* over this stream's\n     * memory and is invalidated by this call. Use {@link copyOut} or {@link copyInto} for\n     * output you intend to keep.\n     */\n    public resetWrite(): void {\n        this.writeIndex = 0;\n    }\n\n    /**\n     * Returns the encoded bytes as an exactly-sized, standalone Buffer.\n     *\n     * Unlike {@link getWriteBuffer} the result does not alias this stream, so it survives\n     * {@link resetWrite}, and it does not pin a pool chunk: because `Buffer.allocUnsafe` is\n     * pool-backed (`Buffer.poolSize` is 64 KB on current Node), holding on to a handful of\n     * small slices from {@link getWriteBuffer} can keep megabytes alive.\n     * @returns {Buffer}\n     */\n    public copyOut(): Buffer {\n        const out = Buffer.allocUnsafeSlow(this.writeIndex);\n        if (this.writeIndex > 0) {\n            this.writeBuffer!.copy(out, 0, 0, this.writeIndex);\n        }\n        return out;\n    }\n\n    /**\n     * Copies the encoded bytes into a caller-owned buffer at `offset` and returns the offset\n     * just past them. Lets many packets be encoded into one arena with no per-packet\n     * allocation at all.\n     * @param {Buffer} target\n     * @param {number} offset\n     * @returns {number} the new offset\n     */\n    public copyInto(target: Buffer, offset: number = 0): number {\n        if (this.writeIndex > 0) {\n            this.writeBuffer!.copy(target, offset, 0, this.writeIndex);\n        }\n        return offset + this.writeIndex;\n    }\n\n    /**\n     * Increases the write offset by the given length.\n     * @param {number} length\n     */\n    private addOffset(length: number): number {\n        return (this.readIndex += length) - length;\n    }\n\n    /**\n     * Returns whatever or not the read offset is at end of line.\n     * @returns {number}\n     */\n    public feof(): boolean {\n        const buf = this.readBuffer;\n        if (buf === null) throw new Error('Buffer is write only!');\n        // A numeric compare rather than `typeof buf[i] === 'undefined'`. The latter is an\n        // out-of-bounds element load, and V8 bails out of the optimized code for this\n        // function the first time it happens - which is every packet decoded to its end.\n        return this.readIndex >= buf.byteLength;\n    }\n\n    /**\n     * Reads the remaining bytes and returns the buffer slice.\n     * @returns {Buffer}\n     */\n    public readRemaining(): Buffer {\n        if (!this.readBuffer) throw new Error('Buffer is write only!');\n        const buf = this.readBuffer!.subarray(this.readIndex);\n        this.readIndex = this.readBuffer.byteLength;\n        return buf;\n    }\n\n    /**\n     * Skips len bytes on the buffer.\n     * @param {number} len\n     */\n    public skip(len: number): void {\n        assert(Number.isInteger(len), 'Cannot skip a float amount of bytes');\n        this.readIndex += len;\n    }\n\n    /**\n     * Returns the encoded buffer.\n     *\n     * Beware: when a read buffer is present this returns *that*, discarding everything\n     * written. On a stream used for both reading and writing it never returns your output.\n     * @returns {Buffer}\n     * @deprecated See {@link getReadBuffer} and {@link getWriteBuffer}.\n     */\n    public getBuffer(): Buffer {\n        return this.readBuffer !== null ? this.readBuffer : this.writeBuffer!.subarray(0, this.writeIndex);\n    }\n\n    /**\n     * Returns the read buffer if available.\n     * @returns {Buffer}\n     */\n    public getReadBuffer(): Buffer | null {\n        return this.readBuffer;\n    }\n\n    /**\n     * Returns the encoded bytes as a *view* over this stream's internal buffer.\n     *\n     * The view is only valid until the next write: {@link resetWrite}, {@link clear} and\n     * {@link reuse} all rewind the cursor without reallocating, so a previously returned\n     * buffer is silently overwritten by the next packet. If you queue the result - a send\n     * queue, a resend window - use {@link copyOut} or {@link copyInto} instead.\n     *\n     * It also keeps the whole pooled 64 KB chunk it was carved from alive; retaining a\n     * scattered handful of small packets this way can pin megabytes.\n     * @returns {Buffer}\n     */\n    public getWriteBuffer(): Buffer {\n        return this.writeBuffer!.subarray(0, this.writeIndex);\n    }\n\n    /**\n     * Sets the buffer for reading.\n     * make sure to reset the reading index!\n     * @param buf - The new Buffer.\n     * @deprecated See {@link setReadBuffer} and {@link setWriteBuffer}.\n     */\n    public setBuffer(buf: Buffer): void {\n        this.readBuffer = buf;\n    }\n\n    /**\n     * Sets the buffer for reading.\n     * @param buf - The new Buffer.\n     * @param rIndex - The new read index (default: 0, pass -1 to keep current).\n     */\n    public setReadBuffer(buf: Buffer, rIndex = 0): void {\n        this.readBuffer = buf;\n        if (rIndex >= 0) this.readIndex = rIndex;\n    }\n\n    /**\n     * Sets the buffer for writing.\n     * @param buf - The new Buffer.\n     * @param wIndex - The new write index (default: 0, pass -1 to keep current).\n     */\n    public setWriteBuffer(buf: Buffer, wIndex = 0): void {\n        this.writeBuffer = buf;\n        if (wIndex >= 0) this.writeIndex = wIndex;\n        this.writeCapacity = buf.byteLength;\n    }\n\n    /**\n     * Clears the whole BinaryStream instance.\n     *\n     * The write buffer and its capacity are kept, so any view previously returned by\n     * {@link getWriteBuffer} is invalidated. See {@link resetWrite}.\n     */\n    public clear(): void {\n        this.readBuffer = null;\n        this.readIndex = 0;\n        this.writeIndex = 0;\n    }\n\n    /**\n     * Conventional method to reuse the stream\n     * without having to create a new BinaryStream instance.\n     *\n     * The write buffer and its capacity are kept, so any view previously returned by\n     * {@link getWriteBuffer} is invalidated. See {@link resetWrite}.\n     * @param buf - The new buffer instance.\n     */\n    public reuse(buf: Buffer): void {\n        this.readBuffer = buf;\n        this.readIndex = 0;\n        this.writeIndex = 0;\n    }\n\n    /**\n     * Sets the reading index.\n     * @param index - The new read index.\n     */\n    public setReadIndex(index: number): void {\n        assert(index >= 0, 'Index must be non-negative');\n        this.readIndex = index;\n    }\n\n    /**\n     * Sets the new writing index.\n     * @param index - The new write index.\n     */\n    public setWriteIndex(index: number): void {\n        assert(index >= 0, 'Index must be non-negative');\n        this.writeIndex = index;\n    }\n\n    /**\n     * Retuns the read index.\n     * @returns {number}\n     */\n    public getReadIndex(): number {\n        return this.readIndex;\n    }\n\n    /**\n     * Returns the write index.\n     * @returns {number}\n     */\n    public getWriteIndex(): number {\n        return this.writeIndex;\n    }\n\n    /**\n     * Do read assertions, check if the read buffer is null.\n     * @param {number} byteLength\n     */\n    private doReadAssertions(byteLength: number): void {\n        const buf = this.readBuffer;\n        if (buf === null) {\n            assert.fail('Cannot read without buffer data!');\n        }\n        // This used to compare the *total* buffer length against the requested length and\n        // ignore readIndex entirely, so it caught almost nothing: read(4) at offset 998 of a\n        // 1000-byte buffer returned 2 bytes with no error, readBoolean past the end returned\n        // true, and the fixed-width readers blew up with an ERR_OUT_OF_RANGE raised from\n        // inside Buffer rather than an AssertionError raised here.\n        if (this.readIndex + byteLength > buf.byteLength) {\n            assert.fail(\n                `Cannot read ${byteLength} byte(s) at offset ${this.readIndex}: ` +\n                    `only ${Math.max(0, buf.byteLength - this.readIndex)} left in buffer`\n            );\n        }\n    }\n\n    /**\n     * Do read assertions, check if the read buffer is null.\n     * @param {number|bigint} num\n     * @param {number|bigint} minVal\n     * @param {number|bigint} maxVal\n     */\n    private doWriteAssertions(num: number, minVal: number, maxVal: number): void {\n        // Argument expressions are evaluated *before* the call, so the template literal used\n        // to be built on every successful write - sixteen write methods route through here.\n        // For writeFloat/writeDouble the bounds are doubles, so each call ran three\n        // double-to-string conversions and threw the result away. Building the message only\n        // on failure is worth ~2.3x on a mixed packet-encoding workload.\n        //\n        // `!(a && b)` rather than `a < min || a > max`: the latter silently accepts NaN,\n        // which this method has always rejected.\n        if (!(num >= minVal && num <= maxVal)) {\n            assert.fail(`Value out of bounds: value=${num}, min=${minVal}, max=${maxVal}`);\n        }\n    }\n}\n\n// Default export for backward compatibility\nexport default BinaryStream;\n"],"mappings":"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"}