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

package/dist/cjs/encoder/encoder.d.cts

@@ -1,2 +1,2 @@
-import { t as Encoder } from "../encoder-DXuhGwd7.cjs";
+import { t as Encoder } from "../encoder-yQYOtvXU.cjs";
 export = Encoder;

package/dist/cjs/encoder/index.cjs

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_encoder_textEncoders_defaultTextEncoder = require("./textEncoders/defaultTextEncoder.cjs");
-const require_encoder_encoderBuffer = require("./encoderBuffer.cjs");
 const require_encoder_encoder = require("./encoder.cjs");
 const require_encoder_textEncoders_nodeTextEncoder = require("./textEncoders/nodeTextEncoder.cjs");
+const require_encoder_encode = require("./encode.cjs");
 exports.DefaultTextEncoder = require_encoder_textEncoders_defaultTextEncoder;
 exports.Encoder = require_encoder_encoder;
-exports.EncoderBuffer = require_encoder_encoderBuffer;
 exports.NodeTextEncoder = require_encoder_textEncoders_nodeTextEncoder;
+exports.encode = require_encoder_encode;

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

@@ -1,7 +1,7 @@
-import { a as OmitByPattern, i as ExtensionEncoderBuffer, n as MessagePackEncoderBuffer, r as EncoderBufferOptions } from "../messagePackExtension-C_TQXlEn.cjs";
-import { t as MessagePackTextEncoder } from "../messagePackTextEncoder-D7iCft_t.cjs";
-import { t as EncoderBuffer } from "../encoderBuffer-DWGIXXjj.cjs";
-import { t as Encoder } from "../encoder-DXuhGwd7.cjs";
-import { t as DefaultTextEncoder } from "../defaultTextEncoder-DzdGBX6s.cjs";
-import { t as NodeTextEncoder } from "../nodeTextEncoder-DJzFDBXd.cjs";
-export { DefaultTextEncoder, Encoder, EncoderBuffer, type EncoderBufferOptions, type ExtensionEncoderBuffer, type MessagePackEncoderBuffer, type MessagePackTextEncoder, NodeTextEncoder, type OmitByPattern };
+import { a as EncoderOptions, n as MessagePackEncoder, o as ExtensionEncoder } from "../error-B129l__v.cjs";
+import { t as MessagePackTextEncoder } from "../messagePackTextEncoder-MeyNUt3L.cjs";
+import { t as Encoder } from "../encoder-yQYOtvXU.cjs";
+import { t as encode } from "../encode-4SxHVw0M.cjs";
+import { t as DefaultTextEncoder } from "../defaultTextEncoder-BpUrJKD9.cjs";
+import { t as NodeTextEncoder } from "../nodeTextEncoder-BpJi8Jx-.cjs";
+export { DefaultTextEncoder, Encoder, type EncoderOptions, type ExtensionEncoder, type MessagePackEncoder, type MessagePackTextEncoder, NodeTextEncoder, encode };

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

@@ -1,4 +1,4 @@
-import { n as MessagePackEncoderBuffer } from "../../messagePackExtension-C_TQXlEn.cjs";
-import { t as MessagePackTextEncoder } from "../../messagePackTextEncoder-D7iCft_t.cjs";
-import "../../index-DeSJDZGk.cjs";
-export type { MessagePackEncoderBuffer, MessagePackTextEncoder };
+import { n as MessagePackEncoder } from "../../error-B129l__v.cjs";
+import { t as MessagePackTextEncoder } from "../../messagePackTextEncoder-MeyNUt3L.cjs";
+import "../../index-CaxrMD1A.cjs";
+export type { MessagePackEncoder, MessagePackTextEncoder };

package/dist/cjs/encoder/interfaces/messagePackEncoder.d.cts

@@ -0,0 +1,2 @@
+import { n as MessagePackEncoder } from "../../error-B129l__v.cjs";
+export = MessagePackEncoder;

package/dist/cjs/encoder/interfaces/messagePackTextEncoder.d.cts

@@ -1,2 +1,2 @@
-import { t as MessagePackTextEncoder } from "../../messagePackTextEncoder-D7iCft_t.cjs";
+import { t as MessagePackTextEncoder } from "../../messagePackTextEncoder-MeyNUt3L.cjs";
 export = MessagePackTextEncoder;

package/dist/cjs/encoder/textEncoders/defaultTextEncoder.d.cts

@@ -1,2 +1,2 @@
-import { t as DefaultTextEncoder } from "../../defaultTextEncoder-DzdGBX6s.cjs";
+import { t as DefaultTextEncoder } from "../../defaultTextEncoder-BpUrJKD9.cjs";
 export = DefaultTextEncoder;

package/dist/cjs/encoder/textEncoders/index.d.cts

@@ -1,4 +1,4 @@
-import { t as DefaultTextEncoder } from "../../defaultTextEncoder-DzdGBX6s.cjs";
-import { t as NodeTextEncoder } from "../../nodeTextEncoder-DJzFDBXd.cjs";
-import "../../index-DMnXy2Rv.cjs";
+import { t as DefaultTextEncoder } from "../../defaultTextEncoder-BpUrJKD9.cjs";
+import { t as NodeTextEncoder } from "../../nodeTextEncoder-BpJi8Jx-.cjs";
+import "../../index-CQnkyOId.cjs";
 export { DefaultTextEncoder, NodeTextEncoder };

package/dist/cjs/encoder/textEncoders/nodeTextEncoder.d.cts

@@ -1,2 +1,2 @@
-import { t as NodeTextEncoder } from "../../nodeTextEncoder-DJzFDBXd.cjs";
+import { t as NodeTextEncoder } from "../../nodeTextEncoder-BpJi8Jx-.cjs";
 export = NodeTextEncoder;

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

@@ -1,2 +1,2 @@
-import { a as OmitByPattern, i as ExtensionEncoderBuffer, r as EncoderBufferOptions } from "../messagePackExtension-C_TQXlEn.cjs";
-export { EncoderBufferOptions, ExtensionEncoderBuffer, OmitByPattern };
+import { a as EncoderOptions, o as ExtensionEncoder } from "../error-B129l__v.cjs";
+export { EncoderOptions, ExtensionEncoder };

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

@@ -1,12 +1,10 @@
-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 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 Constructor } from "./types-BcIA43h9.cjs";
+import { a as EncoderOptions, c as BufferFactory, f as MessagePackBuiltInExtension, i as MessagePackExtension, n as MessagePackEncoder, o as ExtensionEncoder } from "./error-B129l__v.cjs";
+import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-MeyNUt3L.cjs";
+import { t as BufferWithExtensions } from "./bufferWithExtensions-Cg4LGSIy.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;
   /**
    * Shared buffer is used to encode strings, to avoid allocating a new buffer
    * for each string. The shared buffer is resized if the string is larger than
@@ -14,6 +12,10 @@ declare class EncoderBuffer<TBuffer extends Uint8Array = Uint8Array> extends Buf
    * reducing memory allocations and garbage collection overhead.
    */
   protected sharedBuffer: TBuffer;
+  protected extensionsByConstructors: Map<Constructor<object>, MessagePackExtension<object, TBuffer>>;
+  protected builtInExtensionsByConstructors: Map<Constructor<object>, MessagePackBuiltInExtension<object, TBuffer>>;
+  /** The current offset in the buffer where the next write operation will occur. */
+  offset: number;
   /**
    * Determines whether the keys of a map should be sorted before encoding.
    * Sorting keys can be useful for ensuring consistent serialization of
@@ -29,25 +31,39 @@ declare class EncoderBuffer<TBuffer extends Uint8Array = Uint8Array> extends Buf
    * small numbers.
    */
   readonly forceFloat32: boolean;
+  /**
+   * The initial size of the main buffer. This determines how much memory is
+   * allocated for the buffer when the encoder is first created. If the buffer
+   * needs to grow beyond this size, it will be reallocated with a larger size.
+   */
+  readonly initialBufferSize: number;
+  /**
+   * The initial size of the shared buffer used for encoding strings. This
+   * determines how much memory is allocated for the shared buffer when the
+   * encoder is first created. If the shared buffer needs to grow beyond this
+   * size, it will be reallocated with a larger size.
+   */
+  readonly initialSharedBufferSize: number;
   /**
    * A function that creates a new buffer of the specified size. This function
    * is used to allocate new buffers when the current buffer is not large enough
    * to accommodate the data being written. The function should return a new
    * instance of TBuffer with the specified size.
    */
-  protected newBufferFn: NewBufferFn<TBuffer>;
+  readonly bufferFactory: BufferFactory<TBuffer>;
   readonly textEncoder: MessagePackTextEncoder<TBuffer>;
   buffer: TBuffer;
   view: DataView;
-  constructor(options?: Partial<EncoderBufferOptions<TBuffer>>);
-  getExtensionBuffer(): EncoderBuffer<TBuffer>;
+  constructor(options?: Partial<EncoderOptions<TBuffer>>);
+  addExtension<TValue extends object>(extension: MessagePackExtension<TValue, TBuffer>): this;
+  getExtensionEncoder(): Encoder<TBuffer>;
   resizeBuffer(newSize: number): this;
   ensureCapacity(sizeToWrite: number): this;
   resetBuffer(): this;
   flush(): TBuffer;
   writePositiveFixInt(value: number): this;
   writeNegativeFixInt(value: number): this;
-  writeBin(bytes: Uint8Array): this;
+  writeBin<TBytes extends Uint8Array>(bytes: TBytes): this;
   writeFloat32(value: number): this;
   writeFloat64(value: number): this;
   writeUint8(value: number): this;
@@ -94,16 +110,22 @@ 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;
-  tryToWriteExtensionValue(value: object | bigint): number;
+  writeExtensionSymbol(type: number, size: number): this;
+  writeExtension<TValue extends object = object>(extension: MessagePackExtension<TValue, TBuffer> | MessagePackBuiltInExtension<TValue, TBuffer>, extensionEncoder: ExtensionEncoder<TBuffer>): this;
   writeBigInt(value: bigint): this;
+  writeError(error: Error): 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-yQYOtvXU.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encoder-yQYOtvXU.d.cts","names":[],"sources":["../../src/encoder/encoder.ts"],"mappings":";;;;;cA0BM,QAAQ,gBAAgB,aAAa,oBACjC,qBAAqB,oBAClB,mBAAmB;;;;;;;;YAQpB,cAAc;YAEd,0BAAwB,IAAA,qBAAA,6BAAA;YAKxB,iCAA+B,IAAA,qBAAA,oCAAA;;EAMzC;;;;;;;WAQS;;;;;;;;WASA;;;;;;WAOA;;;;;;;WAQA;;;;;;;WAQA,eAAe,cAAc;WAE7B,aAAa,uBAAuB;EAE7C,QAAQ;EACR,MAAM;EAcN,YAAY,UAAU,QAAQ,eAAe;EA4CpC,aAAa,uBACpB,WAAW,qBAAqB,QAAQ;EAmB1C,uBAAuB,QAAQ;EA0B/B,aAAa;EAeb,eAAe;EAUf;EAMA,SAAS;EAST,oBAAoB;EAMpB,oBAAoB;EAMpB,SAAS,eAAe,YAAY,OAAO;EAQ3C,aAAa;EAOb,aAAa;EAOb,WAAW;EAMX,YAAY;EAOZ,YAAY;EAOZ,YAAY;EAaZ,UAAU;EAMV,WAAW;EAOX,WAAW;EAOX,WAAW;EAYX,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;EAYX,gBAAgB,OAAO;EAiBvB,qBAAqB,cAAc;EAwCnC,eAAe,gCACb,WACI,qBAAqB,QAAQ,WAC7B,4BAA4B,QAAQ,UACxC,kBAAkB,iBAAiB;EAgBrC,YAAY;EA8EZ,WAAW,OAAO;EAUlB,YAAY;EAqCZ,MAAM"}

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

@@ -1,20 +1,97 @@
-import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-CMG0LPbJ.cjs";
-import { t as BufferOptions } from "./types-BJie2edF.cjs";
-import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-D7iCft_t.cjs";
-//#region src/interfaces/messagePackBufferWithExtensions.d.ts
-interface MessagePackBufferWithExtensions<TBuffer extends Uint8Array = Uint8Array> {
+import { t as MessagePackDecoder } from "./messagePackDecoder-BZOBJ2h5.cjs";
+import { t as Constructor } from "./types-BcIA43h9.cjs";
+import { t as MessagePackExtensionBase } from "./messagePackExtensionBase-DVMgQv12.cjs";
+import { n as ErrorExtensionFactoryInput, r as ErrorExtensionOptions, t as ErrorExtensionFactory } from "./types-BLh5F2iA.cjs";
+import { t as MessagePackTime } from "./types-B9KMW-kD.cjs";
+import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-MeyNUt3L.cjs";
+import { t as SerializerExtension } from "./serializer-nJmZCyQ0.cjs";
+//#region src/extensions/interfaces/messagePackBuiltInExtension.d.ts
+interface MessagePackBuiltInExtension<TValue extends object = object, TBuffer extends Uint8Array = Uint8Array> extends MessagePackExtensionBase<TValue, TBuffer> {
+  /**
+   * Encodes the given value into the provided encoder buffer according to the
+   * MessagePack format.
+   *
+   * This method must set all the values needed to correctly serialize this
+   * extension. That includes setting the flags, field sizes, and preparing any
+   * other information required for the extension to be encoded correctly.
+   *
+   * @param value - The value to be encoded.
+   * @param encoder - The main encoder instance where the data will be written.
+   */
+  encodeInto(value: TValue, encoder: MessagePackEncoder<TBuffer>): void;
+}
+//#endregion
+//#region src/extensions/timestampDate/timestampDate.d.ts
+/**
+ * The `TimestampDateExtension` class is responsible for encoding JavaScript
+ * `Date` objects into the MessagePack timestamp format.
+ *
+ * Timestamp extension type is assigned to extension type -1. It defines 3
+ * formats: 32-bit format, 64-bit format, and 96-bit format.
+ *
+ * - Timestamp 32 format can represent a timestamp in [1970-01-01 00:00:00 UTC,
+ *   2106-02-07 06:28:16 UTC) range. Nanoseconds part is 0.
+ * - Timestamp 64 format can represent a timestamp in [1970-01-01
+ *   00:00:00.000000000 UTC, 2514-05-30 01:53:04.000000000 UTC) range.
+ * - Timestamp 96 format can represent a timestamp in [-292277022657-01-27
+ *   08:29:52 UTC, 292277026596-12-04 15:30:08.000000000 UTC) range.
+ * - In timestamp 64 and timestamp 96 formats, nanoseconds must not be larger than
+ *   999999999.
+ *
+ * @see https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
+ * @see https://github.com/msgpack/msgpack-javascript/blob/main/src/timestamp.ts
+ * @see https://github.com/msgpack/msgpack-javascript/issues/216
+ */
+declare class TimestampDateExtension<TBuffer extends Uint8Array = Uint8Array> implements MessagePackBuiltInExtension<Date, TBuffer> {
+  static readonly DEFAULT_TYPE = -1;
+  readonly type = -1;
+  readonly constructors: Constructor<Date>[];
+  parseToMessagePackTime(date: Date): MessagePackTime;
+  encodeInto(value: Date, encoder: MessagePackEncoder<TBuffer>): void;
+  decode(decoder: MessagePackDecoder<TBuffer>, size: number): Date;
+}
+//#endregion
+//#region src/types.d.ts
+interface ExtensionsOptions<TBuffer extends Uint8Array = Uint8Array> {
+  /** Configuration options for the timestamp date extension. */
+  timestampDate?: false | TimestampDateExtension<TBuffer>;
+  /** Configuration options for the BigInt extension. */
+  bigInt?: false | BigIntExtensionOptions;
+  /** Configuration options for the error extension. */
+  error?: false | ErrorExtensionOptions | ErrorExtension<TBuffer>;
+}
+interface BigIntExtensionOptions {
   /**
-   * Adds a MessagePack extension encoder.
+   * The type identifier used for the BigInt extension.
    *
-   * @param extension The extension to add.
+   * @default 0
+   */
+  type: number;
+}
+interface BufferWithExtensionsOptions<TBuffer extends Uint8Array = Uint8Array> {
+  /** Configuration options for the extensions used in the buffer. */
+  extensions?: false | ExtensionsOptions<TBuffer>;
+}
+type BufferFactory<TBuffer extends Uint8Array = Uint8Array> = (requiredSize: number) => TBuffer;
+interface BufferOptions<TBuffer extends Uint8Array = Uint8Array> extends BufferWithExtensionsOptions<TBuffer> {
+  /**
+   * The initial size of the buffer used for encoding. If the buffer is not
+   * large enough to hold the encoded data, it will be automatically resized.
    *
-   * @returns The current instance for chaining.
+   * @default 1024
+   */
+  initialBufferSize?: number;
+  /**
+   * A function that creates a new buffer of the specified size.
+   *
+   * @default (size) => new Uint8Array(size)
    */
-  addExtension(extension: MessagePackExtension<unknown, TBuffer>): this;
+  bufferFactory?: BufferFactory<TBuffer>;
 }
 //#endregion
 //#region src/encoder/types.d.ts
-interface EncoderBufferOptions<TBuffer extends Uint8Array = Uint8Array> extends BufferOptions<TBuffer> {
+type OmitByPattern<TRecord, Pattern extends string> = { [TKey in keyof TRecord as TKey extends Pattern ? never : TKey]: TRecord[TKey]; };
+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
@@ -53,16 +130,47 @@ interface EncoderBufferOptions<TBuffer extends Uint8Array = Uint8Array> extends
    */
   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'>;
+type ExtensionEncoder<TBuffer extends Uint8Array = Uint8Array> = OmitByPattern<MessagePackEncoder<TBuffer>, `${string}Extension` | 'resetBuffer' | 'extensions'>;
+//#endregion
+//#region src/extensions/interfaces/messagePackExtension.d.ts
+interface MessagePackExtension<TValue extends object = object, TBuffer extends Uint8Array = Uint8Array> extends MessagePackExtensionBase<TValue, TBuffer> {
+  /**
+   * Encodes the given value into the provided buffer according to the
+   * MessagePack format.
+   *
+   * @param value - The value to be encoded. This can be of any type, but the
+   *   implementation should handle specific types as needed.
+   * @param encoder - The extension encoder where the data will be written.
+   */
+  encode(value: InstanceType<Constructor<TValue>>, encoder: ExtensionEncoder<TBuffer>): void;
+}
+//#endregion
+//#region src/interfaces/messagePackBufferWithExtensions.d.ts
+interface MessagePackBufferWithExtensions<TBuffer extends Uint8Array = Uint8Array> {
+  /**
+   * Adds a MessagePack extension encoder.
+   *
+   * @param extension The extension to add.
+   *
+   * @returns The current instance for chaining.
+   */
+  addExtension<TValue extends object = object>(extension: MessagePackExtension<TValue, TBuffer>): this;
+  /**
+   * Gets the registered MessagePack extensions.
+   *
+   * @returns A read-only map of the registered extensions, where the key is the
+   *   extension type and the value is the extension instance.
+   */
+  getExtensions(): ReadonlyMap<number, MessagePackExtension<object, TBuffer>>;
+}
 //#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
@@ -86,7 +194,7 @@ interface MessagePackEncoderBuffer<TBuffer extends Uint8Array = Uint8Array> exte
    * This encoder is responsible for converting strings into their corresponding
    * byte representations according to the MessagePack specification.
    */
-  readonly textEncoder: MessagePackTextEncoder;
+  readonly textEncoder: MessagePackTextEncoder<TBuffer>;
   /**
    * Ensures that the buffer has enough capacity to write the specified number
    * of bytes.
@@ -157,7 +265,7 @@ interface MessagePackEncoderBuffer<TBuffer extends Uint8Array = Uint8Array> exte
    * +========+
    * ```
    */
-  writeBin(bytes: Uint8Array): this;
+  writeBin<TBytes extends Uint8Array>(bytes: TBytes): this;
   /**
    * Writes a MessagePack float 32 stores a floating point number in IEEE 754
    * single precision floating point number format.
@@ -708,6 +816,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 +963,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 +986,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 +1018,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.
    *
@@ -823,17 +1031,6 @@ interface MessagePackEncoderBuffer<TBuffer extends Uint8Array = Uint8Array> exte
    *   buffer.
    */
   writeObject(value: object): this;
-  /**
-   * Encode a bigint value into the buffer. This method handles the encoding of
-   * signed 64-bit integers, ensuring that they are correctly represented in the
-   * MessagePack format.
-   *
-   * Maximum int64.
-   *
-   * @param value - The bigint value to be encoded and written to the buffer.
-   *   The method will determine the appropriate encoding based on the value's
-   *   size and sign.
-   */
   /**
    * Writes a Uint8Array using the MessagePack bin format family.
    *
@@ -855,6 +1052,61 @@ interface MessagePackEncoderBuffer<TBuffer extends Uint8Array = Uint8Array> exte
    * ```
    */
   writeUint8Array(value: Uint8Array): this;
+  /**
+   * Writes a MessagePack extension symbols using fixext 1, fixext 2, fixext 4,
+   * fixext 8, fixext 16, ext 8, ext 16, or ext 32.
+   *
+   * ```
+   * fixext 1:
+   * +--------+--------+
+   * |  0xd4  |  type  |
+   * +--------+--------+
+   *
+   * fixext 2:
+   * +--------+--------+
+   * |  0xd5  |  type  |
+   * +--------+--------+
+   *
+   * fixext 4:
+   * +--------+--------+
+   * |  0xd6  |  type  |
+   * +--------+--------+
+   *
+   * fixext 8:
+   * +--------+--------+
+   * |  0xd7  |  type  |
+   * +--------+--------+
+   *
+   * fixext 16:
+   * +--------+--------+
+   * |  0xd8  |  type  |
+   * +--------+--------+
+   *
+   * ext 8:
+   * +--------+--------+--------+
+   * |  0xc7  |XXXXXXXX|  type  |
+   * +--------+--------+--------+
+   *
+   * ext 16:
+   * +--------+--------+--------+--------+
+   * |  0xc8  |YYYYYYYY|YYYYYYYY|  type  |
+   * +--------+--------+--------+--------+
+   *
+   * ext 32:
+   * +--------+--------+--------+--------+--------+--------+
+   * |  0xc9  |ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|ZZZZZZZZ|  type  |
+   * +--------+--------+--------+--------+--------+--------+
+   *
+   * XXXXXXXX is a 8-bit unsigned integer which represents N.
+   * YYYYYYYY_YYYYYYYY is a 16-bit big-endian unsigned integer which
+   * represents N.
+   * ZZZZZZZZ_ZZZZZZZZ_ZZZZZZZZ_ZZZZZZZZ is a big-endian 32-bit unsigned
+   * integer which represents N.
+   * N is the length of data.
+   * type is a signed 8-bit integer.
+   * ```
+   */
+  writeExtensionSymbol(type: number, size: number): this;
   /**
    * Writes a MessagePack extension using fixext 1, fixext 2, fixext 4, fixext
    * 8, fixext 16, ext 8, ext 16, or ext 32.
@@ -912,39 +1164,41 @@ interface MessagePackEncoderBuffer<TBuffer extends Uint8Array = Uint8Array> exte
    * type is a signed 8-bit integer.
    * ```
    */
-  writeExtension(extension: MessagePackExtension, buffer: ExtensionEncoderBuffer<TBuffer>): this;
+  writeExtension<TValue extends object = object>(extension: MessagePackExtension<TValue, TBuffer> | MessagePackBuiltInExtension<TValue, TBuffer>, extensionEncoder: ExtensionEncoder<TBuffer>): this;
+  /**
+   * Get the current extension encoder.
+   *
+   * Extension encoder is used to provide an empty encoder buffer for
+   * extensions.
+   */
+  getExtensionEncoder(): MessagePackEncoder<TBuffer>;
 }
 //#endregion
-//#region src/extensions/interfaces/messagePackExtension.d.ts
-interface MessagePackExtension<TValue = unknown, TBuffer extends Uint8Array = Uint8Array> {
+//#region src/extensions/error/error.d.ts
+declare class ErrorExtension<TBuffer extends Uint8Array = Uint8Array> extends SerializerExtension<Error, ErrorExtensionFactoryInput, ErrorExtensionFactory, TBuffer> implements MessagePackBuiltInExtension<Error, TBuffer> {
   /**
-   * The unique type identifier for this extension. This value is used to
-   * distinguish between different extensions during the encoding and decoding
-   * process.
+   * The default type value for the error extension. This is used when no
+   * specific type is provided during instantiation.
    */
-  readonly type: number;
+  static readonly DEFAULT_TYPE = 1;
+  type: number;
+  constructor(options?: ErrorExtensionOptions);
   /**
-   * Encodes the given value into the provided buffer according to the
-   * MessagePack format.
+   * Encodes an Error value into the provided buffer. The method is responsible
+   * for serializing the Error object according to the Message Pack extension
+   * format.
    *
-   * @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 value - The Error value to encode.
+   * @param encoder - The extension encoder to write the encoded data to.
    */
-  encode(value: object | bigint, buffer: MessagePackEncoderBuffer<TBuffer>): void;
+  encodeInto(value: Error, encoder: MessagePackEncoder<TBuffer>): void;
   /**
-   * Decodes a value from the provided DataView starting at the specified
-   * offset. The method should read the necessary bytes from the DataView,
-   * reconstruct the original value, and return it.
-   *
-   * @param decoderBuffer - The buffer containing the encoded data to be
-   *   decoded.
-   * @param size - The number of bytes to read from the buffer for decoding.
-   *
-   * @returns The decoded value of type TValue.
+   * Decodes an Error value from the provided DataView. It reads the encoded
+   * data and reconstructs the Error object according to the Message Pack
+   * extension format. The method returns the decoded Error value.
    */
-  decode(decoderBuffer: MessagePackDecoderBuffer, size: number): TValue;
+  decode(decoder: MessagePackDecoder<TBuffer>, size: number): Error;
 }
 //#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 { EncoderOptions as a, BufferFactory as c, TimestampDateExtension as d, MessagePackBuiltInExtension as f, MessagePackExtension as i, BufferOptions as l, MessagePackEncoder as n, ExtensionEncoder as o, MessagePackBufferWithExtensions as r, BigIntExtensionOptions as s, ErrorExtension as t, BufferWithExtensionsOptions as u };
+//# sourceMappingURL=error-B129l__v.d.cts.map

package/dist/cjs/error-B129l__v.d.cts.map

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