@schema-pack/message-pack 0.0.0-commit.03ddd0427843dd0e1b45dcd0325ecf52097255a4

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

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

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

@@ -0,0 +1,2 @@
+import { a as OmitByPattern, i as ExtensionEncoderBuffer, r as EncoderBufferOptions } from "../messagePackExtension-Cd99Rw9t.cjs";
+export { EncoderBufferOptions, ExtensionEncoderBuffer, OmitByPattern };

package/dist/cjs/encoder-B-rTvI4P.d.cts

@@ -0,0 +1,23 @@
+import { r as EncoderBufferOptions, t as MessagePackExtension } from "./messagePackExtension-Cd99Rw9t.cjs";
+import { t as EncoderBuffer } from "./encoderBuffer-3ur0iCYR.cjs";
+//#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): TBuffer;
+  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-B-rTvI4P.d.cts.map

package/dist/cjs/encoder-B-rTvI4P.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder-B-rTvI4P.d.cts","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/cjs/encoderBuffer-3ur0iCYR.d.cts

@@ -0,0 +1,111 @@
+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 { 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> {
+  #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
+   * the current size of the shared buffer. This helps to improve performance by
+   * reducing memory allocations and garbage collection overhead.
+   */
+  protected sharedBuffer: TBuffer;
+  /**
+   * Determines whether the keys of a map should be sorted before encoding.
+   * Sorting keys can be useful for ensuring consistent serialization of
+   * objects, which is important for tasks like hashing or comparing serialized
+   * data.
+   */
+  readonly sortKeys: boolean;
+  /**
+   * If true, forces the encoder to use 32-bit floating point representation for
+   * numbers, even if they could be represented as 64-bit floats. This can be
+   * useful for reducing the size of the encoded data when high precision is not
+   * required. However, it may lead to loss of precision for very large or very
+   * small numbers.
+   */
+  readonly forceFloat32: boolean;
+  /**
+   * 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 bufferFactory: BufferFactory<TBuffer>;
+  readonly textEncoder: MessagePackTextEncoder<TBuffer>;
+  buffer: TBuffer;
+  view: DataView;
+  constructor(options?: Partial<EncoderBufferOptions<TBuffer>>);
+  getExtensionBuffer(): EncoderBuffer<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;
+  writeFloat32(value: number): this;
+  writeFloat64(value: number): this;
+  writeUint8(value: number): this;
+  writeUint16(value: number): this;
+  writeUint32(value: number): this;
+  writeUint64(value: number): this;
+  writeInt8(value: number): this;
+  writeInt16(value: number): this;
+  writeInt32(value: number): this;
+  writeInt64(value: number): this;
+  writeStr(value: string): this;
+  writeNilSymbol(): this;
+  writeFalseSymbol(): this;
+  writeTrueSymbol(): this;
+  writeFixMapSymbol(keysSize: number): this;
+  writeFixArraySymbol(arraySize: number): this;
+  writeFixStrSymbol(byteLength: number): this;
+  writeBin8Symbol(size: number): this;
+  writeBin16Symbol(size: number): this;
+  writeBin32Symbol(size: number): this;
+  writeFloat32Symbol(): this;
+  writeFloat64Symbol(): this;
+  writeUint8Symbol(): this;
+  writeUint16Symbol(): this;
+  writeUint32Symbol(): this;
+  writeUint64Symbol(): this;
+  writeInt8Symbol(): this;
+  writeInt16Symbol(): this;
+  writeInt32Symbol(): this;
+  writeInt64Symbol(): this;
+  writeStr8Symbol(size: number): this;
+  writeStr16Symbol(size: number): this;
+  writeStr32Symbol(size: number): this;
+  writeArray16Symbol(size: number): this;
+  writeArray32Symbol(size: number): this;
+  writeMap16Symbol(size: number): this;
+  writeMap32Symbol(size: number): this;
+  writeFixExt1Symbol(type: number): this;
+  writeFixExt2Symbol(type: number): this;
+  writeFixExt4Symbol(type: number): this;
+  writeFixExt8Symbol(type: number): this;
+  writeFixExt16Symbol(type: number): this;
+  writeExt8Symbol(type: number, size: number): this;
+  writeExt16Symbol(type: number, size: number): this;
+  writeExt32Symbol(type: number, size: number): this;
+  writeString(value: string): 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;
+  writeBigInt(value: bigint): this;
+  writeObject(value: object): this;
+  write(value: unknown): this;
+}
+//#endregion
+export { EncoderBuffer as t };
+//# sourceMappingURL=encoderBuffer-3ur0iCYR.d.cts.map

package/dist/cjs/encoderBuffer-3ur0iCYR.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoderBuffer-3ur0iCYR.d.cts","names":[],"sources":["../../src/encoder/encoderBuffer.ts"],"mappings":";;;;;cAuBM,cAAc,gBAAgB,aAAa,oBACvC,qBAAqB,oBAClB,yBAAyB;;;EAGpC;;;;;;;YAQU,cAAc;;;;;;;WAQf;;;;;;;;WASA;;;;;;;YAQC,eAAe,cAAc;WAE9B,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;EA0EZ,QAAQ;EAqBR,SAAS,8BAA8B,QACrC,OAAO,OAAO,MAAM;EAqBtB,UAAU;EAqBV,WAAW;EAwBX,gBAAgB,OAAO;EAiBvB,eACE,WAAW,sBACX,QAAQ,uBAAuB;EAiDjC,yBAAyB;EAqBzB,YAAY;EAYZ,YAAY;EAkBZ,MAAM"}

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

@@ -0,0 +1,54 @@
+const require_untypedExtension = require("../../untypedExtension.cjs");
+//#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 require_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
+module.exports = BigIntExtension;

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

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

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

@@ -0,0 +1,2 @@
+const require_extensions_bigint_bigInt = require("./bigInt.cjs");
+module.exports = require_extensions_bigint_bigInt;

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

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

package/dist/cjs/extensions/index.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_extensions_timestampDate_timestampDate = require("./timestampDate/timestampDate.cjs");
+exports.TimestampDateExtension = require_extensions_timestampDate_timestampDate;

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

@@ -0,0 +1,4 @@
+import { t as MessagePackExtension } from "../messagePackExtension-Cd99Rw9t.cjs";
+import { t as MessagePackTime } from "../types-B9KMW-kD.cjs";
+import { t as TimestampDateExtension } from "../timestampDate-Bi1rnvVd.cjs";
+export { type MessagePackExtension, type MessagePackTime, TimestampDateExtension };

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

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

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

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

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

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_extensions_timestampDate_timestampDate = require("./timestampDate.cjs");
+exports.TimestampDateExtension = require_extensions_timestampDate_timestampDate;

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

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

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

@@ -0,0 +1,79 @@
+//#region src/extensions/timestampDate/timestampDate.ts
+const TIMESTAMP32_MAX_SEC = 4294967295;
+const TIMESTAMP64_MAX_SEC = 17179869183;
+/**
+* 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
+*/
+var TimestampDateExtension = class {
+	type = -1;
+	parseToMessagePackTime(date) {
+		const msec = date.getTime();
+		const sec = Math.floor(msec / 1e3);
+		const nsec = (msec - sec * 1e3) * 1e6;
+		const nsecInSec = Math.floor(nsec / 1e9);
+		return {
+			nsec: nsec - nsecInSec * 1e9,
+			sec: sec + nsecInSec
+		};
+	}
+	encode(value, buffer) {
+		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);
+				else {
+					const secHigh = time.sec / 4294967296;
+					const secLow = time.sec & 4294967295;
+					buffer.writeUint32(time.nsec << 2 | secHigh & 3);
+					buffer.writeUint32(secLow);
+				}
+			} else {
+				buffer.writeUint32(time.nsec);
+				buffer.writeInt64(time.sec);
+			}
+		}
+	}
+	decode(decoderBuffer, size) {
+		const byteOffset = decoderBuffer.offset;
+		switch (size) {
+			case 4: {
+				const sec = decoderBuffer.view.getUint32(byteOffset);
+				return /* @__PURE__ */ new Date(sec * 1e3 + 0);
+			}
+			case 8: {
+				const nsec30AndSecHigh2 = decoderBuffer.view.getUint32(byteOffset);
+				const secLow32 = decoderBuffer.view.getUint32(byteOffset + 4);
+				const sec = (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32;
+				const nsec = nsec30AndSecHigh2 >>> 2;
+				return /* @__PURE__ */ new Date(sec * 1e3 + nsec / 1e6);
+			}
+			case 12: {
+				const high = decoderBuffer.view.getInt32(byteOffset + 4);
+				const low = decoderBuffer.view.getUint32(byteOffset + 8);
+				const sec = high * 4294967296 + low;
+				const nsec = decoderBuffer.view.getUint32(byteOffset);
+				return /* @__PURE__ */ new Date(sec * 1e3 + nsec / 1e6);
+			}
+			default: throw new Error(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${decoderBuffer.view.byteLength}`);
+		}
+	}
+};
+//#endregion
+module.exports = TimestampDateExtension;

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

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

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

@@ -0,0 +1,2 @@
+import { t as MessagePackTime } from "../../types-B9KMW-kD.cjs";
+export { MessagePackTime };

package/dist/cjs/fitIn16Bits-D9lga-sP.d.cts

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

package/dist/cjs/fitIn16Bits-D9lga-sP.d.cts.map

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

package/dist/cjs/fitIn32Bits-BrGIMOff.d.cts

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

package/dist/cjs/fitIn32Bits-BrGIMOff.d.cts.map

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

package/dist/cjs/fitIn7Bits-BVHyKXCg.d.cts

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

package/dist/cjs/fitIn7Bits-BVHyKXCg.d.cts.map

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

package/dist/cjs/fitIn8Bits-DQnQIhdh.d.cts

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

package/dist/cjs/fitIn8Bits-DQnQIhdh.d.cts.map

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

package/dist/cjs/fitInt64Bits-CY7lVKne.d.cts

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

package/dist/cjs/fitInt64Bits-CY7lVKne.d.cts.map

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

package/dist/cjs/index-5OuLsWCC.d.cts

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/cjs/index.cjs

@@ -0,0 +1,51 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bufferWithExtensions = require("./bufferWithExtensions.cjs");
+const require_constants = require("./constants.cjs");
+const require_symbols = require("./symbols.cjs");
+const require_untypedExtension = require("./untypedExtension.cjs");
+const require_utils_fitIn7Bits = require("./utils/fitIn7Bits.cjs");
+const require_utils_fitIn8Bits = require("./utils/fitIn8Bits.cjs");
+const require_utils_fitIn16Bits = require("./utils/fitIn16Bits.cjs");
+const require_utils_fitIn32Bits = require("./utils/fitIn32Bits.cjs");
+const require_encoder_textEncoders_defaultTextEncoder = require("./encoder/textEncoders/defaultTextEncoder.cjs");
+const require_encoder_encoderBuffer = require("./encoder/encoderBuffer.cjs");
+const require_encoder_encoder = require("./encoder/encoder.cjs");
+const require_benchmark_decoderDataTypesFactory = require("./benchmark/decoderDataTypesFactory.cjs");
+const require_decoder_textDecoders_defaultTextDecoder = require("./decoder/textDecoders/defaultTextDecoder.cjs");
+const require_decoder_textDecoders_nodeTextDecoder = require("./decoder/textDecoders/nodeTextDecoder.cjs");
+const require_decoder_decoderBuffer = require("./decoder/decoderBuffer.cjs");
+const require_decoder_decoder = require("./decoder/decoder.cjs");
+const require_decoder_decode = require("./decoder/decode.cjs");
+require("./decoder/index.cjs");
+const require_encoder_textEncoders_nodeTextEncoder = require("./encoder/textEncoders/nodeTextEncoder.cjs");
+const require_encoder_encode = require("./encoder/encode.cjs");
+require("./encoder/index.cjs");
+const require_extensions_timestampDate_timestampDate = require("./extensions/timestampDate/timestampDate.cjs");
+require("./extensions/index.cjs");
+const require_utils_fitInt64Bits = require("./utils/fitInt64Bits.cjs");
+require("./utils/index.cjs");
+exports.BufferWithExtensions = require_bufferWithExtensions;
+exports.DEFAULT_ALLOCATION_SIZE = require_constants.DEFAULT_ALLOCATION_SIZE;
+exports.Decoder = require_decoder_decoder;
+exports.DecoderBuffer = require_decoder_decoderBuffer;
+exports.DefaultTextDecoder = require_decoder_textDecoders_defaultTextDecoder;
+exports.DefaultTextEncoder = require_encoder_textEncoders_defaultTextEncoder;
+exports.Encoder = require_encoder_encoder;
+exports.EncoderBuffer = require_encoder_encoderBuffer;
+exports.INT32_MIN = require_constants.INT32_MIN;
+exports.INT64_MIN = require_constants.INT64_MIN;
+exports.NodeTextDecoder = require_decoder_textDecoders_nodeTextDecoder;
+exports.NodeTextEncoder = require_encoder_textEncoders_nodeTextEncoder;
+exports.Symbols = require_symbols;
+exports.TimestampDateExtension = require_extensions_timestampDate_timestampDate;
+exports.UINT32_MAX = require_constants.UINT32_MAX;
+exports.UINT64_MAX = require_constants.UINT64_MAX;
+exports.UntypedExtension = require_untypedExtension;
+exports.decode = require_decoder_decode;
+exports.decoderDataTypesFactory = require_benchmark_decoderDataTypesFactory;
+exports.encode = require_encoder_encode;
+exports.fitIn16Bits = require_utils_fitIn16Bits;
+exports.fitIn32Bits = require_utils_fitIn32Bits;
+exports.fitIn7Bits = require_utils_fitIn7Bits;
+exports.fitIn8Bits = require_utils_fitIn8Bits;
+exports.fitInt64Bits = require_utils_fitInt64Bits;

package/dist/cjs/index.d.cts

@@ -0,0 +1,27 @@
+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 { t as MessagePackTextEncoder } from "./messagePackTextEncoder-D7iCft_t.cjs";
+import { t as BufferWithExtensions } from "./bufferWithExtensions-n6DtcUoA.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 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 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 MessagePackTime } from "./types-B9KMW-kD.cjs";
+import { t as TimestampDateExtension } from "./timestampDate-Bi1rnvVd.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 };

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

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

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

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

package/dist/cjs/messagePackDecoderBuffer-B2rRVlMX.d.cts

@@ -0,0 +1,12 @@
+import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-J3fr-wQn.cjs";
+//#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-B2rRVlMX.d.cts.map

package/dist/cjs/messagePackDecoderBuffer-B2rRVlMX.d.cts.map

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