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

package/dist/cjs/{encoderBuffer-DWGIXXjj.d.cts → encoder-C9JlmRrE.d.cts}

@@ -1,9 +1,9 @@
-import { i as ExtensionEncoderBuffer, n as MessagePackEncoderBuffer, r as EncoderBufferOptions, t as MessagePackExtension } from "./messagePackExtension-C_TQXlEn.cjs";
-import { n as NewBufferFn } from "./types-BJie2edF.cjs";
+import { t as BufferFactory } from "./types-DTcs4Mkd.cjs";
+import { a as MessagePackEncoder, n as EncoderOptions, r as ExtensionEncoder, t as MessagePackExtension } from "./messagePackExtension-DS5fpQDE.cjs";
 import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-D7iCft_t.cjs";
-import { t as BufferWithExtensions } from "./bufferWithExtensions-BAinwJsn.cjs";
-//#region src/encoder/encoderBuffer.d.ts
-declare class EncoderBuffer<TBuffer extends Uint8Array = Uint8Array> extends BufferWithExtensions<TBuffer> implements MessagePackEncoderBuffer<TBuffer> {
+import { t as BufferWithExtensions } from "./bufferWithExtensions-Bn-W9WIx.cjs";
+//#region src/encoder/encoder.d.ts
+declare class Encoder<TBuffer extends Uint8Array = Uint8Array> extends BufferWithExtensions<TBuffer> implements MessagePackEncoder<TBuffer> {
   #private;
   /** The current offset in the buffer where the next write operation will occur. */
   offset: number;
@@ -35,12 +35,12 @@ declare class EncoderBuffer<TBuffer extends Uint8Array = Uint8Array> extends Buf
    * to accommodate the data being written. The function should return a new
    * instance of TBuffer with the specified size.
    */
-  protected newBufferFn: NewBufferFn<TBuffer>;
+  protected bufferFactory: BufferFactory<TBuffer>;
   readonly textEncoder: MessagePackTextEncoder<TBuffer>;
   buffer: TBuffer;
   view: DataView;
-  constructor(options?: Partial<EncoderBufferOptions<TBuffer>>);
-  getExtensionBuffer(): EncoderBuffer<TBuffer>;
+  constructor(options?: Partial<EncoderOptions<TBuffer>>);
+  getExtensionEncoder(): Encoder<TBuffer>;
   resizeBuffer(newSize: number): this;
   ensureCapacity(sizeToWrite: number): this;
   resetBuffer(): this;
@@ -94,16 +94,21 @@ declare class EncoderBuffer<TBuffer extends Uint8Array = Uint8Array> extends Buf
   writeExt16Symbol(type: number, size: number): this;
   writeExt32Symbol(type: number, size: number): this;
   writeString(value: string): this;
+  writeSignedInteger(value: number): this;
+  writeUnsignedInteger(value: number): this;
+  writeFloat(value: number): this;
   writeNumber(value: number): this;
+  openMap(keysLength: number): this;
   writeMap<TKey extends string | number, TValue>(value: Record<TKey, TValue>): this;
+  openArray(length: number): this;
   writeArray(value: unknown[]): this;
   writeUint8Array(value: Uint8Array): this;
-  writeExtension(extension: MessagePackExtension, buffer: ExtensionEncoderBuffer<TBuffer>): this;
+  writeExtension(extension: MessagePackExtension, encoder: ExtensionEncoder<TBuffer>): this;
   tryToWriteExtensionValue(value: object | bigint): number;
   writeBigInt(value: bigint): this;
   writeObject(value: object): this;
   write(value: unknown): this;
 }
 //#endregion
-export { EncoderBuffer as t };
-//# sourceMappingURL=encoderBuffer-DWGIXXjj.d.cts.map
+export { Encoder as t };
+//# sourceMappingURL=encoder-C9JlmRrE.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encoder-C9JlmRrE.d.cts","names":[],"sources":["../../src/encoder/encoder.ts"],"mappings":";;;;;cAuBM,QAAQ,gBAAgB,aAAa,oBACjC,qBAAqB,oBAClB,mBAAmB;;;EAG9B;;;;;;;YAQU,cAAc;;;;;;;WAQf;;;;;;;;WASA;;;;;;;YAQC,eAAe,cAAc;WAE9B,aAAa,uBAAuB;EAE7C,QAAQ;EACR,MAAM;EAcN,YAAY,UAAU,QAAQ,eAAe;EAwB7C,uBAAuB,QAAQ;EAc/B,aAAa;EAeb,eAAe;EAUf;EAMA,SAAS;EAST,oBAAoB;EAMpB,oBAAoB;EAMpB,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,mBAAmB;EA2BnB,qBAAqB;EAmCrB,WAAW;EAYX,YAAY;EAYZ,QAAQ;EAqBR,SAAS,8BAA8B,QACrC,OAAO,OAAO,MAAM;EAqBtB,UAAU;EAqBV,WAAW;EAwBX,gBAAgB,OAAO;EAiBvB,eACE,WAAW,sBACX,SAAS,iBAAiB;EAiD5B,yBAAyB;EAqBzB,YAAY;EAYZ,YAAY;EAkBZ,MAAM"}

package/dist/cjs/extensions/bigint/bigInt.cjs

@@ -19,17 +19,17 @@ var BigIntExtension = class extends require_untypedExtension {
 	* indicate negativity.
 	*
 	* @param value - The BigInt value to encode.
-	* @param buffer - The buffer to write the encoded data to.
+	* @param encoder - The extension encoder to write the encoded data to.
 	*/
-	encode(value, buffer) {
+	encode(value, encoder) {
 		if (typeof value === "bigint") {
 			let magnitude;
 			if (value < 0n) magnitude = (-value << 1n) - 1n;
 			else magnitude = value << 1n;
 			while (magnitude > 0n) {
-				buffer.ensureCapacity(8);
-				buffer.view.setBigUint64(buffer.offset, magnitude & BIGINT_MASK, false);
-				buffer.offset += 8;
+				encoder.ensureCapacity(8);
+				encoder.view.setBigUint64(encoder.offset, magnitude & BIGINT_MASK, false);
+				encoder.offset += 8;
 				magnitude >>= 64n;
 			}
 		}

package/dist/cjs/extensions/bigint/bigInt.d.cts

@@ -1,2 +1,2 @@
-import { t as BigIntExtension } from "../../bigInt-CBB8PGpe.cjs";
+import { t as BigIntExtension } from "../../bigInt-CrswAzNE.cjs";
 export = BigIntExtension;

package/dist/cjs/extensions/bigint/index.d.cts

@@ -1,3 +1,3 @@
-import { t as BigIntExtension } from "../../bigInt-CBB8PGpe.cjs";
-import "../../index-CQnkyOId.cjs";
+import { t as BigIntExtension } from "../../bigInt-CrswAzNE.cjs";
+import "../../index-5OuLsWCC.cjs";
 export = BigIntExtension;

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

@@ -1,4 +1,4 @@
-import { t as MessagePackExtension } from "../messagePackExtension-C_TQXlEn.cjs";
+import { t as MessagePackExtension } from "../messagePackExtension-DS5fpQDE.cjs";
 import { t as MessagePackTime } from "../types-B9KMW-kD.cjs";
-import { t as TimestampDateExtension } from "../timestampDate-BtBd4bAx.cjs";
+import { t as TimestampDateExtension } from "../timestampDate-mzf7iMkQ.cjs";
 export { type MessagePackExtension, type MessagePackTime, TimestampDateExtension };

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

@@ -1,3 +1,3 @@
-import { t as MessagePackExtension } from "../../messagePackExtension-C_TQXlEn.cjs";
-import "../../index-CUX405iZ.cjs";
+import { t as MessagePackExtension } from "../../messagePackExtension-DS5fpQDE.cjs";
+import "../../index-B5vbV8Ak.cjs";
 export type { MessagePackExtension };

package/dist/cjs/extensions/interfaces/messagePackExtension.d.cts

@@ -1,2 +1,2 @@
-import { t as MessagePackExtension } from "../../messagePackExtension-C_TQXlEn.cjs";
+import { t as MessagePackExtension } from "../../messagePackExtension-DS5fpQDE.cjs";
 export = MessagePackExtension;

package/dist/cjs/extensions/timestampDate/index.d.cts

@@ -1,4 +1,4 @@
 import { t as MessagePackTime } from "../../types-B9KMW-kD.cjs";
-import { t as TimestampDateExtension } from "../../timestampDate-BtBd4bAx.cjs";
-import "../../index-5OuLsWCC.cjs";
+import { t as TimestampDateExtension } from "../../timestampDate-mzf7iMkQ.cjs";
+import "../../index-CUX405iZ.cjs";
 export { type MessagePackTime, TimestampDateExtension };

package/dist/cjs/extensions/timestampDate/timestampDate.cjs

@@ -33,20 +33,20 @@ var TimestampDateExtension = class {
 			sec: sec + nsecInSec
 		};
 	}
-	encode(value, buffer) {
+	encode(value, encoder) {
 		if (value instanceof Date) {
 			const time = this.parseToMessagePackTime(value);
 			if (time.sec >= 0 && time.nsec >= 0 && time.sec <= TIMESTAMP64_MAX_SEC) {
-				if (time.nsec === 0 && time.sec <= TIMESTAMP32_MAX_SEC) buffer.writeUint32(time.sec);
+				if (time.nsec === 0 && time.sec <= TIMESTAMP32_MAX_SEC) encoder.writeUint32(time.sec);
 				else {
 					const secHigh = time.sec / 4294967296;
 					const secLow = time.sec & 4294967295;
-					buffer.writeUint32(time.nsec << 2 | secHigh & 3);
-					buffer.writeUint32(secLow);
+					encoder.writeUint32(time.nsec << 2 | secHigh & 3);
+					encoder.writeUint32(secLow);
 				}
 			} else {
-				buffer.writeUint32(time.nsec);
-				buffer.writeInt64(time.sec);
+				encoder.writeUint32(time.nsec);
+				encoder.writeInt64(time.sec);
 			}
 		}
 	}

package/dist/cjs/extensions/timestampDate/timestampDate.d.cts

@@ -1,2 +1,2 @@
-import { t as TimestampDateExtension } from "../../timestampDate-BtBd4bAx.cjs";
+import { t as TimestampDateExtension } from "../../timestampDate-mzf7iMkQ.cjs";
 export = TimestampDateExtension;

package/dist/cjs/index-B5vbV8Ak.d.cts

@@ -0,0 +1 @@
+export {}

package/dist/cjs/index.cjs

@@ -3,18 +3,20 @@ const require_bufferWithExtensions = require("./bufferWithExtensions.cjs");
 const require_constants = require("./constants.cjs");
 const require_symbols = require("./symbols.cjs");
 const require_untypedExtension = require("./untypedExtension.cjs");
+const require_decoder_textDecoders_defaultTextDecoder = require("./decoder/textDecoders/defaultTextDecoder.cjs");
+const require_decoder_textDecoders_nodeTextDecoder = require("./decoder/textDecoders/nodeTextDecoder.cjs");
+const require_decoder_decoderBuffer = require("./decoder/decoderBuffer.cjs");
+const require_decoder_decoder = require("./decoder/decoder.cjs");
+const require_decoder_decode = require("./decoder/decode.cjs");
+require("./decoder/index.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("./encoder/textEncoders/defaultTextEncoder.cjs");
-const require_encoder_encoderBuffer = require("./encoder/encoderBuffer.cjs");
 const require_encoder_encoder = require("./encoder/encoder.cjs");
-const require_benchmark_decoderDataTypesFactory = require("./benchmark/decoderDataTypesFactory.cjs");
-const require_decoder_decoderBuffer = require("./decoder/decoderBuffer.cjs");
-const require_decoder_decoder = require("./decoder/decoder.cjs");
-require("./decoder/index.cjs");
 const require_encoder_textEncoders_nodeTextEncoder = require("./encoder/textEncoders/nodeTextEncoder.cjs");
+const require_encoder_encode = require("./encoder/encode.cjs");
 require("./encoder/index.cjs");
 const require_extensions_timestampDate_timestampDate = require("./extensions/timestampDate/timestampDate.cjs");
 require("./extensions/index.cjs");
@@ -24,18 +26,20 @@ exports.BufferWithExtensions = require_bufferWithExtensions;
 exports.DEFAULT_ALLOCATION_SIZE = require_constants.DEFAULT_ALLOCATION_SIZE;
 exports.Decoder = require_decoder_decoder;
 exports.DecoderBuffer = require_decoder_decoderBuffer;
+exports.DefaultTextDecoder = require_decoder_textDecoders_defaultTextDecoder;
 exports.DefaultTextEncoder = require_encoder_textEncoders_defaultTextEncoder;
 exports.Encoder = require_encoder_encoder;
-exports.EncoderBuffer = require_encoder_encoderBuffer;
 exports.INT32_MIN = require_constants.INT32_MIN;
 exports.INT64_MIN = require_constants.INT64_MIN;
+exports.NodeTextDecoder = require_decoder_textDecoders_nodeTextDecoder;
 exports.NodeTextEncoder = require_encoder_textEncoders_nodeTextEncoder;
 exports.Symbols = require_symbols;
 exports.TimestampDateExtension = require_extensions_timestampDate_timestampDate;
 exports.UINT32_MAX = require_constants.UINT32_MAX;
 exports.UINT64_MAX = require_constants.UINT64_MAX;
 exports.UntypedExtension = require_untypedExtension;
-exports.decoderDataTypesFactory = require_benchmark_decoderDataTypesFactory;
+exports.decode = require_decoder_decode;
+exports.encode = require_encoder_encode;
 exports.fitIn16Bits = require_utils_fitIn16Bits;
 exports.fitIn32Bits = require_utils_fitIn32Bits;
 exports.fitIn7Bits = require_utils_fitIn7Bits;

package/dist/cjs/index.d.cts

@@ -1,23 +1,25 @@
-import decoderDataTypesFactory from "./benchmark/decoderDataTypesFactory.cjs";
-import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-CtyB0N6j.cjs";
-import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-CMG0LPbJ.cjs";
-import { a as OmitByPattern, i as ExtensionEncoderBuffer, n as MessagePackEncoderBuffer, o as MessagePackBufferWithExtensions, r as EncoderBufferOptions, t as MessagePackExtension } from "./messagePackExtension-C_TQXlEn.cjs";
+import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-J3fr-wQn.cjs";
+import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-B2rRVlMX.cjs";
+import { a as MessagePackEncoder, i as OmitByPattern, n as EncoderOptions, o as MessagePackBufferWithExtensions, r as ExtensionEncoder, t as MessagePackExtension } from "./messagePackExtension-DS5fpQDE.cjs";
 import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-D7iCft_t.cjs";
-import { t as BufferWithExtensions } from "./bufferWithExtensions-BAinwJsn.cjs";
+import { t as BufferWithExtensions } from "./bufferWithExtensions-Bn-W9WIx.cjs";
 import { DEFAULT_ALLOCATION_SIZE, INT32_MIN, INT64_MIN, UINT32_MAX, UINT64_MAX } from "./constants.cjs";
-import { t as DecoderBuffer } from "./decoderBuffer-C9_0y-3q.cjs";
-import { t as Decoder } from "./decoder-C1cd4I8S.cjs";
-import { t as EncoderBuffer } from "./encoderBuffer-DWGIXXjj.cjs";
-import { t as Encoder } from "./encoder-DXuhGwd7.cjs";
+import { t as decode } from "./decode-BraWmoPw.cjs";
+import { t as DefaultTextDecoder } from "./defaultTextDecoder-DY92jDSO.cjs";
+import { t as DecoderBuffer } from "./decoderBuffer-BQIG2-IB.cjs";
+import { t as Decoder } from "./decoder-BElySab6.cjs";
+import { t as NodeTextDecoder } from "./nodeTextDecoder-DrNFdTVk.cjs";
+import { t as encode } from "./encode-4SxHVw0M.cjs";
+import { t as Encoder } from "./encoder-C9JlmRrE.cjs";
 import { t as DefaultTextEncoder } from "./defaultTextEncoder-DzdGBX6s.cjs";
 import { t as NodeTextEncoder } from "./nodeTextEncoder-DJzFDBXd.cjs";
-import { t as UntypedExtension } from "./untypedExtension-WQvArYoO.cjs";
+import { t as UntypedExtension } from "./untypedExtension-3ndklPO7.cjs";
 import { t as MessagePackTime } from "./types-B9KMW-kD.cjs";
-import { t as TimestampDateExtension } from "./timestampDate-BtBd4bAx.cjs";
+import { t as TimestampDateExtension } from "./timestampDate-mzf7iMkQ.cjs";
 import Symbols from "./symbols.cjs";
 import { t as fitIn7Bits } from "./fitIn7Bits-BVHyKXCg.cjs";
 import { t as fitIn8Bits } from "./fitIn8Bits-DQnQIhdh.cjs";
 import { t as fitIn16Bits } from "./fitIn16Bits-D9lga-sP.cjs";
 import { t as fitIn32Bits } from "./fitIn32Bits-BrGIMOff.cjs";
 import { t as fitInt64Bits } from "./fitInt64Bits-CY7lVKne.cjs";
-export { BufferWithExtensions, DEFAULT_ALLOCATION_SIZE, Decoder, DecoderBuffer, DefaultTextEncoder, Encoder, EncoderBuffer, type EncoderBufferOptions, type ExtensionEncoderBuffer, INT32_MIN, INT64_MIN, type MessagePackBufferWithExtensions, type MessagePackDecoderBuffer, type MessagePackEncoderBuffer, type MessagePackExtension, type MessagePackTextDecoder, type MessagePackTextEncoder, type MessagePackTime, NodeTextEncoder, type OmitByPattern, Symbols, TimestampDateExtension, UINT32_MAX, UINT64_MAX, UntypedExtension, decoderDataTypesFactory, fitIn16Bits, fitIn32Bits, fitIn7Bits, fitIn8Bits, fitInt64Bits };
+export { BufferWithExtensions, DEFAULT_ALLOCATION_SIZE, Decoder, DecoderBuffer, DefaultTextDecoder, DefaultTextEncoder, Encoder, type EncoderOptions, type ExtensionEncoder, INT32_MIN, INT64_MIN, type MessagePackBufferWithExtensions, type MessagePackDecoderBuffer, type MessagePackEncoder, type MessagePackExtension, type MessagePackTextDecoder, type MessagePackTextEncoder, type MessagePackTime, NodeTextDecoder, NodeTextEncoder, type OmitByPattern, Symbols, TimestampDateExtension, UINT32_MAX, UINT64_MAX, UntypedExtension, decode, encode, fitIn16Bits, fitIn32Bits, fitIn7Bits, fitIn8Bits, fitInt64Bits };

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

@@ -1,2 +1,2 @@
-import { o as MessagePackBufferWithExtensions } from "../messagePackExtension-C_TQXlEn.cjs";
+import { o as MessagePackBufferWithExtensions } from "../messagePackExtension-DS5fpQDE.cjs";
 export type { MessagePackBufferWithExtensions };

package/dist/cjs/interfaces/messagePackBufferWithExtensions.d.cts

@@ -1,2 +1,2 @@
-import { o as MessagePackBufferWithExtensions } from "../messagePackExtension-C_TQXlEn.cjs";
+import { o as MessagePackBufferWithExtensions } from "../messagePackExtension-DS5fpQDE.cjs";
 export = MessagePackBufferWithExtensions;

package/dist/{esm/messagePackDecoderBuffer-CGyYSweZ.d.mts → cjs/messagePackDecoderBuffer-B2rRVlMX.d.cts}

@@ -1,4 +1,4 @@
-import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-CtyB0N6j.mjs";
+import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-J3fr-wQn.cjs";
 //#region src/decoder/interfaces/messagePackDecoderBuffer.d.ts
 interface MessagePackDecoderBuffer<TBuffer extends Uint8Array = Uint8Array> {
   view: DataView;
@@ -9,4 +9,4 @@ interface MessagePackDecoderBuffer<TBuffer extends Uint8Array = Uint8Array> {
 }
 //#endregion
 export { MessagePackDecoderBuffer as t };
-//# sourceMappingURL=messagePackDecoderBuffer-CGyYSweZ.d.mts.map
+//# sourceMappingURL=messagePackDecoderBuffer-B2rRVlMX.d.cts.map

package/dist/cjs/{messagePackDecoderBuffer-CMG0LPbJ.d.cts.map → messagePackDecoderBuffer-B2rRVlMX.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"messagePackDecoderBuffer-CMG0LPbJ.d.cts","names":[],"sources":["../../src/decoder/interfaces/messagePackDecoderBuffer.ts"],"mappings":";;UAEyB,yBACvB,gBAAgB,aAAa;EAE7B,MAAM;EACN,QAAQ;EACR,aAAa;EACb;EAGA,UAAU,qBAAqB"}
+{"version":3,"file":"messagePackDecoderBuffer-B2rRVlMX.d.cts","names":[],"sources":["../../src/decoder/interfaces/messagePackDecoderBuffer.ts"],"mappings":";;UAEyB,yBACvB,gBAAgB,aAAa;EAE7B,MAAM;EACN,QAAQ;EACR,aAAa;EACb;EAGA,UAAU,qBAAqB"}

package/dist/cjs/{messagePackExtension-C_TQXlEn.d.cts → messagePackExtension-DS5fpQDE.d.cts}

@@ -1,5 +1,5 @@
-import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-CMG0LPbJ.cjs";
-import { t as BufferOptions } from "./types-BJie2edF.cjs";
+import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-B2rRVlMX.cjs";
+import { n as BufferOptions } from "./types-DTcs4Mkd.cjs";
 import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-D7iCft_t.cjs";
 //#region src/interfaces/messagePackBufferWithExtensions.d.ts
 interface MessagePackBufferWithExtensions<TBuffer extends Uint8Array = Uint8Array> {
@@ -13,56 +13,13 @@ interface MessagePackBufferWithExtensions<TBuffer extends Uint8Array = Uint8Arra
   addExtension(extension: MessagePackExtension<unknown, TBuffer>): this;
 }
 //#endregion
-//#region src/encoder/types.d.ts
-interface EncoderBufferOptions<TBuffer extends Uint8Array = Uint8Array> extends BufferOptions<TBuffer> {
-  /**
-   * The initial size of the shared buffer. Shared buffer is used to encode
-   * strings, to avoid allocating a new buffer for each string. This helps to
-   * improve performance by reducing memory allocations and garbage collection
-   * overhead.
-   *
-   * @default 1024
-   */
-  initialSharedBufferSize?: number;
-  /**
-   * A text encoder that will be used to encode strings into bytes.
-   *
-   * @default DefaultTextEncoder
-   */
-  textEncoder?: MessagePackTextEncoder<TBuffer>;
-  /**
-   * If true, the keys of objects will be sorted before encoding. This can be
-   * useful for ensuring consistent encoding of objects with the same keys but
-   * in different orders.
-   *
-   * @default false
-   */
-  sortKeys?: boolean;
-  /**
-   * If true, all floats will be encoded as float32, but it may result in loss
-   * of precision for some floats (like `1.2`), this is a JavaScript
-   * limitation.
-   *
-   * If false, floats will be encoded as float64, which is more precise but
-   * takes up more space.
-   *
-   * Set to true only if you are sure that your floats can be represented as
-   * float32 without loss of precision.
-   *
-   * @default false
-   */
-  forceFloat32?: boolean;
-}
-type OmitByPattern<TRecord, Pattern extends string> = { [TKey in keyof TRecord as TKey extends Pattern ? never : TKey]: TRecord[TKey]; };
-type ExtensionEncoderBuffer<TBuffer extends Uint8Array = Uint8Array> = OmitByPattern<MessagePackEncoderBuffer<TBuffer>, `${string}Extension` | 'resetBuffer' | 'extensions'>;
-//#endregion
-//#region src/encoder/interfaces/messagePackEncoderBuffer.d.ts
+//#region src/encoder/interfaces/messagePackEncoder.d.ts
 /**
  * Defines the core methods for managing a buffer. It serves as the foundation
  * for buffer management in the encoding process, allowing for efficient
  * handling of binary data while adhering to the MessagePack format.
  */
-interface MessagePackEncoderBuffer<TBuffer extends Uint8Array = Uint8Array> extends MessagePackBufferWithExtensions<TBuffer> {
+interface MessagePackEncoder<TBuffer extends Uint8Array = Uint8Array> extends MessagePackBufferWithExtensions<TBuffer> {
   /** Buffer management * */
   /**
    * Returns the underlying buffer. This method provides access to the raw data
@@ -708,6 +665,84 @@ interface MessagePackEncoderBuffer<TBuffer extends Uint8Array = Uint8Array> exte
    * ```
    */
   writeString(value: string): this;
+  /**
+   * Writes a MessagePack number using signed integer point formats.
+   *
+   * ```
+   * negative fixint:
+   * +--------+
+   * |111YYYYY|
+   * +--------+
+   *
+   * int 8:
+   * +--------+--------+
+   * |  0xd0  |ZZZZZZZZ|
+   * +--------+--------+
+   *
+   * int 16:
+   * +--------+--------+--------+
+   * |  0xd1  |ZZZZZZZZ|ZZZZZZZZ|
+   * +--------+--------+--------+
+   *
+   * int 32:
+   * +--------+--------+--------+--------+--------+
+   * |  0xd2  |ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|
+   * +--------+--------+--------+--------+--------+
+   *
+   * int 64:
+   * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+   * |  0xd3  |ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|
+   * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+   * ```
+   */
+  writeSignedInteger(value: number): this;
+  /**
+   * Writes a MessagePack number using unsigned integer point formats.
+   *
+   * ```
+   * positive fixint:
+   * +--------+
+   * |0XXXXXXX|
+   * +--------+
+   *
+   * uint 8:
+   * +--------+--------+
+   * |  0xcc  |ZZZZZZZZ|
+   * +--------+--------+
+   *
+   * uint 16:
+   * +--------+--------+--------+
+   * |  0xcd  |ZZZZZZZZ|ZZZZZZZZ|
+   * +--------+--------+--------+
+   *
+   * uint 32:
+   * +--------+--------+--------+--------+--------+
+   * |  0xce  |ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|
+   * +--------+--------+--------+--------+--------+
+   *
+   * uint 64:
+   * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+   * |  0xcf  |ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|
+   * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+   * ```
+   */
+  writeUnsignedInteger(value: number): this;
+  /**
+   * Writes a MessagePack number using floating point formats.
+   *
+   * ```
+   * float 32:
+   * +--------+--------+--------+--------+--------+
+   * |  0xca  |XXXXXXXX|XXXXXXXX|XXXXXXXX|XXXXXXXX|
+   * +--------+--------+--------+--------+--------+
+   *
+   * float 64:
+   * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+   * |  0xcb  |YYYYYYYY|YYYYYYYY|YYYYYYYY|YYYYYYYY|YYYYYYYY|YYYYYYYY|YYYYYYYY|YYYYYYYY|
+   * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
+   * ```
+   */
+  writeFloat(value: number): this;
   /**
    * Writes a MessagePack number using integer or floating point formats.
    *
@@ -777,6 +812,11 @@ interface MessagePackEncoderBuffer<TBuffer extends Uint8Array = Uint8Array> exte
   /**
    * Writes a record as a MessagePack map using fixmap, map 16, or map 32.
    *
+   * This method calls `openMap` to write the appropriate map header based on
+   * the number of keys in the record. It then iterates over the key-value pairs
+   * in the record, writing each key and value to the buffer using the
+   * appropriate MessagePack encoding methods.
+   *
    * ```
    * fixmap:
    * +--------+~~~~~~~~~~~~~~~~~+
@@ -795,9 +835,20 @@ interface MessagePackEncoderBuffer<TBuffer extends Uint8Array = Uint8Array> exte
    * ```
    */
   writeMap<TKey extends string | number, TValue>(value: Record<TKey, TValue>): this;
+  /**
+   * Opens a map in the buffer for writing key-value pairs. This method only
+   * writes the appropriate MessagePack map header based on the specified number
+   * of keys.
+   */
+  openMap(keysLength: number): this;
   /**
    * Writes an array using the MessagePack array format family.
    *
+   * This method calls `openArray` to write the appropriate array header based
+   * on the number of elements in the array. It then iterates over the elements
+   * in the array, writing each element to the buffer using the appropriate
+   * MessagePack encoding methods.
+   *
    * ```
    * fixarray:
    * +--------+~~~~~~~~~~~~~~~~~+
@@ -816,6 +867,12 @@ interface MessagePackEncoderBuffer<TBuffer extends Uint8Array = Uint8Array> exte
    * ```
    */
   writeArray(value: unknown[]): this;
+  /**
+   * Opens an array in the buffer for writing elements. This method only writes
+   * the appropriate MessagePack array header based on the specified number of
+   * elements.
+   */
+  openArray(length: number): this;
   /**
    * Writes a JavaScript object using the MessagePack format.
    *
@@ -912,8 +969,51 @@ interface MessagePackEncoderBuffer<TBuffer extends Uint8Array = Uint8Array> exte
    * type is a signed 8-bit integer.
    * ```
    */
-  writeExtension(extension: MessagePackExtension, buffer: ExtensionEncoderBuffer<TBuffer>): this;
+  writeExtension(extension: MessagePackExtension, buffer: ExtensionEncoder<TBuffer>): this;
+}
+//#endregion
+//#region src/encoder/types.d.ts
+interface EncoderOptions<TBuffer extends Uint8Array = Uint8Array> extends BufferOptions<TBuffer> {
+  /**
+   * The initial size of the shared buffer. Shared buffer is used to encode
+   * strings, to avoid allocating a new buffer for each string. This helps to
+   * improve performance by reducing memory allocations and garbage collection
+   * overhead.
+   *
+   * @default 1024
+   */
+  initialSharedBufferSize?: number;
+  /**
+   * A text encoder that will be used to encode strings into bytes.
+   *
+   * @default DefaultTextEncoder
+   */
+  textEncoder?: MessagePackTextEncoder<TBuffer>;
+  /**
+   * If true, the keys of objects will be sorted before encoding. This can be
+   * useful for ensuring consistent encoding of objects with the same keys but
+   * in different orders.
+   *
+   * @default false
+   */
+  sortKeys?: boolean;
+  /**
+   * If true, all floats will be encoded as float32, but it may result in loss
+   * of precision for some floats (like `1.2`), this is a JavaScript
+   * limitation.
+   *
+   * If false, floats will be encoded as float64, which is more precise but
+   * takes up more space.
+   *
+   * Set to true only if you are sure that your floats can be represented as
+   * float32 without loss of precision.
+   *
+   * @default false
+   */
+  forceFloat32?: boolean;
 }
+type OmitByPattern<TRecord, Pattern extends string> = { [TKey in keyof TRecord as TKey extends Pattern ? never : TKey]: TRecord[TKey]; };
+type ExtensionEncoder<TBuffer extends Uint8Array = Uint8Array> = OmitByPattern<MessagePackEncoder<TBuffer>, `${string}Extension` | 'resetBuffer' | 'extensions'>;
 //#endregion
 //#region src/extensions/interfaces/messagePackExtension.d.ts
 interface MessagePackExtension<TValue = unknown, TBuffer extends Uint8Array = Uint8Array> {
@@ -929,9 +1029,9 @@ interface MessagePackExtension<TValue = unknown, TBuffer extends Uint8Array = Ui
    *
    * @param value - The value to be encoded. This can be of any type, but the
    *   implementation should handle specific types as needed.
-   * @param buffer - The buffer where the encoded data will be written.
+   * @param encoder - The extension encoder where the data will be written.
    */
-  encode(value: object | bigint, buffer: MessagePackEncoderBuffer<TBuffer>): void;
+  encode(value: object | bigint, encoder: ExtensionEncoder<TBuffer>): void;
   /**
    * Decodes a value from the provided DataView starting at the specified
    * offset. The method should read the necessary bytes from the DataView,
@@ -946,5 +1046,5 @@ interface MessagePackExtension<TValue = unknown, TBuffer extends Uint8Array = Ui
   decode(decoderBuffer: MessagePackDecoderBuffer, size: number): TValue;
 }
 //#endregion
-export { OmitByPattern as a, ExtensionEncoderBuffer as i, MessagePackEncoderBuffer as n, MessagePackBufferWithExtensions as o, EncoderBufferOptions as r, MessagePackExtension as t };
-//# sourceMappingURL=messagePackExtension-C_TQXlEn.d.cts.map
+export { MessagePackEncoder as a, OmitByPattern as i, EncoderOptions as n, MessagePackBufferWithExtensions as o, ExtensionEncoder as r, MessagePackExtension as t };
+//# sourceMappingURL=messagePackExtension-DS5fpQDE.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messagePackExtension-DS5fpQDE.d.cts","names":[],"sources":["../../src/interfaces/messagePackBufferWithExtensions.ts","../../src/encoder/interfaces/messagePackEncoder.ts","../../src/encoder/types.ts","../../src/extensions/interfaces/messagePackExtension.ts"],"mappings":"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"}

package/dist/cjs/messagePackTextDecoder-J3fr-wQn.d.cts

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

package/dist/cjs/messagePackTextDecoder-J3fr-wQn.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messagePackTextDecoder-J3fr-wQn.d.cts","names":[],"sources":["../../src/decoder/interfaces/messagePackTextDecoder.ts"],"mappings":";UAAyB,uBACvB,gBAAgB,aAAa;EAE7B,OAAO,QAAQ,SAAS,qBAAqB"}

package/dist/cjs/nodeTextDecoder-DrNFdTVk.d.cts

@@ -0,0 +1,9 @@
+import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-J3fr-wQn.cjs";
+import { Buffer } from "node:buffer";
+//#region src/decoder/textDecoders/nodeTextDecoder.d.ts
+declare class NodeTextDecoder implements MessagePackTextDecoder<Buffer> {
+  decode(buffer: Buffer, start: number, end: number): string;
+}
+//#endregion
+export { NodeTextDecoder as t };
+//# sourceMappingURL=nodeTextDecoder-DrNFdTVk.d.cts.map

package/dist/cjs/nodeTextDecoder-DrNFdTVk.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeTextDecoder-DrNFdTVk.d.cts","names":[],"sources":["../../src/decoder/textDecoders/nodeTextDecoder.ts"],"mappings":";;;cAIM,2BAA2B,uBAAuB;EACtD,OAAO,QAAQ,QAAQ,eAAe"}

package/dist/cjs/{timestampDate-BtBd4bAx.d.cts → timestampDate-mzf7iMkQ.d.cts}

@@ -1,5 +1,5 @@
-import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-CMG0LPbJ.cjs";
-import { n as MessagePackEncoderBuffer, t as MessagePackExtension } from "./messagePackExtension-C_TQXlEn.cjs";
+import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-B2rRVlMX.cjs";
+import { r as ExtensionEncoder, t as MessagePackExtension } from "./messagePackExtension-DS5fpQDE.cjs";
 import { t as MessagePackTime } from "./types-B9KMW-kD.cjs";
 //#region src/extensions/timestampDate/timestampDate.d.ts
 /**
@@ -25,9 +25,9 @@ import { t as MessagePackTime } from "./types-B9KMW-kD.cjs";
 declare class TimestampDateExtension<TBuffer extends Uint8Array = Uint8Array> implements MessagePackExtension<Date, TBuffer> {
   readonly type = -1;
   parseToMessagePackTime(date: Date): MessagePackTime;
-  encode(value: object | bigint, buffer: MessagePackEncoderBuffer<TBuffer>): void;
+  encode(value: object | bigint, encoder: ExtensionEncoder<TBuffer>): void;
   decode(decoderBuffer: MessagePackDecoderBuffer<TBuffer>, size: number): Date;
 }
 //#endregion
 export { TimestampDateExtension as t };
-//# sourceMappingURL=timestampDate-BtBd4bAx.d.cts.map
+//# sourceMappingURL=timestampDate-mzf7iMkQ.d.cts.map

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

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

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

@@ -0,0 +1,9 @@
+import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-J3fr-wQn.cjs";
+import { n as BufferOptions } from "./types-DTcs4Mkd.cjs";
+//#region src/decoder/types.d.ts
+type DecoderBufferOptions<TBuffer extends Uint8Array = Uint8Array> = Pick<BufferOptions<TBuffer>, 'bufferFactory'> & {
+  textDecoder?: MessagePackTextDecoder<TBuffer>;
+};
+//#endregion
+export { DecoderBufferOptions as t };
+//# sourceMappingURL=types-CC2wkzZa.d.cts.map

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

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