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

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

@@ -0,0 +1 @@
+{"version":3,"file":"messagePackExtension-Cd99Rw9t.d.cts","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;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BZ,SAAS,8BAA8B,QACrC,OAAO,OAAO,MAAM;;;;;;EAQtB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BR,WAAW;;;;;;EAOX,UAAU;;;;;;;EAQV,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCZ,gBAAgB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DvB,eACE,WAAW,sBACX,QAAQ,uBAAuB;;;;UC17BV,qBACvB,kBACA,gBAAgB,aAAa;;;;;;WAOpB;;;;;;;;;EAUT,OACE,wBACA,QAAQ,yBAAyB;;;;;;;;;;;;EAcnC,OAAO,eAAe,0BAA0B,eAAe"}

package/dist/cjs/messagePackTextDecoder-J3fr-wQn.d.cts

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

package/dist/cjs/messagePackTextDecoder-J3fr-wQn.d.cts.map

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

package/dist/cjs/messagePackTextEncoder-D7iCft_t.d.cts

@@ -0,0 +1,16 @@
+//#region src/encoder/interfaces/messagePackTextEncoder.d.ts
+/** An interface for encoding strings into MessagePack format. */
+interface MessagePackTextEncoder<TBuffer extends Uint8Array = Uint8Array> {
+  /**
+   * Writes a string to the provided buffer using the MessagePack format.
+   *
+   * @param source - The string to be encoded and written to the buffer.
+   * @param buffer - The buffer where the encoded string will be written.
+   *
+   * @returns The number of bytes written to the buffer.
+   */
+  writeBytes(source: string, buffer: TBuffer): number;
+}
+//#endregion
+export { MessagePackTextEncoder as t };
+//# sourceMappingURL=messagePackTextEncoder-D7iCft_t.d.cts.map

package/dist/cjs/messagePackTextEncoder-D7iCft_t.d.cts.map

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

package/dist/cjs/nodeTextDecoder-DrNFdTVk.d.cts

@@ -0,0 +1,9 @@
+import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-J3fr-wQn.cjs";
+import { Buffer } from "node:buffer";
+//#region src/decoder/textDecoders/nodeTextDecoder.d.ts
+declare class NodeTextDecoder implements MessagePackTextDecoder<Buffer> {
+  decode(buffer: Buffer, start: number, end: number): string;
+}
+//#endregion
+export { NodeTextDecoder as t };
+//# sourceMappingURL=nodeTextDecoder-DrNFdTVk.d.cts.map

package/dist/cjs/nodeTextDecoder-DrNFdTVk.d.cts.map

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

package/dist/cjs/nodeTextEncoder-DJzFDBXd.d.cts

@@ -0,0 +1,8 @@
+import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-D7iCft_t.cjs";
+//#region src/encoder/textEncoders/nodeTextEncoder.d.ts
+declare class NodeTextEncoder implements MessagePackTextEncoder {
+  writeBytes(value: string, buffer: Buffer): number;
+}
+//#endregion
+export { NodeTextEncoder as t };
+//# sourceMappingURL=nodeTextEncoder-DJzFDBXd.d.cts.map

package/dist/cjs/nodeTextEncoder-DJzFDBXd.d.cts.map

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

package/dist/cjs/symbols.cjs

@@ -0,0 +1,47 @@
+//#region src/symbols.ts
+const Symbols = {
+	POSITIVE_FIXINT_START: 0,
+	POSITIVE_FIXINT_END: 127,
+	FIXMAP_START: 128,
+	FIXMAP_END: 143,
+	FIXARRAY_START: 144,
+	FIXARRAY_END: 159,
+	FIXSTR_START: 160,
+	FIXSTR_END: 191,
+	NIL: 192,
+	NEVER_USED: 193,
+	FALSE: 194,
+	TRUE: 195,
+	BIN8: 196,
+	BIN16: 197,
+	BIN32: 198,
+	EXT8: 199,
+	EXT16: 200,
+	EXT32: 201,
+	FLOAT32: 202,
+	FLOAT64: 203,
+	UINT8: 204,
+	UINT16: 205,
+	UINT32: 206,
+	UINT64: 207,
+	INT8: 208,
+	INT16: 209,
+	INT32: 210,
+	INT64: 211,
+	FIXEXT1: 212,
+	FIXEXT2: 213,
+	FIXEXT4: 214,
+	FIXEXT8: 215,
+	FIXEXT16: 216,
+	STR8: 217,
+	STR16: 218,
+	STR32: 219,
+	ARRAY16: 220,
+	ARRAY32: 221,
+	MAP16: 222,
+	MAP32: 223,
+	NEGATIVE_FIXINT_START: 224,
+	NEGATIVE_FIXINT_END: 255
+};
+//#endregion
+module.exports = Symbols;

package/dist/cjs/symbols.d.cts

@@ -0,0 +1,47 @@
+//#region src/symbols.d.ts
+declare const Symbols: {
+  readonly POSITIVE_FIXINT_START: 0;
+  readonly POSITIVE_FIXINT_END: 127;
+  readonly FIXMAP_START: 128;
+  readonly FIXMAP_END: 143;
+  readonly FIXARRAY_START: 144;
+  readonly FIXARRAY_END: 159;
+  readonly FIXSTR_START: 160;
+  readonly FIXSTR_END: 191;
+  readonly NIL: 192;
+  readonly NEVER_USED: 193;
+  readonly FALSE: 194;
+  readonly TRUE: 195;
+  readonly BIN8: 196;
+  readonly BIN16: 197;
+  readonly BIN32: 198;
+  readonly EXT8: 199;
+  readonly EXT16: 200;
+  readonly EXT32: 201;
+  readonly FLOAT32: 202;
+  readonly FLOAT64: 203;
+  readonly UINT8: 204;
+  readonly UINT16: 205;
+  readonly UINT32: 206;
+  readonly UINT64: 207;
+  readonly INT8: 208;
+  readonly INT16: 209;
+  readonly INT32: 210;
+  readonly INT64: 211;
+  readonly FIXEXT1: 212;
+  readonly FIXEXT2: 213;
+  readonly FIXEXT4: 214;
+  readonly FIXEXT8: 215;
+  readonly FIXEXT16: 216;
+  readonly STR8: 217;
+  readonly STR16: 218;
+  readonly STR32: 219;
+  readonly ARRAY16: 220;
+  readonly ARRAY32: 221;
+  readonly MAP16: 222;
+  readonly MAP32: 223;
+  readonly NEGATIVE_FIXINT_START: 224;
+  readonly NEGATIVE_FIXINT_END: 255;
+};
+export = Symbols;
+//# sourceMappingURL=symbols.d.cts.map

package/dist/cjs/symbols.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols.d.cts","names":[],"sources":["../../src/symbols.ts"],"mappings":";cAEM;WACJ;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA"}

package/dist/cjs/timestampDate-Bi1rnvVd.d.cts

@@ -0,0 +1,33 @@
+import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-B2rRVlMX.cjs";
+import { n as MessagePackEncoderBuffer, t as MessagePackExtension } from "./messagePackExtension-Cd99Rw9t.cjs";
+import { t as MessagePackTime } from "./types-B9KMW-kD.cjs";
+//#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-Bi1rnvVd.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timestampDate-Bi1rnvVd.d.cts","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/cjs/types-B9KMW-kD.d.cts

@@ -0,0 +1,8 @@
+//#region src/extensions/timestampDate/types.d.ts
+interface MessagePackTime {
+  sec: number;
+  nsec: number;
+}
+//#endregion
+export { MessagePackTime as t };
+//# sourceMappingURL=types-B9KMW-kD.d.cts.map

package/dist/cjs/types-B9KMW-kD.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-B9KMW-kD.d.cts","names":[],"sources":["../../src/extensions/timestampDate/types.ts"],"mappings":";UAAiB;EACf;EACA"}

package/dist/cjs/types-CC2wkzZa.d.cts

@@ -0,0 +1,9 @@
+import { t as MessagePackTextDecoder } from "./messagePackTextDecoder-J3fr-wQn.cjs";
+import { n as BufferOptions } from "./types-DTcs4Mkd.cjs";
+//#region src/decoder/types.d.ts
+type DecoderBufferOptions<TBuffer extends Uint8Array = Uint8Array> = Pick<BufferOptions<TBuffer>, 'bufferFactory'> & {
+  textDecoder?: MessagePackTextDecoder<TBuffer>;
+};
+//#endregion
+export { DecoderBufferOptions as t };
+//# sourceMappingURL=types-CC2wkzZa.d.cts.map

package/dist/cjs/types-CC2wkzZa.d.cts.map

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

package/dist/cjs/types-DTcs4Mkd.d.cts

@@ -0,0 +1,20 @@
+//#region src/types.d.ts
+type BufferFactory<TBuffer extends Uint8Array = Uint8Array> = (requiredSize: number) => TBuffer;
+interface BufferOptions<TBuffer extends Uint8Array = Uint8Array> {
+  /**
+   * The initial size of the buffer used for encoding. If the buffer is not
+   * 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)
+   */
+  bufferFactory?: BufferFactory<TBuffer>;
+}
+//#endregion
+export { BufferOptions as n, BufferFactory as t };
+//# sourceMappingURL=types-DTcs4Mkd.d.cts.map

package/dist/cjs/types-DTcs4Mkd.d.cts.map

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

package/dist/cjs/types.d.cts

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

package/dist/cjs/untypedExtension-wx6-_4mg.d.cts

@@ -0,0 +1,16 @@
+import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-B2rRVlMX.cjs";
+import { n as MessagePackEncoderBuffer, t as MessagePackExtension } from "./messagePackExtension-Cd99Rw9t.cjs";
+//#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-wx6-_4mg.d.cts.map

package/dist/cjs/untypedExtension-wx6-_4mg.d.cts.map

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

package/dist/cjs/untypedExtension.cjs

@@ -0,0 +1,13 @@
+//#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
+module.exports = UntypedExtension;

package/dist/cjs/untypedExtension.d.cts

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

package/dist/cjs/utils/fitIn16Bits.cjs

@@ -0,0 +1,6 @@
+//#region src/utils/fitIn16Bits.ts
+function fitIn16Bits(length) {
+	return length < 65536;
+}
+//#endregion
+module.exports = fitIn16Bits;

package/dist/cjs/utils/fitIn16Bits.d.cts

@@ -0,0 +1,2 @@
+import { t as fitIn16Bits } from "../fitIn16Bits-D9lga-sP.cjs";
+export = fitIn16Bits;

package/dist/cjs/utils/fitIn32Bits.cjs

@@ -0,0 +1,6 @@
+//#region src/utils/fitIn32Bits.ts
+function fitIn32Bits(length) {
+	return length < 4294967296;
+}
+//#endregion
+module.exports = fitIn32Bits;

package/dist/cjs/utils/fitIn32Bits.d.cts

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

package/dist/cjs/utils/fitIn7Bits.cjs

@@ -0,0 +1,6 @@
+//#region src/utils/fitIn7Bits.ts
+function fitIn7Bits(length) {
+	return length < 128;
+}
+//#endregion
+module.exports = fitIn7Bits;

package/dist/cjs/utils/fitIn7Bits.d.cts

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

package/dist/cjs/utils/fitIn8Bits.cjs

@@ -0,0 +1,6 @@
+//#region src/utils/fitIn8Bits.ts
+function fitIn8Bits(length) {
+	return length < 256;
+}
+//#endregion
+module.exports = fitIn8Bits;

package/dist/cjs/utils/fitIn8Bits.d.cts

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

package/dist/cjs/utils/fitInt64Bits.cjs

@@ -0,0 +1,6 @@
+//#region src/utils/fitInt64Bits.ts
+function fitInt64Bits(value) {
+	return value <= Number.MAX_SAFE_INTEGER;
+}
+//#endregion
+module.exports = fitInt64Bits;

package/dist/cjs/utils/fitInt64Bits.d.cts

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

package/dist/cjs/utils/index.cjs

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_utils_fitIn7Bits = require("./fitIn7Bits.cjs");
+const require_utils_fitIn8Bits = require("./fitIn8Bits.cjs");
+const require_utils_fitIn16Bits = require("./fitIn16Bits.cjs");
+const require_utils_fitIn32Bits = require("./fitIn32Bits.cjs");
+const require_utils_fitInt64Bits = require("./fitInt64Bits.cjs");
+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/utils/index.d.cts

@@ -0,0 +1,6 @@
+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 { fitIn16Bits, fitIn32Bits, fitIn7Bits, fitIn8Bits, fitInt64Bits };

package/dist/esm/benchmark/decoderDataTypesFactory.d.mts

@@ -0,0 +1,6 @@
+import { dataTypesFactory } from "@schema-pack/benchmark";
+//#region src/benchmark/decoderDataTypesFactory.d.ts
+declare const decoderDataTypesFactory: Record<keyof typeof dataTypesFactory, () => Uint8Array>;
+//#endregion
+export { decoderDataTypesFactory as default };
+//# sourceMappingURL=decoderDataTypesFactory.d.mts.map

package/dist/esm/benchmark/decoderDataTypesFactory.d.mts.map

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

package/dist/esm/benchmark/decoderDataTypesFactory.mjs

@@ -0,0 +1,39 @@
+import Encoder from "../encoder/encoder.mjs";
+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())
+};
+//#endregion
+export { decoderDataTypesFactory as default };
+
+//# sourceMappingURL=decoderDataTypesFactory.mjs.map

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

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

package/dist/esm/bigInt-D37SPzzB.d.mts

@@ -0,0 +1,35 @@
+import { t as MessagePackDecoderBuffer } from "./messagePackDecoderBuffer-Cqvg0zW7.mjs";
+import { i as ExtensionEncoderBuffer } from "./messagePackExtension-fq36EMAg.mjs";
+import { t as UntypedExtension } from "./untypedExtension-Ckk9RwQw.mjs";
+//#region src/extensions/bigint/bigInt.d.ts
+/**
+ * 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.
+ */
+declare class BigIntExtension<TBuffer extends Uint8Array = Uint8Array> extends UntypedExtension<bigint, TBuffer> {
+  /**
+   * 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: object | bigint, buffer: ExtensionEncoderBuffer<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
+   * encoding scheme. The method returns the decoded BigInt value.
+   */
+  decode(buffer: MessagePackDecoderBuffer, size: number): bigint;
+}
+//#endregion
+export { BigIntExtension as t };
+//# sourceMappingURL=bigInt-D37SPzzB.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bigInt-D37SPzzB.d.mts","names":[],"sources":["../../src/extensions/bigint/bigInt.ts"],"mappings":";;;;;;;;;;;;cAcM,gBACJ,gBAAgB,aAAa,oBACrB,yBAAyB;;;;;;;;;;;;EAYjC,OACE,wBACA,QAAQ,uBAAuB;;;;;;EAyBjC,OAAO,QAAQ,0BAA0B"}

package/dist/esm/bufferWithExtensions-DzAs7yX1.d.mts

@@ -0,0 +1,12 @@
+import { o as MessagePackBufferWithExtensions, t as MessagePackExtension } from "./messagePackExtension-fq36EMAg.mjs";
+//#region src/bufferWithExtensions.d.ts
+declare abstract class BufferWithExtensions<TBuffer extends Uint8Array = Uint8Array> implements MessagePackBufferWithExtensions<TBuffer> {
+  protected extensions: Map<number, MessagePackExtension<unknown, TBuffer>>;
+  constructor();
+  addExtension(extension: MessagePackExtension<unknown, TBuffer>): this;
+  addInternalExtension(extension: MessagePackExtension<unknown, TBuffer>): this;
+  fetchExtension(type: number): MessagePackExtension<unknown, TBuffer>;
+}
+//#endregion
+export { BufferWithExtensions as t };
+//# sourceMappingURL=bufferWithExtensions-DzAs7yX1.d.mts.map

package/dist/esm/bufferWithExtensions-DzAs7yX1.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferWithExtensions-DzAs7yX1.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

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

package/dist/esm/bufferWithExtensions.mjs

@@ -0,0 +1,30 @@
+//#region src/bufferWithExtensions.ts
+var BufferWithExtensions = class {
+	extensions;
+	constructor() {
+		this.extensions = /* @__PURE__ */ new Map();
+	}
+	addExtension(extension) {
+		if (this.extensions.has(extension.type)) throw new Error(`Extension with type ${extension.type} already exists`);
+		if (extension.type < 0) throw new Error(`Extension type must be a non-negative integer, got ${extension.type}. Extensions between -128 and -1 are reserved for internal use. Use addInternalExtension() to register an internal extension.`);
+		if (extension.type > 127) throw new Error(`Extension type must be in the range 0 to 127, got ${extension.type}`);
+		this.extensions.set(extension.type, extension);
+		return this;
+	}
+	addInternalExtension(extension) {
+		if (this.extensions.has(extension.type)) throw new Error(`Extension with type ${extension.type} already exists`);
+		if (extension.type >= 0) throw new Error(`Internal extension type must be a negative integer, got ${extension.type}. Use addExtension() to register a custom extension.`);
+		if (extension.type < -128) throw new Error(`Internal extension type must be in the range -128 to -1, got ${extension.type}`);
+		this.extensions.set(extension.type, extension);
+		return this;
+	}
+	fetchExtension(type) {
+		const extension = this.extensions.get(type);
+		if (!extension) throw new Error(`Extension with type ${type} not found`);
+		return extension;
+	}
+};
+//#endregion
+export { BufferWithExtensions as default };
+
+//# sourceMappingURL=bufferWithExtensions.mjs.map

package/dist/esm/bufferWithExtensions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferWithExtensions.mjs","names":[],"sources":["../../src/bufferWithExtensions.ts"],"sourcesContent":["import type MessagePackExtension from './extensions/interfaces/messagePackExtension.ts';\nimport type MessagePackBufferWithExtensions from './interfaces/messagePackBufferWithExtensions.ts';\n\nabstract class BufferWithExtensions<\n  TBuffer extends Uint8Array = Uint8Array,\n> implements MessagePackBufferWithExtensions<TBuffer> {\n  protected extensions: Map<number, MessagePackExtension<unknown, TBuffer>>;\n\n  constructor() {\n    this.extensions = new Map();\n  }\n\n  addExtension(extension: MessagePackExtension<unknown, TBuffer>): this {\n    if (this.extensions.has(extension.type)) {\n      throw new Error(`Extension with type ${extension.type} already exists`);\n    }\n\n    if (extension.type < 0) {\n      throw new Error(\n        `Extension type must be a non-negative integer, got ${extension.type}. Extensions between -128 and -1 are reserved for internal use. Use addInternalExtension() to register an internal extension.`,\n      );\n    }\n\n    if (extension.type > 127) {\n      throw new Error(\n        `Extension type must be in the range 0 to 127, got ${extension.type}`,\n      );\n    }\n\n    this.extensions.set(extension.type, extension);\n\n    return this;\n  }\n\n  addInternalExtension(\n    extension: MessagePackExtension<unknown, TBuffer>,\n  ): this {\n    if (this.extensions.has(extension.type)) {\n      throw new Error(`Extension with type ${extension.type} already exists`);\n    }\n\n    if (extension.type >= 0) {\n      throw new Error(\n        `Internal extension type must be a negative integer, got ${extension.type}. Use addExtension() to register a custom extension.`,\n      );\n    }\n\n    if (extension.type < -128) {\n      throw new Error(\n        `Internal extension type must be in the range -128 to -1, got ${extension.type}`,\n      );\n    }\n\n    this.extensions.set(extension.type, extension);\n\n    return this;\n  }\n\n  fetchExtension(type: number): MessagePackExtension<unknown, TBuffer> {\n    const extension = this.extensions.get(type);\n\n    if (!extension) {\n      throw new Error(`Extension with type ${type} not found`);\n    }\n\n    return extension;\n  }\n}\n\nexport default BufferWithExtensions;\n"],"mappings":";AAGA,IAAe,uBAAf,MAEsD;CACpD;CAEA,cAAc;EACZ,KAAK,6BAAa,IAAI,IAAI;CAC5B;CAEA,aAAa,WAAyD;EACpE,IAAI,KAAK,WAAW,IAAI,UAAU,IAAI,GACpC,MAAM,IAAI,MAAM,uBAAuB,UAAU,KAAK,gBAAgB;EAGxE,IAAI,UAAU,OAAO,GACnB,MAAM,IAAI,MACR,sDAAsD,UAAU,KAAK,8HACvE;EAGF,IAAI,UAAU,OAAO,KACnB,MAAM,IAAI,MACR,qDAAqD,UAAU,MACjE;EAGF,KAAK,WAAW,IAAI,UAAU,MAAM,SAAS;EAE7C,OAAO;CACT;CAEA,qBACE,WACM;EACN,IAAI,KAAK,WAAW,IAAI,UAAU,IAAI,GACpC,MAAM,IAAI,MAAM,uBAAuB,UAAU,KAAK,gBAAgB;EAGxE,IAAI,UAAU,QAAQ,GACpB,MAAM,IAAI,MACR,2DAA2D,UAAU,KAAK,qDAC5E;EAGF,IAAI,UAAU,OAAO,MACnB,MAAM,IAAI,MACR,gEAAgE,UAAU,MAC5E;EAGF,KAAK,WAAW,IAAI,UAAU,MAAM,SAAS;EAE7C,OAAO;CACT;CAEA,eAAe,MAAsD;EACnE,MAAM,YAAY,KAAK,WAAW,IAAI,IAAI;EAE1C,IAAI,CAAC,WACH,MAAM,IAAI,MAAM,uBAAuB,KAAK,WAAW;EAGzD,OAAO;CACT;AACF"}

package/dist/esm/constants.d.mts

@@ -0,0 +1,32 @@
+//#region src/constants.d.ts
+/**
+ * JavaScript numbers are stored as IEEE 754 double precision floating point
+ * numbers, which means that they can only safely represent max uint64 as:
+ *
+ * 2^53 - 1 = 9007199254740991, or Number.MAX_SAFE_INTEGER.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
+ */
+declare const UINT64_MAX: number;
+/**
+ * JavaScript numbers are stored as IEEE 754 double precision floating point
+ * numbers, which means that they can only safely represent min int64 as:
+ *
+ * -(2^53 - 1) = -9007199254740991, or Number.MIN_SAFE_INTEGER.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER
+ */
+declare const INT64_MIN: number;
+/** 4294967295. */
+declare const UINT32_MAX: number;
+/** -2147483648. */
+declare const INT32_MIN = -2147483648;
+/**
+ * Default allocation size for the encoder and decoder buffers. This is the
+ * initial size of the buffer when it is created, and it will grow as needed
+ * when more data is written to it.
+ */
+declare const DEFAULT_ALLOCATION_SIZE = 1024;
+//#endregion
+export { DEFAULT_ALLOCATION_SIZE, INT32_MIN, INT64_MIN, UINT32_MAX, UINT64_MAX };
+//# sourceMappingURL=constants.d.mts.map

package/dist/esm/constants.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.mts","names":[],"sources":["../../src/constants.ts"],"mappings":";;;;;;;;;cAQa;;;;;;;;;cAUA;;cAGA;;cAGA;;;;;;cAOA"}

package/dist/esm/constants.mjs

@@ -0,0 +1,33 @@
+//#region src/constants.ts
+/**
+* JavaScript numbers are stored as IEEE 754 double precision floating point
+* numbers, which means that they can only safely represent max uint64 as:
+*
+* 2^53 - 1 = 9007199254740991, or Number.MAX_SAFE_INTEGER.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
+*/
+const UINT64_MAX = Number.MAX_SAFE_INTEGER;
+/**
+* JavaScript numbers are stored as IEEE 754 double precision floating point
+* numbers, which means that they can only safely represent min int64 as:
+*
+* -(2^53 - 1) = -9007199254740991, or Number.MIN_SAFE_INTEGER.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER
+*/
+const INT64_MIN = Number.MIN_SAFE_INTEGER;
+/** 4294967295. */
+const UINT32_MAX = -1 >>> 0;
+/** -2147483648. */
+const INT32_MIN = -2147483648;
+/**
+* Default allocation size for the encoder and decoder buffers. This is the
+* initial size of the buffer when it is created, and it will grow as needed
+* when more data is written to it.
+*/
+const DEFAULT_ALLOCATION_SIZE = 1024;
+//#endregion
+export { DEFAULT_ALLOCATION_SIZE, INT32_MIN, INT64_MIN, UINT32_MAX, UINT64_MAX };
+
+//# sourceMappingURL=constants.mjs.map

package/dist/esm/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":[],"sources":["../../src/constants.ts"],"sourcesContent":["/**\n * JavaScript numbers are stored as IEEE 754 double precision floating point\n * numbers, which means that they can only safely represent max uint64 as:\n *\n * 2^53 - 1 = 9007199254740991, or Number.MAX_SAFE_INTEGER.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER\n */\nexport const UINT64_MAX = Number.MAX_SAFE_INTEGER;\n\n/**\n * JavaScript numbers are stored as IEEE 754 double precision floating point\n * numbers, which means that they can only safely represent min int64 as:\n *\n * -(2^53 - 1) = -9007199254740991, or Number.MIN_SAFE_INTEGER.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER\n */\nexport const INT64_MIN = Number.MIN_SAFE_INTEGER;\n\n/** 4294967295. */\nexport const UINT32_MAX = ~0 >>> 0;\n\n/** -2147483648. */\nexport const INT32_MIN = -0x80_00_00_00;\n\n/**\n * Default allocation size for the encoder and decoder buffers. This is the\n * initial size of the buffer when it is created, and it will grow as needed\n * when more data is written to it.\n */\nexport const DEFAULT_ALLOCATION_SIZE = 1024;\n"],"mappings":";;;;;;;;;AAQA,MAAa,aAAa,OAAO;;;;;;;;;AAUjC,MAAa,YAAY,OAAO;;AAGhC,MAAa,aAAa,OAAO;;AAGjC,MAAa,YAAY;;;;;;AAOzB,MAAa,0BAA0B"}