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

package/dist/esm/encoder-CQfcjnAe.d.mts

@@ -1,23 +0,0 @@
-import { r as EncoderBufferOptions, t as MessagePackExtension } from "./messagePackExtension-5TI02KG6.mjs";
-import { t as EncoderBuffer } from "./encoderBuffer-DEy8CuWQ.mjs";
-//#region src/encoder/encoder.d.ts
-/**
- * The `Encoder` class is responsible for encoding JavaScript values into the
- * MessagePack format.
- *
- * This class is just a wrapper around the buffer, which does the actual
- * encoding. The buffer is responsible for managing the encoding process and
- * handling extensions.
- */
-declare class Encoder<TBuffer extends Uint8Array = Uint8Array> {
-  buffer: EncoderBuffer<TBuffer>;
-  constructor(options?: Partial<EncoderBufferOptions<TBuffer>>);
-  encode(value: unknown): Uint8Array;
-  addExtension(extension: MessagePackExtension<unknown, TBuffer>): this;
-  addInternalExtension(extension: MessagePackExtension<unknown, TBuffer>): this;
-  addExtensionType(type: number, extension: Omit<MessagePackExtension<unknown, TBuffer>, 'type'>): this;
-  fetchExtension(type: number): MessagePackExtension<unknown, TBuffer>;
-}
-//#endregion
-export { Encoder as t };
-//# sourceMappingURL=encoder-CQfcjnAe.d.mts.map

package/dist/esm/encoder-CQfcjnAe.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoder-CQfcjnAe.d.mts","names":[],"sources":["../../src/encoder/encoder.ts"],"mappings":";;;;;;;;;;;cAYM,QAAQ,gBAAgB,aAAa;EACzC,QAAQ,cAAc;EAEtB,YAAY,UAAU,QAAQ,qBAAqB;EAInD,OAAO,iBAAiB;EAQxB,aAAa,WAAW,8BAA8B;EAMtD,qBACE,WAAW,8BAA8B;EAO3C,iBACE,cACA,WAAW,KAAK,8BAA8B;EAOhD,eAAe,eAAe,8BAA8B"}

package/dist/esm/encoderBuffer-DEy8CuWQ.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoderBuffer-DEy8CuWQ.d.mts","names":[],"sources":["../../src/encoder/encoderBuffer.ts"],"mappings":";;;;;cAsBM,cAAc,gBAAgB,aAAa,oBACvC,qBAAqB,oBAClB,yBAAyB;;;EAGpC;;;;;;;YAQU,cAAc;;;;;;;WAQf;;;;;;;;WASA;;;;;;;YAQC,aAAa,YAAY;WAE1B,aAAa,uBAAuB;EAE7C,QAAQ;EACR,MAAM;EAcN,YAAY,UAAU,QAAQ,qBAAqB;EAwBnD,sBAAsB,cAAc;EAcpC,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;EA4EZ,SAAS,8BAA8B,QACrC,OAAO,OAAO,MAAM;EAiCtB,WAAW;EAoCX,gBAAgB,OAAO;EAiBvB,eACE,WAAW,sBACX,QAAQ,uBAAuB;EAiDjC,yBAAyB;EAqBzB,YAAY;EAYZ,YAAY;EAkBZ,MAAM"}

package/dist/esm/extensions/bigint/bigInt.d.mts

@@ -1,2 +0,0 @@
-import { t as BigIntExtension } from "../../bigInt-BvNVHUwj.mjs";
-export { BigIntExtension as default };

package/dist/esm/extensions/bigint/bigInt.mjs

@@ -1,56 +0,0 @@
-import UntypedExtension from "../../untypedExtension.mjs";
-//#region src/extensions/bigint/bigInt.ts
-const BIGINT_MASK = 18446744073709551615n;
-/**
-* This class encodes and decodes JavaScript BigInt values that are outside the
-* safe integer range. It encodes and decodes BigInt values using a custom
-* extension type, allowing for the serialization of large integers that cannot
-* be represented as standard JavaScript numbers. The encoding scheme uses a
-* variable-length representation to efficiently store the magnitude of the
-* BigInt value.
-*/
-var BigIntExtension = class extends UntypedExtension {
-	/**
-	* Encodes a BigInt value into the provided buffer. If the value is within the
-	* safe integer range, it is encoded directly following the Message Pack
-	* specification. Otherwise, if the value is outside the safe integer range,
-	* it is encoded using a variable-length representation. Negative values are
-	* handled by encoding their magnitude and using a specific bit pattern to
-	* indicate negativity.
-	*
-	* @param value - The BigInt value to encode.
-	* @param buffer - The buffer to write the encoded data to.
-	*/
-	encode(value, buffer) {
-		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;
-				magnitude >>= 64n;
-			}
-		}
-	}
-	/**
-	* Decodes a BigInt value from the provided DataView. It reads the encoded
-	* data, reconstructs the magnitude, and determines the sign based on the
-	* encoding scheme. The method returns the decoded BigInt value.
-	*/
-	decode(buffer, size) {
-		let encoded = 0n;
-		let shift = 0n;
-		for (let offset = buffer.offset; offset < size; offset += 8) {
-			encoded |= buffer.view.getBigUint64(offset, false) << shift;
-			shift += 64n;
-		}
-		if ((encoded & 1n) === 1n) return -(encoded + 1n >> 1n);
-		return encoded >> 1n;
-	}
-};
-//#endregion
-export { BigIntExtension as default };
-
-//# sourceMappingURL=bigInt.mjs.map

package/dist/esm/extensions/bigint/bigInt.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"bigInt.mjs","names":[],"sources":["../../../../src/extensions/bigint/bigInt.ts"],"sourcesContent":["import type MessagePackDecoderBuffer from '../../decoder/interfaces/messagePackDecoderBuffer.ts';\nimport type { ExtensionEncoderBuffer } from '../../encoder/types.ts';\nimport UntypedExtension from '../../untypedExtension.ts';\n\nconst BIGINT_MASK = 0xff_ff_ff_ff_ff_ff_ff_ffn;\n\n/**\n * This class encodes and decodes JavaScript BigInt values that are outside the\n * safe integer range. It encodes and decodes BigInt values using a custom\n * extension type, allowing for the serialization of large integers that cannot\n * be represented as standard JavaScript numbers. The encoding scheme uses a\n * variable-length representation to efficiently store the magnitude of the\n * BigInt value.\n */\nclass BigIntExtension<\n  TBuffer extends Uint8Array = Uint8Array,\n> extends UntypedExtension<bigint, TBuffer> {\n  /**\n   * Encodes a BigInt value into the provided buffer. If the value is within the\n   * safe integer range, it is encoded directly following the Message Pack\n   * specification. Otherwise, if the value is outside the safe integer range,\n   * it is encoded using a variable-length representation. Negative values are\n   * handled by encoding their magnitude and using a specific bit pattern to\n   * indicate negativity.\n   *\n   * @param value - The BigInt value to encode.\n   * @param buffer - The buffer to write the encoded data to.\n   */\n  encode(\n    value: object | bigint,\n    buffer: ExtensionEncoderBuffer<TBuffer>,\n  ): void {\n    if (typeof value === 'bigint') {\n      let magnitude: bigint;\n\n      if (value < 0n) {\n        magnitude = (-value << 1n) - 1n;\n      } else {\n        magnitude = value << 1n;\n      }\n\n      while (magnitude > 0n) {\n        buffer.ensureCapacity(8);\n        buffer.view.setBigUint64(buffer.offset, magnitude & BIGINT_MASK, false);\n        buffer.offset += 8;\n        magnitude >>= 64n;\n      }\n    }\n  }\n\n  /**\n   * Decodes a BigInt value from the provided DataView. It reads the encoded\n   * data, reconstructs the magnitude, and determines the sign based on the\n   * encoding scheme. The method returns the decoded BigInt value.\n   */\n  decode(buffer: MessagePackDecoderBuffer, size: number): bigint {\n    let encoded = 0n;\n    let shift = 0n;\n\n    for (let offset = buffer.offset; offset < size; offset += 8) {\n      encoded |= buffer.view.getBigUint64(offset, false) << shift;\n      shift += 64n;\n    }\n\n    if ((encoded & 1n) === 1n) {\n      return -((encoded + 1n) >> 1n);\n    }\n\n    return encoded >> 1n;\n  }\n}\n\nexport default BigIntExtension;\n"],"mappings":";;AAIA,MAAM,cAAc;;;;;;;;;AAUpB,IAAM,kBAAN,cAEU,iBAAkC;;;;;;;;;;;;CAY1C,OACE,OACA,QACM;EACN,IAAI,OAAO,UAAU,UAAU;GAC7B,IAAI;GAEJ,IAAI,QAAQ,IACV,aAAa,CAAC,SAAS,MAAM;QAE7B,YAAY,SAAS;GAGvB,OAAO,YAAY,IAAI;IACrB,OAAO,eAAe,CAAC;IACvB,OAAO,KAAK,aAAa,OAAO,QAAQ,YAAY,aAAa,KAAK;IACtE,OAAO,UAAU;IACjB,cAAc;GAChB;EACF;CACF;;;;;;CAOA,OAAO,QAAkC,MAAsB;EAC7D,IAAI,UAAU;EACd,IAAI,QAAQ;EAEZ,KAAK,IAAI,SAAS,OAAO,QAAQ,SAAS,MAAM,UAAU,GAAG;GAC3D,WAAW,OAAO,KAAK,aAAa,QAAQ,KAAK,KAAK;GACtD,SAAS;EACX;EAEA,KAAK,UAAU,QAAQ,IACrB,OAAO,EAAG,UAAU,MAAO;EAG7B,OAAO,WAAW;CACpB;AACF"}

package/dist/esm/extensions/bigint/index.d.mts

@@ -1,3 +0,0 @@
-import { t as BigIntExtension } from "../../bigInt-BvNVHUwj.mjs";
-import "../../index-CQnkyOId.mjs";
-export { BigIntExtension as default };

package/dist/esm/extensions/bigint/index.mjs

@@ -1,2 +0,0 @@
-import BigIntExtension from "./bigInt.mjs";
-export { BigIntExtension as default };

package/dist/esm/extensions/interfaces/index.d.mts

@@ -1,3 +0,0 @@
-import { t as MessagePackExtension } from "../../messagePackExtension-5TI02KG6.mjs";
-import "../../index-CUX405iZ.mjs";
-export type { MessagePackExtension };

package/dist/esm/fitIn16Bits-D9lga-sP.d.mts

@@ -1,5 +0,0 @@
-//#region src/utils/fitIn16Bits.d.ts
-declare function fitIn16Bits(length: number): boolean;
-//#endregion
-export { fitIn16Bits as t };
-//# sourceMappingURL=fitIn16Bits-D9lga-sP.d.mts.map

package/dist/esm/fitIn16Bits-D9lga-sP.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fitIn16Bits-D9lga-sP.d.mts","names":[],"sources":["../../src/utils/fitIn16Bits.ts"],"mappings":";iBAAwB,YAAY"}

package/dist/esm/fitIn32Bits-BrGIMOff.d.mts

@@ -1,5 +0,0 @@
-//#region src/utils/fitIn32Bits.d.ts
-declare function fitIn32Bits(length: number): boolean;
-//#endregion
-export { fitIn32Bits as t };
-//# sourceMappingURL=fitIn32Bits-BrGIMOff.d.mts.map

package/dist/esm/fitIn32Bits-BrGIMOff.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fitIn32Bits-BrGIMOff.d.mts","names":[],"sources":["../../src/utils/fitIn32Bits.ts"],"mappings":";iBAAwB,YAAY"}

package/dist/esm/fitIn7Bits-BVHyKXCg.d.mts

@@ -1,5 +0,0 @@
-//#region src/utils/fitIn7Bits.d.ts
-declare function fitIn7Bits(length: number): boolean;
-//#endregion
-export { fitIn7Bits as t };
-//# sourceMappingURL=fitIn7Bits-BVHyKXCg.d.mts.map

package/dist/esm/fitIn7Bits-BVHyKXCg.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fitIn7Bits-BVHyKXCg.d.mts","names":[],"sources":["../../src/utils/fitIn7Bits.ts"],"mappings":";iBAAwB,WAAW"}

package/dist/esm/fitIn8Bits-DQnQIhdh.d.mts

@@ -1,5 +0,0 @@
-//#region src/utils/fitIn8Bits.d.ts
-declare function fitIn8Bits(length: number): boolean;
-//#endregion
-export { fitIn8Bits as t };
-//# sourceMappingURL=fitIn8Bits-DQnQIhdh.d.mts.map

package/dist/esm/fitIn8Bits-DQnQIhdh.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fitIn8Bits-DQnQIhdh.d.mts","names":[],"sources":["../../src/utils/fitIn8Bits.ts"],"mappings":";iBAAwB,WAAW"}

package/dist/esm/fitInt64Bits-CY7lVKne.d.mts

@@ -1,5 +0,0 @@
-//#region src/utils/fitInt64Bits.d.ts
-declare function fitInt64Bits(value: number | bigint): boolean;
-//#endregion
-export { fitInt64Bits as t };
-//# sourceMappingURL=fitInt64Bits-CY7lVKne.d.mts.map

package/dist/esm/fitInt64Bits-CY7lVKne.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fitInt64Bits-CY7lVKne.d.mts","names":[],"sources":["../../src/utils/fitInt64Bits.ts"],"mappings":";iBAAwB,aAAa"}

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

@@ -1,2 +0,0 @@
-import { o as MessagePackBufferWithExtensions } from "../messagePackExtension-5TI02KG6.mjs";
-export type { MessagePackBufferWithExtensions };

package/dist/esm/messagePackDecoderBuffer-CGyYSweZ.d.mts

@@ -1,12 +0,0 @@
-import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-CtyB0N6j.mjs";
-//#region src/decoder/interfaces/messagePackDecoderBuffer.d.ts
-interface MessagePackDecoderBuffer<TBuffer extends Uint8Array = Uint8Array> {
-  view: DataView;
-  buffer: TBuffer;
-  textDecoder: MessagePackTextDecoder;
-  offset: number;
-  nextValue<TValue = unknown>(): TValue;
-}
-//#endregion
-export { MessagePackDecoderBuffer as t };
-//# sourceMappingURL=messagePackDecoderBuffer-CGyYSweZ.d.mts.map

package/dist/esm/messagePackDecoderBuffer-CGyYSweZ.d.mts.map

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

package/dist/esm/messagePackExtension-5TI02KG6.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messagePackExtension-5TI02KG6.d.mts","names":[],"sources":["../../src/interfaces/messagePackBufferWithExtensions.ts","../../src/encoder/types.ts","../../src/encoder/interfaces/messagePackEncoderBuffer.ts","../../src/extensions/interfaces/messagePackExtension.ts"],"mappings":";;;;UAEyB,gCACvB,gBAAgB,aAAa;;;;;;;;EAS7B,aAAa,WAAW,8BAA8B;;;;UCRvC,qBACf,gBAAgB,aAAa,oBACrB,cAAc;;;;;;;;;EAStB;;;;;;EAMA,cAAc,uBAAuB;;;;;;;;EAQrC;;;;;;;;;;;;;;EAcA;;KAGU,cAAc,SAAS,6BAChC,cAAc,WAAW,aAAa,kBAAkB,OAAO,QAAQ;KAG9D,uBAAuB,gBAAgB,aAAa,cAC9D,cACE,yBAAyB;;;;;;;;UC1CJ,yBACvB,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;;;;;;;;;;;;;;;;;;;;;EAsBZ,SAAS,8BAA8B,QACrC,OAAO,OAAO,MAAM;;;;;;;;;;;;;;;;;;;;;EAuBtB,WAAW;;;;;;;EAQX,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCZ,gBAAgB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DvB,eACE,WAAW,sBACX,QAAQ,uBAAuB;;;;UCl6BV,qBACvB,kBACA,gBAAgB,aAAa;;;;;;WAOpB;;;;;;;;;EAUT,OACE,wBACA,QAAQ,yBAAyB;;;;;;;;;;;;EAcnC,OAAO,eAAe,0BAA0B,eAAe"}

package/dist/esm/messagePackTextDecoder-CtyB0N6j.d.mts

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

package/dist/esm/messagePackTextDecoder-CtyB0N6j.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messagePackTextDecoder-CtyB0N6j.d.mts","names":[],"sources":["../../src/decoder/interfaces/messagePackTextDecoder.ts"],"mappings":";UAAyB;EACvB,OAAO,QAAQ,YAAY,qBAAqB"}

package/dist/esm/messagePackTextEncoder-D7iCft_t.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messagePackTextEncoder-D7iCft_t.d.mts","names":[],"sources":["../../src/encoder/interfaces/messagePackTextEncoder.ts"],"mappings":";;UACyB,uBACvB,gBAAgB,aAAa;;;;;;;;;EAU7B,WAAW,gBAAgB,QAAQ"}

package/dist/esm/nodeTextEncoder-CegSnA6z.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodeTextEncoder-CegSnA6z.d.mts","names":[],"sources":["../../src/encoder/textEncoders/nodeTextEncoder.ts"],"mappings":";;cAEM,2BAA2B;EAC/B,WAAW,eAAe,QAAQ"}

package/dist/esm/timestampDate-C1UzHhZL.d.mts

@@ -1,33 +0,0 @@
-import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-CGyYSweZ.mjs";
-import { n as MessagePackEncoderBuffer, t as MessagePackExtension } from "./messagePackExtension-5TI02KG6.mjs";
-import { t as MessagePackTime } from "./types-B9KMW-kD.mjs";
-//#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 MessagePackExtension<Date, TBuffer> {
-  readonly type = -1;
-  parseToMessagePackTime(date: Date): MessagePackTime;
-  encode(value: object | bigint, buffer: MessagePackEncoderBuffer<TBuffer>): void;
-  decode(decoderBuffer: MessagePackDecoderBuffer<TBuffer>, size: number): Date;
-}
-//#endregion
-export { TimestampDateExtension as t };
-//# sourceMappingURL=timestampDate-C1UzHhZL.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"timestampDate-C1UzHhZL.d.mts","names":[],"sources":["../../src/extensions/timestampDate/timestampDate.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;cA4BM,uBACJ,gBAAgB,aAAa,uBAClB,qBAAqB,MAAM;WAC7B;EAET,uBAAuB,MAAM,OAAO;EAcpC,OACE,wBACA,QAAQ,yBAAyB;EAuBnC,OAAO,eAAe,yBAAyB,UAAU,eAAe"}

package/dist/esm/types-BJie2edF.d.mts

@@ -1,20 +0,0 @@
-//#region src/types.d.ts
-type NewBufferFn<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
-   * large enough to hold the encoded data, it will be automatically resized.
-   *
-   * @default 1024
-   */
-  initialBufferSize?: number;
-  /**
-   * A function that creates a new buffer of the specified size.
-   *
-   * @default (size) => new Uint8Array(size)
-   */
-  newBufferFn?: NewBufferFn<TBuffer>;
-}
-//#endregion
-export { NewBufferFn as n, BufferOptions as t };
-//# sourceMappingURL=types-BJie2edF.d.mts.map

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

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

package/dist/esm/types-DoBZbRkk.d.mts

@@ -1,6 +0,0 @@
-import { t as BufferOptions } from "./types-BJie2edF.mjs";
-//#region src/decoder/types.d.ts
-type DecoderBufferOptions<TBuffer extends Uint8Array = Uint8Array> = BufferOptions<TBuffer>;
-//#endregion
-export { DecoderBufferOptions as t };
-//# sourceMappingURL=types-DoBZbRkk.d.mts.map

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

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

package/dist/esm/untypedExtension-6bNMj-lY.d.mts

@@ -1,16 +0,0 @@
-import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-CGyYSweZ.mjs";
-import { n as MessagePackEncoderBuffer, t as MessagePackExtension } from "./messagePackExtension-5TI02KG6.mjs";
-//#region src/untypedExtension.d.ts
-declare abstract class UntypedExtension<TValue = unknown, TBuffer extends Uint8Array = Uint8Array> implements MessagePackExtension<TValue, TBuffer> {
-  readonly type: number;
-  /**
-   * @param type - The extension type for BigInt values. Can be a integer
-   *   between 0 and 127, default is 0.
-   */
-  constructor(type?: number);
-  abstract encode(value: object | bigint, buffer: MessagePackEncoderBuffer<TBuffer>): void;
-  abstract decode(decoderBuffer: MessagePackDecoderBuffer, size: number): TValue;
-}
-//#endregion
-export { UntypedExtension as t };
-//# sourceMappingURL=untypedExtension-6bNMj-lY.d.mts.map

package/dist/esm/untypedExtension-6bNMj-lY.d.mts.map

@@ -1 +0,0 @@
-{"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"}

package/dist/esm/untypedExtension.d.mts

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

package/dist/esm/untypedExtension.mjs

@@ -1,15 +0,0 @@
-//#region src/untypedExtension.ts
-var UntypedExtension = class {
-	type;
-	/**
-	* @param type - The extension type for BigInt values. Can be a integer
-	*   between 0 and 127, default is 0.
-	*/
-	constructor(type = 0) {
-		this.type = type;
-	}
-};
-//#endregion
-export { UntypedExtension as default };
-
-//# sourceMappingURL=untypedExtension.mjs.map

package/dist/esm/untypedExtension.mjs.map

@@ -1 +0,0 @@
-{"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"}

package/dist/esm/utils/fitInt64Bits.d.mts

@@ -1,2 +0,0 @@
-import { t as fitInt64Bits } from "../fitInt64Bits-CY7lVKne.mjs";
-export { fitInt64Bits as default };

package/dist/esm/utils/fitInt64Bits.mjs

@@ -1,8 +0,0 @@
-//#region src/utils/fitInt64Bits.ts
-function fitInt64Bits(value) {
-	return value <= Number.MAX_SAFE_INTEGER;
-}
-//#endregion
-export { fitInt64Bits as default };
-
-//# sourceMappingURL=fitInt64Bits.mjs.map

package/dist/esm/utils/fitInt64Bits.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"fitInt64Bits.mjs","names":[],"sources":["../../../src/utils/fitInt64Bits.ts"],"sourcesContent":["export default function fitInt64Bits(value: number | bigint): boolean {\n  return value <= Number.MAX_SAFE_INTEGER;\n}\n"],"mappings":";AAAA,SAAwB,aAAa,OAAiC;CACpE,OAAO,SAAS,OAAO;AACzB"}

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

@@ -1,6 +0,0 @@
-import { t as fitIn7Bits } from "../fitIn7Bits-BVHyKXCg.mjs";
-import { t as fitIn8Bits } from "../fitIn8Bits-DQnQIhdh.mjs";
-import { t as fitIn16Bits } from "../fitIn16Bits-D9lga-sP.mjs";
-import { t as fitIn32Bits } from "../fitIn32Bits-BrGIMOff.mjs";
-import { t as fitInt64Bits } from "../fitInt64Bits-CY7lVKne.mjs";
-export { fitIn16Bits, fitIn32Bits, fitIn7Bits, fitIn8Bits, fitInt64Bits };

package/dist/esm/utils/index.mjs

@@ -1,6 +0,0 @@
-import fitIn7Bits from "./fitIn7Bits.mjs";
-import fitIn8Bits from "./fitIn8Bits.mjs";
-import fitIn16Bits from "./fitIn16Bits.mjs";
-import fitIn32Bits from "./fitIn32Bits.mjs";
-import fitInt64Bits from "./fitInt64Bits.mjs";
-export { fitIn16Bits, fitIn32Bits, fitIn7Bits, fitIn8Bits, fitInt64Bits };