@schema-pack/message-pack 0.0.0-commit.56d3200cf684346bbdb90bed64d3516657fdaaec → 0.0.0-commit.632b7ade369bd3712db3787f22db1554139bec60

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

@@ -0,0 +1,51 @@
+import { d as TimestampDateExtension, f as MessagePackBuiltInExtension, i as MessagePackExtension, r as MessagePackBufferWithExtensions, s as BigIntExtensionOptions, t as ErrorExtension, u as BufferWithExtensionsOptions } from "./error-B129l__v.cjs";
+//#region src/bufferWithExtensions.d.ts
+type MessagePackExtensionLike<TBuffer extends Uint8Array> = MessagePackExtension<object, TBuffer> | MessagePackBuiltInExtension<object, TBuffer>;
+declare abstract class BufferWithExtensions<TBuffer extends Uint8Array = Uint8Array> implements MessagePackBufferWithExtensions<TBuffer> {
+  /**
+   * Default extension type for `BigInt` values. This is used when the user does
+   * not provide a custom extension type for `BigInt` values.
+   */
+  static readonly DEFAULT_BIG_INT_EXTENSION_TYPE = 0;
+  /**
+   * The extensions map is used to store the registered extensions. The key is
+   * the extension type, and the value is the extension instance.
+   */
+  protected extensions: Map<number, MessagePackExtension<object, TBuffer>>;
+  /**
+   * The built-in extensions map is used to store the built-in extensions. The
+   * key is the extension type, and the value is the extension instance.
+   */
+  protected builtInExtensions: Map<number, MessagePackBuiltInExtension<object, TBuffer>>;
+  /**
+   * The timestamp date extension is used to encode and decode `Date` values. It
+   * is optional and can be disabled by setting the `extensions.timestampDate`
+   * option to `false`.
+   */
+  readonly timestampDateExtension?: TimestampDateExtension<TBuffer>;
+  /**
+   * The big integer extension is used to encode and decode `BigInt` values. It
+   * is optional and can be disabled by setting the `extensions.bigInt` option
+   * to `false`.
+   *
+   * If enabled, the user can provide a custom extension type for `BigInt`
+   * values by setting the `extensions.bigInt.type` option.
+   */
+  readonly bigIntExtension?: BigIntExtensionOptions;
+  /**
+   * The error extension is used to encode and decode `Error` values. It is
+   * optional and can be disabled by setting the `extensions.error` option to
+   * `false`.
+   *
+   * If enabled, the user can provide a custom extension for `Error` values by
+   * setting the `extensions.error` option to an instance of `ErrorExtension`.
+   */
+  readonly errorExtension?: ErrorExtension<TBuffer>;
+  constructor(options?: BufferWithExtensionsOptions<TBuffer>);
+  getExtensions(): ReadonlyMap<number, MessagePackExtension<object, TBuffer>>;
+  addExtension<TValue extends object>(extension: MessagePackExtension<TValue, TBuffer>): this;
+  fetchExtension(type: number): MessagePackExtensionLike<TBuffer>;
+}
+//#endregion
+export { BufferWithExtensions as t };
+//# sourceMappingURL=bufferWithExtensions-Cg4LGSIy.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bufferWithExtensions-Cg4LGSIy.d.cts","names":[],"sources":["../../src/bufferWithExtensions.ts"],"mappings":";;KAYK,yBAAyB,gBAAgB,cAC1C,6BAA6B,WAC7B,oCAAoC;uBAEzB,qBACb,gBAAgB,aAAa,uBAClB,gCAAgC;;;;;kBAK3B;;;;;YAMN,YAAU,YAAA,6BAAA;;;;;YASV,mBAAiB,YAAA,oCAAA;;;;;;WAUlB,yBAAyB,uBAAuB;;;;;;;;;WAUhD,kBAAkB;;;;;;;;;WAUlB,iBAAiB,eAAe;EAEzC,YAAY,UAAU,4BAA4B;EA0ClD,iBAAiB,oBAAoB,6BAA6B;EAIlE,aAAa,uBACX,WAAW,qBAAqB,QAAQ;EAiC1C,eAAe,eAAe,yBAAyB"}

package/dist/cjs/bufferWithExtensions.cjs

@@ -1,26 +1,89 @@
+const require_extensions_error_error = require("./extensions/error/error.cjs");
+const require_extensions_timestampDate_timestampDate = require("./extensions/timestampDate/timestampDate.cjs");
+const require_utils_assertValidExtensionType = require("./utils/assertValidExtensionType.cjs");
 //#region src/bufferWithExtensions.ts
-var BufferWithExtensions = class {
-	extensions;
-	constructor() {
-		this.extensions = /* @__PURE__ */ new Map();
+var BufferWithExtensions = class BufferWithExtensions {
+	/**
+	* Default extension type for `BigInt` values. This is used when the user does
+	* not provide a custom extension type for `BigInt` values.
+	*/
+	static DEFAULT_BIG_INT_EXTENSION_TYPE = 0;
+	/**
+	* The extensions map is used to store the registered extensions. The key is
+	* the extension type, and the value is the extension instance.
+	*/
+	extensions = /* @__PURE__ */ new Map();
+	/**
+	* The built-in extensions map is used to store the built-in extensions. The
+	* key is the extension type, and the value is the extension instance.
+	*/
+	builtInExtensions = /* @__PURE__ */ new Map();
+	/**
+	* The timestamp date extension is used to encode and decode `Date` values. It
+	* is optional and can be disabled by setting the `extensions.timestampDate`
+	* option to `false`.
+	*/
+	timestampDateExtension = void 0;
+	/**
+	* The big integer extension is used to encode and decode `BigInt` values. It
+	* is optional and can be disabled by setting the `extensions.bigInt` option
+	* to `false`.
+	*
+	* If enabled, the user can provide a custom extension type for `BigInt`
+	* values by setting the `extensions.bigInt.type` option.
+	*/
+	bigIntExtension = void 0;
+	/**
+	* The error extension is used to encode and decode `Error` values. It is
+	* optional and can be disabled by setting the `extensions.error` option to
+	* `false`.
+	*
+	* If enabled, the user can provide a custom extension for `Error` values by
+	* setting the `extensions.error` option to an instance of `ErrorExtension`.
+	*/
+	errorExtension = void 0;
+	constructor(options) {
+		if (options?.extensions !== false) {
+			if (options?.extensions?.bigInt !== false) {
+				this.bigIntExtension = options?.extensions?.bigInt ?? { type: BufferWithExtensions.DEFAULT_BIG_INT_EXTENSION_TYPE };
+				require_utils_assertValidExtensionType(this.bigIntExtension.type);
+			}
+			if (options?.extensions?.error !== false) {
+				if (options?.extensions?.error instanceof require_extensions_error_error) this.errorExtension = options.extensions.error;
+				else this.errorExtension = new require_extensions_error_error(options?.extensions?.error);
+				require_utils_assertValidExtensionType(this.errorExtension.type);
+				this.builtInExtensions.set(this.errorExtension.type, this.errorExtension);
+			}
+			if (options?.extensions?.timestampDate !== false) {
+				if (options?.extensions?.timestampDate instanceof require_extensions_timestampDate_timestampDate) this.timestampDateExtension = options.extensions.timestampDate;
+				else this.timestampDateExtension = new require_extensions_timestampDate_timestampDate();
+				this.builtInExtensions.set(require_extensions_timestampDate_timestampDate.DEFAULT_TYPE, this.timestampDateExtension);
+			}
+		}
 	}
-	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;
+	getExtensions() {
+		return this.extensions;
 	}
-	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}`);
+	addExtension(extension) {
+		if (this.extensions.has(extension.type)) {
+			const existent = this.extensions.get(extension.type);
+			throw new Error(`Extension with type ${extension.type} already registered for ${existent.constructor.name}`);
+		}
+		require_utils_assertValidExtensionType(extension.type);
+		if (this.builtInExtensions.has(extension.type)) {
+			const existent = this.builtInExtensions.get(extension.type);
+			throw new Error(`Extension with type ${extension.type} conflicts with built-in extension ${existent.constructor.name}`);
+		}
+		if (extension.type === this.bigIntExtension?.type) throw new Error(`Extension with type ${extension.type} conflicts with built-in BigInt extension`);
 		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`);
+		let extension = this.builtInExtensions.get(type);
+		if (!extension) {
+			extension = this.extensions.get(type);
+			if (!extension) throw new Error(`Extension with type ${type} not found`);
+		}
 		return extension;
 	}
 };

package/dist/cjs/bufferWithExtensions.d.cts

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

package/dist/cjs/decoder/decode.cjs

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

package/dist/cjs/decoder/decoder.cjs

@@ -1,29 +1,278 @@
-const require_decoder_decoderBuffer = require("./decoderBuffer.cjs");
+const require_symbols = require("../symbols.cjs");
+const require_bufferWithExtensions = require("../bufferWithExtensions.cjs");
+const require_defaultNewBufferFn = require("../defaultNewBufferFn.cjs");
+const require_decoder_textDecoders_defaultTextDecoder = require("./textDecoders/defaultTextDecoder.cjs");
 //#region src/decoder/decoder.ts
-var Decoder = class {
-	decoderBuffer;
+var Decoder = class Decoder extends require_bufferWithExtensions {
+	buffer;
+	offset;
+	view;
+	textDecoder;
+	copyBuffers;
 	constructor(options) {
-		this.decoderBuffer = new require_decoder_decoderBuffer(options);
+		super(options);
+		const bufferFactory = options?.bufferFactory ?? require_defaultNewBufferFn;
+		this.buffer = bufferFactory(0);
+		this.view = new DataView(this.buffer.buffer);
+		this.offset = 0;
+		this.textDecoder = options?.textDecoder ?? new require_decoder_textDecoders_defaultTextDecoder();
+		this.copyBuffers = options?.copyBuffers ?? false;
 	}
-	decode(encodedBuffer) {
-		const decoderBuffer = this.decoderBuffer;
-		decoderBuffer.setBuffer(encodedBuffer);
-		return decoderBuffer.nextValue();
+	static fromEncoder(encoder, options) {
+		const decoder = new Decoder({
+			bufferFactory: encoder.bufferFactory,
+			extensions: {
+				bigInt: encoder.bigIntExtension ?? false,
+				error: encoder.errorExtension ?? false,
+				timestampDate: encoder.timestampDateExtension ?? false
+			},
+			...options
+		});
+		const extensions = encoder.getExtensions();
+		for (const extension of extensions.values()) decoder.addExtension(extension);
+		return decoder;
 	}
-	addExtension(extension) {
-		this.decoderBuffer.addExtension(extension);
+	setBuffer(buffer) {
+		this.buffer = buffer;
+		this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+		this.offset = 0;
 		return this;
 	}
-	addInternalExtension(extension) {
-		this.decoderBuffer.addInternalExtension(extension);
-		return this;
+	readArray(elementCount) {
+		const decodedArray = new Array(elementCount);
+		for (let index = 0; index < elementCount; index++) decodedArray[index] = this.nextValue();
+		return decodedArray;
 	}
-	addExtensionType(type, extension) {
-		this.decoderBuffer.addExtension({
-			type,
-			...extension
-		});
-		return this;
+	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;
+	}
+	decodeBigInt(length) {
+		if (!this.bigIntExtension) throw new Error(`BigInt extension is disabled, cannot decode BigInt.`);
+		let encoded = 0n;
+		let shift = 0n;
+		const endOffset = this.offset + length;
+		while (this.offset < endOffset) {
+			encoded |= this.view.getBigUint64(this.offset, false) << shift;
+			this.offset += 8;
+			shift += 64n;
+		}
+		if ((encoded & 1n) === 1n) return -(encoded + 1n >> 1n);
+		return encoded >> 1n;
+	}
+	decodeBin(length) {
+		const startOffset = this.offset;
+		this.offset = startOffset + length;
+		if (this.copyBuffers) return Uint8Array.prototype.slice.call(this.buffer, startOffset, this.offset);
+		return this.buffer.subarray(startOffset, this.offset);
+	}
+	decodeExtension(extensionId, length) {
+		if (extensionId === this.bigIntExtension?.type) return this.decodeBigInt(length);
+		const extension = this.fetchExtension(extensionId);
+		const expectedNewOffset = this.offset + length;
+		const decoded = extension.decode(this, length);
+		if (this.offset !== expectedNewOffset) throw new Error(`Extension decoder did not consume the expected number of bytes for extensionId ${extensionId} and length ${length}.`);
+		return decoded;
+	}
+	decodeControlSlow(headerByte) {
+		const { buffer } = this;
+		switch (headerByte) {
+			case 193: return;
+			case require_symbols.BIN8: {
+				const byteLength = buffer[this.offset++];
+				return this.decodeBin(byteLength);
+			}
+			case require_symbols.BIN16: {
+				const byteLength = this.view.getUint16(this.offset);
+				this.offset += 2;
+				return this.decodeBin(byteLength);
+			}
+			case require_symbols.BIN32: {
+				const byteLength = this.view.getUint32(this.offset);
+				this.offset += 4;
+				return this.decodeBin(byteLength);
+			}
+			case require_symbols.EXT8: {
+				const length = this.buffer[this.offset++];
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.decodeExtension(extensionId, length);
+			}
+			case require_symbols.EXT16: {
+				const length = this.view.getUint16(this.offset);
+				this.offset += 2;
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.decodeExtension(extensionId, length);
+			}
+			case require_symbols.EXT32: {
+				const length = this.view.getUint32(this.offset);
+				this.offset += 4;
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.decodeExtension(extensionId, 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.decodeExtension(extensionId, 1);
+			}
+			case require_symbols.FIXEXT2: {
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.decodeExtension(extensionId, 2);
+			}
+			case require_symbols.FIXEXT4: {
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.decodeExtension(extensionId, 4);
+			}
+			case require_symbols.FIXEXT8: {
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.decodeExtension(extensionId, 8);
+			}
+			case require_symbols.FIXEXT16: {
+				const extensionId = this.view.getInt8(this.offset++);
+				return this.decodeExtension(extensionId, 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 decodedUint16 = this.view.getUint16(this.offset);
+				this.offset += 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);
+	}
+	decode(encodedBuffer) {
+		this.setBuffer(encodedBuffer);
+		return this.nextValue();
 	}
 };
 //#endregion

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

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

package/dist/cjs/decoder/index.cjs

@@ -1,11 +1,9 @@
 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

@@ -1,8 +1,7 @@
-import { t as MessagePackTextDecoder } from "../messagePackTextDecoder-J3fr-wQn.cjs";
-import { t as MessagePackDecoderBuffer } from "../messagePackDecoderBuffer-B2rRVlMX.cjs";
+import { t as MessagePackTextDecoder } from "../messagePackTextDecoder-CfBSOsxU.cjs";
+import { t as MessagePackDecoder } from "../messagePackDecoder-BZOBJ2h5.cjs";
 import { t as decode } from "../decode-BraWmoPw.cjs";
-import { t as DefaultTextDecoder } from "../defaultTextDecoder-DY92jDSO.cjs";
-import { t as DecoderBuffer } from "../decoderBuffer-BFoz1PcE.cjs";
-import { t as Decoder } from "../decoder-BugzrbIU.cjs";
-import { t as NodeTextDecoder } from "../nodeTextDecoder-DrNFdTVk.cjs";
-export { Decoder, DecoderBuffer, DefaultTextDecoder, type MessagePackDecoderBuffer, type MessagePackTextDecoder, NodeTextDecoder, decode };
+import { t as Decoder } from "../decoder-T6p4ZZJi.cjs";
+import { t as DefaultTextDecoder } from "../defaultTextDecoder-CyZtJbK1.cjs";
+import { t as NodeTextDecoder } from "../nodeTextDecoder-B48jwo-L.cjs";
+export { Decoder, DefaultTextDecoder, type MessagePackDecoder, type MessagePackTextDecoder, NodeTextDecoder, decode };

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

@@ -1,4 +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 };
+import { t as MessagePackTextDecoder } from "../../messagePackTextDecoder-CfBSOsxU.cjs";
+import { t as MessagePackDecoder } from "../../messagePackDecoder-BZOBJ2h5.cjs";
+import "../../index-DeSJDZGk.cjs";
+export type { MessagePackDecoder, MessagePackTextDecoder };

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

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

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

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

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

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

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

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

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

@@ -1,2 +1,2 @@
-import { t as NodeTextDecoder } from "../../nodeTextDecoder-DrNFdTVk.cjs";
+import { t as NodeTextDecoder } from "../../nodeTextDecoder-B48jwo-L.cjs";
 export = NodeTextDecoder;

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

@@ -1,2 +1,2 @@
-import { t as DecoderBufferOptions } from "../types-CC2wkzZa.cjs";
-export { DecoderBufferOptions };
+import { t as DecoderOptions } from "../types-CbicLx9m.cjs";
+export { DecoderOptions };

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

@@ -0,0 +1,30 @@
+import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-CfBSOsxU.cjs";
+import { t as MessagePackDecoder } from "./messagePackDecoder-BZOBJ2h5.cjs";
+import { a as EncoderOptions } from "./error-B129l__v.cjs";
+import { t as BufferWithExtensions } from "./bufferWithExtensions-Cg4LGSIy.cjs";
+import { t as Encoder } from "./encoder-yQYOtvXU.cjs";
+import { t as DecoderOptions } from "./types-CbicLx9m.cjs";
+//#region src/decoder/decoder.d.ts
+declare class Decoder<TBuffer extends Uint8Array = Uint8Array> extends BufferWithExtensions<TBuffer> implements MessagePackDecoder<TBuffer> {
+  buffer: TBuffer;
+  offset: number;
+  view: DataView;
+  textDecoder: MessagePackTextDecoder<TBuffer>;
+  copyBuffers: boolean;
+  constructor(options?: DecoderOptions<TBuffer>);
+  static fromEncoder<TBuffer extends Uint8Array = Uint8Array>(encoder: Encoder<TBuffer>, options?: NoInfer<Omit<DecoderOptions<TBuffer>, keyof EncoderOptions<TBuffer>>>): Decoder<TBuffer>;
+  setBuffer(buffer: TBuffer): this;
+  protected readArray(elementCount: number): unknown[];
+  protected readStr(byteLength: number): string;
+  protected readMapKey(): string | number;
+  protected readMap(length: number): Record<string | number, unknown>;
+  protected decodeBigInt(length: number): bigint;
+  protected decodeBin(length: number): TBuffer;
+  protected decodeExtension(extensionId: number, length: number): unknown;
+  protected decodeControlSlow(headerByte: number): unknown;
+  nextValue<TValue = unknown>(): TValue;
+  decode<TValue = unknown>(encodedBuffer: TBuffer): TValue;
+}
+//#endregion
+export { Decoder as t };
+//# sourceMappingURL=decoder-T6p4ZZJi.d.cts.map

package/dist/cjs/decoder-T6p4ZZJi.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder-T6p4ZZJi.d.cts","names":[],"sources":["../../src/decoder/decoder.ts"],"mappings":";;;;;;;cAYM,QAAQ,gBAAgB,aAAa,oBACjC,qBAAqB,oBAClB,mBAAmB;EAE9B,QAAQ;EACR;EACA,MAAM;EACN,aAAa,uBAAuB;EACpC;EAEA,YAAY,UAAU,eAAe;SAc9B,YAAY,gBAAgB,aAAa,YAC9C,SAAS,QAAQ,UACjB,UAAU,QACR,KAAK,eAAe,gBAAgB,eAAe,aAEpD,QAAQ;EAoBX,UAAU,QAAQ;YAYR,UAAU;YAcV,QAAQ;YAkDR;YAIA,QAAQ,iBAAiB;YAkBzB,aAAa;YAsBb,UAAU,iBAAiB;YAgB3B,gBAAgB,qBAAqB;YAqBrC,kBAAkB;EAuK5B,UAAU,qBAAqB;EA2D/B,OAAO,kBAAkB,eAAe,UAAU"}

package/dist/cjs/defaultNewBufferFn.cjs

@@ -1,6 +1,4 @@
 //#region src/defaultNewBufferFn.ts
-function defaultNewBufferFn(requiredSize) {
-	return new Uint8Array(requiredSize);
-}
+const defaultNewBufferFn = (requiredSize) => new Uint8Array(requiredSize);
 //#endregion
 module.exports = defaultNewBufferFn;

package/dist/cjs/defaultNewBufferFn.d.cts

@@ -1,4 +1,5 @@
+import { c as BufferFactory } from "./error-B129l__v.cjs";
 //#region src/defaultNewBufferFn.d.ts
-declare function defaultNewBufferFn<TBuffer extends Uint8Array = Uint8Array>(requiredSize: number): TBuffer;
+declare const defaultNewBufferFn: BufferFactory;
 export = defaultNewBufferFn;
 //# sourceMappingURL=defaultNewBufferFn.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"defaultNewBufferFn.d.cts","names":[],"sources":["../../src/defaultNewBufferFn.ts"],"mappings":";iBAAwB,mBACtB,gBAAgB,aAAa,YAC7B,uBAAuB"}
+{"version":3,"file":"defaultNewBufferFn.d.cts","names":[],"sources":["../../src/defaultNewBufferFn.ts"],"mappings":";;cAEM,oBAAoB"}

package/dist/cjs/defaultTextDecoder-CyZtJbK1.d.cts

@@ -0,0 +1,10 @@
+import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-CfBSOsxU.cjs";
+//#region src/decoder/textDecoders/defaultTextDecoder.d.ts
+declare class DefaultTextDecoder<TBuffer extends Uint8Array = Uint8Array> implements MessagePackTextDecoder<TBuffer> {
+  protected textDecoder: TextDecoder;
+  constructor();
+  decode(buffer: TBuffer, start: number, end: number): string;
+}
+//#endregion
+export { DefaultTextDecoder as t };
+//# sourceMappingURL=defaultTextDecoder-CyZtJbK1.d.cts.map

package/dist/cjs/defaultTextDecoder-CyZtJbK1.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultTextDecoder-CyZtJbK1.d.cts","names":[],"sources":["../../src/decoder/textDecoders/defaultTextDecoder.ts"],"mappings":";;cAEM,mBACJ,gBAAgB,aAAa,uBAClB,uBAAuB;YACxB,aAAa;EAEvB;EAIA,OAAO,QAAQ,SAAS,eAAe"}

package/dist/{esm/defaultTextEncoder-BkIjtDkg.d.mts → cjs/defaultTextEncoder-BpUrJKD9.d.cts}

@@ -1,4 +1,4 @@
-import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-D7iCft_t.mjs";
+import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-MeyNUt3L.cjs";
 //#region src/encoder/textEncoders/defaultTextEncoder.d.ts
 /**
  * DefaultTextEncoder provides functionality to encode strings into UTF-8 bytes,
@@ -11,4 +11,4 @@ declare class DefaultTextEncoder<TBuffer extends Uint8Array = Uint8Array> implem
 }
 //#endregion
 export { DefaultTextEncoder as t };
-//# sourceMappingURL=defaultTextEncoder-BkIjtDkg.d.mts.map
+//# sourceMappingURL=defaultTextEncoder-BpUrJKD9.d.cts.map

package/dist/cjs/{defaultTextEncoder-DzdGBX6s.d.cts.map → defaultTextEncoder-BpUrJKD9.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"defaultTextEncoder-DzdGBX6s.d.cts","names":[],"sources":["../../src/encoder/textEncoders/defaultTextEncoder.ts"],"mappings":";;;;;;cAMM,mBACJ,gBAAgB,aAAa,uBAClB,uBAAuB;;EAElC,mBAAiB;EAEV,WAAW,eAAe,QAAQ"}
+{"version":3,"file":"defaultTextEncoder-BpUrJKD9.d.cts","names":[],"sources":["../../src/encoder/textEncoders/defaultTextEncoder.ts"],"mappings":";;;;;;cAMM,mBACJ,gBAAgB,aAAa,uBAClB,uBAAuB;;EAElC,mBAAiB;EAEV,WAAW,eAAe,QAAQ"}