@schema-pack/message-pack 0.0.0-commit.03ddd0427843dd0e1b45dcd0325ecf52097255a4 → 0.0.0-commit.56d3200cf684346bbdb90bed64d3516657fdaaec

package/dist/cjs/{encoderBuffer-3ur0iCYR.d.cts → encoder-BliskZYy.d.cts}

@@ -1,9 +1,9 @@
-import { i as ExtensionEncoderBuffer, n as MessagePackEncoderBuffer, r as EncoderBufferOptions, t as MessagePackExtension } from "./messagePackExtension-Cd99Rw9t.cjs";
 import { t as BufferFactory } from "./types-DTcs4Mkd.cjs";
+import { a as MessagePackEncoder, n as EncoderOptions, r as ExtensionEncoder, t as MessagePackExtension } from "./messagePackExtension-xBTe48A-.cjs";
 import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-D7iCft_t.cjs";
-import { t as BufferWithExtensions } from "./bufferWithExtensions-n6DtcUoA.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-qiA6axeV.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;
@@ -39,8 +39,8 @@ declare class EncoderBuffer<TBuffer extends Uint8Array = Uint8Array> extends Buf
   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;
@@ -100,12 +100,12 @@ declare class EncoderBuffer<TBuffer extends Uint8Array = Uint8Array> extends Buf
   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-3ur0iCYR.d.cts.map
+export { Encoder as t };
+//# sourceMappingURL=encoder-BliskZYy.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encoder-BliskZYy.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;EAOpB,SAAS,OAAO;EAQhB,aAAa;EAOb,aAAa;EAOb,WAAW;EAMX,YAAY;EAOZ,YAAY;EAOZ,YAAY;EAaZ,UAAU;EAMV,WAAW;EAOX,WAAW;EAOX,WAAW;EA0BX,SAAS;EAMT;EAMA;EAMA;EAMA,kBAAkB;EAMlB,oBAAoB;EAMpB,kBAAkB;EAMlB,gBAAgB;EAOhB,iBAAiB;EAQjB,iBAAiB;EAQjB;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA,gBAAgB;EAOhB,iBAAiB;EASjB,iBAAiB;EASjB,mBAAmB;EASnB,mBAAmB;EASnB,iBAAiB;EASjB,iBAAiB;EASjB,mBAAmB;EAOnB,mBAAmB;EAOnB,mBAAmB;EAOnB,mBAAmB;EAOnB,oBAAoB;EAOpB,gBAAgB,cAAc;EAQ9B,iBAAiB,cAAc;EAW/B,iBAAiB,cAAc;EAW/B,YAAY;EAyGZ,YAAY;EA0EZ,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-BdjzezQQ.cjs";
+import { t as BigIntExtension } from "../../bigInt-ALGpR4Rn.cjs";
 export = BigIntExtension;

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

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

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

@@ -1,4 +1,4 @@
-import { t as MessagePackExtension } from "../messagePackExtension-Cd99Rw9t.cjs";
+import { t as MessagePackExtension } from "../messagePackExtension-xBTe48A-.cjs";
 import { t as MessagePackTime } from "../types-B9KMW-kD.cjs";
-import { t as TimestampDateExtension } from "../timestampDate-Bi1rnvVd.cjs";
+import { t as TimestampDateExtension } from "../timestampDate-B8IXKYcA.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-Cd99Rw9t.cjs";
+import { t as MessagePackExtension } from "../../messagePackExtension-xBTe48A-.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-Cd99Rw9t.cjs";
+import { t as MessagePackExtension } from "../../messagePackExtension-xBTe48A-.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-Bi1rnvVd.cjs";
+import { t as TimestampDateExtension } from "../../timestampDate-B8IXKYcA.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-Bi1rnvVd.cjs";
+import { t as TimestampDateExtension } from "../../timestampDate-B8IXKYcA.cjs";
 export = TimestampDateExtension;

package/dist/cjs/index.cjs

@@ -8,7 +8,6 @@ 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_textDecoders_defaultTextDecoder = require("./decoder/textDecoders/defaultTextDecoder.cjs");
@@ -31,7 +30,6 @@ 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;

package/dist/cjs/index.d.cts

@@ -1,27 +1,26 @@
 import decoderDataTypesFactory from "./benchmark/decoderDataTypesFactory.cjs";
 import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-J3fr-wQn.cjs";
 import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-B2rRVlMX.cjs";
-import { a as OmitByPattern, i as ExtensionEncoderBuffer, n as MessagePackEncoderBuffer, o as MessagePackBufferWithExtensions, r as EncoderBufferOptions, t as MessagePackExtension } from "./messagePackExtension-Cd99Rw9t.cjs";
+import { a as MessagePackEncoder, i as OmitByPattern, n as EncoderOptions, o as MessagePackBufferWithExtensions, r as ExtensionEncoder, t as MessagePackExtension } from "./messagePackExtension-xBTe48A-.cjs";
 import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-D7iCft_t.cjs";
-import { t as BufferWithExtensions } from "./bufferWithExtensions-n6DtcUoA.cjs";
+import { t as BufferWithExtensions } from "./bufferWithExtensions-qiA6axeV.cjs";
 import { DEFAULT_ALLOCATION_SIZE, INT32_MIN, INT64_MIN, UINT32_MAX, UINT64_MAX } from "./constants.cjs";
 import { t as decode } from "./decode-BraWmoPw.cjs";
 import { t as DefaultTextDecoder } from "./defaultTextDecoder-DY92jDSO.cjs";
-import { t as DecoderBuffer } from "./decoderBuffer-CJU2hdt2.cjs";
-import { t as Decoder } from "./decoder-3WpVBZjY.cjs";
+import { t as DecoderBuffer } from "./decoderBuffer-BFoz1PcE.cjs";
+import { t as Decoder } from "./decoder-BugzrbIU.cjs";
 import { t as NodeTextDecoder } from "./nodeTextDecoder-DrNFdTVk.cjs";
 import { t as encode } from "./encode-4SxHVw0M.cjs";
-import { t as EncoderBuffer } from "./encoderBuffer-3ur0iCYR.cjs";
-import { t as Encoder } from "./encoder-B-rTvI4P.cjs";
+import { t as Encoder } from "./encoder-BliskZYy.cjs";
 import { t as DefaultTextEncoder } from "./defaultTextEncoder-DzdGBX6s.cjs";
 import { t as NodeTextEncoder } from "./nodeTextEncoder-DJzFDBXd.cjs";
-import { t as UntypedExtension } from "./untypedExtension-wx6-_4mg.cjs";
+import { t as UntypedExtension } from "./untypedExtension-DPZG3pQo.cjs";
 import { t as MessagePackTime } from "./types-B9KMW-kD.cjs";
-import { t as TimestampDateExtension } from "./timestampDate-Bi1rnvVd.cjs";
+import { t as TimestampDateExtension } from "./timestampDate-B8IXKYcA.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, DefaultTextDecoder, 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, NodeTextDecoder, NodeTextEncoder, type OmitByPattern, Symbols, TimestampDateExtension, UINT32_MAX, UINT64_MAX, UntypedExtension, decode, decoderDataTypesFactory, encode, 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, decoderDataTypesFactory, encode, fitIn16Bits, fitIn32Bits, fitIn7Bits, fitIn8Bits, fitInt64Bits };

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

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

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

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

package/dist/cjs/{messagePackExtension-Cd99Rw9t.d.cts → messagePackExtension-xBTe48A-.d.cts}

@@ -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
@@ -934,9 +891,52 @@ 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> {
   /**
@@ -951,9 +951,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,
@@ -968,5 +968,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-Cd99Rw9t.d.cts.map
+export { MessagePackEncoder as a, OmitByPattern as i, EncoderOptions as n, MessagePackBufferWithExtensions as o, ExtensionEncoder as r, MessagePackExtension as t };
+//# sourceMappingURL=messagePackExtension-xBTe48A-.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messagePackExtension-xBTe48A-.d.cts","names":[],"sources":["../../src/interfaces/messagePackBufferWithExtensions.ts","../../src/encoder/interfaces/messagePackEncoder.ts","../../src/encoder/types.ts","../../src/extensions/interfaces/messagePackExtension.ts"],"mappings":";;;;UAEyB,gCACvB,gBAAgB,aAAa;;;;;;;;EAS7B,aAAa,WAAW,8BAA8B;;;;;;;;;UCF/B,mBACvB,gBAAgB,aAAa,oBACrB,gCAAgC;;;;;;EAMxC,QAAQ;;;;;;EAOR;;;;;;;EAQA,MAAM;;;;;WAMG,aAAa;;;;;;;;;;;;;;;;EAiBtB,eAAe;;;;;;;;EASf,aAAa;;;;;;EAOb;;;;;;EAOA,SAAS;;;;;;;;;;;;;EAcT,oBAAoB;;;;;;;;;;;;EAapB,oBAAoB;;;;;;;;;;EAWpB,SAAS,OAAO;;;;;;;;;;;;EAahB,aAAa;;;;;;;;;;;;EAab,aAAa;;;;;;;;;;;EAYb,WAAW;;;;;;;;;;;EAYX,YAAY;;;;;;;;;;;EAYZ,YAAY;;;;;;;;;;;EAYZ,YAAY;;;;;;;;;;;EAYZ,UAAU;;;;;;;;;;;EAYV,WAAW;;;;;;;;;;;EAYX,WAAW;;;;;;;;;;;EAYX,WAAW;;;;;;;;;;EAWX,SAAS;;;;;;;;;;;;EAaT;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;;EAaA,kBAAkB;;;;;;;;;;;;EAalB,oBAAoB;;;;;;;;;;;;EAapB,kBAAkB;;;;;;;;;;;;EAalB,gBAAgB;;;;;;;;;;;;EAahB,iBAAiB;;;;;;;;;;;;EAajB,iBAAiB;;;;;;;;;;;EAYjB;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;EAYA;;;;;;;;;;;;EAaA,gBAAgB;;;;;;;;;;;;EAahB,iBAAiB;;;;;;;;;;;;EAajB,iBAAiB;;;;;;;;;;;;EAajB,mBAAmB;;;;;;;;;;;;EAanB,mBAAmB;;;;;;;;;;;;EAanB,iBAAiB;;;;;;;;;;;;EAajB,iBAAiB;;;;;;;;;;;;EAajB,mBAAmB;;;;;;;;;;;;EAanB,mBAAmB;;;;;;;;;;;;EAanB,mBAAmB;;;;;;;;;;;;EAanB,mBAAmB;;;;;;;;;;;;EAanB,oBAAoB;;;;;;;;;;;;EAapB,gBAAgB,cAAc;;;;;;;;;;;;EAa9B,iBAAiB,cAAc;;;;;;;;;;;;EAa/B,iBAAiB,cAAc;;;;;;EAO/B,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BN,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmEZ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BZ,SAAS,8BAA8B,QACrC,OAAO,OAAO,MAAM;;;;;;EAQtB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BR,WAAW;;;;;;EAOX,UAAU;;;;;;;EAQV,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCZ,gBAAgB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DvB,eACE,WAAW,sBACX,QAAQ,iBAAiB;;;;UCz7BZ,eACf,gBAAgB,aAAa,oBACrB,cAAc;;;;;;;;;EAStB;;;;;;EAMA,cAAc,uBAAuB;;;;;;;;EAQrC;;;;;;;;;;;;;;EAcA;;KAGU,cAAc,SAAS,6BAChC,cAAc,WAAW,aAAa,kBAAkB,OAAO,QAAQ;KAG9D,iBAAiB,gBAAgB,aAAa,cACxD,cACE,mBAAmB;;;UCjDE,qBACvB,kBACA,gBAAgB,aAAa;;;;;;WAOpB;;;;;;;;;EAUT,OAAO,wBAAwB,SAAS,iBAAiB;;;;;;;;;;;;EAazD,OAAO,eAAe,0BAA0B,eAAe"}

package/dist/cjs/{timestampDate-Bi1rnvVd.d.cts → timestampDate-B8IXKYcA.d.cts}

@@ -1,5 +1,5 @@
 import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-B2rRVlMX.cjs";
-import { n as MessagePackEncoderBuffer, t as MessagePackExtension } from "./messagePackExtension-Cd99Rw9t.cjs";
+import { r as ExtensionEncoder, t as MessagePackExtension } from "./messagePackExtension-xBTe48A-.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-Bi1rnvVd.d.cts.map
+//# sourceMappingURL=timestampDate-B8IXKYcA.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timestampDate-B8IXKYcA.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/{untypedExtension-wx6-_4mg.d.cts → untypedExtension-DPZG3pQo.d.cts}

@@ -1,5 +1,5 @@
 import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-B2rRVlMX.cjs";
-import { n as MessagePackEncoderBuffer, t as MessagePackExtension } from "./messagePackExtension-Cd99Rw9t.cjs";
+import { r as ExtensionEncoder, t as MessagePackExtension } from "./messagePackExtension-xBTe48A-.cjs";
 //#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-wx6-_4mg.d.cts.map
+//# sourceMappingURL=untypedExtension-DPZG3pQo.d.cts.map

package/dist/cjs/{untypedExtension-wx6-_4mg.d.cts.map → untypedExtension-DPZG3pQo.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"untypedExtension-wx6-_4mg.d.cts","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-DPZG3pQo.d.cts","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/cjs/untypedExtension.d.cts

@@ -1,2 +1,2 @@
-import { t as UntypedExtension } from "./untypedExtension-wx6-_4mg.cjs";
+import { t as UntypedExtension } from "./untypedExtension-DPZG3pQo.cjs";
 export = UntypedExtension;

package/dist/esm/benchmark/decoderDataTypesFactory.mjs

@@ -3,35 +3,35 @@ import { dataTypesFactory } from "@schema-pack/benchmark";
 //#region src/benchmark/decoderDataTypesFactory.ts
 const encoder = new Encoder();
 const decoderDataTypesFactory = {
-	array16: () => encoder.encode(dataTypesFactory.array16()),
-	array32: () => encoder.encode(dataTypesFactory.array32()),
-	bin16: () => encoder.encode(dataTypesFactory.bin16()),
-	bin32: () => encoder.encode(dataTypesFactory.bin32()),
-	bin8: () => encoder.encode(dataTypesFactory.bin8()),
-	false: () => encoder.encode(dataTypesFactory.false()),
-	fixarray: () => encoder.encode(dataTypesFactory.fixarray()),
-	fixmap: () => encoder.encode(dataTypesFactory.fixmap()),
-	fixstr: () => encoder.encode(dataTypesFactory.fixstr()),
-	float32: () => encoder.encode(dataTypesFactory.float32()),
-	float64: () => encoder.encode(dataTypesFactory.float64()),
-	int16: () => encoder.encode(dataTypesFactory.int16()),
-	int32: () => encoder.encode(dataTypesFactory.int32()),
-	int64: () => encoder.encode(dataTypesFactory.int64()),
-	int8: () => encoder.encode(dataTypesFactory.int8()),
-	map16: () => encoder.encode(dataTypesFactory.map16()),
-	map32: () => encoder.encode(dataTypesFactory.map32()),
-	negativeFixint: () => encoder.encode(dataTypesFactory.negativeFixint()),
-	nil: () => encoder.encode(dataTypesFactory.nil()),
-	positiveFixint: () => encoder.encode(dataTypesFactory.positiveFixint()),
-	str16: () => encoder.encode(dataTypesFactory.str16()),
-	str32: () => encoder.encode(dataTypesFactory.str32()),
-	str8: () => encoder.encode(dataTypesFactory.str8()),
-	true: () => encoder.encode(dataTypesFactory.true()),
-	uint16: () => encoder.encode(dataTypesFactory.uint16()),
-	uint32: () => encoder.encode(dataTypesFactory.uint32()),
-	uint64: () => encoder.encode(dataTypesFactory.uint64()),
-	uint8: () => encoder.encode(dataTypesFactory.uint8()),
-	undefined: () => encoder.encode(dataTypesFactory.undefined())
+	array16: () => encoder.write(dataTypesFactory.array16()).flush(),
+	array32: () => encoder.write(dataTypesFactory.array32()).flush(),
+	bin16: () => encoder.write(dataTypesFactory.bin16()).flush(),
+	bin32: () => encoder.write(dataTypesFactory.bin32()).flush(),
+	bin8: () => encoder.write(dataTypesFactory.bin8()).flush(),
+	false: () => encoder.write(dataTypesFactory.false()).flush(),
+	fixarray: () => encoder.write(dataTypesFactory.fixarray()).flush(),
+	fixmap: () => encoder.write(dataTypesFactory.fixmap()).flush(),
+	fixstr: () => encoder.write(dataTypesFactory.fixstr()).flush(),
+	float32: () => encoder.write(dataTypesFactory.float32()).flush(),
+	float64: () => encoder.write(dataTypesFactory.float64()).flush(),
+	int16: () => encoder.write(dataTypesFactory.int16()).flush(),
+	int32: () => encoder.write(dataTypesFactory.int32()).flush(),
+	int64: () => encoder.write(dataTypesFactory.int64()).flush(),
+	int8: () => encoder.write(dataTypesFactory.int8()).flush(),
+	map16: () => encoder.write(dataTypesFactory.map16()).flush(),
+	map32: () => encoder.write(dataTypesFactory.map32()).flush(),
+	negativeFixint: () => encoder.write(dataTypesFactory.negativeFixint()).flush(),
+	nil: () => encoder.write(dataTypesFactory.nil()).flush(),
+	positiveFixint: () => encoder.write(dataTypesFactory.positiveFixint()).flush(),
+	str16: () => encoder.write(dataTypesFactory.str16()).flush(),
+	str32: () => encoder.write(dataTypesFactory.str32()).flush(),
+	str8: () => encoder.write(dataTypesFactory.str8()).flush(),
+	true: () => encoder.write(dataTypesFactory.true()).flush(),
+	uint16: () => encoder.write(dataTypesFactory.uint16()).flush(),
+	uint32: () => encoder.write(dataTypesFactory.uint32()).flush(),
+	uint64: () => encoder.write(dataTypesFactory.uint64()).flush(),
+	uint8: () => encoder.write(dataTypesFactory.uint8()).flush(),
+	undefined: () => encoder.write(dataTypesFactory.undefined()).flush()
 };
 //#endregion
 export { decoderDataTypesFactory as default };

package/dist/esm/benchmark/decoderDataTypesFactory.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"decoderDataTypesFactory.mjs","names":[],"sources":["../../../src/benchmark/decoderDataTypesFactory.ts"],"sourcesContent":["import { dataTypesFactory } from '@schema-pack/benchmark';\n\nimport Encoder from '../encoder/encoder.ts';\n\nconst encoder = new Encoder();\n\nconst decoderDataTypesFactory: Record<\n  keyof typeof dataTypesFactory,\n  () => Uint8Array\n> = {\n  array16: () => encoder.encode(dataTypesFactory.array16()),\n  array32: () => encoder.encode(dataTypesFactory.array32()),\n  // bigint: () => encoder.encode(dataTypesFactory.bigint()),\n  bin16: () => encoder.encode(dataTypesFactory.bin16()),\n  bin32: () => encoder.encode(dataTypesFactory.bin32()),\n  bin8: () => encoder.encode(dataTypesFactory.bin8()),\n  false: () => encoder.encode(dataTypesFactory.false()),\n  fixarray: () => encoder.encode(dataTypesFactory.fixarray()),\n  fixmap: () => encoder.encode(dataTypesFactory.fixmap()),\n  fixstr: () => encoder.encode(dataTypesFactory.fixstr()),\n  float32: () => encoder.encode(dataTypesFactory.float32()),\n  float64: () => encoder.encode(dataTypesFactory.float64()),\n  int16: () => encoder.encode(dataTypesFactory.int16()),\n  int32: () => encoder.encode(dataTypesFactory.int32()),\n  int64: () => encoder.encode(dataTypesFactory.int64()),\n  int8: () => encoder.encode(dataTypesFactory.int8()),\n  map16: () => encoder.encode(dataTypesFactory.map16()),\n  map32: () => encoder.encode(dataTypesFactory.map32()),\n  negativeFixint: () => encoder.encode(dataTypesFactory.negativeFixint()),\n  nil: () => encoder.encode(dataTypesFactory.nil()),\n  positiveFixint: () => encoder.encode(dataTypesFactory.positiveFixint()),\n  str16: () => encoder.encode(dataTypesFactory.str16()),\n  str32: () => encoder.encode(dataTypesFactory.str32()),\n  str8: () => encoder.encode(dataTypesFactory.str8()),\n  true: () => encoder.encode(dataTypesFactory.true()),\n  uint16: () => encoder.encode(dataTypesFactory.uint16()),\n  uint32: () => encoder.encode(dataTypesFactory.uint32()),\n  uint64: () => encoder.encode(dataTypesFactory.uint64()),\n  uint8: () => encoder.encode(dataTypesFactory.uint8()),\n  // oxlint-disable-next-line typescript/no-confusing-void-expression\n  undefined: () => encoder.encode(dataTypesFactory.undefined()),\n};\n\nexport default decoderDataTypesFactory;\n"],"mappings":";;;AAIA,MAAM,UAAU,IAAI,QAAQ;AAE5B,MAAM,0BAGF;CACF,eAAe,QAAQ,OAAO,iBAAiB,QAAQ,CAAC;CACxD,eAAe,QAAQ,OAAO,iBAAiB,QAAQ,CAAC;CAExD,aAAa,QAAQ,OAAO,iBAAiB,MAAM,CAAC;CACpD,aAAa,QAAQ,OAAO,iBAAiB,MAAM,CAAC;CACpD,YAAY,QAAQ,OAAO,iBAAiB,KAAK,CAAC;CAClD,aAAa,QAAQ,OAAO,iBAAiB,MAAM,CAAC;CACpD,gBAAgB,QAAQ,OAAO,iBAAiB,SAAS,CAAC;CAC1D,cAAc,QAAQ,OAAO,iBAAiB,OAAO,CAAC;CACtD,cAAc,QAAQ,OAAO,iBAAiB,OAAO,CAAC;CACtD,eAAe,QAAQ,OAAO,iBAAiB,QAAQ,CAAC;CACxD,eAAe,QAAQ,OAAO,iBAAiB,QAAQ,CAAC;CACxD,aAAa,QAAQ,OAAO,iBAAiB,MAAM,CAAC;CACpD,aAAa,QAAQ,OAAO,iBAAiB,MAAM,CAAC;CACpD,aAAa,QAAQ,OAAO,iBAAiB,MAAM,CAAC;CACpD,YAAY,QAAQ,OAAO,iBAAiB,KAAK,CAAC;CAClD,aAAa,QAAQ,OAAO,iBAAiB,MAAM,CAAC;CACpD,aAAa,QAAQ,OAAO,iBAAiB,MAAM,CAAC;CACpD,sBAAsB,QAAQ,OAAO,iBAAiB,eAAe,CAAC;CACtE,WAAW,QAAQ,OAAO,iBAAiB,IAAI,CAAC;CAChD,sBAAsB,QAAQ,OAAO,iBAAiB,eAAe,CAAC;CACtE,aAAa,QAAQ,OAAO,iBAAiB,MAAM,CAAC;CACpD,aAAa,QAAQ,OAAO,iBAAiB,MAAM,CAAC;CACpD,YAAY,QAAQ,OAAO,iBAAiB,KAAK,CAAC;CAClD,YAAY,QAAQ,OAAO,iBAAiB,KAAK,CAAC;CAClD,cAAc,QAAQ,OAAO,iBAAiB,OAAO,CAAC;CACtD,cAAc,QAAQ,OAAO,iBAAiB,OAAO,CAAC;CACtD,cAAc,QAAQ,OAAO,iBAAiB,OAAO,CAAC;CACtD,aAAa,QAAQ,OAAO,iBAAiB,MAAM,CAAC;CAEpD,iBAAiB,QAAQ,OAAO,iBAAiB,UAAU,CAAC;AAC9D"}
+{"version":3,"file":"decoderDataTypesFactory.mjs","names":[],"sources":["../../../src/benchmark/decoderDataTypesFactory.ts"],"sourcesContent":["import { dataTypesFactory } from '@schema-pack/benchmark';\n\nimport Encoder from '../encoder/encoder.ts';\n\nconst encoder = new Encoder();\n\nconst decoderDataTypesFactory: Record<\n  keyof typeof dataTypesFactory,\n  () => Uint8Array\n> = {\n  array16: () => encoder.write(dataTypesFactory.array16()).flush(),\n  array32: () => encoder.write(dataTypesFactory.array32()).flush(),\n  // bigint: () => encoder.write(dataTypesFactory.bigint()).flush(),\n  bin16: () => encoder.write(dataTypesFactory.bin16()).flush(),\n  bin32: () => encoder.write(dataTypesFactory.bin32()).flush(),\n  bin8: () => encoder.write(dataTypesFactory.bin8()).flush(),\n  false: () => encoder.write(dataTypesFactory.false()).flush(),\n  fixarray: () => encoder.write(dataTypesFactory.fixarray()).flush(),\n  fixmap: () => encoder.write(dataTypesFactory.fixmap()).flush(),\n  fixstr: () => encoder.write(dataTypesFactory.fixstr()).flush(),\n  float32: () => encoder.write(dataTypesFactory.float32()).flush(),\n  float64: () => encoder.write(dataTypesFactory.float64()).flush(),\n  int16: () => encoder.write(dataTypesFactory.int16()).flush(),\n  int32: () => encoder.write(dataTypesFactory.int32()).flush(),\n  int64: () => encoder.write(dataTypesFactory.int64()).flush(),\n  int8: () => encoder.write(dataTypesFactory.int8()).flush(),\n  map16: () => encoder.write(dataTypesFactory.map16()).flush(),\n  map32: () => encoder.write(dataTypesFactory.map32()).flush(),\n  negativeFixint: () =>\n    encoder.write(dataTypesFactory.negativeFixint()).flush(),\n  nil: () => encoder.write(dataTypesFactory.nil()).flush(),\n  positiveFixint: () =>\n    encoder.write(dataTypesFactory.positiveFixint()).flush(),\n  str16: () => encoder.write(dataTypesFactory.str16()).flush(),\n  str32: () => encoder.write(dataTypesFactory.str32()).flush(),\n  str8: () => encoder.write(dataTypesFactory.str8()).flush(),\n  true: () => encoder.write(dataTypesFactory.true()).flush(),\n  uint16: () => encoder.write(dataTypesFactory.uint16()).flush(),\n  uint32: () => encoder.write(dataTypesFactory.uint32()).flush(),\n  uint64: () => encoder.write(dataTypesFactory.uint64()).flush(),\n  uint8: () => encoder.write(dataTypesFactory.uint8()).flush(),\n  // oxlint-disable-next-line typescript/no-confusing-void-expression\n  undefined: () => encoder.write(dataTypesFactory.undefined()).flush(),\n};\n\nexport default decoderDataTypesFactory;\n"],"mappings":";;;AAIA,MAAM,UAAU,IAAI,QAAQ;AAE5B,MAAM,0BAGF;CACF,eAAe,QAAQ,MAAM,iBAAiB,QAAQ,CAAC,CAAC,CAAC,MAAM;CAC/D,eAAe,QAAQ,MAAM,iBAAiB,QAAQ,CAAC,CAAC,CAAC,MAAM;CAE/D,aAAa,QAAQ,MAAM,iBAAiB,MAAM,CAAC,CAAC,CAAC,MAAM;CAC3D,aAAa,QAAQ,MAAM,iBAAiB,MAAM,CAAC,CAAC,CAAC,MAAM;CAC3D,YAAY,QAAQ,MAAM,iBAAiB,KAAK,CAAC,CAAC,CAAC,MAAM;CACzD,aAAa,QAAQ,MAAM,iBAAiB,MAAM,CAAC,CAAC,CAAC,MAAM;CAC3D,gBAAgB,QAAQ,MAAM,iBAAiB,SAAS,CAAC,CAAC,CAAC,MAAM;CACjE,cAAc,QAAQ,MAAM,iBAAiB,OAAO,CAAC,CAAC,CAAC,MAAM;CAC7D,cAAc,QAAQ,MAAM,iBAAiB,OAAO,CAAC,CAAC,CAAC,MAAM;CAC7D,eAAe,QAAQ,MAAM,iBAAiB,QAAQ,CAAC,CAAC,CAAC,MAAM;CAC/D,eAAe,QAAQ,MAAM,iBAAiB,QAAQ,CAAC,CAAC,CAAC,MAAM;CAC/D,aAAa,QAAQ,MAAM,iBAAiB,MAAM,CAAC,CAAC,CAAC,MAAM;CAC3D,aAAa,QAAQ,MAAM,iBAAiB,MAAM,CAAC,CAAC,CAAC,MAAM;CAC3D,aAAa,QAAQ,MAAM,iBAAiB,MAAM,CAAC,CAAC,CAAC,MAAM;CAC3D,YAAY,QAAQ,MAAM,iBAAiB,KAAK,CAAC,CAAC,CAAC,MAAM;CACzD,aAAa,QAAQ,MAAM,iBAAiB,MAAM,CAAC,CAAC,CAAC,MAAM;CAC3D,aAAa,QAAQ,MAAM,iBAAiB,MAAM,CAAC,CAAC,CAAC,MAAM;CAC3D,sBACE,QAAQ,MAAM,iBAAiB,eAAe,CAAC,CAAC,CAAC,MAAM;CACzD,WAAW,QAAQ,MAAM,iBAAiB,IAAI,CAAC,CAAC,CAAC,MAAM;CACvD,sBACE,QAAQ,MAAM,iBAAiB,eAAe,CAAC,CAAC,CAAC,MAAM;CACzD,aAAa,QAAQ,MAAM,iBAAiB,MAAM,CAAC,CAAC,CAAC,MAAM;CAC3D,aAAa,QAAQ,MAAM,iBAAiB,MAAM,CAAC,CAAC,CAAC,MAAM;CAC3D,YAAY,QAAQ,MAAM,iBAAiB,KAAK,CAAC,CAAC,CAAC,MAAM;CACzD,YAAY,QAAQ,MAAM,iBAAiB,KAAK,CAAC,CAAC,CAAC,MAAM;CACzD,cAAc,QAAQ,MAAM,iBAAiB,OAAO,CAAC,CAAC,CAAC,MAAM;CAC7D,cAAc,QAAQ,MAAM,iBAAiB,OAAO,CAAC,CAAC,CAAC,MAAM;CAC7D,cAAc,QAAQ,MAAM,iBAAiB,OAAO,CAAC,CAAC,CAAC,MAAM;CAC7D,aAAa,QAAQ,MAAM,iBAAiB,MAAM,CAAC,CAAC,CAAC,MAAM;CAE3D,iBAAiB,QAAQ,MAAM,iBAAiB,UAAU,CAAC,CAAC,CAAC,MAAM;AACrE"}

package/dist/esm/{bigInt-D37SPzzB.d.mts → bigInt-lSrNuXkn.d.mts}

@@ -1,6 +1,6 @@
 import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-Cqvg0zW7.mjs";
-import { i as ExtensionEncoderBuffer } from "./messagePackExtension-fq36EMAg.mjs";
-import { t as UntypedExtension } from "./untypedExtension-Ckk9RwQw.mjs";
+import { r as ExtensionEncoder } from "./messagePackExtension-Ceq7jzFB.mjs";
+import { t as UntypedExtension } from "./untypedExtension-DKgyS2ak.mjs";
 //#region src/extensions/bigint/bigInt.d.ts
 /**
  * This class encodes and decodes JavaScript BigInt values that are outside the
@@ -20,9 +20,9 @@ declare class BigIntExtension<TBuffer extends Uint8Array = Uint8Array> extends U
    * 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: object | bigint, buffer: ExtensionEncoderBuffer<TBuffer>): void;
+  encode(value: object | bigint, encoder: ExtensionEncoder<TBuffer>): void;
   /**
    * Decodes a BigInt value from the provided DataView. It reads the encoded
    * data, reconstructs the magnitude, and determines the sign based on the
@@ -32,4 +32,4 @@ declare class BigIntExtension<TBuffer extends Uint8Array = Uint8Array> extends U
 }
 //#endregion
 export { BigIntExtension as t };
-//# sourceMappingURL=bigInt-D37SPzzB.d.mts.map
+//# sourceMappingURL=bigInt-lSrNuXkn.d.mts.map

package/dist/esm/bigInt-lSrNuXkn.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigInt-lSrNuXkn.d.mts","names":[],"sources":["../../src/extensions/bigint/bigInt.ts"],"mappings":";;;;;;;;;;;;cAcM,gBACJ,gBAAgB,aAAa,oBACrB,yBAAyB;;;;;;;;;;;;EAYjC,OAAO,wBAAwB,SAAS,iBAAiB;;;;;;EA4BzD,OAAO,QAAQ,0BAA0B"}

package/dist/{cjs/bufferWithExtensions-n6DtcUoA.d.cts → esm/bufferWithExtensions-Bc7vjIkw.d.mts}

@@ -1,4 +1,4 @@
-import { o as MessagePackBufferWithExtensions, t as MessagePackExtension } from "./messagePackExtension-Cd99Rw9t.cjs";
+import { o as MessagePackBufferWithExtensions, t as MessagePackExtension } from "./messagePackExtension-Ceq7jzFB.mjs";
 //#region src/bufferWithExtensions.d.ts
 declare abstract class BufferWithExtensions<TBuffer extends Uint8Array = Uint8Array> implements MessagePackBufferWithExtensions<TBuffer> {
   protected extensions: Map<number, MessagePackExtension<unknown, TBuffer>>;
@@ -9,4 +9,4 @@ declare abstract class BufferWithExtensions<TBuffer extends Uint8Array = Uint8Ar
 }
 //#endregion
 export { BufferWithExtensions as t };
-//# sourceMappingURL=bufferWithExtensions-n6DtcUoA.d.cts.map
+//# sourceMappingURL=bufferWithExtensions-Bc7vjIkw.d.mts.map

package/dist/{cjs/bufferWithExtensions-n6DtcUoA.d.cts.map → esm/bufferWithExtensions-Bc7vjIkw.d.mts.map}

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

package/dist/esm/bufferWithExtensions.d.mts

@@ -1,2 +1,2 @@
-import { t as BufferWithExtensions } from "./bufferWithExtensions-DzAs7yX1.mjs";
+import { t as BufferWithExtensions } from "./bufferWithExtensions-Bc7vjIkw.mjs";
 export { BufferWithExtensions as default };

package/dist/esm/decoder/decoder.d.mts

@@ -1,2 +1,2 @@
-import { t as Decoder } from "../decoder-ByAWOgvm.mjs";
+import { t as Decoder } from "../decoder-CQrtmASU.mjs";
 export { Decoder as default };

package/dist/esm/decoder/decoderBuffer.d.mts

@@ -1,2 +1,2 @@
-import { t as DecoderBuffer } from "../decoderBuffer-93dMcsbx.mjs";
+import { t as DecoderBuffer } from "../decoderBuffer-BKic0U2F.mjs";
 export { DecoderBuffer as default };

package/dist/esm/decoder/index.d.mts

@@ -2,7 +2,7 @@ import { t as MessagePackTextDecoder } from "../messagePackTextDecoder-J3fr-wQn.
 import { t as MessagePackDecoderBuffer } from "../messagePackDecoderBuffer-Cqvg0zW7.mjs";
 import { t as decode } from "../decode-BraWmoPw.mjs";
 import { t as DefaultTextDecoder } from "../defaultTextDecoder-DztyzoBV.mjs";
-import { t as DecoderBuffer } from "../decoderBuffer-93dMcsbx.mjs";
-import { t as Decoder } from "../decoder-ByAWOgvm.mjs";
+import { t as DecoderBuffer } from "../decoderBuffer-BKic0U2F.mjs";
+import { t as Decoder } from "../decoder-CQrtmASU.mjs";
 import { t as NodeTextDecoder } from "../nodeTextDecoder-Dhre7WkB.mjs";
 export { Decoder, DecoderBuffer, DefaultTextDecoder, type MessagePackDecoderBuffer, type MessagePackTextDecoder, NodeTextDecoder, decode };

package/dist/esm/{decoder-ByAWOgvm.d.mts → decoder-CQrtmASU.d.mts}

@@ -1,6 +1,6 @@
-import { t as MessagePackExtension } from "./messagePackExtension-fq36EMAg.mjs";
+import { t as MessagePackExtension } from "./messagePackExtension-Ceq7jzFB.mjs";
 import { t as DecoderBufferOptions } from "./types-CNR_qJsr.mjs";
-import { t as DecoderBuffer } from "./decoderBuffer-93dMcsbx.mjs";
+import { t as DecoderBuffer } from "./decoderBuffer-BKic0U2F.mjs";
 //#region src/decoder/decoder.d.ts
 declare class Decoder<TBuffer extends Uint8Array = Uint8Array> {
   protected decoderBuffer: DecoderBuffer<TBuffer>;
@@ -12,4 +12,4 @@ declare class Decoder<TBuffer extends Uint8Array = Uint8Array> {
 }
 //#endregion
 export { Decoder as t };
-//# sourceMappingURL=decoder-ByAWOgvm.d.mts.map
+//# sourceMappingURL=decoder-CQrtmASU.d.mts.map

package/dist/esm/{decoder-ByAWOgvm.d.mts.map → decoder-CQrtmASU.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"decoder-ByAWOgvm.d.mts","names":[],"sources":["../../src/decoder/decoder.ts"],"mappings":";;;;cAIM,QAAQ,gBAAgB,aAAa;YAC/B,eAAe,cAAc;EAEvC,YAAY,UAAU,qBAAqB;EAI3C,OAAO,kBAAkB,eAAe,UAAU;EAQlD,aAAa,WAAW,8BAA8B;EAMtD,qBACE,WAAW,8BAA8B;EAO3C,iBACE,cACA,WAAW,KAAK,8BAA8B"}
+{"version":3,"file":"decoder-CQrtmASU.d.mts","names":[],"sources":["../../src/decoder/decoder.ts"],"mappings":";;;;cAIM,QAAQ,gBAAgB,aAAa;YAC/B,eAAe,cAAc;EAEvC,YAAY,UAAU,qBAAqB;EAI3C,OAAO,kBAAkB,eAAe,UAAU;EAQlD,aAAa,WAAW,8BAA8B;EAMtD,qBACE,WAAW,8BAA8B;EAO3C,iBACE,cACA,WAAW,KAAK,8BAA8B"}

package/dist/esm/{decoderBuffer-93dMcsbx.d.mts → decoderBuffer-BKic0U2F.d.mts}

@@ -1,5 +1,5 @@
 import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-Cqvg0zW7.mjs";
-import { t as BufferWithExtensions } from "./bufferWithExtensions-DzAs7yX1.mjs";
+import { t as BufferWithExtensions } from "./bufferWithExtensions-Bc7vjIkw.mjs";
 import { t as DefaultTextDecoder } from "./defaultTextDecoder-DztyzoBV.mjs";
 import { t as DecoderBufferOptions } from "./types-CNR_qJsr.mjs";
 //#region src/decoder/decoderBuffer.d.ts
@@ -19,4 +19,4 @@ declare class DecoderBuffer<TBuffer extends Uint8Array = Uint8Array> extends Buf
 }
 //#endregion
 export { DecoderBuffer as t };
-//# sourceMappingURL=decoderBuffer-93dMcsbx.d.mts.map
+//# sourceMappingURL=decoderBuffer-BKic0U2F.d.mts.map