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

package/dist/cjs/encoder/encoderBuffer.cjs

@@ -0,0 +1,608 @@
+const require_bufferWithExtensions = require("../bufferWithExtensions.cjs");
+const require_constants = require("../constants.cjs");
+const require_defaultNewBufferFn = require("../defaultNewBufferFn.cjs");
+const require_symbols = require("../symbols.cjs");
+const require_utils_fitIn7Bits = require("../utils/fitIn7Bits.cjs");
+const require_utils_fitIn8Bits = require("../utils/fitIn8Bits.cjs");
+const require_utils_fitIn16Bits = require("../utils/fitIn16Bits.cjs");
+const require_utils_fitIn32Bits = require("../utils/fitIn32Bits.cjs");
+const require_encoder_textEncoders_defaultTextEncoder = require("./textEncoders/defaultTextEncoder.cjs");
+//#region src/encoder/encoderBuffer.ts
+var EncoderBuffer = class EncoderBuffer extends require_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 require_encoder_textEncoders_defaultTextEncoder();
+		this.bufferFactory = options?.bufferFactory ?? require_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++] = require_symbols.NIL;
+		return this;
+	}
+	writeFalseSymbol() {
+		this.buffer[this.offset++] = require_symbols.FALSE;
+		return this;
+	}
+	writeTrueSymbol() {
+		this.buffer[this.offset++] = require_symbols.TRUE;
+		return this;
+	}
+	writeFixMapSymbol(keysSize) {
+		this.buffer[this.offset++] = require_symbols.FIXMAP_START | keysSize;
+		return this;
+	}
+	writeFixArraySymbol(arraySize) {
+		this.buffer[this.offset++] = require_symbols.FIXARRAY_START | arraySize;
+		return this;
+	}
+	writeFixStrSymbol(byteLength) {
+		this.buffer[this.offset++] = require_symbols.FIXSTR_START | byteLength;
+		return this;
+	}
+	writeBin8Symbol(size) {
+		this.buffer[this.offset++] = require_symbols.BIN8;
+		this.buffer[this.offset++] = size;
+		return this;
+	}
+	writeBin16Symbol(size) {
+		this.buffer[this.offset++] = require_symbols.BIN16;
+		this.view.setUint16(this.offset, size);
+		this.offset += 2;
+		return this;
+	}
+	writeBin32Symbol(size) {
+		this.buffer[this.offset++] = require_symbols.BIN32;
+		this.view.setUint32(this.offset, size);
+		this.offset += 4;
+		return this;
+	}
+	writeFloat32Symbol() {
+		this.buffer[this.offset++] = require_symbols.FLOAT32;
+		return this;
+	}
+	writeFloat64Symbol() {
+		this.buffer[this.offset++] = require_symbols.FLOAT64;
+		return this;
+	}
+	writeUint8Symbol() {
+		this.buffer[this.offset++] = require_symbols.UINT8;
+		return this;
+	}
+	writeUint16Symbol() {
+		this.buffer[this.offset++] = require_symbols.UINT16;
+		return this;
+	}
+	writeUint32Symbol() {
+		this.buffer[this.offset++] = require_symbols.UINT32;
+		return this;
+	}
+	writeUint64Symbol() {
+		this.buffer[this.offset++] = require_symbols.UINT64;
+		return this;
+	}
+	writeInt8Symbol() {
+		this.buffer[this.offset++] = require_symbols.INT8;
+		return this;
+	}
+	writeInt16Symbol() {
+		this.buffer[this.offset++] = require_symbols.INT16;
+		return this;
+	}
+	writeInt32Symbol() {
+		this.buffer[this.offset++] = require_symbols.INT32;
+		return this;
+	}
+	writeInt64Symbol() {
+		this.buffer[this.offset++] = require_symbols.INT64;
+		return this;
+	}
+	writeStr8Symbol(size) {
+		this.buffer[this.offset++] = require_symbols.STR8;
+		this.buffer[this.offset++] = size;
+		return this;
+	}
+	writeStr16Symbol(size) {
+		this.buffer[this.offset++] = require_symbols.STR16;
+		this.view.setUint16(this.offset, size);
+		this.offset += 2;
+		return this;
+	}
+	writeStr32Symbol(size) {
+		this.buffer[this.offset++] = require_symbols.STR32;
+		this.view.setUint32(this.offset, size);
+		this.offset += 4;
+		return this;
+	}
+	writeArray16Symbol(size) {
+		this.buffer[this.offset++] = require_symbols.ARRAY16;
+		this.view.setUint16(this.offset, size);
+		this.offset += 2;
+		return this;
+	}
+	writeArray32Symbol(size) {
+		this.buffer[this.offset++] = require_symbols.ARRAY32;
+		this.view.setUint32(this.offset, size);
+		this.offset += 4;
+		return this;
+	}
+	writeMap16Symbol(size) {
+		this.buffer[this.offset++] = require_symbols.MAP16;
+		this.view.setUint16(this.offset, size);
+		this.offset += 2;
+		return this;
+	}
+	writeMap32Symbol(size) {
+		this.buffer[this.offset++] = require_symbols.MAP32;
+		this.view.setUint32(this.offset, size);
+		this.offset += 4;
+		return this;
+	}
+	writeFixExt1Symbol(type) {
+		this.buffer[this.offset++] = require_symbols.FIXEXT1;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeFixExt2Symbol(type) {
+		this.buffer[this.offset++] = require_symbols.FIXEXT2;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeFixExt4Symbol(type) {
+		this.buffer[this.offset++] = require_symbols.FIXEXT4;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeFixExt8Symbol(type) {
+		this.buffer[this.offset++] = require_symbols.FIXEXT8;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeFixExt16Symbol(type) {
+		this.buffer[this.offset++] = require_symbols.FIXEXT16;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeExt8Symbol(type, size) {
+		this.buffer[this.offset++] = require_symbols.EXT8;
+		this.buffer[this.offset++] = size;
+		this.buffer[this.offset++] = type;
+		return this;
+	}
+	writeExt16Symbol(type, size) {
+		this.buffer[this.offset++] = require_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++] = require_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] = require_symbols.FIXSTR_START | totalBytes;
+				this.offset += totalBytes;
+				return this;
+			} else if (fitInStr8) {
+				this.buffer[byteLengthoffset] = require_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 (require_utils_fitIn8Bits(byteLength)) {
+			this.ensureCapacity(2 + byteLength);
+			this.writeStr8Symbol(byteLength);
+		} else if (require_utils_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 >= require_constants.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 (require_utils_fitIn7Bits(value)) {
+					this.ensureCapacity(1);
+					return this.writePositiveFixInt(value);
+				}
+				if (require_utils_fitIn8Bits(value)) {
+					this.ensureCapacity(2);
+					this.writeUint8Symbol();
+					return this.writeUint8(value);
+				}
+				if (require_utils_fitIn16Bits(value)) {
+					this.ensureCapacity(3);
+					this.writeUint16Symbol();
+					return this.writeUint16(value);
+				}
+				if (require_utils_fitIn32Bits(value)) {
+					this.ensureCapacity(5);
+					this.writeUint32Symbol();
+					return this.writeUint32(value);
+				}
+				if (value <= require_constants.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 (require_utils_fitIn16Bits(keysLength)) {
+			this.ensureCapacity(requiredSize + 3);
+			this.writeMap16Symbol(keysLength);
+		} else if (require_utils_fitIn32Bits(keysLength)) {
+			this.ensureCapacity(requiredSize + 5);
+			this.writeMap32Symbol(keysLength);
+		} else throw new Error(`Map size ${keysLength} exceeds maximum allowed size of ${require_constants.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 (require_utils_fitIn16Bits(length)) {
+			this.ensureCapacity(requiredSize + 3);
+			this.writeArray16Symbol(length);
+		} else if (require_utils_fitIn32Bits(length)) {
+			this.ensureCapacity(requiredSize + 5);
+			this.writeArray32Symbol(length);
+		} else throw new Error(`Array size ${length} exceeds maximum allowed size of ${require_constants.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 (require_utils_fitIn8Bits(value.length)) {
+			this.ensureCapacity(2 + value.length);
+			this.writeBin8Symbol(value.length);
+		} else if (require_utils_fitIn16Bits(value.length)) {
+			this.ensureCapacity(3 + value.length);
+			this.writeBin16Symbol(value.length);
+		} else if (require_utils_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 (require_utils_fitIn8Bits(writtenBytes)) {
+			this.ensureCapacity(3 + writtenBytes);
+			this.writeExt8Symbol(extension.type, writtenBytes);
+		} else if (require_utils_fitIn16Bits(writtenBytes)) {
+			this.ensureCapacity(4 + writtenBytes);
+			this.writeExt16Symbol(extension.type, writtenBytes);
+		} else if (require_utils_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
+module.exports = EncoderBuffer;

package/dist/cjs/encoder/encoderBuffer.d.cts

@@ -0,0 +1,2 @@
+import { t as EncoderBuffer } from "../encoderBuffer-3ur0iCYR.cjs";
+export = EncoderBuffer;

package/dist/cjs/encoder/index.cjs

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_encoder_textEncoders_defaultTextEncoder = require("./textEncoders/defaultTextEncoder.cjs");
+const require_encoder_encoderBuffer = require("./encoderBuffer.cjs");
+const require_encoder_encoder = require("./encoder.cjs");
+const require_encoder_textEncoders_nodeTextEncoder = require("./textEncoders/nodeTextEncoder.cjs");
+const require_encoder_encode = require("./encode.cjs");
+exports.DefaultTextEncoder = require_encoder_textEncoders_defaultTextEncoder;
+exports.Encoder = require_encoder_encoder;
+exports.EncoderBuffer = require_encoder_encoderBuffer;
+exports.NodeTextEncoder = require_encoder_textEncoders_nodeTextEncoder;
+exports.encode = require_encoder_encode;

package/dist/cjs/encoder/index.d.cts

@@ -0,0 +1,8 @@
+import { a as OmitByPattern, i as ExtensionEncoderBuffer, n as MessagePackEncoderBuffer, r as EncoderBufferOptions } from "../messagePackExtension-Cd99Rw9t.cjs";
+import { t as MessagePackTextEncoder } from "../messagePackTextEncoder-D7iCft_t.cjs";
+import { t as encode } from "../encode-4SxHVw0M.cjs";
+import { t as EncoderBuffer } from "../encoderBuffer-3ur0iCYR.cjs";
+import { t as Encoder } from "../encoder-B-rTvI4P.cjs";
+import { t as DefaultTextEncoder } from "../defaultTextEncoder-DzdGBX6s.cjs";
+import { t as NodeTextEncoder } from "../nodeTextEncoder-DJzFDBXd.cjs";
+export { DefaultTextEncoder, Encoder, EncoderBuffer, type EncoderBufferOptions, type ExtensionEncoderBuffer, type MessagePackEncoderBuffer, type MessagePackTextEncoder, NodeTextEncoder, type OmitByPattern, encode };

package/dist/cjs/encoder/interfaces/index.d.cts

@@ -0,0 +1,4 @@
+import { n as MessagePackEncoderBuffer } from "../../messagePackExtension-Cd99Rw9t.cjs";
+import { t as MessagePackTextEncoder } from "../../messagePackTextEncoder-D7iCft_t.cjs";
+import "../../index-DMnXy2Rv.cjs";
+export type { MessagePackEncoderBuffer, MessagePackTextEncoder };

package/dist/cjs/encoder/interfaces/messagePackEncoderBuffer.d.cts

@@ -0,0 +1,2 @@
+import { n as MessagePackEncoderBuffer } from "../../messagePackExtension-Cd99Rw9t.cjs";
+export = MessagePackEncoderBuffer;

package/dist/cjs/encoder/interfaces/messagePackTextEncoder.d.cts

@@ -0,0 +1,2 @@
+import { t as MessagePackTextEncoder } from "../../messagePackTextEncoder-D7iCft_t.cjs";
+export = MessagePackTextEncoder;

package/dist/cjs/encoder/textEncoders/defaultTextEncoder.cjs

@@ -0,0 +1,14 @@
+//#region src/encoder/textEncoders/defaultTextEncoder.ts
+/**
+* DefaultTextEncoder provides functionality to encode strings into UTF-8 bytes,
+* using the native TextEncoder.
+*/
+var DefaultTextEncoder = class {
+	/** The native TextEncoder instance used for encoding strings into UTF-8 bytes. */
+	nativeTextEncoder = new TextEncoder();
+	writeBytes(value, buffer) {
+		return this.nativeTextEncoder.encodeInto(value, buffer).written;
+	}
+};
+//#endregion
+module.exports = DefaultTextEncoder;

package/dist/cjs/encoder/textEncoders/defaultTextEncoder.d.cts

@@ -0,0 +1,2 @@
+import { t as DefaultTextEncoder } from "../../defaultTextEncoder-DzdGBX6s.cjs";
+export = DefaultTextEncoder;

package/dist/cjs/encoder/textEncoders/index.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_encoder_textEncoders_defaultTextEncoder = require("./defaultTextEncoder.cjs");
+const require_encoder_textEncoders_nodeTextEncoder = require("./nodeTextEncoder.cjs");
+exports.DefaultTextEncoder = require_encoder_textEncoders_defaultTextEncoder;
+exports.NodeTextEncoder = require_encoder_textEncoders_nodeTextEncoder;

package/dist/cjs/encoder/textEncoders/index.d.cts

@@ -0,0 +1,4 @@
+import { t as DefaultTextEncoder } from "../../defaultTextEncoder-DzdGBX6s.cjs";
+import { t as NodeTextEncoder } from "../../nodeTextEncoder-DJzFDBXd.cjs";
+import "../../index-CQnkyOId.cjs";
+export { DefaultTextEncoder, NodeTextEncoder };

package/dist/cjs/encoder/textEncoders/nodeTextEncoder.cjs

@@ -0,0 +1,8 @@
+//#region src/encoder/textEncoders/nodeTextEncoder.ts
+var NodeTextEncoder = class {
+	writeBytes(value, buffer) {
+		return Buffer.prototype.utf8Write.call(buffer, value, 0, buffer.length);
+	}
+};
+//#endregion
+module.exports = NodeTextEncoder;