@schema-pack/message-pack 0.0.0-commit.03ddd0427843dd0e1b45dcd0325ecf52097255a4

package/dist/esm/encoder/encoder.mjs

@@ -0,0 +1,43 @@
+import EncoderBuffer from "./encoderBuffer.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 {
+	buffer;
+	constructor(options) {
+		this.buffer = new EncoderBuffer(options);
+	}
+	encode(value) {
+		const buffer = this.buffer;
+		buffer.write(value);
+		return buffer.flush();
+	}
+	addExtension(extension) {
+		this.buffer.addExtension(extension);
+		return this;
+	}
+	addInternalExtension(extension) {
+		this.buffer.addInternalExtension(extension);
+		return this;
+	}
+	addExtensionType(type, extension) {
+		this.buffer.addExtension({
+			type,
+			...extension
+		});
+		return this;
+	}
+	fetchExtension(type) {
+		return this.buffer.fetchExtension(type);
+	}
+};
+//#endregion
+export { Encoder as default };
+
+//# sourceMappingURL=encoder.mjs.map

package/dist/esm/encoder/encoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.mjs","names":[],"sources":["../../../src/encoder/encoder.ts"],"sourcesContent":["import type MessagePackExtension from '../extensions/interfaces/messagePackExtension.ts';\nimport EncoderBuffer from './encoderBuffer.ts';\nimport type { EncoderBufferOptions } from './types.ts';\n\n/**\n * The `Encoder` class is responsible for encoding JavaScript values into the\n * MessagePack format.\n *\n * This class is just a wrapper around the buffer, which does the actual\n * encoding. The buffer is responsible for managing the encoding process and\n * handling extensions.\n */\nclass Encoder<TBuffer extends Uint8Array = Uint8Array> {\n  buffer: EncoderBuffer<TBuffer>;\n\n  constructor(options?: Partial<EncoderBufferOptions<TBuffer>>) {\n    this.buffer = new EncoderBuffer<TBuffer>(options);\n  }\n\n  encode(value: unknown): TBuffer {\n    const buffer = this.buffer;\n\n    buffer.write(value);\n\n    return buffer.flush();\n  }\n\n  addExtension(extension: MessagePackExtension<unknown, TBuffer>): this {\n    this.buffer.addExtension(extension);\n\n    return this;\n  }\n\n  addInternalExtension(\n    extension: MessagePackExtension<unknown, TBuffer>,\n  ): this {\n    this.buffer.addInternalExtension(extension);\n\n    return this;\n  }\n\n  addExtensionType(\n    type: number,\n    extension: Omit<MessagePackExtension<unknown, TBuffer>, 'type'>,\n  ): this {\n    this.buffer.addExtension({ type, ...extension });\n\n    return this;\n  }\n\n  fetchExtension(type: number): MessagePackExtension<unknown, TBuffer> {\n    return this.buffer.fetchExtension(type);\n  }\n}\n\nexport default Encoder;\n"],"mappings":";;;;;;;;;;AAYA,IAAM,UAAN,MAAuD;CACrD;CAEA,YAAY,SAAkD;EAC5D,KAAK,SAAS,IAAI,cAAuB,OAAO;CAClD;CAEA,OAAO,OAAyB;EAC9B,MAAM,SAAS,KAAK;EAEpB,OAAO,MAAM,KAAK;EAElB,OAAO,OAAO,MAAM;CACtB;CAEA,aAAa,WAAyD;EACpE,KAAK,OAAO,aAAa,SAAS;EAElC,OAAO;CACT;CAEA,qBACE,WACM;EACN,KAAK,OAAO,qBAAqB,SAAS;EAE1C,OAAO;CACT;CAEA,iBACE,MACA,WACM;EACN,KAAK,OAAO,aAAa;GAAE;GAAM,GAAG;EAAU,CAAC;EAE/C,OAAO;CACT;CAEA,eAAe,MAAsD;EACnE,OAAO,KAAK,OAAO,eAAe,IAAI;CACxC;AACF"}

package/dist/esm/encoder/encoderBuffer.d.mts

@@ -0,0 +1,2 @@
+import { t as EncoderBuffer } from "../encoderBuffer-BZMIF5I2.mjs";
+export { EncoderBuffer as default };

package/dist/esm/encoder/encoderBuffer.mjs

@@ -0,0 +1,610 @@
+import BufferWithExtensions from "../bufferWithExtensions.mjs";
+import { INT64_MIN, UINT32_MAX, UINT64_MAX } from "../constants.mjs";
+import defaultNewBufferFn from "../defaultNewBufferFn.mjs";
+import Symbols from "../symbols.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/encoderBuffer.ts
+var EncoderBuffer = class EncoderBuffer extends BufferWithExtensions {
+	/** The current offset in the buffer where the next write operation will occur. */
+	offset;
+	/**
+	* 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;
+	/**
+	* 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;
+	/**
+	* 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 buffer 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.
+	*/
+	#extensionBuffer;
+	constructor(options) {
+		super();
+		this.offset = 0;
+		this.textEncoder = options?.textEncoder ?? new DefaultTextEncoder();
+		this.bufferFactory = options?.bufferFactory ?? defaultNewBufferFn;
+		this.buffer = this.bufferFactory(options?.initialBufferSize ?? 1024);
+		this.sharedBuffer = this.bufferFactory(options?.initialSharedBufferSize ?? 1024);
+		this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+		this.sortKeys = options?.sortKeys ?? false;
+		this.forceFloat32 = options?.forceFloat32 ?? false;
+	}
+	getExtensionBuffer() {
+		if (!this.#extensionBuffer) this.#extensionBuffer = new EncoderBuffer({
+			bufferFactory: this.bufferFactory,
+			initialBufferSize: this.sharedBuffer.byteLength,
+			initialSharedBufferSize: 0,
+			sortKeys: this.sortKeys,
+			textEncoder: this.textEncoder
+		});
+		return this.#extensionBuffer;
+	}
+	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;
+	}
+	writeUint32Symbol() {
+		this.buffer[this.offset++] = Symbols.UINT32;
+		return this;
+	}
+	writeUint64Symbol() {
+		this.buffer[this.offset++] = Symbols.UINT64;
+		return this;
+	}
+	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 < 51) {
+			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;
+	}
+	writeNumber(value) {
+		if (Number.isInteger(value)) {
+			if (value < 0) {
+				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.`);
+			} else {
+				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.`);
+			}
+		} else if (this.forceFloat32) {
+			this.ensureCapacity(5);
+			this.writeFloat32Symbol();
+			return this.writeFloat32(value);
+		}
+		this.ensureCapacity(9);
+		this.writeFloat64Symbol();
+		return this.writeFloat64(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);
+	}
+	writeExtension(extension, buffer) {
+		const writtenBytes = buffer.offset;
+		if (writtenBytes === 1) {
+			this.ensureCapacity(3);
+			this.writeFixExt1Symbol(extension.type);
+		} else if (writtenBytes === 2) {
+			this.ensureCapacity(4);
+			this.writeFixExt2Symbol(extension.type);
+		} else if (writtenBytes === 4) {
+			this.ensureCapacity(6);
+			this.writeFixExt4Symbol(extension.type);
+		} else if (writtenBytes === 8) {
+			this.ensureCapacity(10);
+			this.writeFixExt8Symbol(extension.type);
+		} else if (writtenBytes === 16) {
+			this.ensureCapacity(18);
+			this.writeFixExt16Symbol(extension.type);
+		} else if (fitIn8Bits(writtenBytes)) {
+			this.ensureCapacity(3 + writtenBytes);
+			this.writeExt8Symbol(extension.type, writtenBytes);
+		} else if (fitIn16Bits(writtenBytes)) {
+			this.ensureCapacity(4 + writtenBytes);
+			this.writeExt16Symbol(extension.type, writtenBytes);
+		} else if (fitIn32Bits(writtenBytes)) {
+			this.ensureCapacity(6 + writtenBytes);
+			this.writeExt32Symbol(extension.type, writtenBytes);
+		} else throw new Error(`Extension data too large to encode: ${writtenBytes} bytes`);
+		this.buffer.set(buffer.buffer.subarray(0, writtenBytes), this.offset);
+		this.offset += writtenBytes;
+		return this;
+	}
+	tryToWriteExtensionValue(value) {
+		if (this.extensions.size > 0) {
+			const iterator = this.extensions.values();
+			const extensionBuffer = this.getExtensionBuffer();
+			for (const extension of iterator) {
+				extensionBuffer.resetBuffer();
+				extension.encode(value, extensionBuffer);
+				if (extensionBuffer.offset > 0) {
+					this.writeExtension(extension, extensionBuffer);
+					return extensionBuffer.offset;
+				}
+			}
+		}
+		return 0;
+	}
+	writeBigInt(value) {
+		if (this.tryToWriteExtensionValue(value) > 0) return this;
+		throw new TypeError("\"bigint\" encoding is not supported by default. Consider using BigIntExtension");
+	}
+	writeObject(value) {
+		if (Array.isArray(value)) return this.writeArray(value);
+		if (this.tryToWriteExtensionValue(value) > 0) return this;
+		if (value instanceof Uint8Array) return this.writeUint8Array(value);
+		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
+export { EncoderBuffer as default };
+
+//# sourceMappingURL=encoderBuffer.mjs.map