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

package/dist/cjs/encoder/encoderBuffer.cjs

@@ -1,602 +0,0 @@
-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.
-	*/
-	newBufferFn;
-	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.newBufferFn = options?.newBufferFn ?? require_defaultNewBufferFn;
-		this.buffer = this.newBufferFn(options?.initialBufferSize ?? 1024);
-		this.sharedBuffer = this.newBufferFn(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({
-			initialBufferSize: this.sharedBuffer.byteLength,
-			initialSharedBufferSize: 0,
-			newBufferFn: this.newBufferFn,
-			sortKeys: this.sortKeys,
-			textEncoder: this.textEncoder
-		});
-		return this.#extensionBuffer;
-	}
-	resizeBuffer(newSize) {
-		const newBuffer = this.newBufferFn(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.newBufferFn(requiredSize);
-		const { sharedBuffer } = this;
-		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();
-			this.writeFloat32(value);
-		} else {
-			this.ensureCapacity(9);
-			this.writeFloat64Symbol();
-			this.writeFloat64(value);
-		}
-		return this;
-	}
-	writeMap(value) {
-		const keys = Object.keys(value);
-		if (this.sortKeys) keys.sort();
-		const keysLength = keys.length;
-		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 too large to encode: ${keysLength} keys`);
-		for (const key of keys) {
-			this.write(key);
-			this.write(value[key]);
-		}
-		return this;
-	}
-	writeArray(value) {
-		const length = value.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 too large to encode: ${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

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

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

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

package/dist/cjs/encoder-DXuhGwd7.d.cts

@@ -1,23 +0,0 @@
-import { r as EncoderBufferOptions, t as MessagePackExtension } from "./messagePackExtension-C_TQXlEn.cjs";
-import { t as EncoderBuffer } from "./encoderBuffer-DWGIXXjj.cjs";
-//#region src/encoder/encoder.d.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.
- */
-declare class Encoder<TBuffer extends Uint8Array = Uint8Array> {
-  buffer: EncoderBuffer<TBuffer>;
-  constructor(options?: Partial<EncoderBufferOptions<TBuffer>>);
-  encode(value: unknown): Uint8Array;
-  addExtension(extension: MessagePackExtension<unknown, TBuffer>): this;
-  addInternalExtension(extension: MessagePackExtension<unknown, TBuffer>): this;
-  addExtensionType(type: number, extension: Omit<MessagePackExtension<unknown, TBuffer>, 'type'>): this;
-  fetchExtension(type: number): MessagePackExtension<unknown, TBuffer>;
-}
-//#endregion
-export { Encoder as t };
-//# sourceMappingURL=encoder-DXuhGwd7.d.cts.map

package/dist/cjs/encoder-DXuhGwd7.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoder-DXuhGwd7.d.cts","names":[],"sources":["../../src/encoder/encoder.ts"],"mappings":";;;;;;;;;;;cAYM,QAAQ,gBAAgB,aAAa;EACzC,QAAQ,cAAc;EAEtB,YAAY,UAAU,QAAQ,qBAAqB;EAInD,OAAO,iBAAiB;EAQxB,aAAa,WAAW,8BAA8B;EAMtD,qBACE,WAAW,8BAA8B;EAO3C,iBACE,cACA,WAAW,KAAK,8BAA8B;EAOhD,eAAe,eAAe,8BAA8B"}

package/dist/cjs/encoderBuffer-DWGIXXjj.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoderBuffer-DWGIXXjj.d.cts","names":[],"sources":["../../src/encoder/encoderBuffer.ts"],"mappings":";;;;;cAsBM,cAAc,gBAAgB,aAAa,oBACvC,qBAAqB,oBAClB,yBAAyB;;;EAGpC;;;;;;;YAQU,cAAc;;;;;;;WAQf;;;;;;;;WASA;;;;;;;YAQC,aAAa,YAAY;WAE1B,aAAa,uBAAuB;EAE7C,QAAQ;EACR,MAAM;EAcN,YAAY,UAAU,QAAQ,qBAAqB;EAwBnD,sBAAsB,cAAc;EAcpC,aAAa;EAeb,eAAe;EAUf;EAMA,SAAS;EAST,oBAAoB;EAMpB,oBAAoB;EAOpB,SAAS,OAAO;EAQhB,aAAa;EAOb,aAAa;EAOb,WAAW;EAMX,YAAY;EAOZ,YAAY;EAOZ,YAAY;EAaZ,UAAU;EAMV,WAAW;EAOX,WAAW;EAOX,WAAW;EA0BX,SAAS;EAMT;EAMA;EAMA;EAMA,kBAAkB;EAMlB,oBAAoB;EAMpB,kBAAkB;EAMlB,gBAAgB;EAOhB,iBAAiB;EAQjB,iBAAiB;EAQjB;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA,gBAAgB;EAOhB,iBAAiB;EASjB,iBAAiB;EASjB,mBAAmB;EASnB,mBAAmB;EASnB,iBAAiB;EASjB,iBAAiB;EASjB,mBAAmB;EAOnB,mBAAmB;EAOnB,mBAAmB;EAOnB,mBAAmB;EAOnB,oBAAoB;EAOpB,gBAAgB,cAAc;EAQ9B,iBAAiB,cAAc;EAW/B,iBAAiB,cAAc;EAW/B,YAAY;EAyGZ,YAAY;EA4EZ,SAAS,8BAA8B,QACrC,OAAO,OAAO,MAAM;EAiCtB,WAAW;EAoCX,gBAAgB,OAAO;EAiBvB,eACE,WAAW,sBACX,QAAQ,uBAAuB;EAiDjC,yBAAyB;EAqBzB,YAAY;EAYZ,YAAY;EAkBZ,MAAM"}

package/dist/cjs/messagePackExtension-C_TQXlEn.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messagePackExtension-C_TQXlEn.d.cts","names":[],"sources":["../../src/interfaces/messagePackBufferWithExtensions.ts","../../src/encoder/types.ts","../../src/encoder/interfaces/messagePackEncoderBuffer.ts","../../src/extensions/interfaces/messagePackExtension.ts"],"mappings":";;;;UAEyB,gCACvB,gBAAgB,aAAa;;;;;;;;EAS7B,aAAa,WAAW,8BAA8B;;;;UCRvC,qBACf,gBAAgB,aAAa,oBACrB,cAAc;;;;;;;;;EAStB;;;;;;EAMA,cAAc,uBAAuB;;;;;;;;EAQrC;;;;;;;;;;;;;;EAcA;;KAGU,cAAc,SAAS,6BAChC,cAAc,WAAW,aAAa,kBAAkB,OAAO,QAAQ;KAG9D,uBAAuB,gBAAgB,aAAa,cAC9D,cACE,yBAAyB;;;;;;;;UC1CJ,yBACvB,gBAAgB,aAAa,oBACrB,gCAAgC;;;;;;EAMxC,QAAQ;;;;;;EAOR;;;;;;;EAQA,MAAM;;;;;WAMG,aAAa;;;;;;;;;;;;;;;;EAiBtB,eAAe;;;;;;;;EASf,aAAa;;;;;;EAOb;;;;;;EAOA,SAAS;;;;;;;;;;;;;EAcT,oBAAoB;;;;;;;;;;;;EAapB,oBAAoB;;;;;;;;;;EAWpB,SAAS,OAAO;;;;;;;;;;;;EAahB,aAAa;;;;;;;;;;;;EAab,aAAa;;;;;;;;;;;EAYb,WAAW;;;;;;;;;;;EAYX,YAAY;;;;;;;;;;;EAYZ,YAAY;;;;;;;;;;;EAYZ,YAAY;;;;;;;;;;;EAYZ,UAAU;;;;;;;;;;;EAYV,WAAW;;;;;;;;;;;EAYX,WAAW;;;;;;;;;;;EAYX,WAAW;;;;;;;;;;EAWX,SAAS;;;;;;;;;;;;EAaT;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;;EAaA,kBAAkB;;;;;;;;;;;;EAalB,oBAAoB;;;;;;;;;;;;EAapB,kBAAkB;;;;;;;;;;;;EAalB,gBAAgB;;;;;;;;;;;;EAahB,iBAAiB;;;;;;;;;;;;EAajB,iBAAiB;;;;;;;;;;;EAYjB;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;;EAaA,gBAAgB;;;;;;;;;;;;EAahB,iBAAiB;;;;;;;;;;;;EAajB,iBAAiB;;;;;;;;;;;;EAajB,mBAAmB;;;;;;;;;;;;EAanB,mBAAmB;;;;;;;;;;;;EAanB,iBAAiB;;;;;;;;;;;;EAajB,iBAAiB;;;;;;;;;;;;EAajB,mBAAmB;;;;;;;;;;;;EAanB,mBAAmB;;;;;;;;;;;;EAanB,mBAAmB;;;;;;;;;;;;EAanB,mBAAmB;;;;;;;;;;;;EAanB,oBAAoB;;;;;;;;;;;;EAapB,gBAAgB,cAAc;;;;;;;;;;;;EAa9B,iBAAiB,cAAc;;;;;;;;;;;;EAa/B,iBAAiB,cAAc;;;;;;EAO/B,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BN,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmEZ,YAAY;;;;;;;;;;;;;;;;;;;;;EAsBZ,SAAS,8BAA8B,QACrC,OAAO,OAAO,MAAM;;;;;;;;;;;;;;;;;;;;;EAuBtB,WAAW;;;;;;;EAQX,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCZ,gBAAgB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DvB,eACE,WAAW,sBACX,QAAQ,uBAAuB;;;;UCl6BV,qBACvB,kBACA,gBAAgB,aAAa;;;;;;WAOpB;;;;;;;;;EAUT,OACE,wBACA,QAAQ,yBAAyB;;;;;;;;;;;;EAcnC,OAAO,eAAe,0BAA0B,eAAe"}

package/dist/cjs/messagePackTextDecoder-CtyB0N6j.d.cts

@@ -1,7 +0,0 @@
-//#region src/decoder/interfaces/messagePackTextDecoder.d.ts
-interface MessagePackTextDecoder {
-  decode(buffer: Uint8Array, startOffset: number, endOffset: number): string;
-}
-//#endregion
-export { MessagePackTextDecoder as t };
-//# sourceMappingURL=messagePackTextDecoder-CtyB0N6j.d.cts.map

package/dist/cjs/messagePackTextDecoder-CtyB0N6j.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messagePackTextDecoder-CtyB0N6j.d.cts","names":[],"sources":["../../src/decoder/interfaces/messagePackTextDecoder.ts"],"mappings":";UAAyB;EACvB,OAAO,QAAQ,YAAY,qBAAqB"}

package/dist/cjs/timestampDate-BtBd4bAx.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timestampDate-BtBd4bAx.d.cts","names":[],"sources":["../../src/extensions/timestampDate/timestampDate.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;cA4BM,uBACJ,gBAAgB,aAAa,uBAClB,qBAAqB,MAAM;WAC7B;EAET,uBAAuB,MAAM,OAAO;EAcpC,OACE,wBACA,QAAQ,yBAAyB;EAuBnC,OAAO,eAAe,yBAAyB,UAAU,eAAe"}

package/dist/cjs/types-BJie2edF.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-BJie2edF.d.cts","names":[],"sources":["../../src/types.ts"],"mappings":";KAAY,YAAY,gBAAgB,aAAa,eACnD,yBACG;UAEY,cAAc,gBAAgB,aAAa;;;;;;;EAO1D;;;;;;EAOA,cAAc,YAAY"}

package/dist/cjs/types-DHnp4kMw.d.cts

@@ -1,6 +0,0 @@
-import { t as BufferOptions } from "./types-BJie2edF.cjs";
-//#region src/decoder/types.d.ts
-type DecoderBufferOptions<TBuffer extends Uint8Array = Uint8Array> = BufferOptions<TBuffer>;
-//#endregion
-export { DecoderBufferOptions as t };
-//# sourceMappingURL=types-DHnp4kMw.d.cts.map

package/dist/cjs/types-DHnp4kMw.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-DHnp4kMw.d.cts","names":[],"sources":["../../src/decoder/types.ts"],"mappings":";;KAEY,qBAAqB,gBAAgB,aAAa,cAC5D,cAAc"}

package/dist/esm/benchmark/decoderDataTypesFactory.d.mts

@@ -1,6 +0,0 @@
-import { dataTypesFactory } from "@schema-pack/benchmark";
-//#region src/benchmark/decoderDataTypesFactory.d.ts
-declare const decoderDataTypesFactory: Record<keyof typeof dataTypesFactory, () => Uint8Array>;
-//#endregion
-export { decoderDataTypesFactory as default };
-//# sourceMappingURL=decoderDataTypesFactory.d.mts.map

package/dist/esm/benchmark/decoderDataTypesFactory.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"decoderDataTypesFactory.d.mts","names":[],"sources":["../../../src/benchmark/decoderDataTypesFactory.ts"],"mappings":";;cAMM,yBAAyB,oBAChB,wBACP"}