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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present Pawnary, Inc. and Elvis Muñoz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,37 @@
+<!-- prettier-ignore-start -->
+> [!WARNING]
+> This is a Work In Progress, and the API is not stable yet. Breaking changes
+> may be introduced at any time.
+<!-- prettier-ignore-end -->
+
+# @schema-pack/message-pack
+
+Incremental
+[MessagePack](https://github.com/msgpack/msgpack/blob/master/spec.md)
+encoder/decoder for TypeScript and JavaScript. It targets full compliance with
+the MessagePack spec and exposes a pluggable extension system for encoding
+custom types.
+
+## Installation
+
+```bash
+pnpm add @schema-pack/message-pack@next
+```
+
+### Quick start
+
+```ts
+import { encode, decode } from '@schema-pack/message-pack';
+
+const buffer = encode({ hello: 'world', values: [1, 2, 3] });
+
+const value = decode(buffer);
+// { hello: 'world', values: [1, 2, 3] }
+```
+
+For more information, visit the
+[documentation](https://pawnary.github.io/schema-pack/docs/message-pack).
+
+## License
+
+MIT

package/dist/cjs/benchmark/decoderDataTypesFactory.cjs

@@ -0,0 +1,37 @@
+const require_encoder_encoder = require("../encoder/encoder.cjs");
+let _schema_pack_benchmark = require("@schema-pack/benchmark");
+//#region src/benchmark/decoderDataTypesFactory.ts
+const encoder = new require_encoder_encoder();
+const decoderDataTypesFactory = {
+	array16: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.array16()),
+	array32: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.array32()),
+	bin16: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.bin16()),
+	bin32: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.bin32()),
+	bin8: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.bin8()),
+	false: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.false()),
+	fixarray: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.fixarray()),
+	fixmap: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.fixmap()),
+	fixstr: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.fixstr()),
+	float32: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.float32()),
+	float64: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.float64()),
+	int16: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.int16()),
+	int32: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.int32()),
+	int64: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.int64()),
+	int8: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.int8()),
+	map16: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.map16()),
+	map32: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.map32()),
+	negativeFixint: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.negativeFixint()),
+	nil: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.nil()),
+	positiveFixint: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.positiveFixint()),
+	str16: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.str16()),
+	str32: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.str32()),
+	str8: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.str8()),
+	true: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.true()),
+	uint16: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.uint16()),
+	uint32: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.uint32()),
+	uint64: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.uint64()),
+	uint8: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.uint8()),
+	undefined: () => encoder.encode(_schema_pack_benchmark.dataTypesFactory.undefined())
+};
+//#endregion
+module.exports = decoderDataTypesFactory;

package/dist/cjs/benchmark/decoderDataTypesFactory.d.cts

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

package/dist/cjs/benchmark/decoderDataTypesFactory.d.cts.map

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

package/dist/cjs/bigInt-BdjzezQQ.d.cts

@@ -0,0 +1,35 @@
+import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-B2rRVlMX.cjs";
+import { i as ExtensionEncoderBuffer } from "./messagePackExtension-Cd99Rw9t.cjs";
+import { t as UntypedExtension } from "./untypedExtension-wx6-_4mg.cjs";
+//#region src/extensions/bigint/bigInt.d.ts
+/**
+ * This class encodes and decodes JavaScript BigInt values that are outside the
+ * safe integer range. It encodes and decodes BigInt values using a custom
+ * extension type, allowing for the serialization of large integers that cannot
+ * be represented as standard JavaScript numbers. The encoding scheme uses a
+ * variable-length representation to efficiently store the magnitude of the
+ * BigInt value.
+ */
+declare class BigIntExtension<TBuffer extends Uint8Array = Uint8Array> extends UntypedExtension<bigint, TBuffer> {
+  /**
+   * Encodes a BigInt value into the provided buffer. If the value is within the
+   * safe integer range, it is encoded directly following the Message Pack
+   * specification. Otherwise, if the value is outside the safe integer range,
+   * it is encoded using a variable-length representation. Negative values are
+   * handled by encoding their magnitude and using a specific bit pattern to
+   * indicate negativity.
+   *
+   * @param value - The BigInt value to encode.
+   * @param buffer - The buffer to write the encoded data to.
+   */
+  encode(value: object | bigint, buffer: ExtensionEncoderBuffer<TBuffer>): void;
+  /**
+   * Decodes a BigInt value from the provided DataView. It reads the encoded
+   * data, reconstructs the magnitude, and determines the sign based on the
+   * encoding scheme. The method returns the decoded BigInt value.
+   */
+  decode(buffer: MessagePackDecoderBuffer, size: number): bigint;
+}
+//#endregion
+export { BigIntExtension as t };
+//# sourceMappingURL=bigInt-BdjzezQQ.d.cts.map

package/dist/cjs/bigInt-BdjzezQQ.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigInt-BdjzezQQ.d.cts","names":[],"sources":["../../src/extensions/bigint/bigInt.ts"],"mappings":";;;;;;;;;;;;cAcM,gBACJ,gBAAgB,aAAa,oBACrB,yBAAyB;;;;;;;;;;;;EAYjC,OACE,wBACA,QAAQ,uBAAuB;;;;;;EAyBjC,OAAO,QAAQ,0BAA0B"}

package/dist/cjs/bufferWithExtensions-n6DtcUoA.d.cts

@@ -0,0 +1,12 @@
+import { o as MessagePackBufferWithExtensions, t as MessagePackExtension } from "./messagePackExtension-Cd99Rw9t.cjs";
+//#region src/bufferWithExtensions.d.ts
+declare abstract class BufferWithExtensions<TBuffer extends Uint8Array = Uint8Array> implements MessagePackBufferWithExtensions<TBuffer> {
+  protected extensions: Map<number, MessagePackExtension<unknown, TBuffer>>;
+  constructor();
+  addExtension(extension: MessagePackExtension<unknown, TBuffer>): this;
+  addInternalExtension(extension: MessagePackExtension<unknown, TBuffer>): this;
+  fetchExtension(type: number): MessagePackExtension<unknown, TBuffer>;
+}
+//#endregion
+export { BufferWithExtensions as t };
+//# sourceMappingURL=bufferWithExtensions-n6DtcUoA.d.cts.map

package/dist/cjs/bufferWithExtensions-n6DtcUoA.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferWithExtensions-n6DtcUoA.d.cts","names":[],"sources":["../../src/bufferWithExtensions.ts"],"mappings":";;uBAGe,qBACb,gBAAgB,aAAa,uBAClB,gCAAgC;YACjC,YAAY,YAAY,8BAA8B;EAEhE;EAIA,aAAa,WAAW,8BAA8B;EAsBtD,qBACE,WAAW,8BAA8B;EAuB3C,eAAe,eAAe,8BAA8B"}

package/dist/cjs/bufferWithExtensions.cjs

@@ -0,0 +1,28 @@
+//#region src/bufferWithExtensions.ts
+var BufferWithExtensions = class {
+	extensions;
+	constructor() {
+		this.extensions = /* @__PURE__ */ new Map();
+	}
+	addExtension(extension) {
+		if (this.extensions.has(extension.type)) throw new Error(`Extension with type ${extension.type} already exists`);
+		if (extension.type < 0) throw new Error(`Extension type must be a non-negative integer, got ${extension.type}. Extensions between -128 and -1 are reserved for internal use. Use addInternalExtension() to register an internal extension.`);
+		if (extension.type > 127) throw new Error(`Extension type must be in the range 0 to 127, got ${extension.type}`);
+		this.extensions.set(extension.type, extension);
+		return this;
+	}
+	addInternalExtension(extension) {
+		if (this.extensions.has(extension.type)) throw new Error(`Extension with type ${extension.type} already exists`);
+		if (extension.type >= 0) throw new Error(`Internal extension type must be a negative integer, got ${extension.type}. Use addExtension() to register a custom extension.`);
+		if (extension.type < -128) throw new Error(`Internal extension type must be in the range -128 to -1, got ${extension.type}`);
+		this.extensions.set(extension.type, extension);
+		return this;
+	}
+	fetchExtension(type) {
+		const extension = this.extensions.get(type);
+		if (!extension) throw new Error(`Extension with type ${type} not found`);
+		return extension;
+	}
+};
+//#endregion
+module.exports = BufferWithExtensions;

package/dist/cjs/bufferWithExtensions.d.cts

@@ -0,0 +1,2 @@
+import { t as BufferWithExtensions } from "./bufferWithExtensions-n6DtcUoA.cjs";
+export = BufferWithExtensions;

package/dist/cjs/constants.cjs

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/constants.ts
+/**
+* JavaScript numbers are stored as IEEE 754 double precision floating point
+* numbers, which means that they can only safely represent max uint64 as:
+*
+* 2^53 - 1 = 9007199254740991, or Number.MAX_SAFE_INTEGER.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
+*/
+const UINT64_MAX = Number.MAX_SAFE_INTEGER;
+/**
+* JavaScript numbers are stored as IEEE 754 double precision floating point
+* numbers, which means that they can only safely represent min int64 as:
+*
+* -(2^53 - 1) = -9007199254740991, or Number.MIN_SAFE_INTEGER.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER
+*/
+const INT64_MIN = Number.MIN_SAFE_INTEGER;
+/** 4294967295. */
+const UINT32_MAX = -1 >>> 0;
+/** -2147483648. */
+const INT32_MIN = -2147483648;
+/**
+* Default allocation size for the encoder and decoder buffers. This is the
+* initial size of the buffer when it is created, and it will grow as needed
+* when more data is written to it.
+*/
+const DEFAULT_ALLOCATION_SIZE = 1024;
+//#endregion
+exports.DEFAULT_ALLOCATION_SIZE = DEFAULT_ALLOCATION_SIZE;
+exports.INT32_MIN = INT32_MIN;
+exports.INT64_MIN = INT64_MIN;
+exports.UINT32_MAX = UINT32_MAX;
+exports.UINT64_MAX = UINT64_MAX;

package/dist/cjs/constants.d.cts

@@ -0,0 +1,32 @@
+//#region src/constants.d.ts
+/**
+ * JavaScript numbers are stored as IEEE 754 double precision floating point
+ * numbers, which means that they can only safely represent max uint64 as:
+ *
+ * 2^53 - 1 = 9007199254740991, or Number.MAX_SAFE_INTEGER.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
+ */
+declare const UINT64_MAX: number;
+/**
+ * JavaScript numbers are stored as IEEE 754 double precision floating point
+ * numbers, which means that they can only safely represent min int64 as:
+ *
+ * -(2^53 - 1) = -9007199254740991, or Number.MIN_SAFE_INTEGER.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER
+ */
+declare const INT64_MIN: number;
+/** 4294967295. */
+declare const UINT32_MAX: number;
+/** -2147483648. */
+declare const INT32_MIN = -2147483648;
+/**
+ * Default allocation size for the encoder and decoder buffers. This is the
+ * initial size of the buffer when it is created, and it will grow as needed
+ * when more data is written to it.
+ */
+declare const DEFAULT_ALLOCATION_SIZE = 1024;
+//#endregion
+export { DEFAULT_ALLOCATION_SIZE, INT32_MIN, INT64_MIN, UINT32_MAX, UINT64_MAX };
+//# sourceMappingURL=constants.d.cts.map

package/dist/cjs/constants.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.cts","names":[],"sources":["../../src/constants.ts"],"mappings":";;;;;;;;;cAQa;;;;;;;;;cAUA;;cAGA;;cAGA;;;;;;cAOA"}

package/dist/cjs/decode-BraWmoPw.d.cts

@@ -0,0 +1,5 @@
+//#region src/decoder/decode.d.ts
+declare function decode<TValue = unknown>(buffer: Uint8Array): TValue;
+//#endregion
+export { decode as t };
+//# sourceMappingURL=decode-BraWmoPw.d.cts.map

package/dist/cjs/decode-BraWmoPw.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-BraWmoPw.d.cts","names":[],"sources":["../../src/decoder/decode.ts"],"mappings":";iBAIwB,OAAO,kBAAkB,QAAQ,aAAa"}

package/dist/cjs/decoder/decode.cjs

@@ -0,0 +1,8 @@
+//#region src/decoder/decode.ts
+const sharedDecoderBuffer = new (require("./decoderBuffer.cjs"))();
+function decode(buffer) {
+	sharedDecoderBuffer.setBuffer(buffer);
+	return sharedDecoderBuffer.nextValue();
+}
+//#endregion
+module.exports = decode;

package/dist/cjs/decoder/decode.d.cts

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

package/dist/cjs/decoder/decoder.cjs

@@ -0,0 +1,30 @@
+const require_decoder_decoderBuffer = require("./decoderBuffer.cjs");
+//#region src/decoder/decoder.ts
+var Decoder = class {
+	decoderBuffer;
+	constructor(options) {
+		this.decoderBuffer = new require_decoder_decoderBuffer(options);
+	}
+	decode(encodedBuffer) {
+		const decoderBuffer = this.decoderBuffer;
+		decoderBuffer.setBuffer(encodedBuffer);
+		return decoderBuffer.nextValue();
+	}
+	addExtension(extension) {
+		this.decoderBuffer.addExtension(extension);
+		return this;
+	}
+	addInternalExtension(extension) {
+		this.decoderBuffer.addInternalExtension(extension);
+		return this;
+	}
+	addExtensionType(type, extension) {
+		this.decoderBuffer.addExtension({
+			type,
+			...extension
+		});
+		return this;
+	}
+};
+//#endregion
+module.exports = Decoder;

package/dist/cjs/decoder/decoder.d.cts

@@ -0,0 +1,2 @@
+import { t as Decoder } from "../decoder-3WpVBZjY.cjs";
+export = Decoder;

package/dist/cjs/decoder/decoderBuffer.cjs

@@ -0,0 +1,238 @@
+const require_bufferWithExtensions = require("../bufferWithExtensions.cjs");
+const require_defaultNewBufferFn = require("../defaultNewBufferFn.cjs");
+const require_symbols = require("../symbols.cjs");
+const require_decoder_textDecoders_defaultTextDecoder = require("./textDecoders/defaultTextDecoder.cjs");
+//#region src/decoder/decoderBuffer.ts
+var DecoderBuffer = class extends require_bufferWithExtensions {
+	buffer;
+	offset;
+	view;
+	textDecoder = new require_decoder_textDecoders_defaultTextDecoder();
+	constructor(options) {
+		super();
+		const bufferFactory = options?.bufferFactory ?? require_defaultNewBufferFn;
+		this.buffer = bufferFactory(0);
+		this.view = new DataView(this.buffer.buffer);
+		this.offset = 0;
+	}
+	setBuffer(buffer) {
+		this.buffer = buffer;
+		this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+		this.offset = 0;
+		return this;
+	}
+	readArray(elementCount) {
+		const decodedArray = new Array(elementCount);
+		for (let index = 0; index < elementCount; index++) decodedArray[index] = this.nextValue();
+		return decodedArray;
+	}
+	readStr(byteLength) {
+		if (byteLength === 0) return "";
+		const { buffer } = this;
+		const stringStartOffset = this.offset;
+		const stringEndOffset = stringStartOffset + byteLength;
+		this.offset = stringEndOffset;
+		if (byteLength <= 64) {
+			let isAsciiOnly = true;
+			for (let byteIndex = stringStartOffset; byteIndex < stringEndOffset; byteIndex++) if (buffer[byteIndex] > 127) {
+				isAsciiOnly = false;
+				break;
+			}
+			if (isAsciiOnly) {
+				let decodedString = "";
+				for (let byteIndex = stringStartOffset; byteIndex < stringEndOffset; byteIndex++) decodedString += String.fromCharCode(buffer[byteIndex]);
+				return decodedString;
+			}
+		}
+		return this.textDecoder.decode(buffer, stringStartOffset, stringEndOffset);
+	}
+	readMapKey() {
+		return this.nextValue();
+	}
+	readMap(length) {
+		const decodedMap = {};
+		for (let index = 0; index < length; ++index) {
+			const mapKey = this.readMapKey();
+			if (mapKey === "__proto__") throw new Error("Invalid map key: \"__proto__\" are not allowed as keys to prevent prototype pollution.");
+			decodedMap[mapKey] = this.nextValue();
+		}
+		return decodedMap;
+	}
+	decodeControlSlow(headerByte) {
+		const { buffer } = this;
+		switch (headerByte) {
+			case 193: return;
+			case require_symbols.BIN8: {
+				const byteLength = buffer[this.offset++];
+				const dataStartOffset = this.offset;
+				this.offset = dataStartOffset + byteLength;
+				return buffer.subarray(dataStartOffset, this.offset);
+			}
+			case require_symbols.BIN16: {
+				const valueStartOffset = this.offset;
+				const byteLength = this.view.getUint16(valueStartOffset);
+				const dataStartOffset = valueStartOffset + 2;
+				this.offset = dataStartOffset + byteLength;
+				return buffer.subarray(dataStartOffset, this.offset);
+			}
+			case require_symbols.BIN32: {
+				const valueStartOffset = this.offset;
+				const byteLength = this.view.getUint32(valueStartOffset);
+				const dataStartOffset = valueStartOffset + 4;
+				this.offset = dataStartOffset + byteLength;
+				return buffer.subarray(dataStartOffset, this.offset);
+			}
+			case require_symbols.EXT8: {
+				const length = this.buffer[this.offset++];
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.fetchExtension(extensionId).decode(this, length);
+			}
+			case require_symbols.EXT16: {
+				const length = this.view.getInt16(this.offset);
+				this.offset += 2;
+				const extensionId = this.buffer[this.offset++];
+				return this.fetchExtension(extensionId).decode(this, length);
+			}
+			case require_symbols.EXT32: {
+				const length = this.view.getInt32(this.offset);
+				this.offset += 4;
+				const extensionId = this.buffer[this.offset++];
+				return this.fetchExtension(extensionId).decode(this, length);
+			}
+			case require_symbols.FLOAT32: {
+				const decodedFloat32 = this.view.getFloat32(this.offset);
+				this.offset += 4;
+				return decodedFloat32;
+			}
+			case require_symbols.FLOAT64: {
+				const decodedFloat64 = this.view.getFloat64(this.offset);
+				this.offset += 8;
+				return decodedFloat64;
+			}
+			case require_symbols.UINT64: {
+				const high = this.view.getUint32(this.offset);
+				this.offset += 4;
+				const low = this.view.getUint32(this.offset);
+				this.offset += 4;
+				return high * 4294967296 + low;
+			}
+			case require_symbols.INT8: {
+				const decodedInt8 = this.view.getInt8(this.offset);
+				this.offset += 1;
+				return decodedInt8;
+			}
+			case require_symbols.INT16: {
+				const valueStartOffset = this.offset;
+				const decodedInt16 = this.view.getInt16(valueStartOffset);
+				this.offset = valueStartOffset + 2;
+				return decodedInt16;
+			}
+			case require_symbols.INT32: {
+				const valueStartOffset = this.offset;
+				const decodedInt32 = this.view.getInt32(valueStartOffset);
+				this.offset = valueStartOffset + 4;
+				return decodedInt32;
+			}
+			case require_symbols.INT64: {
+				const high = this.view.getInt32(this.offset);
+				this.offset += 4;
+				const low = this.view.getUint32(this.offset);
+				this.offset += 4;
+				return high * 4294967296 + low;
+			}
+			case require_symbols.FIXEXT1: {
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.fetchExtension(extensionId).decode(this, 1);
+			}
+			case require_symbols.FIXEXT2: {
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.fetchExtension(extensionId).decode(this, 2);
+			}
+			case require_symbols.FIXEXT4: {
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.fetchExtension(extensionId).decode(this, 4);
+			}
+			case require_symbols.FIXEXT8: {
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.fetchExtension(extensionId).decode(this, 8);
+			}
+			case require_symbols.FIXEXT16: {
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.fetchExtension(extensionId).decode(this, 16);
+			}
+			case require_symbols.STR8: {
+				const byteLength = buffer[this.offset++];
+				return this.readStr(byteLength);
+			}
+			case require_symbols.STR16: {
+				const valueStartOffset = this.offset;
+				const byteLength = this.view.getUint16(valueStartOffset);
+				this.offset = valueStartOffset + 2;
+				return this.readStr(byteLength);
+			}
+			case require_symbols.STR32: {
+				const byteLength = this.view.getUint32(this.offset);
+				this.offset += 4;
+				return this.readStr(byteLength);
+			}
+			case require_symbols.ARRAY16: {
+				const valueStartOffset = this.offset;
+				const elementCount = this.view.getUint16(valueStartOffset);
+				this.offset = valueStartOffset + 2;
+				return this.readArray(elementCount);
+			}
+			case require_symbols.ARRAY32: {
+				const valueStartOffset = this.offset;
+				const elementCount = this.view.getUint32(valueStartOffset);
+				this.offset = valueStartOffset + 4;
+				return this.readArray(elementCount);
+			}
+			case require_symbols.MAP16: {
+				const valueStartOffset = this.offset;
+				const length = this.view.getUint16(valueStartOffset);
+				this.offset = valueStartOffset + 2;
+				return this.readMap(length);
+			}
+			case require_symbols.MAP32: {
+				const length = this.view.getUint32(this.offset);
+				this.offset += 4;
+				return this.readMap(length);
+			}
+			default: return;
+		}
+	}
+	nextValue() {
+		const { buffer } = this;
+		const headerByte = buffer[this.offset++];
+		if ((headerByte & 224) === require_symbols.NIL) switch (headerByte) {
+			case require_symbols.NIL: return null;
+			case require_symbols.FALSE: return false;
+			case require_symbols.TRUE: return true;
+			case require_symbols.UINT8: return buffer[this.offset++];
+			case require_symbols.UINT16: {
+				const valueStartOffset = this.offset;
+				const decodedUint16 = buffer[valueStartOffset] << 8 | buffer[valueStartOffset + 1];
+				this.offset = valueStartOffset + 2;
+				return decodedUint16;
+			}
+			case require_symbols.UINT32: {
+				const decodedUint32 = this.view.getUint32(this.offset);
+				this.offset += 4;
+				return decodedUint32;
+			}
+			default: return this.decodeControlSlow(headerByte);
+		}
+		if (headerByte >= require_symbols.NEGATIVE_FIXINT_START) return headerByte - 256;
+		if (headerByte < require_symbols.FIXARRAY_START) {
+			if (headerByte < require_symbols.FIXMAP_START) return headerByte;
+			return this.readMap(headerByte & 15);
+		}
+		if (headerByte < require_symbols.FIXSTR_START) {
+			const elementCount = headerByte & 15;
+			return this.readArray(elementCount);
+		}
+		return this.readStr(headerByte & 31);
+	}
+};
+//#endregion
+module.exports = DecoderBuffer;

package/dist/cjs/decoder/decoderBuffer.d.cts

@@ -0,0 +1,2 @@
+import { t as DecoderBuffer } from "../decoderBuffer-CJU2hdt2.cjs";
+export = DecoderBuffer;

package/dist/cjs/decoder/index.cjs

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_decoder_textDecoders_defaultTextDecoder = require("./textDecoders/defaultTextDecoder.cjs");
+const require_decoder_textDecoders_nodeTextDecoder = require("./textDecoders/nodeTextDecoder.cjs");
+const require_decoder_decoderBuffer = require("./decoderBuffer.cjs");
+const require_decoder_decoder = require("./decoder.cjs");
+const require_decoder_decode = require("./decode.cjs");
+exports.Decoder = require_decoder_decoder;
+exports.DecoderBuffer = require_decoder_decoderBuffer;
+exports.DefaultTextDecoder = require_decoder_textDecoders_defaultTextDecoder;
+exports.NodeTextDecoder = require_decoder_textDecoders_nodeTextDecoder;
+exports.decode = require_decoder_decode;

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

@@ -0,0 +1,8 @@
+import { t as MessagePackTextDecoder } from "../messagePackTextDecoder-J3fr-wQn.cjs";
+import { t as MessagePackDecoderBuffer } from "../messagePackDecoderBuffer-B2rRVlMX.cjs";
+import { t as decode } from "../decode-BraWmoPw.cjs";
+import { t as DefaultTextDecoder } from "../defaultTextDecoder-DY92jDSO.cjs";
+import { t as DecoderBuffer } from "../decoderBuffer-CJU2hdt2.cjs";
+import { t as Decoder } from "../decoder-3WpVBZjY.cjs";
+import { t as NodeTextDecoder } from "../nodeTextDecoder-DrNFdTVk.cjs";
+export { Decoder, DecoderBuffer, DefaultTextDecoder, type MessagePackDecoderBuffer, type MessagePackTextDecoder, NodeTextDecoder, decode };

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

@@ -0,0 +1,4 @@
+import { t as MessagePackTextDecoder } from "../../messagePackTextDecoder-J3fr-wQn.cjs";
+import { t as MessagePackDecoderBuffer } from "../../messagePackDecoderBuffer-B2rRVlMX.cjs";
+import "../../index-CaxrMD1A.cjs";
+export type { MessagePackDecoderBuffer, MessagePackTextDecoder };

package/dist/cjs/decoder/interfaces/messagePackDecoderBuffer.d.cts

@@ -0,0 +1,2 @@
+import { t as MessagePackDecoderBuffer } from "../../messagePackDecoderBuffer-B2rRVlMX.cjs";
+export = MessagePackDecoderBuffer;

package/dist/cjs/decoder/interfaces/messagePackTextDecoder.d.cts

@@ -0,0 +1,2 @@
+import { t as MessagePackTextDecoder } from "../../messagePackTextDecoder-J3fr-wQn.cjs";
+export = MessagePackTextDecoder;

package/dist/cjs/decoder/textDecoders/defaultTextDecoder.cjs

@@ -0,0 +1,12 @@
+//#region src/decoder/textDecoders/defaultTextDecoder.ts
+var DefaultTextDecoder = class {
+	textDecoder;
+	constructor() {
+		this.textDecoder = new TextDecoder();
+	}
+	decode(buffer, start, end) {
+		return this.textDecoder.decode(buffer.subarray(start, end));
+	}
+};
+//#endregion
+module.exports = DefaultTextDecoder;

package/dist/cjs/decoder/textDecoders/defaultTextDecoder.d.cts

@@ -0,0 +1,2 @@
+import { t as DefaultTextDecoder } from "../../defaultTextDecoder-DY92jDSO.cjs";
+export = DefaultTextDecoder;

package/dist/cjs/decoder/textDecoders/index.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_decoder_textDecoders_defaultTextDecoder = require("./defaultTextDecoder.cjs");
+const require_decoder_textDecoders_nodeTextDecoder = require("./nodeTextDecoder.cjs");
+exports.DefaultTextDecoder = require_decoder_textDecoders_defaultTextDecoder;
+exports.NodeTextDecoder = require_decoder_textDecoders_nodeTextDecoder;

package/dist/cjs/decoder/textDecoders/index.d.cts

@@ -0,0 +1,4 @@
+import { t as DefaultTextDecoder } from "../../defaultTextDecoder-DY92jDSO.cjs";
+import { t as NodeTextDecoder } from "../../nodeTextDecoder-DrNFdTVk.cjs";
+import "../../index-DeSJDZGk.cjs";
+export { DefaultTextDecoder, NodeTextDecoder };