@schema-pack/message-pack 0.0.0-commit.8d5dca5ce6fa2841d57d39bd48f82979461a0a69 → 0.0.0-commit.a13995b1ec0a9d8be0fcfbdf0d45a0c8a2c75b3c

package/dist/esm/encoder/encoder.mjs

@@ -1,40 +1,704 @@
-import EncoderBuffer from "./encoderBuffer.mjs";
+import Symbols from "../symbols.mjs";
+import BufferWithExtensions from "../bufferWithExtensions.mjs";
+import { INT64_MIN, UINT32_MAX, UINT64_MAX } from "../constants.mjs";
+import defaultNewBufferFn from "../defaultNewBufferFn.mjs";
+import fitIn7Bits from "../utils/fitIn7Bits.mjs";
+import fitIn8Bits from "../utils/fitIn8Bits.mjs";
+import fitIn16Bits from "../utils/fitIn16Bits.mjs";
+import fitIn32Bits from "../utils/fitIn32Bits.mjs";
+import DefaultTextEncoder from "./textEncoders/defaultTextEncoder.mjs";
 //#region src/encoder/encoder.ts
-/**
-* The `Encoder` class is responsible for encoding JavaScript values into the
-* MessagePack format.
-*
-* This class is just a wrapper around the buffer, which does the actual
-* encoding. The buffer is responsible for managing the encoding process and
-* handling extensions.
-*/
-var Encoder = class {
+const BIGINT_MASK = 18446744073709551615n;
+var Encoder = class Encoder extends BufferWithExtensions {
+	/**
+	* Shared buffer is used to encode strings, to avoid allocating a new buffer
+	* for each string. The shared buffer is resized if the string is larger than
+	* the current size of the shared buffer. This helps to improve performance by
+	* reducing memory allocations and garbage collection overhead.
+	*/
+	sharedBuffer;
+	extensionsByConstructors = /* @__PURE__ */ new Map();
+	builtInExtensionsByConstructors = /* @__PURE__ */ new Map();
+	/** The current offset in the buffer where the next write operation will occur. */
+	offset;
+	/**
+	* Determines whether the keys of a map should be sorted before encoding.
+	* Sorting keys can be useful for ensuring consistent serialization of
+	* objects, which is important for tasks like hashing or comparing serialized
+	* data.
+	*/
+	sortKeys;
+	/**
+	* If true, forces the encoder to use 32-bit floating point representation for
+	* numbers, even if they could be represented as 64-bit floats. This can be
+	* useful for reducing the size of the encoded data when high precision is not
+	* required. However, it may lead to loss of precision for very large or very
+	* small numbers.
+	*/
+	forceFloat32;
+	/**
+	* The initial size of the main buffer. This determines how much memory is
+	* allocated for the buffer when the encoder is first created. If the buffer
+	* needs to grow beyond this size, it will be reallocated with a larger size.
+	*/
+	initialBufferSize;
+	/**
+	* The initial size of the shared buffer used for encoding strings. This
+	* determines how much memory is allocated for the shared buffer when the
+	* encoder is first created. If the shared buffer needs to grow beyond this
+	* size, it will be reallocated with a larger size.
+	*/
+	initialSharedBufferSize;
+	/**
+	* A function that creates a new buffer of the specified size. This function
+	* is used to allocate new buffers when the current buffer is not large enough
+	* to accommodate the data being written. The function should return a new
+	* instance of TBuffer with the specified size.
+	*/
+	bufferFactory;
+	textEncoder;
 	buffer;
+	view;
+	/**
+	* The extension encoder is used to encode extension types. It is a separate
+	* buffer from the main buffer, and is used to encode the extension data
+	* before writing it to the main buffer. This allows for efficient encoding of
+	* extension types, as the extension data can be encoded in a separate buffer
+	* and then written to the main buffer in a single operation.
+	*
+	* The extension buffer must be resized using ensureCapacity before writing to
+	* it, to ensure that there is enough space for the extension data.
+	*/
+	#extensionEncoder;
 	constructor(options) {
-		this.buffer = new EncoderBuffer(options);
-	}
-	encode(value) {
-		const { buffer } = this;
-		buffer.write(value);
-		return this.buffer.flush();
+		super(options);
+		this.offset = 0;
+		this.textEncoder = options?.textEncoder ?? new DefaultTextEncoder();
+		this.initialBufferSize = options?.initialBufferSize ?? 1024;
+		this.initialSharedBufferSize = options?.initialSharedBufferSize ?? 1024;
+		this.bufferFactory = options?.bufferFactory ?? defaultNewBufferFn;
+		this.buffer = this.bufferFactory(this.initialBufferSize);
+		this.sharedBuffer = this.bufferFactory(this.initialSharedBufferSize);
+		this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+		this.sortKeys = options?.sortKeys ?? false;
+		this.forceFloat32 = options?.forceFloat32 ?? false;
+		if (this.errorExtension) for (const constructor of this.errorExtension.constructors) this.builtInExtensionsByConstructors.set(constructor, this.errorExtension);
+		if (this.timestampDateExtension) for (const constructor of this.timestampDateExtension.constructors) this.builtInExtensionsByConstructors.set(constructor, this.timestampDateExtension);
 	}
 	addExtension(extension) {
-		this.buffer.addExtension(extension);
+		super.addExtension(extension);
+		if (Array.isArray(extension.constructors)) for (const constructor of extension.constructors) this.extensionsByConstructors.set(constructor, extension);
+		else this.extensionsByConstructors.set(extension.constructors, extension);
+		if (this.#extensionEncoder) this.#extensionEncoder.addExtension(extension);
+		return this;
+	}
+	getExtensionEncoder() {
+		if (!this.#extensionEncoder) {
+			const extensionEncoder = new Encoder({
+				bufferFactory: this.bufferFactory,
+				extensions: {
+					bigInt: this.bigIntExtension ?? false,
+					error: this.errorExtension ?? false,
+					timestampDate: this.timestampDateExtension ?? false
+				},
+				forceFloat32: this.forceFloat32,
+				initialBufferSize: this.initialBufferSize,
+				initialSharedBufferSize: this.initialSharedBufferSize,
+				sortKeys: this.sortKeys,
+				textEncoder: this.textEncoder
+			});
+			for (const extension of this.extensions.values()) extensionEncoder.addExtension(extension);
+			this.#extensionEncoder = extensionEncoder;
+		}
+		return this.#extensionEncoder;
+	}
+	resizeBuffer(newSize) {
+		const newBuffer = this.bufferFactory(newSize);
+		newBuffer.set(this.buffer);
+		this.buffer = newBuffer;
+		this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+		return this;
+	}
+	ensureCapacity(sizeToWrite) {
+		const required = this.offset + sizeToWrite;
+		if (this.buffer.byteLength < required) this.resizeBuffer(required * 2);
+		return this;
+	}
+	resetBuffer() {
+		this.offset = 0;
+		return this;
+	}
+	flush() {
+		const buffer = this.buffer.subarray(0, this.offset);
+		this.resetBuffer();
+		return buffer;
+	}
+	writePositiveFixInt(value) {
+		this.writeUint8(value);
+		return this;
+	}
+	writeNegativeFixInt(value) {
+		this.buffer[this.offset++] = value + 256;
+		return this;
+	}
+	writeBin(bytes) {
+		this.buffer.set(bytes, this.offset);
+		this.offset += bytes.length;
+		return this;
+	}
+	writeFloat32(value) {
+		this.view.setFloat32(this.offset, value);
+		this.offset += 4;
+		return this;
+	}
+	writeFloat64(value) {
+		this.view.setFloat64(this.offset, value);
+		this.offset += 8;
+		return this;
+	}
+	writeUint8(value) {
+		this.buffer[this.offset++] = value;
+		return this;
+	}
+	writeUint16(value) {
+		this.view.setUint16(this.offset, value);
+		this.offset += 2;
+		return this;
+	}
+	writeUint32(value) {
+		this.view.setUint32(this.offset, value);
+		this.offset += 4;
+		return this;
+	}
+	writeUint64(value) {
+		const high = value / 4294967296;
+		const low = value;
+		this.view.setUint32(this.offset, high);
+		this.offset += 4;
+		this.view.setUint32(this.offset, low);
+		this.offset += 4;
+		return this;
+	}
+	writeInt8(value) {
+		this.view.setInt8(this.offset++, value & 255);
+		return this;
+	}
+	writeInt16(value) {
+		this.view.setInt16(this.offset, value);
+		this.offset += 2;
+		return this;
+	}
+	writeInt32(value) {
+		this.view.setInt32(this.offset, value);
+		this.offset += 4;
+		return this;
+	}
+	writeInt64(value) {
+		const high = Math.floor(value / 4294967296);
+		const low = value;
+		this.view.setInt32(this.offset, high);
+		this.offset += 4;
+		this.view.setInt32(this.offset, low);
+		this.offset += 4;
+		return this;
+	}
+	writeStr(value) {
+		this.offset += this.textEncoder.writeBytes(value, this.buffer);
+		return this;
+	}
+	writeNilSymbol() {
+		this.buffer[this.offset++] = Symbols.NIL;
+		return this;
+	}
+	writeFalseSymbol() {
+		this.buffer[this.offset++] = Symbols.FALSE;
+		return this;
+	}
+	writeTrueSymbol() {
+		this.buffer[this.offset++] = Symbols.TRUE;
+		return this;
+	}
+	writeFixMapSymbol(keysSize) {
+		this.buffer[this.offset++] = Symbols.FIXMAP_START | keysSize;
+		return this;
+	}
+	writeFixArraySymbol(arraySize) {
+		this.buffer[this.offset++] = Symbols.FIXARRAY_START | arraySize;
+		return this;
+	}
+	writeFixStrSymbol(byteLength) {
+		this.buffer[this.offset++] = Symbols.FIXSTR_START | byteLength;
+		return this;
+	}
+	writeBin8Symbol(size) {
+		this.buffer[this.offset++] = Symbols.BIN8;
+		this.buffer[this.offset++] = size;
+		return this;
+	}
+	writeBin16Symbol(size) {
+		this.buffer[this.offset++] = Symbols.BIN16;
+		this.view.setUint16(this.offset, size);
+		this.offset += 2;
+		return this;
+	}
+	writeBin32Symbol(size) {
+		this.buffer[this.offset++] = Symbols.BIN32;
+		this.view.setUint32(this.offset, size);
+		this.offset += 4;
+		return this;
+	}
+	writeFloat32Symbol() {
+		this.buffer[this.offset++] = Symbols.FLOAT32;
+		return this;
+	}
+	writeFloat64Symbol() {
+		this.buffer[this.offset++] = Symbols.FLOAT64;
+		return this;
+	}
+	writeUint8Symbol() {
+		this.buffer[this.offset++] = Symbols.UINT8;
+		return this;
+	}
+	writeUint16Symbol() {
+		this.buffer[this.offset++] = Symbols.UINT16;
 		return this;
 	}
-	addInternalExtension(extension) {
-		this.buffer.addInternalExtension(extension);
+	writeUint32Symbol() {
+		this.buffer[this.offset++] = Symbols.UINT32;
 		return this;
 	}
-	addExtensionType(type, extension) {
-		this.buffer.addExtension({
-			type,
-			...extension
-		});
+	writeUint64Symbol() {
+		this.buffer[this.offset++] = Symbols.UINT64;
 		return this;
 	}
-	fetchExtension(type) {
-		return this.buffer.fetchExtension(type);
+	writeInt8Symbol() {
+		this.buffer[this.offset++] = Symbols.INT8;
+		return this;
+	}
+	writeInt16Symbol() {
+		this.buffer[this.offset++] = Symbols.INT16;
+		return this;
+	}
+	writeInt32Symbol() {
+		this.buffer[this.offset++] = Symbols.INT32;
+		return this;
+	}
+	writeInt64Symbol() {
+		this.buffer[this.offset++] = Symbols.INT64;
+		return this;
+	}
+	writeStr8Symbol(size) {
+		this.buffer[this.offset++] = Symbols.STR8;
+		this.buffer[this.offset++] = size;
+		return this;
+	}
+	writeStr16Symbol(size) {
+		this.buffer[this.offset++] = Symbols.STR16;
+		this.view.setUint16(this.offset, size);
+		this.offset += 2;
+		return this;
+	}
+	writeStr32Symbol(size) {
+		this.buffer[this.offset++] = Symbols.STR32;
+		this.view.setUint32(this.offset, size);
+		this.offset += 4;
+		return this;
+	}
+	writeArray16Symbol(size) {
+		this.buffer[this.offset++] = Symbols.ARRAY16;
+		this.view.setUint16(this.offset, size);
+		this.offset += 2;
+		return this;
+	}
+	writeArray32Symbol(size) {
+		this.buffer[this.offset++] = Symbols.ARRAY32;
+		this.view.setUint32(this.offset, size);
+		this.offset += 4;
+		return this;
+	}
+	writeMap16Symbol(size) {
+		this.buffer[this.offset++] = Symbols.MAP16;
+		this.view.setUint16(this.offset, size);
+		this.offset += 2;
+		return this;
+	}
+	writeMap32Symbol(size) {
+		this.buffer[this.offset++] = Symbols.MAP32;
+		this.view.setUint32(this.offset, size);
+		this.offset += 4;
+		return this;
+	}
+	writeFixExt1Symbol(type) {
+		this.buffer[this.offset++] = Symbols.FIXEXT1;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeFixExt2Symbol(type) {
+		this.buffer[this.offset++] = Symbols.FIXEXT2;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeFixExt4Symbol(type) {
+		this.buffer[this.offset++] = Symbols.FIXEXT4;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeFixExt8Symbol(type) {
+		this.buffer[this.offset++] = Symbols.FIXEXT8;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeFixExt16Symbol(type) {
+		this.buffer[this.offset++] = Symbols.FIXEXT16;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeExt8Symbol(type, size) {
+		this.buffer[this.offset++] = Symbols.EXT8;
+		this.buffer[this.offset++] = size;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeExt16Symbol(type, size) {
+		this.buffer[this.offset++] = Symbols.EXT16;
+		this.view.setUint16(this.offset, size);
+		this.offset += 2;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeExt32Symbol(type, size) {
+		this.buffer[this.offset++] = Symbols.EXT32;
+		this.view.setUint32(this.offset, size);
+		this.offset += 4;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeString(value) {
+		const valueLength = value.length;
+		const requiredSize = value.length * 4;
+		if (valueLength < 64) {
+			this.ensureCapacity(1 + requiredSize);
+			const initialoffset = this.offset;
+			const byteLengthoffset = this.offset++;
+			let totalBytes = 0;
+			let fitInFixStr = true;
+			let fitInStr8 = true;
+			let { offset } = this;
+			for (let index = 0; index < valueLength; index++) {
+				const code = value.charCodeAt(index);
+				if (code < 128) {
+					this.buffer[offset++] = code;
+					totalBytes++;
+				} else if (code < 2048) {
+					this.buffer[offset++] = 192 | code >> 6;
+					this.buffer[offset++] = 128 | code & 63;
+					totalBytes += 2;
+				} else if (code < 55296 || code >= 57344) {
+					this.buffer[offset++] = 224 | code >> 12;
+					this.buffer[offset++] = 128 | code >> 6 & 63;
+					this.buffer[offset++] = 128 | code & 63;
+					totalBytes += 3;
+				} else {
+					index++;
+					const nextCode = value.charCodeAt(index);
+					const surrogatePair = ((code & 1023) << 10 | nextCode & 1023) + 65536;
+					this.buffer[offset++] = 240 | surrogatePair >> 18;
+					this.buffer[offset++] = 128 | surrogatePair >> 12 & 63;
+					this.buffer[offset++] = 128 | surrogatePair >> 6 & 63;
+					this.buffer[offset++] = 128 | surrogatePair & 63;
+					totalBytes += 4;
+				}
+				if (totalBytes > 31) fitInFixStr = false;
+				else if (totalBytes > 255) {
+					fitInStr8 = false;
+					break;
+				}
+			}
+			if (fitInFixStr) {
+				this.buffer[byteLengthoffset] = Symbols.FIXSTR_START | totalBytes;
+				this.offset += totalBytes;
+				return this;
+			} else if (fitInStr8) {
+				this.buffer[byteLengthoffset] = Symbols.STR8;
+				const totalBytesPosition = byteLengthoffset + 1;
+				this.buffer.copyWithin(totalBytesPosition + 1, totalBytesPosition, offset);
+				this.buffer[totalBytesPosition] = totalBytes;
+				this.offset++;
+				this.offset += totalBytes;
+				return this;
+			}
+			this.offset = initialoffset;
+		}
+		if (this.sharedBuffer.byteLength < requiredSize) this.sharedBuffer = this.bufferFactory(requiredSize);
+		const sharedBuffer = this.sharedBuffer;
+		const byteLength = this.textEncoder.writeBytes(value, sharedBuffer);
+		if (fitIn8Bits(byteLength)) {
+			this.ensureCapacity(2 + byteLength);
+			this.writeStr8Symbol(byteLength);
+		} else if (fitIn16Bits(byteLength)) {
+			this.ensureCapacity(3 + byteLength);
+			this.writeStr16Symbol(byteLength);
+		} else {
+			this.ensureCapacity(5 + byteLength);
+			this.writeStr32Symbol(byteLength);
+		}
+		this.writeBin(sharedBuffer.subarray(0, byteLength));
+		return this;
+	}
+	writeSignedInteger(value) {
+		if (value > -33) {
+			this.ensureCapacity(1);
+			return this.writeNegativeFixInt(value);
+		} else if (value > -129) {
+			this.ensureCapacity(2);
+			this.writeInt8Symbol();
+			return this.writeInt8(value);
+		} else if (value > -32769) {
+			this.ensureCapacity(3);
+			this.writeInt16Symbol();
+			return this.writeInt16(value);
+		} else if (value > -2147483649) {
+			this.ensureCapacity(5);
+			this.writeInt32Symbol();
+			return this.writeInt32(value);
+		} else if (value >= INT64_MIN) {
+			this.ensureCapacity(9);
+			this.writeInt64Symbol();
+			return this.writeInt64(value);
+		}
+		throw new Error(`Integer too small to encode: ${value}. Consider using BigIntExtension.`);
+	}
+	writeUnsignedInteger(value) {
+		if (fitIn7Bits(value)) {
+			this.ensureCapacity(1);
+			return this.writePositiveFixInt(value);
+		}
+		if (fitIn8Bits(value)) {
+			this.ensureCapacity(2);
+			this.writeUint8Symbol();
+			return this.writeUint8(value);
+		}
+		if (fitIn16Bits(value)) {
+			this.ensureCapacity(3);
+			this.writeUint16Symbol();
+			return this.writeUint16(value);
+		}
+		if (fitIn32Bits(value)) {
+			this.ensureCapacity(5);
+			this.writeUint32Symbol();
+			return this.writeUint32(value);
+		}
+		if (value <= UINT64_MAX) {
+			this.ensureCapacity(9);
+			this.writeUint64Symbol();
+			return this.writeUint64(value);
+		}
+		throw new Error(`Integer too large to encode: ${value}. Consider using BigIntExtension.`);
+	}
+	writeFloat(value) {
+		if (this.forceFloat32) {
+			this.ensureCapacity(5);
+			this.writeFloat32Symbol();
+			return this.writeFloat32(value);
+		}
+		this.ensureCapacity(9);
+		this.writeFloat64Symbol();
+		return this.writeFloat64(value);
+	}
+	writeNumber(value) {
+		if (Number.isInteger(value)) {
+			if (value < 0) return this.writeSignedInteger(value);
+			return this.writeUnsignedInteger(value);
+		}
+		return this.writeFloat(value);
+	}
+	openMap(keysLength) {
+		const requiredSize = keysLength * 4;
+		if (keysLength < 16) {
+			this.ensureCapacity(requiredSize + 1);
+			this.writeFixMapSymbol(keysLength);
+		} else if (fitIn16Bits(keysLength)) {
+			this.ensureCapacity(requiredSize + 3);
+			this.writeMap16Symbol(keysLength);
+		} else if (fitIn32Bits(keysLength)) {
+			this.ensureCapacity(requiredSize + 5);
+			this.writeMap32Symbol(keysLength);
+		} else throw new Error(`Map size ${keysLength} exceeds maximum allowed size of ${UINT32_MAX}`);
+		return this;
+	}
+	writeMap(value) {
+		const keys = Object.keys(value);
+		if (this.sortKeys) keys.sort();
+		const keysLength = keys.length;
+		this.openMap(keysLength);
+		for (const key of keys) {
+			this.writeString(key);
+			this.write(value[key]);
+		}
+		return this;
+	}
+	openArray(length) {
+		const requiredSize = length * 4;
+		if (length < 16) {
+			this.ensureCapacity(requiredSize + 1);
+			this.writeFixArraySymbol(length);
+		} else if (fitIn16Bits(length)) {
+			this.ensureCapacity(requiredSize + 3);
+			this.writeArray16Symbol(length);
+		} else if (fitIn32Bits(length)) {
+			this.ensureCapacity(requiredSize + 5);
+			this.writeArray32Symbol(length);
+		} else throw new Error(`Array size ${length} exceeds maximum allowed size of ${UINT32_MAX}`);
+		return this;
+	}
+	writeArray(value) {
+		const length = value.length;
+		this.openArray(length);
+		for (let index = 0; index < length; ++index) this.write(value[index]);
+		return this;
+	}
+	writeUint8Array(value) {
+		if (fitIn8Bits(value.length)) {
+			this.ensureCapacity(2 + value.length);
+			this.writeBin8Symbol(value.length);
+		} else if (fitIn16Bits(value.length)) {
+			this.ensureCapacity(3 + value.length);
+			this.writeBin16Symbol(value.length);
+		} else if (fitIn32Bits(value.length)) {
+			this.ensureCapacity(5 + value.length);
+			this.writeBin32Symbol(value.length);
+		} else throw new Error(`Uint8Array too large to encode: ${value.length}`);
+		return this.writeBin(value);
+	}
+	writeExtensionSymbol(type, size) {
+		if (size === 1) {
+			this.ensureCapacity(3);
+			this.writeFixExt1Symbol(type);
+		} else if (size === 2) {
+			this.ensureCapacity(4);
+			this.writeFixExt2Symbol(type);
+		} else if (size === 4) {
+			this.ensureCapacity(6);
+			this.writeFixExt4Symbol(type);
+		} else if (size === 8) {
+			this.ensureCapacity(10);
+			this.writeFixExt8Symbol(type);
+		} else if (size === 16) {
+			this.ensureCapacity(18);
+			this.writeFixExt16Symbol(type);
+		} else if (fitIn8Bits(size)) {
+			this.ensureCapacity(3 + size);
+			this.writeExt8Symbol(type, size);
+		} else if (fitIn16Bits(size)) {
+			this.ensureCapacity(4 + size);
+			this.writeExt16Symbol(type, size);
+		} else if (fitIn32Bits(size)) {
+			this.ensureCapacity(6 + size);
+			this.writeExt32Symbol(type, size);
+		} else throw new Error(`Extension data too large to encode: ${size} bytes`);
+		return this;
+	}
+	writeExtension(extension, extensionEncoder) {
+		const writtenBytes = extensionEncoder.offset;
+		this.writeExtensionSymbol(extension.type, writtenBytes);
+		this.buffer.set(extensionEncoder.buffer.subarray(0, writtenBytes), this.offset);
+		this.offset += writtenBytes;
+		return this;
+	}
+	writeBigInt(value) {
+		if (!this.bigIntExtension) throw new Error(`BigInt extension is disabled, cannot encode BigInt.`);
+		let magnitude;
+		if (value < 0n) magnitude = (-value << 1n) - 1n;
+		else magnitude = value << 1n;
+		let sizeOffset;
+		let size = 0;
+		if (magnitude >> 64n === 0n) {
+			this.ensureCapacity(2);
+			this.writeFixExt8Symbol(this.bigIntExtension.type);
+		} else if (magnitude >> 128n === 0n) {
+			this.ensureCapacity(2);
+			this.writeFixExt16Symbol(this.bigIntExtension.type);
+		} else if (magnitude >> 1984n === 0n) {
+			this.ensureCapacity(3);
+			this.buffer[this.offset++] = Symbols.EXT8;
+			sizeOffset = this.offset++;
+			this.buffer[this.offset++] = this.bigIntExtension.type;
+		} else if (magnitude >> 524224n === 0n) {
+			this.ensureCapacity(4);
+			this.buffer[this.offset++] = Symbols.EXT16;
+			sizeOffset = this.offset;
+			this.offset += 2;
+			this.buffer[this.offset++] = this.bigIntExtension.type;
+		} else {
+			this.ensureCapacity(6);
+			this.buffer[this.offset++] = Symbols.EXT32;
+			sizeOffset = this.offset;
+			this.offset += 4;
+			this.buffer[this.offset++] = this.bigIntExtension.type;
+		}
+		if (magnitude === 0n) {
+			this.ensureCapacity(8);
+			this.view.setBigUint64(this.offset, 0n, false);
+			this.offset += 8;
+			return this;
+		}
+		while (magnitude > 0n) {
+			this.ensureCapacity(8);
+			this.view.setBigUint64(this.offset, magnitude & BIGINT_MASK, false);
+			this.offset += 8;
+			magnitude >>= 64n;
+			size += 8;
+		}
+		if (sizeOffset !== void 0) {
+			if (fitIn8Bits(size)) this.buffer[sizeOffset] = size;
+			else if (fitIn16Bits(size)) this.view.setUint16(sizeOffset, size, false);
+			else this.view.setUint32(sizeOffset, size, false);
+		}
+		return this;
+	}
+	writeError(error) {
+		if (!this.errorExtension) throw new Error(`Error extension is disabled, cannot encode Error.`);
+		this.errorExtension.encodeInto(error, this);
+		return this;
+	}
+	writeObject(value) {
+		if (Array.isArray(value)) return this.writeArray(value);
+		if (value instanceof Uint8Array) return this.writeUint8Array(value);
+		const valueConstructor = value.constructor;
+		const builtInExtension = this.builtInExtensionsByConstructors.get(valueConstructor);
+		if (builtInExtension) {
+			builtInExtension.encodeInto(value, this);
+			return this;
+		}
+		const extension = this.extensionsByConstructors.get(valueConstructor);
+		if (extension) {
+			const extensionEncoder = this.getExtensionEncoder();
+			extensionEncoder.resetBuffer();
+			extension.encode(value, extensionEncoder);
+			if (extensionEncoder.offset > 0) return this.writeExtension(extension, extensionEncoder);
+		}
+		return this.writeMap(value);
+	}
+	write(value) {
+		switch (typeof value) {
+			case "number": return this.writeNumber(value);
+			case "string": return this.writeString(value);
+			case "boolean":
+				this.ensureCapacity(1);
+				if (value) return this.writeTrueSymbol();
+				return this.writeFalseSymbol();
+			case "undefined":
+				this.ensureCapacity(1);
+				return this.writeNilSymbol();
+			case "bigint": return this.writeBigInt(value);
+			case "object":
+				if (value === null) {
+					this.ensureCapacity(1);
+					return this.writeNilSymbol();
+				}
+				return this.writeObject(value);
+			default: throw new TypeError(`Unsupported type for encoding: ${typeof value}. Consider using an extension.`);
+		}
 	}
 };
 //#endregion