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

package/dist/esm/{messagePackExtension-5TI02KG6.d.mts → messagePackExtension-BSIrLaDi.d.mts}

@@ -1,5 +1,5 @@
-import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-CGyYSweZ.mjs";
-import { t as BufferOptions } from "./types-BJie2edF.mjs";
+import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-Cqvg0zW7.mjs";
+import { n as BufferOptions } from "./types-DTcs4Mkd.mjs";
 import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-D7iCft_t.mjs";
 //#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-5TI02KG6.d.mts.map
+export { MessagePackEncoder as a, OmitByPattern as i, EncoderOptions as n, MessagePackBufferWithExtensions as o, ExtensionEncoder as r, MessagePackExtension as t };
+//# sourceMappingURL=messagePackExtension-BSIrLaDi.d.mts.map

package/dist/esm/messagePackExtension-BSIrLaDi.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messagePackExtension-BSIrLaDi.d.mts","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/esm/messagePackTextDecoder-J3fr-wQn.d.mts

@@ -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.mts.map

package/dist/esm/messagePackTextDecoder-J3fr-wQn.d.mts.map

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

package/dist/esm/nodeTextDecoder-Dhre7WkB.d.mts

@@ -0,0 +1,9 @@
+import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-J3fr-wQn.mjs";
+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-Dhre7WkB.d.mts.map

package/dist/esm/nodeTextDecoder-Dhre7WkB.d.mts.map

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

package/dist/esm/{timestampDate-C1UzHhZL.d.mts → timestampDate-CK1MD05_.d.mts}

@@ -1,5 +1,5 @@
-import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-CGyYSweZ.mjs";
-import { n as MessagePackEncoderBuffer, t as MessagePackExtension } from "./messagePackExtension-5TI02KG6.mjs";
+import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-Cqvg0zW7.mjs";
+import { r as ExtensionEncoder, t as MessagePackExtension } from "./messagePackExtension-BSIrLaDi.mjs";
 import { t as MessagePackTime } from "./types-B9KMW-kD.mjs";
 //#region src/extensions/timestampDate/timestampDate.d.ts
 /**
@@ -25,9 +25,9 @@ import { t as MessagePackTime } from "./types-B9KMW-kD.mjs";
 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-C1UzHhZL.d.mts.map
+//# sourceMappingURL=timestampDate-CK1MD05_.d.mts.map

package/dist/esm/timestampDate-CK1MD05_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestampDate-CK1MD05_.d.mts","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/esm/types-CNR_qJsr.d.mts

@@ -0,0 +1,9 @@
+import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-J3fr-wQn.mjs";
+import { n as BufferOptions } from "./types-DTcs4Mkd.mjs";
+//#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-CNR_qJsr.d.mts.map

package/dist/esm/types-CNR_qJsr.d.mts.map

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

package/dist/esm/{types-BJie2edF.d.mts → types-DTcs4Mkd.d.mts}

@@ -1,5 +1,5 @@
 //#region src/types.d.ts
-type NewBufferFn<TBuffer extends Uint8Array = Uint8Array> = (requiredSize: number) => TBuffer;
+type BufferFactory<TBuffer extends Uint8Array = Uint8Array> = (requiredSize: number) => TBuffer;
 interface BufferOptions<TBuffer extends Uint8Array = Uint8Array> {
   /**
    * The initial size of the buffer used for encoding. If the buffer is not
@@ -13,8 +13,8 @@ interface BufferOptions<TBuffer extends Uint8Array = Uint8Array> {
    *
    * @default (size) => new Uint8Array(size)
    */
-  newBufferFn?: NewBufferFn<TBuffer>;
+  bufferFactory?: BufferFactory<TBuffer>;
 }
 //#endregion
-export { NewBufferFn as n, BufferOptions as t };
-//# sourceMappingURL=types-BJie2edF.d.mts.map
+export { BufferOptions as n, BufferFactory as t };
+//# sourceMappingURL=types-DTcs4Mkd.d.mts.map

package/dist/esm/types-DTcs4Mkd.d.mts.map

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

package/dist/esm/types.d.mts

@@ -1,2 +1,2 @@
-import { n as NewBufferFn, t as BufferOptions } from "./types-BJie2edF.mjs";
-export { BufferOptions, NewBufferFn };
+import { n as BufferOptions, t as BufferFactory } from "./types-DTcs4Mkd.mjs";
+export { BufferFactory, BufferOptions };

package/dist/{cjs/untypedExtension-WQvArYoO.d.cts → esm/untypedExtension-DU4TuH0s.d.mts}

@@ -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-Cqvg0zW7.mjs";
+import { r as ExtensionEncoder, t as MessagePackExtension } from "./messagePackExtension-BSIrLaDi.mjs";
 //#region src/untypedExtension.d.ts
 declare abstract class UntypedExtension<TValue = unknown, TBuffer extends Uint8Array = Uint8Array> implements MessagePackExtension<TValue, TBuffer> {
   readonly type: number;
@@ -8,9 +8,9 @@ declare abstract class UntypedExtension<TValue = unknown, TBuffer extends Uint8A
    *   between 0 and 127, default is 0.
    */
   constructor(type?: number);
-  abstract encode(value: object | bigint, buffer: MessagePackEncoderBuffer<TBuffer>): void;
+  abstract encode(value: object | bigint, encoder: ExtensionEncoder<TBuffer>): void;
   abstract decode(decoderBuffer: MessagePackDecoderBuffer, size: number): TValue;
 }
 //#endregion
 export { UntypedExtension as t };
-//# sourceMappingURL=untypedExtension-WQvArYoO.d.cts.map
+//# sourceMappingURL=untypedExtension-DU4TuH0s.d.mts.map

package/dist/esm/{untypedExtension-6bNMj-lY.d.mts.map → untypedExtension-DU4TuH0s.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"untypedExtension-6bNMj-lY.d.mts","names":[],"sources":["../../src/untypedExtension.ts"],"mappings":";;;uBAIe,iBACb,kBACA,gBAAgB,aAAa,uBAClB,qBAAqB,QAAQ;WAC/B;;;;;EAMT,YAAY;WAIH,OACP,wBACA,QAAQ,yBAAyB;WAG1B,OACP,eAAe,0BACf,eACC"}
+{"version":3,"file":"untypedExtension-DU4TuH0s.d.mts","names":[],"sources":["../../src/untypedExtension.ts"],"mappings":";;;uBAIe,iBACb,kBACA,gBAAgB,aAAa,uBAClB,qBAAqB,QAAQ;WAC/B;;;;;EAMT,YAAY;WAIH,OACP,wBACA,SAAS,iBAAiB;WAGnB,OACP,eAAe,0BACf,eACC"}

package/dist/esm/untypedExtension.d.mts

@@ -1,2 +1,2 @@
-import { t as UntypedExtension } from "./untypedExtension-6bNMj-lY.mjs";
+import { t as UntypedExtension } from "./untypedExtension-DU4TuH0s.mjs";
 export { UntypedExtension as default };

package/dist/esm/untypedExtension.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"untypedExtension.mjs","names":[],"sources":["../../src/untypedExtension.ts"],"sourcesContent":["import type MessagePackDecoderBuffer from './decoder/interfaces/messagePackDecoderBuffer.ts';\nimport type MessagePackEncoderBuffer from './encoder/interfaces/messagePackEncoderBuffer.ts';\nimport type MessagePackExtension from './extensions/interfaces/messagePackExtension.ts';\n\nabstract class UntypedExtension<\n  TValue = unknown,\n  TBuffer extends Uint8Array = Uint8Array,\n> implements MessagePackExtension<TValue, TBuffer> {\n  readonly type: number;\n\n  /**\n   * @param type - The extension type for BigInt values. Can be a integer\n   *   between 0 and 127, default is 0.\n   */\n  constructor(type = 0) {\n    this.type = type;\n  }\n\n  abstract encode(\n    value: object | bigint,\n    buffer: MessagePackEncoderBuffer<TBuffer>,\n  ): void;\n\n  abstract decode(\n    decoderBuffer: MessagePackDecoderBuffer,\n    size: number,\n  ): TValue;\n}\n\nexport default UntypedExtension;\n"],"mappings":";AAIA,IAAe,mBAAf,MAGmD;CACjD;;;;;CAMA,YAAY,OAAO,GAAG;EACpB,KAAK,OAAO;CACd;AAWF"}
+{"version":3,"file":"untypedExtension.mjs","names":[],"sources":["../../src/untypedExtension.ts"],"sourcesContent":["import type MessagePackDecoderBuffer from './decoder/interfaces/messagePackDecoderBuffer.ts';\nimport type { ExtensionEncoder } from './encoder/types.ts';\nimport type MessagePackExtension from './extensions/interfaces/messagePackExtension.ts';\n\nabstract class UntypedExtension<\n  TValue = unknown,\n  TBuffer extends Uint8Array = Uint8Array,\n> implements MessagePackExtension<TValue, TBuffer> {\n  readonly type: number;\n\n  /**\n   * @param type - The extension type for BigInt values. Can be a integer\n   *   between 0 and 127, default is 0.\n   */\n  constructor(type = 0) {\n    this.type = type;\n  }\n\n  abstract encode(\n    value: object | bigint,\n    encoder: ExtensionEncoder<TBuffer>,\n  ): void;\n\n  abstract decode(\n    decoderBuffer: MessagePackDecoderBuffer,\n    size: number,\n  ): TValue;\n}\n\nexport default UntypedExtension;\n"],"mappings":";AAIA,IAAe,mBAAf,MAGmD;CACjD;;;;;CAMA,YAAY,OAAO,GAAG;EACpB,KAAK,OAAO;CACd;AAWF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schema-pack/message-pack",
-  "version": "0.0.0-commit.8d5dca5ce6fa2841d57d39bd48f82979461a0a69",
+  "version": "0.0.0-commit.cdc6b744227cc8ddcb9fc2fea8035c9fffab4fb5",
   "description": "MessagePack implementation",
   "keywords": [
     "MessagePack",
@@ -34,10 +34,6 @@
       "import": "./dist/esm/index.mjs",
       "require": "./dist/cjs/index.cjs"
     },
-    "./benchmark/decoderDataTypesFactory": {
-      "import": "./dist/esm/benchmark/decoderDataTypesFactory.mjs",
-      "require": "./dist/cjs/benchmark/decoderDataTypesFactory.cjs"
-    },
     "./bufferWithExtensions": {
       "import": "./dist/esm/bufferWithExtensions.mjs",
       "require": "./dist/cjs/bufferWithExtensions.cjs"
@@ -50,6 +46,10 @@
       "import": "./dist/esm/decoder/index.mjs",
       "require": "./dist/cjs/decoder/index.cjs"
     },
+    "./decoder/decode": {
+      "import": "./dist/esm/decoder/decode.mjs",
+      "require": "./dist/cjs/decoder/decode.cjs"
+    },
     "./decoder/decoder": {
       "import": "./dist/esm/decoder/decoder.mjs",
       "require": "./dist/cjs/decoder/decoder.cjs"
@@ -70,10 +70,18 @@
       "import": "./dist/esm/decoder/interfaces/messagePackTextDecoder.mjs",
       "require": "./dist/cjs/decoder/interfaces/messagePackTextDecoder.cjs"
     },
+    "./decoder/textDecoders": {
+      "import": "./dist/esm/decoder/textDecoders/index.mjs",
+      "require": "./dist/cjs/decoder/textDecoders/index.cjs"
+    },
     "./decoder/textDecoders/defaultTextDecoder": {
       "import": "./dist/esm/decoder/textDecoders/defaultTextDecoder.mjs",
       "require": "./dist/cjs/decoder/textDecoders/defaultTextDecoder.cjs"
     },
+    "./decoder/textDecoders/nodeTextDecoder": {
+      "import": "./dist/esm/decoder/textDecoders/nodeTextDecoder.mjs",
+      "require": "./dist/cjs/decoder/textDecoders/nodeTextDecoder.cjs"
+    },
     "./decoder/types": {
       "import": "./dist/esm/decoder/types.mjs",
       "require": "./dist/cjs/decoder/types.cjs"
@@ -86,21 +94,21 @@
       "import": "./dist/esm/encoder/index.mjs",
       "require": "./dist/cjs/encoder/index.cjs"
     },
+    "./encoder/encode": {
+      "import": "./dist/esm/encoder/encode.mjs",
+      "require": "./dist/cjs/encoder/encode.cjs"
+    },
     "./encoder/encoder": {
       "import": "./dist/esm/encoder/encoder.mjs",
       "require": "./dist/cjs/encoder/encoder.cjs"
     },
-    "./encoder/encoderBuffer": {
-      "import": "./dist/esm/encoder/encoderBuffer.mjs",
-      "require": "./dist/cjs/encoder/encoderBuffer.cjs"
-    },
     "./encoder/interfaces": {
       "import": "./dist/esm/encoder/interfaces/index.mjs",
       "require": "./dist/cjs/encoder/interfaces/index.cjs"
     },
-    "./encoder/interfaces/messagePackEncoderBuffer": {
-      "import": "./dist/esm/encoder/interfaces/messagePackEncoderBuffer.mjs",
-      "require": "./dist/cjs/encoder/interfaces/messagePackEncoderBuffer.cjs"
+    "./encoder/interfaces/messagePackEncoder": {
+      "import": "./dist/esm/encoder/interfaces/messagePackEncoder.mjs",
+      "require": "./dist/cjs/encoder/interfaces/messagePackEncoder.cjs"
     },
     "./encoder/interfaces/messagePackTextEncoder": {
       "import": "./dist/esm/encoder/interfaces/messagePackTextEncoder.mjs",

package/dist/cjs/benchmark/decoderDataTypesFactory.cjs

@@ -1,37 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"bigInt-CBB8PGpe.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/decoder-C1cd4I8S.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"decoder-C1cd4I8S.d.cts","names":[],"sources":["../../src/decoder/decoder.ts"],"mappings":";;;;cAUM,QAAQ,gBAAgB,aAAa;YAC/B,eAAe,cAAc;EAEvC,YAAY,UAAU,qBAAqB;EAK3C,OAAO,kBAAkB,eAAe,UAAU;EAoBlD,aAAa,WAAW,8BAA8B;EAMtD,qBACE,WAAW,8BAA8B;EAO3C,iBACE,cACA,WAAW,KAAK,8BAA8B"}

package/dist/cjs/decoderBuffer-C9_0y-3q.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"decoderBuffer-C9_0y-3q.d.cts","names":[],"sources":["../../src/decoder/decoderBuffer.ts"],"mappings":";;;;;cASM,cAAc,gBAAgB,aAAa,oBACvC,qBAAqB,oBAClB,yBAAyB;EAEpC,QAAQ;EACR;EACA,MAAM;EACN,aAAW;EAEX,YAAY,UAAU,qBAAqB;EAY3C,UAAU,QAAQ;EAYlB,UAAU;EAcV,QAAQ;EAkDR;EAIA,QAAQ,iBAAiB;EAoBzB,kBAAkB;EAgLlB,UAAU,qBAAqB"}