binary-packet 1.0.3 → 1.0.5

package/README.md

@@ -31,9 +31,11 @@ Currently, these kinds of `fields` are supported:
 | `Field.FLOAT_32` | 32 bits IEEE754 floating-point | | 4 |
 | `Field.FLOAT_64` | 64 bits IEEE754 floating-point | | 8 |
 | `BinaryPacket` | BinaryPacket "subpacket" | BinaryPacket | size(BinaryPacket) |
-| `FieldArray` | Array of one of the types above | Up to 256 elements | 1 + length \* size(Field) |
+| `FieldArray` | Dynamically-sized array of one of the types above | Up to 256 elements | 1 + length \* size(Element) |
+| `FieldFixedArray` | Statically-sized array of one of the types above | Any pre-defined numbers of elements | length \* size(Element) |
 
-As you can see from the table above, both arrays and nested objects ("subpackets") are supported.
+As you can see from the table above, both arrays and nested objects ("subpackets") are supported. \
+Note that `FieldFixedArray`s are much more memory efficient and performant than `FieldArray`s, but require a pre-defined length.
 
 ## Usage Examples
 
@@ -57,7 +59,7 @@ const CellPacket = BinaryPacket.define(0, Cell)
 const Board = {
   numPlayers: Field.UNSIGNED_INT_8,
   otherStuff: Field.INT_32,
-  cells: FieldArray(CellPacket) // equivalent to { cells: [CellPacket] }
+  cells: FieldArray(CellPacket)
 }
 
 // When done with the board definition we can create its BinaryPacket writer/reader.
@@ -108,14 +110,14 @@ So, take these "performance" comparisons with a grain of salt; or, even better,
 
 This library has been benchmarked against the following alternatives:
 
-- [msgpackr](https://www.npmjs.com/package/msgpackr) - A very popular and very fast and battle-tested serialization library. It currently offers **many** more features than binary-packet, but it appears to be 2x-4x slower in writes and 3x-10x slower in reads.
-- [restructure](https://www.npmjs.com/package/restructure) - A very popular schema-based serialization library, has some extra features like LazyArrays, but it is **much slower** than both binary-packet and msgpackr. And, sadly, easily crashes with complex structures.
+- [msgpackr](https://www.npmjs.com/package/msgpackr) - A very popular, fast and battle-tested library. Currently offers **many** more features than binary-packet, but it appears to be 2x-4x slower in writes and 3x-10x slower in reads (depends on the packet structure) - is also less type-safe.
+- [restructure](https://www.npmjs.com/package/restructure) - An older, popular schema-based library, has some extra features like LazyArrays, but it is **much slower** than both binary-packet and msgpackr. And, sadly, easily crashes with complex structures.
 
 The benchmarks are executed on three different kinds of packets:
 
 - EmptyPacket: basically an empty javascript object.
-- SimplePacket: objects with primitive-only fields.
-- ComplexPacket: objects with primitives, arrays and other nested objects/arrays.
+- SimplePacket: objects with just primitive fields and statically-sized arrays.
+- ComplexPacket: objects with primitives, statically-sized arrays, dynamically-sized arrays and other nested objects/arrays.
 
 You can see and run the benchmarks yourself if you clone the repository and launch `npm run benchmark`.
 

package/dist/index.d.mts

@@ -39,10 +39,22 @@ declare const enum Field {
     FLOAT_64 = 7
 }
 /**
- * Defines an array of a certain type. \
- * As of now, only arrays with at most 256 elements are supported.
+ * Defines a dynamically-sized array with elements of a certain type. \
+ * Dynamically-sized arrays are useful when a packet's field is an array of a non pre-defined length. \
+ * Although, this makes dynamically-sized arrays more memory expensive as the internal buffer needs to be grown accordingly.
+ *
+ * NOTE: If an array will ALWAYS have the same length, prefer using the `FieldFixedArray` type, for both better performance and memory efficiency. \
+ * NOTE: As of now, dynamic arrays can have at most 256 elements.
+ */
+declare function FieldArray<T extends Field | BinaryPacket<Definition>>(item: T): [itemType: T];
+/**
+ * Defines a statically-sized array with elements of a certain type. \
+ * Fixed arrays are useful when a packet's field is an array of a pre-defined length. \
+ * Fixed arrays much more memory efficient and performant than non-fixed ones.
+ *
+ * NOTE: If an array will not always have the same length, use the `FieldArray` type.
  */
-declare function FieldArray<T extends Field | BinaryPacket<Definition>>(item: T): T[];
+declare function FieldFixedArray<T extends Field | BinaryPacket<Definition>, Length extends number>(item: T, length: Length): [itemType: T, length: Length];
 declare class BinaryPacket<T extends Definition> {
     private readonly packetId;
     /**
@@ -139,10 +151,13 @@ declare class BinaryPacket<T extends Definition> {
     private constructor();
     private read;
     private write;
+    /**
+     * Fast write does not support writing dynamically-sized arrays.
+     */
     private fastWrite;
     /**
      * The slow writing path tries writing data into the buffer as fast as the fast writing path does. \
-     * But, if a non-empty array is encountered, the buffer needs to grow, slightly reducing performance.
+     * But, if a non-empty dynamically-sized array is encountered, the buffer needs to grow, slightly reducing performance.
      */
     private slowWrite;
 }
@@ -167,7 +182,7 @@ declare class BinaryPacket<T extends Definition> {
  * // You can also specify arrays of both "primitive" fields and other BinaryPackets.
  * const Board = {
  *  numPlayers: Field.UNSIGNED_INT_8,
- *  cells: FieldArray(CellPacket) // equivalent to { cells: [CellPacket] }
+ *  cells: FieldArray(CellPacket)
  * }
  *
  * // When done with the board definition we can create its BinaryPacket writer/reader.
@@ -190,13 +205,18 @@ declare class BinaryPacket<T extends Definition> {
  * // ...
  */
 type Definition = {
-    [fieldName: string]: Field | Field[] | BinaryPacket<Definition> | BinaryPacket<Definition>[];
+    [fieldName: string]: MaybeArray<Field> | MaybeArray<BinaryPacket<Definition>>;
 };
+type MaybeArray<T> = T | [itemType: T] | [itemType: T, length: number];
 /**
  * Meta-type that converts a `Definition` schema to the type of the actual JavaScript object that will be written into a packet or read from. \
  */
 type ToJson<T extends Definition> = {
-    [K in keyof T]: T[K] extends ReadonlyArray<infer Item> ? Item extends BinaryPacket<infer BPDef> ? ToJson<BPDef>[] : number[] : T[K] extends BinaryPacket<infer BPDef> ? ToJson<BPDef> : number;
+    [K in keyof T]: T[K] extends [infer Item] ? Item extends BinaryPacket<infer BPDef> ? ToJson<BPDef>[] : number[] : T[K] extends [infer Item, infer Length] ? Item extends BinaryPacket<infer BPDef> ? ToJson<BPDef>[] & {
+        length: Length;
+    } : number[] & {
+        length: Length;
+    } : T[K] extends BinaryPacket<infer BPDef> ? ToJson<BPDef> : number;
 };
 
-export { BinaryPacket, type Definition, Field, FieldArray };
+export { BinaryPacket, type Definition, Field, FieldArray, FieldFixedArray };

package/dist/index.d.ts

@@ -39,10 +39,22 @@ declare const enum Field {
     FLOAT_64 = 7
 }
 /**
- * Defines an array of a certain type. \
- * As of now, only arrays with at most 256 elements are supported.
+ * Defines a dynamically-sized array with elements of a certain type. \
+ * Dynamically-sized arrays are useful when a packet's field is an array of a non pre-defined length. \
+ * Although, this makes dynamically-sized arrays more memory expensive as the internal buffer needs to be grown accordingly.
+ *
+ * NOTE: If an array will ALWAYS have the same length, prefer using the `FieldFixedArray` type, for both better performance and memory efficiency. \
+ * NOTE: As of now, dynamic arrays can have at most 256 elements.
+ */
+declare function FieldArray<T extends Field | BinaryPacket<Definition>>(item: T): [itemType: T];
+/**
+ * Defines a statically-sized array with elements of a certain type. \
+ * Fixed arrays are useful when a packet's field is an array of a pre-defined length. \
+ * Fixed arrays much more memory efficient and performant than non-fixed ones.
+ *
+ * NOTE: If an array will not always have the same length, use the `FieldArray` type.
  */
-declare function FieldArray<T extends Field | BinaryPacket<Definition>>(item: T): T[];
+declare function FieldFixedArray<T extends Field | BinaryPacket<Definition>, Length extends number>(item: T, length: Length): [itemType: T, length: Length];
 declare class BinaryPacket<T extends Definition> {
     private readonly packetId;
     /**
@@ -139,10 +151,13 @@ declare class BinaryPacket<T extends Definition> {
     private constructor();
     private read;
     private write;
+    /**
+     * Fast write does not support writing dynamically-sized arrays.
+     */
     private fastWrite;
     /**
      * The slow writing path tries writing data into the buffer as fast as the fast writing path does. \
-     * But, if a non-empty array is encountered, the buffer needs to grow, slightly reducing performance.
+     * But, if a non-empty dynamically-sized array is encountered, the buffer needs to grow, slightly reducing performance.
      */
     private slowWrite;
 }
@@ -167,7 +182,7 @@ declare class BinaryPacket<T extends Definition> {
  * // You can also specify arrays of both "primitive" fields and other BinaryPackets.
  * const Board = {
  *  numPlayers: Field.UNSIGNED_INT_8,
- *  cells: FieldArray(CellPacket) // equivalent to { cells: [CellPacket] }
+ *  cells: FieldArray(CellPacket)
  * }
  *
  * // When done with the board definition we can create its BinaryPacket writer/reader.
@@ -190,13 +205,18 @@ declare class BinaryPacket<T extends Definition> {
  * // ...
  */
 type Definition = {
-    [fieldName: string]: Field | Field[] | BinaryPacket<Definition> | BinaryPacket<Definition>[];
+    [fieldName: string]: MaybeArray<Field> | MaybeArray<BinaryPacket<Definition>>;
 };
+type MaybeArray<T> = T | [itemType: T] | [itemType: T, length: number];
 /**
  * Meta-type that converts a `Definition` schema to the type of the actual JavaScript object that will be written into a packet or read from. \
  */
 type ToJson<T extends Definition> = {
-    [K in keyof T]: T[K] extends ReadonlyArray<infer Item> ? Item extends BinaryPacket<infer BPDef> ? ToJson<BPDef>[] : number[] : T[K] extends BinaryPacket<infer BPDef> ? ToJson<BPDef> : number;
+    [K in keyof T]: T[K] extends [infer Item] ? Item extends BinaryPacket<infer BPDef> ? ToJson<BPDef>[] : number[] : T[K] extends [infer Item, infer Length] ? Item extends BinaryPacket<infer BPDef> ? ToJson<BPDef>[] & {
+        length: Length;
+    } : number[] & {
+        length: Length;
+    } : T[K] extends BinaryPacket<infer BPDef> ? ToJson<BPDef> : number;
 };
 
-export { BinaryPacket, type Definition, Field, FieldArray };
+export { BinaryPacket, type Definition, Field, FieldArray, FieldFixedArray };

package/dist/index.js

@@ -22,7 +22,8 @@ var src_exports = {};
 __export(src_exports, {
   BinaryPacket: () => BinaryPacket,
   Field: () => Field,
-  FieldArray: () => FieldArray
+  FieldArray: () => FieldArray,
+  FieldFixedArray: () => FieldFixedArray
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -59,6 +60,12 @@ var Field = /* @__PURE__ */ ((Field2) => {
 function FieldArray(item) {
   return [item];
 }
+function FieldFixedArray(item, length) {
+  if (length < 0 || !Number.isFinite(length)) {
+    throw new RangeError("Length of a FixedArray must be a positive integer.");
+  }
+  return [item, length];
+}
 var BinaryPacket = class _BinaryPacket {
   constructor(packetId, definition) {
     this.packetId = packetId;
@@ -200,7 +207,10 @@ var BinaryPacket = class _BinaryPacket {
     const result = {};
     for (const [name, def] of this.entries) {
       if (Array.isArray(def)) {
-        const length = readFunctions[0 /* UNSIGNED_INT_8 */](dataIn, offsetPointer.offset++);
+        const length = (
+          // def[1] is the length of a statically-sized array, if undefined: must read the length from the buffer as it means it's a dynamically-sized array
+          def[1] ?? readFunctions[0 /* UNSIGNED_INT_8 */](dataIn, offsetPointer.offset++)
+        );
         const array = Array(length);
         const itemType = def[0];
         if (typeof itemType === "object") {
@@ -242,16 +252,28 @@ var BinaryPacket = class _BinaryPacket {
       );
     }
   }
+  /**
+   * Fast write does not support writing dynamically-sized arrays.
+   */
   fastWrite(buffer, dataOut, offsetPointer, writeFunctions) {
     for (const [name, def] of this.entries) {
-      if (typeof def === "object") {
-        ;
-        def.fastWrite(
-          buffer,
-          dataOut[name],
-          offsetPointer,
-          writeFunctions
-        );
+      if (Array.isArray(def)) {
+        const itemType = def[0];
+        const length = def[1];
+        const data = dataOut[name];
+        if (typeof itemType === "object") {
+          for (let i = 0; i < length; ++i) {
+            itemType.fastWrite(buffer, data[i], offsetPointer, writeFunctions);
+          }
+        } else {
+          const itemSize = BYTE_SIZE[itemType];
+          for (let i = 0; i < length; ++i) {
+            writeFunctions[itemType](buffer, data[i], offsetPointer.offset);
+            offsetPointer.offset += itemSize;
+          }
+        }
+      } else if (typeof def === "object") {
+        def.fastWrite(buffer, dataOut[name], offsetPointer, writeFunctions);
       } else {
         writeFunctions[def](buffer, dataOut[name], offsetPointer.offset);
         offsetPointer.offset += BYTE_SIZE[def];
@@ -260,23 +282,28 @@ var BinaryPacket = class _BinaryPacket {
   }
   /**
    * The slow writing path tries writing data into the buffer as fast as the fast writing path does. \
-   * But, if a non-empty array is encountered, the buffer needs to grow, slightly reducing performance.
+   * But, if a non-empty dynamically-sized array is encountered, the buffer needs to grow, slightly reducing performance.
    */
   slowWrite(buffer, dataOut, offsetPointer, byteLength, maxByteLength, writeFunctions, growBufferFunction) {
     for (const [name, def] of this.entries) {
       const data = dataOut[name];
       if (Array.isArray(def)) {
         const length = data.length;
-        writeFunctions[0 /* UNSIGNED_INT_8 */](buffer, length, offsetPointer.offset);
-        offsetPointer.offset += 1;
+        const isDynamicArray = def[1] === void 0;
+        if (isDynamicArray) {
+          writeFunctions[0 /* UNSIGNED_INT_8 */](buffer, length, offsetPointer.offset);
+          offsetPointer.offset += 1;
+        }
         if (length > 0) {
           const itemType = def[0];
           if (typeof itemType === "object") {
-            const neededBytesForElements = length * itemType.minimumByteLength;
-            byteLength += neededBytesForElements;
-            maxByteLength += neededBytesForElements;
-            if (buffer.byteLength < maxByteLength) {
-              buffer = growBufferFunction(buffer, maxByteLength);
+            if (isDynamicArray) {
+              const neededBytesForElements = length * itemType.minimumByteLength;
+              byteLength += neededBytesForElements;
+              maxByteLength += neededBytesForElements;
+              if (buffer.byteLength < maxByteLength) {
+                buffer = growBufferFunction(buffer, maxByteLength);
+              }
             }
             for (const object of data) {
               writeFunctions[0 /* UNSIGNED_INT_8 */](
@@ -299,11 +326,13 @@ var BinaryPacket = class _BinaryPacket {
             }
           } else {
             const itemSize = BYTE_SIZE[itemType];
-            const neededBytesForElements = length * itemSize;
-            byteLength += neededBytesForElements;
-            maxByteLength += neededBytesForElements;
-            if (buffer.byteLength < maxByteLength) {
-              buffer = growBufferFunction(buffer, maxByteLength);
+            if (isDynamicArray) {
+              const neededBytesForElements = length * itemSize;
+              byteLength += neededBytesForElements;
+              maxByteLength += neededBytesForElements;
+              if (buffer.byteLength < maxByteLength) {
+                buffer = growBufferFunction(buffer, maxByteLength);
+              }
             }
             for (const number of data) {
               writeFunctions[itemType](buffer, number, offsetPointer.offset);
@@ -343,8 +372,13 @@ function inspectEntries(entries) {
   let canFastWrite = true;
   for (const [, type] of entries) {
     if (Array.isArray(type)) {
-      minimumByteLength += 1;
-      canFastWrite = false;
+      if (type.length === 2) {
+        const itemSize = typeof type[0] === "object" ? type[0].minimumByteLength : BYTE_SIZE[type[0]];
+        minimumByteLength += type[1] * itemSize;
+      } else {
+        minimumByteLength += 1;
+        canFastWrite = false;
+      }
     } else if (type instanceof BinaryPacket) {
       minimumByteLength += type.minimumByteLength;
       canFastWrite &&= type.canFastWrite;
@@ -366,12 +400,12 @@ BYTE_SIZE[7 /* FLOAT_64 */] = 8;
 var GET_FUNCTION = Array(8);
 GET_FUNCTION[0 /* UNSIGNED_INT_8 */] = (view, offset) => view.getUint8(offset);
 GET_FUNCTION[3 /* INT_8 */] = (view, offset) => view.getInt8(offset);
-GET_FUNCTION[1 /* UNSIGNED_INT_16 */] = (view, offset, le) => view.getUint16(offset, le);
-GET_FUNCTION[4 /* INT_16 */] = (view, offset, le) => view.getInt16(offset, le);
-GET_FUNCTION[2 /* UNSIGNED_INT_32 */] = (view, offset, le) => view.getUint32(offset, le);
-GET_FUNCTION[5 /* INT_32 */] = (view, offset, le) => view.getInt32(offset, le);
-GET_FUNCTION[6 /* FLOAT_32 */] = (view, offset, le) => view.getFloat32(offset, le);
-GET_FUNCTION[7 /* FLOAT_64 */] = (view, offset, le) => view.getFloat64(offset, le);
+GET_FUNCTION[1 /* UNSIGNED_INT_16 */] = (view, offset) => view.getUint16(offset);
+GET_FUNCTION[4 /* INT_16 */] = (view, offset) => view.getInt16(offset);
+GET_FUNCTION[2 /* UNSIGNED_INT_32 */] = (view, offset) => view.getUint32(offset);
+GET_FUNCTION[5 /* INT_32 */] = (view, offset) => view.getInt32(offset);
+GET_FUNCTION[6 /* FLOAT_32 */] = (view, offset) => view.getFloat32(offset);
+GET_FUNCTION[7 /* FLOAT_64 */] = (view, offset) => view.getFloat64(offset);
 var SET_FUNCTION = Array(8);
 SET_FUNCTION[0 /* UNSIGNED_INT_8 */] = (view, value, offset) => view.setUint8(offset, value);
 SET_FUNCTION[3 /* INT_8 */] = (view, value, offset) => view.setInt8(offset, value);
@@ -407,6 +441,7 @@ if (hasNodeBuffers) {
 0 && (module.exports = {
   BinaryPacket,
   Field,
-  FieldArray
+  FieldArray,
+  FieldFixedArray
 });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/buffers.ts"],"sourcesContent":["import { growDataView, growNodeBuffer, hasNodeBuffers } from './buffers'\r\n\r\nexport const enum Field {\r\n  /**\r\n   * Defines a 1 byte (8 bits) unsigned integer field. \\\r\n   * (Range: 0 - 255)\r\n   */\r\n  UNSIGNED_INT_8 = 0,\r\n\r\n  /**\r\n   * Defines a 2 bytes (16 bits) unsigned integer field. \\\r\n   * (Range: 0 - 65535)\r\n   */\r\n  UNSIGNED_INT_16,\r\n\r\n  /**\r\n   * Defines a 4 bytes (32 bits) unsigned integer field. \\\r\n   * (Range: 0 - 4294967295)\r\n   */\r\n  UNSIGNED_INT_32,\r\n\r\n  /**\r\n   * Defines a 1 byte (8 bits) signed integer field. \\\r\n   * (Range: -128 - 127)\r\n   */\r\n  INT_8,\r\n\r\n  /**\r\n   * Defines a 2 bytes (16 bits) signed integer field. \\\r\n   * (Range: -32768 - 32767)\r\n   */\r\n  INT_16,\r\n\r\n  /**\r\n   * Defines a 4 bytes (32 bits) signed integer field. \\\r\n   * (Range: -2147483648 - 2147483647)\r\n   */\r\n  INT_32,\r\n\r\n  /**\r\n   * Defines a 4 bytes (32 bits) floating-point field. \\\r\n   */\r\n  FLOAT_32,\r\n\r\n  /**\r\n   * Defines a 8 bytes (64 bits) floating-point field. \\\r\n   */\r\n  FLOAT_64\r\n}\r\n\r\n/**\r\n * Defines an array of a certain type. \\\r\n * As of now, only arrays with at most 256 elements are supported.\r\n */\r\nexport function FieldArray<T extends Field | BinaryPacket<Definition>>(item: T) {\r\n  return [item]\r\n}\r\n\r\nexport class BinaryPacket<T extends Definition> {\r\n  /**\r\n   * Defines a new binary packet. \\\r\n   * Make sure that every `packetId` is unique.\r\n   * @throws RangeError If packetId is negative, floating-point, or greater than 255.\r\n   */\r\n  static define<T extends Definition>(packetId: number, definition?: T) {\r\n    if (packetId < 0 || !Number.isFinite(packetId)) {\r\n      throw new RangeError('Packet IDs must be positive integers.')\r\n    }\r\n\r\n    if (packetId > 255) {\r\n      throw new RangeError(\r\n        'Packet IDs greater than 255 are not supported. Do you REALLY need more than 255 different kinds of packets?'\r\n      )\r\n    }\r\n\r\n    return new BinaryPacket(packetId, definition)\r\n  }\r\n\r\n  /**\r\n   * Reads just the packetId from the given Buffer. \\\r\n   * This method practically just reads the uint8 at offset `byteOffset` (default: 0). \\\r\n   * Useful if the receiving side receives multiple types of packets.\r\n   */\r\n  static readPacketIdNodeBuffer(buffer: Buffer, byteOffset = 0) {\r\n    return buffer.readUint8(byteOffset)\r\n  }\r\n\r\n  /**\r\n   * Reads just the packetId from the given DataView. \\\r\n   * This method practically just reads the uint8 at offset `byteOffset` (default: 0). \\\r\n   * Useful if the receiving side receives multiple types of packets.\r\n   */\r\n  static readPacketIdDataView(dataview: DataView, byteOffset = 0) {\r\n    return dataview.getUint8(byteOffset)\r\n  }\r\n\r\n  /**\r\n   * Reads just the packetId from the given ArrayBuffer. \\\r\n   * This method practically just reads the uint8 at offset `byteOffset`. \\\r\n   * Useful if the receiving side receives multiple types of packets.\r\n   *\r\n   * NOTE: Due to security issues, the `byteOffset` argument cannot be defaulted and must be provided by the user. \\\r\n   * NOTE: For more information read the `readArrayBuffer` method documentation.\r\n   */\r\n  static readPacketIdArrayBuffer(arraybuffer: ArrayBuffer, byteOffset: number) {\r\n    return new Uint8Array(arraybuffer, byteOffset, 1)[0]\r\n  }\r\n\r\n  /**\r\n   * Reads/deserializes from the given Buffer. \\\r\n   * Method available ONLY on NodeJS and Bun.\r\n   *\r\n   * If possible, always prefer reading using this method, as it is much faster than the other ones.\r\n   *\r\n   * NOTE: if you have an ArrayBuffer do not bother wrapping it into a node Buffer yourself. \\\r\n   * NOTE: if you have an ArrayBuffer use the appropriate `readArrayBuffer`.\r\n   */\r\n  readNodeBuffer(\r\n    dataIn: Buffer,\r\n    offsetPointer = { offset: 0 },\r\n    byteLength = dataIn.byteLength\r\n  ): ToJson<T> {\r\n    return this.read(dataIn, offsetPointer, byteLength, GET_FUNCTION_BUF)\r\n  }\r\n\r\n  /**\r\n   * Reads/deserializes from the given DataView.\r\n   *\r\n   * NOTE: if you have an ArrayBuffer do not bother wrapping it into a DataView yourself. \\\r\n   * NOTE: if you have an ArrayBuffer use the appropriate `readArrayBuffer`.\r\n   */\r\n  readDataView(\r\n    dataIn: DataView,\r\n    offsetPointer = { offset: 0 },\r\n    byteLength = dataIn.byteLength\r\n  ): ToJson<T> {\r\n    return this.read(dataIn, offsetPointer, byteLength, GET_FUNCTION)\r\n  }\r\n\r\n  /**\r\n   * Reads/deserializes from the given ArrayBuffer. \\\r\n   * WARNING: this method is practically a HACK.\r\n   *\r\n   * When using this method both the `byteOffset` and `byteLength` are REQUIRED and cannot be defaulted. \\\r\n   * This is to prevent serious bugs and security issues. \\\r\n   * That is because often raw ArrayBuffers come from a pre-allocated buffer pool and do not start at byteOffset 0.\r\n   *\r\n   * NOTE: if you have a node Buffer do not bother wrapping it into an ArrayBuffer yourself. \\\r\n   * NOTE: if you have a node Buffer use the appropriate `readNodeBuffer` as it is much faster and less error prone.\r\n   */\r\n  readArrayBuffer(\r\n    dataIn: ArrayBuffer & { buffer?: undefined },\r\n    byteOffset: number,\r\n    byteLength: number\r\n  ) {\r\n    return this.read(\r\n      hasNodeBuffers\r\n        ? Buffer.from(dataIn, byteOffset, byteLength)\r\n        : new DataView(dataIn, byteOffset, byteLength),\r\n      { offset: 0 }, // The underlying buffer has already been offsetted\r\n      byteLength,\r\n      hasNodeBuffers ? GET_FUNCTION_BUF : GET_FUNCTION\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Writes/serializes the given object into a Buffer. \\\r\n   * Method available ONLY on NodeJS and Bun.\r\n   *\r\n   * If possible, always prefer writing using this method, as it is much faster than the other ones.\r\n   */\r\n  writeNodeBuffer(dataOut: ToJson<T>) {\r\n    const buffer = Buffer.allocUnsafe(this.minimumByteLength)\r\n    return this.write(buffer, dataOut, { offset: 0 }, SET_FUNCTION_BUF, growNodeBuffer)\r\n  }\r\n\r\n  /**\r\n   * Writes/serializes the given object into a DataView. \\\r\n   */\r\n  writeDataView(dataOut: ToJson<T>) {\r\n    const dataview = new DataView(new ArrayBuffer(this.minimumByteLength))\r\n    return this.write(dataview, dataOut, { offset: 0 }, SET_FUNCTION, growDataView)\r\n  }\r\n\r\n  /**\r\n   * Writes/serializes the given object into an ArrayBuffer. \\\r\n   * This method is just a wrapper around either  `writeNodeBuffer` or `writeDataView`. \\\r\n   *\r\n   * This method works with JavaScript standard raw ArrayBuffer(s) and, as such, is very error prone: \\\r\n   * Make sure you're using the returned byteLength and byteOffset fields in the read counterpart. \\\r\n   *\r\n   * Always consider whether is possible to use directly `writeNodeBuffer` or `writeDataView` instead of `writeArrayBuffer`. \\\r\n   * For more information read the `readArrayBuffer` documentation.\r\n   */\r\n  writeArrayBuffer(dataOut: ToJson<T>) {\r\n    const buf = hasNodeBuffers ? this.writeNodeBuffer(dataOut) : this.writeDataView(dataOut)\r\n    return { buffer: buf.buffer, byteLength: buf.byteLength, byteOffset: buf.byteOffset }\r\n  }\r\n\r\n  private readonly entries: Entries\r\n  readonly canFastWrite: boolean\r\n  readonly minimumByteLength: number\r\n\r\n  private constructor(\r\n    private readonly packetId: number,\r\n    definition?: T\r\n  ) {\r\n    this.entries = definition ? sortEntries(definition) : []\r\n    const inspection = inspectEntries(this.entries)\r\n\r\n    this.minimumByteLength = inspection.minimumByteLength\r\n    this.canFastWrite = inspection.canFastWrite\r\n  }\r\n\r\n  private read(\r\n    dataIn: DataView | Buffer,\r\n    offsetPointer: { offset: number },\r\n    byteLength: number,\r\n    readFunctions: typeof GET_FUNCTION | typeof GET_FUNCTION_BUF\r\n  ): ToJson<T> {\r\n    if (byteLength + offsetPointer.offset < this.minimumByteLength) {\r\n      throw new Error(\r\n        `There is no space available to fit a packet of type ${this.packetId} at offset ${offsetPointer.offset}`\r\n      )\r\n    }\r\n\r\n    if (\r\n      readFunctions[Field.UNSIGNED_INT_8](dataIn as any, offsetPointer.offset) !== this.packetId\r\n    ) {\r\n      throw new Error(\r\n        `Data at offset ${offsetPointer.offset} is not a packet of type ${this.packetId}`\r\n      )\r\n    }\r\n\r\n    offsetPointer.offset += 1\r\n    const result: any = {}\r\n\r\n    for (const [name, def] of this.entries) {\r\n      if (Array.isArray(def)) {\r\n        const length = readFunctions[Field.UNSIGNED_INT_8](dataIn as any, offsetPointer.offset++)\r\n        const array = Array(length)\r\n\r\n        const itemType = def[0]\r\n\r\n        if (typeof itemType === 'object') {\r\n          // Array of \"subpackets\"\r\n          for (let i = 0; i < length; ++i) {\r\n            array[i] = itemType.read(dataIn, offsetPointer, byteLength, readFunctions)\r\n          }\r\n        } else {\r\n          // Array of primitives (numbers)\r\n          const itemSize = BYTE_SIZE[itemType]\r\n\r\n          // It seems like looping over each element is actually much faster than using TypedArrays bulk copy.\r\n          // TODO: properly benchmark with various array sizes to see if it's actually the case.\r\n          for (let i = 0; i < length; ++i) {\r\n            array[i] = readFunctions[itemType](dataIn as any, offsetPointer.offset)\r\n            offsetPointer.offset += itemSize\r\n          }\r\n        }\r\n\r\n        result[name] = array\r\n      } else if (typeof def === 'object') {\r\n        // Single \"subpacket\"\r\n        result[name] = def.read(dataIn, offsetPointer, byteLength, readFunctions)\r\n      } else {\r\n        // Single primitive (number)\r\n        result[name] = readFunctions[def](dataIn as any, offsetPointer.offset)\r\n        offsetPointer.offset += BYTE_SIZE[def]\r\n      }\r\n    }\r\n\r\n    return result as ToJson<T>\r\n  }\r\n\r\n  private write<Buf extends DataView | Buffer>(\r\n    buffer: Buf,\r\n    dataOut: ToJson<T>,\r\n    offsetPointer: { offset: number },\r\n    writeFunctions: typeof SET_FUNCTION | typeof SET_FUNCTION_BUF,\r\n    growBufferFunction: (buffer: Buf, newByteLength: number) => Buf\r\n  ): Buf {\r\n    writeFunctions[Field.UNSIGNED_INT_8](buffer as any, this.packetId, offsetPointer.offset)\r\n    offsetPointer.offset += 1\r\n\r\n    if (this.canFastWrite) {\r\n      // If there are no arrays, the minimumByteLength always equals to the full needed byteLength.\r\n      // So we can take the fast path, since we know beforehand that the buffer isn't going to grow.\r\n      this.fastWrite(buffer, dataOut, offsetPointer, writeFunctions)\r\n      return buffer\r\n    } else {\r\n      // If non-empty arrays are encountered, the buffer must grow.\r\n      // If every array is empty, the speed of this path is comparable to the fast path.\r\n      return this.slowWrite(\r\n        buffer,\r\n        dataOut,\r\n        offsetPointer,\r\n        this.minimumByteLength,\r\n        this.minimumByteLength,\r\n        writeFunctions,\r\n        growBufferFunction\r\n      )\r\n    }\r\n  }\r\n\r\n  private fastWrite<Buf extends DataView | Buffer>(\r\n    buffer: Buf,\r\n    dataOut: ToJson<T>,\r\n    offsetPointer: { offset: number },\r\n    writeFunctions: typeof SET_FUNCTION | typeof SET_FUNCTION_BUF\r\n  ) {\r\n    for (const [name, def] of this.entries) {\r\n      if (typeof def === 'object') {\r\n        // Single \"subpacket\"\r\n        // In fastWrite there cannot be arrays, but the cast is needed because TypeScript can't possibly know that.\r\n        ;(def as BinaryPacket<Definition>).fastWrite(\r\n          buffer,\r\n          dataOut[name] as ToJson<Definition>,\r\n          offsetPointer,\r\n          writeFunctions\r\n        )\r\n      } else {\r\n        // Single primitive (number)\r\n        writeFunctions[def](buffer as any, dataOut[name] as number, offsetPointer.offset)\r\n        offsetPointer.offset += BYTE_SIZE[def]\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * The slow writing path tries writing data into the buffer as fast as the fast writing path does. \\\r\n   * But, if a non-empty array is encountered, the buffer needs to grow, slightly reducing performance.\r\n   */\r\n  private slowWrite<Buf extends DataView | Buffer>(\r\n    buffer: Buf,\r\n    dataOut: ToJson<T>,\r\n    offsetPointer: { offset: number },\r\n    byteLength: number,\r\n    maxByteLength: number,\r\n    writeFunctions: typeof SET_FUNCTION | typeof SET_FUNCTION_BUF,\r\n    growBufferFunction: (buffer: Buf, newByteLength: number) => Buf\r\n  ): Buf {\r\n    for (const [name, def] of this.entries) {\r\n      const data = dataOut[name]\r\n\r\n      if (Array.isArray(def)) {\r\n        // Could be both an array of just numbers or \"subpackets\"\r\n        const length = (data as any[]).length\r\n\r\n        writeFunctions[Field.UNSIGNED_INT_8](buffer as any, length, offsetPointer.offset)\r\n        offsetPointer.offset += 1\r\n\r\n        if (length > 0) {\r\n          const itemType = def[0]\r\n\r\n          if (typeof itemType === 'object') {\r\n            // Array of \"subpackets\"\r\n            const neededBytesForElements = length * itemType.minimumByteLength\r\n\r\n            byteLength += neededBytesForElements\r\n            maxByteLength += neededBytesForElements\r\n\r\n            if (buffer.byteLength < maxByteLength) {\r\n              buffer = growBufferFunction(buffer, maxByteLength)\r\n            }\r\n\r\n            for (const object of data as unknown as ToJson<Definition>[]) {\r\n              writeFunctions[Field.UNSIGNED_INT_8](\r\n                buffer as any,\r\n                itemType.packetId,\r\n                offsetPointer.offset\r\n              )\r\n\r\n              offsetPointer.offset += 1\r\n\r\n              buffer = itemType.slowWrite(\r\n                buffer,\r\n                object,\r\n                offsetPointer,\r\n                byteLength,\r\n                maxByteLength,\r\n                writeFunctions,\r\n                growBufferFunction\r\n              )\r\n\r\n              byteLength = offsetPointer.offset\r\n              maxByteLength = buffer.byteLength\r\n            }\r\n          } else {\r\n            // Array of primitives (numbers)\r\n            const itemSize = BYTE_SIZE[itemType]\r\n            const neededBytesForElements = length * itemSize\r\n\r\n            byteLength += neededBytesForElements\r\n            maxByteLength += neededBytesForElements\r\n\r\n            if (buffer.byteLength < maxByteLength) {\r\n              buffer = growBufferFunction(buffer, maxByteLength)\r\n            }\r\n\r\n            // It seems like looping over each element is actually much faster than using TypedArrays bulk copy.\r\n            // TODO: properly benchmark with various array sizes to see if it's actually the case.\r\n            for (const number of data as number[]) {\r\n              writeFunctions[itemType](buffer as any, number, offsetPointer.offset)\r\n              offsetPointer.offset += itemSize\r\n            }\r\n          }\r\n        }\r\n      } else if (typeof def === 'object') {\r\n        // Single \"subpacket\"\r\n        writeFunctions[Field.UNSIGNED_INT_8](buffer as any, def.packetId, offsetPointer.offset)\r\n        offsetPointer.offset += 1\r\n\r\n        buffer = def.slowWrite(\r\n          buffer,\r\n          data as ToJson<Definition>,\r\n          offsetPointer,\r\n          byteLength,\r\n          maxByteLength,\r\n          writeFunctions,\r\n          growBufferFunction\r\n        )\r\n\r\n        byteLength = offsetPointer.offset\r\n        maxByteLength = buffer.byteLength\r\n      } else {\r\n        // Single primitive (number)\r\n        writeFunctions[def](buffer as any, data as number, offsetPointer.offset)\r\n        offsetPointer.offset += BYTE_SIZE[def]\r\n      }\r\n    }\r\n\r\n    return buffer\r\n  }\r\n}\r\n\r\n/**\r\n * BinaryPacket definition: \\\r\n * Any packet can be defined through a \"schema\" object explaining its fields names and types.\r\n *\r\n * @example\r\n * // Imagine we have a game board where each cell is a square and is one unit big.\r\n * // A cell can be then defined by its X and Y coordinates.\r\n * // For simplicity, let's say there cannot be more than 256 cells, so we can use 8 bits for each coordinate.\r\n * const Cell = {\r\n *  x: Field.UNSIGNED_INT_8,\r\n *  y: Field.UNSIGNED_INT_8\r\n * }\r\n *\r\n * // When done with the cell definition we can create its BinaryPacket writer/reader.\r\n * // NOTE: each BinaryPacket needs an unique ID, for identification purposes and error checking.\r\n * const CellPacket = BinaryPacket.define(0, Cell)\r\n *\r\n * // Let's now make the definition of the whole game board.\r\n * // You can also specify arrays of both \"primitive\" fields and other BinaryPackets.\r\n * const Board = {\r\n *  numPlayers: Field.UNSIGNED_INT_8,\r\n *  cells: FieldArray(CellPacket) // equivalent to { cells: [CellPacket] }\r\n * }\r\n *\r\n * // When done with the board definition we can create its BinaryPacket writer/reader.\r\n * // NOTE: each BinaryPacket needs an unique ID, for identification purposes and error checking.\r\n * const BoardPacket = BinaryPacket.define(1, Board)\r\n *\r\n * // And use it.\r\n * const buffer = BoardPacket.writeNodeBuffer({\r\n *  numPlayers: 1,\r\n *  cells: [\r\n *    { x: 0, y: 0 },\r\n *    { x: 1, y: 1 }\r\n *  ]\r\n * })\r\n *\r\n * // sendTheBufferOver(buffer)\r\n * // ...\r\n * // const buffer = receiveTheBuffer()\r\n * const board = BoardPacket.readNodeBuffer(buffer)\r\n * // ...\r\n */\r\nexport type Definition = {\r\n  [fieldName: string]: Field | Field[] | BinaryPacket<Definition> | BinaryPacket<Definition>[]\r\n}\r\n\r\n/**\r\n * Meta-type that converts a `Definition` schema to the type of the actual JavaScript object that will be written into a packet or read from. \\\r\n */\r\ntype ToJson<T extends Definition> = {\r\n  [K in keyof T]: T[K] extends ReadonlyArray<infer Item>\r\n    ? Item extends BinaryPacket<infer BPDef>\r\n      ? ToJson<BPDef>[]\r\n      : number[]\r\n    : T[K] extends BinaryPacket<infer BPDef>\r\n      ? ToJson<BPDef>\r\n      : number\r\n}\r\n\r\n/**\r\n * In a JavaScript object, the order of its keys is not strictly defined: sort them by field name. \\\r\n * Thus, we cannot trust iterating over an object keys: we MUST iterate over its entries array. \\\r\n * This is important to make sure that whoever shares BinaryPacket definitions can correctly write/read packets independently of their JS engines.\r\n */\r\nfunction sortEntries(definition: Definition) {\r\n  return Object.entries(definition).sort(([fieldName1], [fieldName2]) =>\r\n    fieldName1.localeCompare(fieldName2)\r\n  )\r\n}\r\n\r\ntype Entries = ReturnType<typeof sortEntries>\r\n\r\n/**\r\n * Helper function that \"inspects\" the entries of a BinaryPacket definition\r\n * and returns useful \"stats\" needed for writing and reading buffers.\r\n *\r\n * This function is ever called only once per BinaryPacket definition.\r\n */\r\nfunction inspectEntries(entries: Entries) {\r\n  // The PacketID is already 1 byte, that's why we aren't starting from 0.\r\n  let minimumByteLength = 1\r\n  let canFastWrite = true\r\n\r\n  for (const [, type] of entries) {\r\n    if (Array.isArray(type)) {\r\n      // Adding 1 byte to serialize the array length\r\n      minimumByteLength += 1\r\n      canFastWrite = false\r\n    } else if (type instanceof BinaryPacket) {\r\n      minimumByteLength += type.minimumByteLength\r\n      canFastWrite &&= type.canFastWrite\r\n    } else {\r\n      minimumByteLength += BYTE_SIZE[type]\r\n    }\r\n  }\r\n\r\n  return { minimumByteLength, canFastWrite }\r\n}\r\n\r\n//////////////////////////////////////////////\r\n// The logic here is practically over       //\r\n// Here below there are needed constants    //\r\n// that map a field-type to a functionality //\r\n//////////////////////////////////////////////\r\n\r\nconst BYTE_SIZE = Array(8)\r\n\r\nBYTE_SIZE[Field.UNSIGNED_INT_8] = 1\r\nBYTE_SIZE[Field.INT_8] = 1\r\n\r\nBYTE_SIZE[Field.UNSIGNED_INT_16] = 2\r\nBYTE_SIZE[Field.INT_16] = 2\r\n\r\nBYTE_SIZE[Field.UNSIGNED_INT_32] = 4\r\nBYTE_SIZE[Field.INT_32] = 4\r\nBYTE_SIZE[Field.FLOAT_32] = 4\r\n\r\nBYTE_SIZE[Field.FLOAT_64] = 8\r\n\r\nconst GET_FUNCTION: ((view: DataView, offset: number, littleEndian?: boolean) => number)[] =\r\n  Array(8)\r\n\r\nGET_FUNCTION[Field.UNSIGNED_INT_8] = (view, offset) => view.getUint8(offset)\r\nGET_FUNCTION[Field.INT_8] = (view, offset) => view.getInt8(offset)\r\n\r\nGET_FUNCTION[Field.UNSIGNED_INT_16] = (view, offset, le) => view.getUint16(offset, le)\r\nGET_FUNCTION[Field.INT_16] = (view, offset, le) => view.getInt16(offset, le)\r\n\r\nGET_FUNCTION[Field.UNSIGNED_INT_32] = (view, offset, le) => view.getUint32(offset, le)\r\nGET_FUNCTION[Field.INT_32] = (view, offset, le) => view.getInt32(offset, le)\r\nGET_FUNCTION[Field.FLOAT_32] = (view, offset, le) => view.getFloat32(offset, le)\r\n\r\nGET_FUNCTION[Field.FLOAT_64] = (view, offset, le) => view.getFloat64(offset, le)\r\n\r\nconst SET_FUNCTION: ((view: DataView, value: number, offset: number) => void)[] = Array(8)\r\n\r\nSET_FUNCTION[Field.UNSIGNED_INT_8] = (view, value, offset) => view.setUint8(offset, value)\r\nSET_FUNCTION[Field.INT_8] = (view, value, offset) => view.setInt8(offset, value)\r\n\r\nSET_FUNCTION[Field.UNSIGNED_INT_16] = (view, value, offset) => view.setUint16(offset, value)\r\nSET_FUNCTION[Field.INT_16] = (view, value, offset) => view.setInt16(offset, value)\r\n\r\nSET_FUNCTION[Field.UNSIGNED_INT_32] = (view, value, offset) => view.setUint32(offset, value)\r\nSET_FUNCTION[Field.INT_32] = (view, value, offset) => view.setInt32(offset, value)\r\nSET_FUNCTION[Field.FLOAT_32] = (view, value, offset) => view.setFloat32(offset, value)\r\n\r\nSET_FUNCTION[Field.FLOAT_64] = (view, value, offset) => view.setFloat64(offset, value)\r\n\r\nconst SET_FUNCTION_BUF: ((nodeBuffer: Buffer, value: number, offset: number) => void)[] = Array(8)\r\n\r\nif (hasNodeBuffers) {\r\n  SET_FUNCTION_BUF[Field.UNSIGNED_INT_8] = (view, value, offset) => view.writeUint8(value, offset)\r\n  SET_FUNCTION_BUF[Field.INT_8] = (view, value, offset) => view.writeInt8(value, offset)\r\n\r\n  SET_FUNCTION_BUF[Field.UNSIGNED_INT_16] = (view, value, offset) =>\r\n    view.writeUint16LE(value, offset)\r\n  SET_FUNCTION_BUF[Field.INT_16] = (view, value, offset) => view.writeInt16LE(value, offset)\r\n\r\n  SET_FUNCTION_BUF[Field.UNSIGNED_INT_32] = (view, value, offset) =>\r\n    view.writeUint32LE(value, offset)\r\n  SET_FUNCTION_BUF[Field.INT_32] = (view, value, offset) => view.writeInt32LE(value, offset)\r\n  SET_FUNCTION_BUF[Field.FLOAT_32] = (view, value, offset) => view.writeFloatLE(value, offset)\r\n\r\n  SET_FUNCTION_BUF[Field.FLOAT_64] = (view, value, offset) => view.writeDoubleLE(value, offset)\r\n}\r\n\r\nconst GET_FUNCTION_BUF: ((nodeBuffer: Buffer, offset: number) => number)[] = Array(8)\r\n\r\nif (hasNodeBuffers) {\r\n  GET_FUNCTION_BUF[Field.UNSIGNED_INT_8] = (view, offset) => view.readUint8(offset)\r\n  GET_FUNCTION_BUF[Field.INT_8] = (view, offset) => view.readInt8(offset)\r\n\r\n  GET_FUNCTION_BUF[Field.UNSIGNED_INT_16] = (view, offset) => view.readUint16LE(offset)\r\n  GET_FUNCTION_BUF[Field.INT_16] = (view, offset) => view.readInt16LE(offset)\r\n\r\n  GET_FUNCTION_BUF[Field.UNSIGNED_INT_32] = (view, offset) => view.readUint32LE(offset)\r\n  GET_FUNCTION_BUF[Field.INT_32] = (view, offset) => view.readInt32LE(offset)\r\n  GET_FUNCTION_BUF[Field.FLOAT_32] = (view, offset) => view.readFloatLE(offset)\r\n\r\n  GET_FUNCTION_BUF[Field.FLOAT_64] = (view, offset) => view.readDoubleLE(offset)\r\n}\r\n","export const hasNodeBuffers = typeof Buffer === 'function'\r\n\r\nexport function growDataView(dataview: DataView, newByteLength: number) {\r\n  const resizedBuffer = new ArrayBuffer(newByteLength)\r\n  const amountToCopy = Math.min(dataview.byteLength, resizedBuffer.byteLength)\r\n\r\n  // Treat the buffer as if it was a Float64Array so we can copy 8 bytes at a time, to finish faster\r\n  let length = Math.trunc(amountToCopy / 8)\r\n  new Float64Array(resizedBuffer, 0, length).set(new Float64Array(dataview.buffer, 0, length))\r\n\r\n  // Copy the remaining up to 7 bytes\r\n  const offset = length * 8\r\n  length = amountToCopy - offset\r\n  new Uint8Array(resizedBuffer, offset, length).set(new Uint8Array(dataview.buffer, offset, length))\r\n\r\n  return new DataView(resizedBuffer)\r\n}\r\n\r\nexport function growNodeBuffer(buffer: Buffer, newByteLength: number) {\r\n  const newBuffer = Buffer.allocUnsafe(newByteLength)\r\n  buffer.copy(newBuffer)\r\n  return newBuffer\r\n}\r\n"],"mappings":"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","names":["Field"]}
+{"version":3,"sources":["../src/index.ts","../src/buffers.ts"],"sourcesContent":["import { growDataView, growNodeBuffer, hasNodeBuffers } from './buffers'\r\n\r\nexport const enum Field {\r\n  /**\r\n   * Defines a 1 byte (8 bits) unsigned integer field. \\\r\n   * (Range: 0 - 255)\r\n   */\r\n  UNSIGNED_INT_8 = 0,\r\n\r\n  /**\r\n   * Defines a 2 bytes (16 bits) unsigned integer field. \\\r\n   * (Range: 0 - 65535)\r\n   */\r\n  UNSIGNED_INT_16,\r\n\r\n  /**\r\n   * Defines a 4 bytes (32 bits) unsigned integer field. \\\r\n   * (Range: 0 - 4294967295)\r\n   */\r\n  UNSIGNED_INT_32,\r\n\r\n  /**\r\n   * Defines a 1 byte (8 bits) signed integer field. \\\r\n   * (Range: -128 - 127)\r\n   */\r\n  INT_8,\r\n\r\n  /**\r\n   * Defines a 2 bytes (16 bits) signed integer field. \\\r\n   * (Range: -32768 - 32767)\r\n   */\r\n  INT_16,\r\n\r\n  /**\r\n   * Defines a 4 bytes (32 bits) signed integer field. \\\r\n   * (Range: -2147483648 - 2147483647)\r\n   */\r\n  INT_32,\r\n\r\n  /**\r\n   * Defines a 4 bytes (32 bits) floating-point field. \\\r\n   */\r\n  FLOAT_32,\r\n\r\n  /**\r\n   * Defines a 8 bytes (64 bits) floating-point field. \\\r\n   */\r\n  FLOAT_64\r\n}\r\n\r\n/**\r\n * Defines a dynamically-sized array with elements of a certain type. \\\r\n * Dynamically-sized arrays are useful when a packet's field is an array of a non pre-defined length. \\\r\n * Although, this makes dynamically-sized arrays more memory expensive as the internal buffer needs to be grown accordingly.\r\n *\r\n * NOTE: If an array will ALWAYS have the same length, prefer using the `FieldFixedArray` type, for both better performance and memory efficiency. \\\r\n * NOTE: As of now, dynamic arrays can have at most 256 elements.\r\n */\r\nexport function FieldArray<T extends Field | BinaryPacket<Definition>>(item: T): [itemType: T] {\r\n  return [item]\r\n}\r\n\r\n/**\r\n * Defines a statically-sized array with elements of a certain type. \\\r\n * Fixed arrays are useful when a packet's field is an array of a pre-defined length. \\\r\n * Fixed arrays much more memory efficient and performant than non-fixed ones.\r\n *\r\n * NOTE: If an array will not always have the same length, use the `FieldArray` type.\r\n */\r\nexport function FieldFixedArray<T extends Field | BinaryPacket<Definition>, Length extends number>(\r\n  item: T,\r\n  length: Length\r\n): [itemType: T, length: Length] {\r\n  if (length < 0 || !Number.isFinite(length)) {\r\n    throw new RangeError('Length of a FixedArray must be a positive integer.')\r\n  }\r\n\r\n  return [item, length]\r\n}\r\n\r\nexport class BinaryPacket<T extends Definition> {\r\n  /**\r\n   * Defines a new binary packet. \\\r\n   * Make sure that every `packetId` is unique.\r\n   * @throws RangeError If packetId is negative, floating-point, or greater than 255.\r\n   */\r\n  static define<T extends Definition>(packetId: number, definition?: T) {\r\n    if (packetId < 0 || !Number.isFinite(packetId)) {\r\n      throw new RangeError('Packet IDs must be positive integers.')\r\n    }\r\n\r\n    if (packetId > 255) {\r\n      throw new RangeError(\r\n        'Packet IDs greater than 255 are not supported. Do you REALLY need more than 255 different kinds of packets?'\r\n      )\r\n    }\r\n\r\n    return new BinaryPacket(packetId, definition)\r\n  }\r\n\r\n  /**\r\n   * Reads just the packetId from the given Buffer. \\\r\n   * This method practically just reads the uint8 at offset `byteOffset` (default: 0). \\\r\n   * Useful if the receiving side receives multiple types of packets.\r\n   */\r\n  static readPacketIdNodeBuffer(buffer: Buffer, byteOffset = 0) {\r\n    return buffer.readUint8(byteOffset)\r\n  }\r\n\r\n  /**\r\n   * Reads just the packetId from the given DataView. \\\r\n   * This method practically just reads the uint8 at offset `byteOffset` (default: 0). \\\r\n   * Useful if the receiving side receives multiple types of packets.\r\n   */\r\n  static readPacketIdDataView(dataview: DataView, byteOffset = 0) {\r\n    return dataview.getUint8(byteOffset)\r\n  }\r\n\r\n  /**\r\n   * Reads just the packetId from the given ArrayBuffer. \\\r\n   * This method practically just reads the uint8 at offset `byteOffset`. \\\r\n   * Useful if the receiving side receives multiple types of packets.\r\n   *\r\n   * NOTE: Due to security issues, the `byteOffset` argument cannot be defaulted and must be provided by the user. \\\r\n   * NOTE: For more information read the `readArrayBuffer` method documentation.\r\n   */\r\n  static readPacketIdArrayBuffer(arraybuffer: ArrayBuffer, byteOffset: number) {\r\n    return new Uint8Array(arraybuffer, byteOffset, 1)[0]\r\n  }\r\n\r\n  /**\r\n   * Reads/deserializes from the given Buffer. \\\r\n   * Method available ONLY on NodeJS and Bun.\r\n   *\r\n   * If possible, always prefer reading using this method, as it is much faster than the other ones.\r\n   *\r\n   * NOTE: if you have an ArrayBuffer do not bother wrapping it into a node Buffer yourself. \\\r\n   * NOTE: if you have an ArrayBuffer use the appropriate `readArrayBuffer`.\r\n   */\r\n  readNodeBuffer(\r\n    dataIn: Buffer,\r\n    offsetPointer = { offset: 0 },\r\n    byteLength = dataIn.byteLength\r\n  ): ToJson<T> {\r\n    return this.read(dataIn, offsetPointer, byteLength, GET_FUNCTION_BUF)\r\n  }\r\n\r\n  /**\r\n   * Reads/deserializes from the given DataView.\r\n   *\r\n   * NOTE: if you have an ArrayBuffer do not bother wrapping it into a DataView yourself. \\\r\n   * NOTE: if you have an ArrayBuffer use the appropriate `readArrayBuffer`.\r\n   */\r\n  readDataView(\r\n    dataIn: DataView,\r\n    offsetPointer = { offset: 0 },\r\n    byteLength = dataIn.byteLength\r\n  ): ToJson<T> {\r\n    return this.read(dataIn, offsetPointer, byteLength, GET_FUNCTION)\r\n  }\r\n\r\n  /**\r\n   * Reads/deserializes from the given ArrayBuffer. \\\r\n   * WARNING: this method is practically a HACK.\r\n   *\r\n   * When using this method both the `byteOffset` and `byteLength` are REQUIRED and cannot be defaulted. \\\r\n   * This is to prevent serious bugs and security issues. \\\r\n   * That is because often raw ArrayBuffers come from a pre-allocated buffer pool and do not start at byteOffset 0.\r\n   *\r\n   * NOTE: if you have a node Buffer do not bother wrapping it into an ArrayBuffer yourself. \\\r\n   * NOTE: if you have a node Buffer use the appropriate `readNodeBuffer` as it is much faster and less error prone.\r\n   */\r\n  readArrayBuffer(\r\n    dataIn: ArrayBuffer & { buffer?: undefined },\r\n    byteOffset: number,\r\n    byteLength: number\r\n  ) {\r\n    return this.read(\r\n      hasNodeBuffers\r\n        ? Buffer.from(dataIn, byteOffset, byteLength)\r\n        : new DataView(dataIn, byteOffset, byteLength),\r\n      { offset: 0 }, // The underlying buffer has already been offsetted\r\n      byteLength,\r\n      hasNodeBuffers ? GET_FUNCTION_BUF : GET_FUNCTION\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Writes/serializes the given object into a Buffer. \\\r\n   * Method available ONLY on NodeJS and Bun.\r\n   *\r\n   * If possible, always prefer writing using this method, as it is much faster than the other ones.\r\n   */\r\n  writeNodeBuffer(dataOut: ToJson<T>) {\r\n    const buffer = Buffer.allocUnsafe(this.minimumByteLength)\r\n    return this.write(buffer, dataOut, { offset: 0 }, SET_FUNCTION_BUF, growNodeBuffer)\r\n  }\r\n\r\n  /**\r\n   * Writes/serializes the given object into a DataView. \\\r\n   */\r\n  writeDataView(dataOut: ToJson<T>) {\r\n    const dataview = new DataView(new ArrayBuffer(this.minimumByteLength))\r\n    return this.write(dataview, dataOut, { offset: 0 }, SET_FUNCTION, growDataView)\r\n  }\r\n\r\n  /**\r\n   * Writes/serializes the given object into an ArrayBuffer. \\\r\n   * This method is just a wrapper around either  `writeNodeBuffer` or `writeDataView`. \\\r\n   *\r\n   * This method works with JavaScript standard raw ArrayBuffer(s) and, as such, is very error prone: \\\r\n   * Make sure you're using the returned byteLength and byteOffset fields in the read counterpart. \\\r\n   *\r\n   * Always consider whether is possible to use directly `writeNodeBuffer` or `writeDataView` instead of `writeArrayBuffer`. \\\r\n   * For more information read the `readArrayBuffer` documentation.\r\n   */\r\n  writeArrayBuffer(dataOut: ToJson<T>) {\r\n    const buf = hasNodeBuffers ? this.writeNodeBuffer(dataOut) : this.writeDataView(dataOut)\r\n    return { buffer: buf.buffer, byteLength: buf.byteLength, byteOffset: buf.byteOffset }\r\n  }\r\n\r\n  private readonly entries: Entries\r\n  readonly canFastWrite: boolean\r\n  readonly minimumByteLength: number\r\n\r\n  private constructor(\r\n    private readonly packetId: number,\r\n    definition?: T\r\n  ) {\r\n    this.entries = definition ? sortEntries(definition) : []\r\n    const inspection = inspectEntries(this.entries)\r\n\r\n    this.minimumByteLength = inspection.minimumByteLength\r\n    this.canFastWrite = inspection.canFastWrite\r\n  }\r\n\r\n  private read(\r\n    dataIn: DataView | Buffer,\r\n    offsetPointer: { offset: number },\r\n    byteLength: number,\r\n    readFunctions: typeof GET_FUNCTION | typeof GET_FUNCTION_BUF\r\n  ): ToJson<T> {\r\n    if (byteLength + offsetPointer.offset < this.minimumByteLength) {\r\n      throw new Error(\r\n        `There is no space available to fit a packet of type ${this.packetId} at offset ${offsetPointer.offset}`\r\n      )\r\n    }\r\n\r\n    if (\r\n      readFunctions[Field.UNSIGNED_INT_8](dataIn as any, offsetPointer.offset) !== this.packetId\r\n    ) {\r\n      throw new Error(\r\n        `Data at offset ${offsetPointer.offset} is not a packet of type ${this.packetId}`\r\n      )\r\n    }\r\n\r\n    offsetPointer.offset += 1\r\n    const result: any = {}\r\n\r\n    for (const [name, def] of this.entries) {\r\n      if (Array.isArray(def)) {\r\n        const length =\r\n          // def[1] is the length of a statically-sized array, if undefined: must read the length from the buffer as it means it's a dynamically-sized array\r\n          def[1] ?? readFunctions[Field.UNSIGNED_INT_8](dataIn as any, offsetPointer.offset++)\r\n\r\n        const array = Array(length)\r\n\r\n        const itemType = def[0]\r\n\r\n        if (typeof itemType === 'object') {\r\n          // Array of \"subpackets\"\r\n          for (let i = 0; i < length; ++i) {\r\n            array[i] = itemType.read(dataIn, offsetPointer, byteLength, readFunctions)\r\n          }\r\n        } else {\r\n          // Array of primitives (numbers)\r\n          const itemSize = BYTE_SIZE[itemType]\r\n\r\n          // It seems like looping over each element is actually much faster than using TypedArrays bulk copy.\r\n          // TODO: properly benchmark with various array sizes to see if it's actually the case.\r\n          for (let i = 0; i < length; ++i) {\r\n            array[i] = readFunctions[itemType](dataIn as any, offsetPointer.offset)\r\n            offsetPointer.offset += itemSize\r\n          }\r\n        }\r\n\r\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\r\n        result[name] = array\r\n      } else if (typeof def === 'object') {\r\n        // Single \"subpacket\"\r\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\r\n        result[name] = def.read(dataIn, offsetPointer, byteLength, readFunctions)\r\n      } else {\r\n        // Single primitive (number)\r\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\r\n        result[name] = readFunctions[def](dataIn as any, offsetPointer.offset)\r\n        offsetPointer.offset += BYTE_SIZE[def]\r\n      }\r\n    }\r\n\r\n    return result as ToJson<T>\r\n  }\r\n\r\n  private write<Buf extends DataView | Buffer>(\r\n    buffer: Buf,\r\n    dataOut: ToJson<T>,\r\n    offsetPointer: { offset: number },\r\n    writeFunctions: typeof SET_FUNCTION | typeof SET_FUNCTION_BUF,\r\n    growBufferFunction: (buffer: Buf, newByteLength: number) => Buf\r\n  ): Buf {\r\n    writeFunctions[Field.UNSIGNED_INT_8](buffer as any, this.packetId, offsetPointer.offset)\r\n    offsetPointer.offset += 1\r\n\r\n    if (this.canFastWrite) {\r\n      // If there are no arrays, the minimumByteLength always equals to the full needed byteLength.\r\n      // So we can take the fast path, since we know beforehand that the buffer isn't going to grow.\r\n      this.fastWrite(buffer, dataOut, offsetPointer, writeFunctions)\r\n      return buffer\r\n    } else {\r\n      // If non-empty arrays are encountered, the buffer must grow.\r\n      // If every array is empty, the speed of this path is comparable to the fast path.\r\n      return this.slowWrite(\r\n        buffer,\r\n        dataOut,\r\n        offsetPointer,\r\n        this.minimumByteLength,\r\n        this.minimumByteLength,\r\n        writeFunctions,\r\n        growBufferFunction\r\n      )\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Fast write does not support writing dynamically-sized arrays.\r\n   */\r\n  private fastWrite<Buf extends DataView | Buffer>(\r\n    buffer: Buf,\r\n    dataOut: ToJson<T>,\r\n    offsetPointer: { offset: number },\r\n    writeFunctions: typeof SET_FUNCTION | typeof SET_FUNCTION_BUF\r\n  ) {\r\n    for (const [name, def] of this.entries) {\r\n      if (Array.isArray(def)) {\r\n        // Statically-sized array\r\n        const itemType = def[0]\r\n        const length = def[1]!\r\n        const data = dataOut[name] as any[]\r\n\r\n        if (typeof itemType === 'object') {\r\n          for (let i = 0; i < length; ++i) {\r\n            itemType.fastWrite(buffer, data[i] as ToJson<Definition>, offsetPointer, writeFunctions)\r\n          }\r\n        } else {\r\n          const itemSize = BYTE_SIZE[itemType]\r\n\r\n          for (let i = 0; i < length; ++i) {\r\n            writeFunctions[itemType](buffer as any, data[i] as number, offsetPointer.offset)\r\n            offsetPointer.offset += itemSize\r\n          }\r\n        }\r\n      } else if (typeof def === 'object') {\r\n        // Single \"subpacket\"\r\n        // In fastWrite there cannot be arrays, but the cast is needed because TypeScript can't possibly know that.\r\n        def.fastWrite(buffer, dataOut[name] as ToJson<Definition>, offsetPointer, writeFunctions)\r\n      } else {\r\n        // Single primitive (number)\r\n        writeFunctions[def](buffer as any, dataOut[name] as number, offsetPointer.offset)\r\n        offsetPointer.offset += BYTE_SIZE[def]\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * The slow writing path tries writing data into the buffer as fast as the fast writing path does. \\\r\n   * But, if a non-empty dynamically-sized array is encountered, the buffer needs to grow, slightly reducing performance.\r\n   */\r\n  private slowWrite<Buf extends DataView | Buffer>(\r\n    buffer: Buf,\r\n    dataOut: ToJson<T>,\r\n    offsetPointer: { offset: number },\r\n    byteLength: number,\r\n    maxByteLength: number,\r\n    writeFunctions: typeof SET_FUNCTION | typeof SET_FUNCTION_BUF,\r\n    growBufferFunction: (buffer: Buf, newByteLength: number) => Buf\r\n  ): Buf {\r\n    for (const [name, def] of this.entries) {\r\n      const data = dataOut[name]\r\n\r\n      if (Array.isArray(def)) {\r\n        // Could be both an array of just numbers or \"subpackets\"\r\n\r\n        const length = (data as any[]).length\r\n        const isDynamicArray = def[1] === undefined\r\n\r\n        // Check if it is a dynamically-sized array, if it is, the length of the array must be serialized in the buffer before its elements\r\n        // Explicitly check for undefined and not falsy values because it could be a statically-sized array of 0 elements.\r\n        if (isDynamicArray) {\r\n          writeFunctions[Field.UNSIGNED_INT_8](buffer as any, length, offsetPointer.offset)\r\n          offsetPointer.offset += 1\r\n        }\r\n\r\n        if (length > 0) {\r\n          const itemType = def[0]\r\n\r\n          if (typeof itemType === 'object') {\r\n            // Array of \"subpackets\"\r\n\r\n            if (isDynamicArray) {\r\n              const neededBytesForElements = length * itemType.minimumByteLength\r\n\r\n              byteLength += neededBytesForElements\r\n              maxByteLength += neededBytesForElements\r\n\r\n              if (buffer.byteLength < maxByteLength) {\r\n                buffer = growBufferFunction(buffer, maxByteLength)\r\n              }\r\n            }\r\n\r\n            for (const object of data as unknown as ToJson<Definition>[]) {\r\n              writeFunctions[Field.UNSIGNED_INT_8](\r\n                buffer as any,\r\n                itemType.packetId,\r\n                offsetPointer.offset\r\n              )\r\n\r\n              offsetPointer.offset += 1\r\n\r\n              buffer = itemType.slowWrite(\r\n                buffer,\r\n                object,\r\n                offsetPointer,\r\n                byteLength,\r\n                maxByteLength,\r\n                writeFunctions,\r\n                growBufferFunction\r\n              )\r\n\r\n              byteLength = offsetPointer.offset\r\n              maxByteLength = buffer.byteLength\r\n            }\r\n          } else {\r\n            // Array of primitives (numbers)\r\n            const itemSize = BYTE_SIZE[itemType]\r\n\r\n            if (isDynamicArray) {\r\n              const neededBytesForElements = length * itemSize\r\n\r\n              byteLength += neededBytesForElements\r\n              maxByteLength += neededBytesForElements\r\n\r\n              if (buffer.byteLength < maxByteLength) {\r\n                buffer = growBufferFunction(buffer, maxByteLength)\r\n              }\r\n            }\r\n\r\n            // It seems like looping over each element is actually much faster than using TypedArrays bulk copy.\r\n            // TODO: properly benchmark with various array sizes to see if it's actually the case.\r\n            for (const number of data as number[]) {\r\n              writeFunctions[itemType](buffer as any, number, offsetPointer.offset)\r\n              offsetPointer.offset += itemSize\r\n            }\r\n          }\r\n        }\r\n      } else if (typeof def === 'object') {\r\n        // Single \"subpacket\"\r\n        writeFunctions[Field.UNSIGNED_INT_8](buffer as any, def.packetId, offsetPointer.offset)\r\n        offsetPointer.offset += 1\r\n\r\n        buffer = def.slowWrite(\r\n          buffer,\r\n          data as ToJson<Definition>,\r\n          offsetPointer,\r\n          byteLength,\r\n          maxByteLength,\r\n          writeFunctions,\r\n          growBufferFunction\r\n        )\r\n\r\n        byteLength = offsetPointer.offset\r\n        maxByteLength = buffer.byteLength\r\n      } else {\r\n        // Single primitive (number)\r\n        writeFunctions[def](buffer as any, data as number, offsetPointer.offset)\r\n        offsetPointer.offset += BYTE_SIZE[def]\r\n      }\r\n    }\r\n\r\n    return buffer\r\n  }\r\n}\r\n\r\n/**\r\n * BinaryPacket definition: \\\r\n * Any packet can be defined through a \"schema\" object explaining its fields names and types.\r\n *\r\n * @example\r\n * // Imagine we have a game board where each cell is a square and is one unit big.\r\n * // A cell can be then defined by its X and Y coordinates.\r\n * // For simplicity, let's say there cannot be more than 256 cells, so we can use 8 bits for each coordinate.\r\n * const Cell = {\r\n *  x: Field.UNSIGNED_INT_8,\r\n *  y: Field.UNSIGNED_INT_8\r\n * }\r\n *\r\n * // When done with the cell definition we can create its BinaryPacket writer/reader.\r\n * // NOTE: each BinaryPacket needs an unique ID, for identification purposes and error checking.\r\n * const CellPacket = BinaryPacket.define(0, Cell)\r\n *\r\n * // Let's now make the definition of the whole game board.\r\n * // You can also specify arrays of both \"primitive\" fields and other BinaryPackets.\r\n * const Board = {\r\n *  numPlayers: Field.UNSIGNED_INT_8,\r\n *  cells: FieldArray(CellPacket)\r\n * }\r\n *\r\n * // When done with the board definition we can create its BinaryPacket writer/reader.\r\n * // NOTE: each BinaryPacket needs an unique ID, for identification purposes and error checking.\r\n * const BoardPacket = BinaryPacket.define(1, Board)\r\n *\r\n * // And use it.\r\n * const buffer = BoardPacket.writeNodeBuffer({\r\n *  numPlayers: 1,\r\n *  cells: [\r\n *    { x: 0, y: 0 },\r\n *    { x: 1, y: 1 }\r\n *  ]\r\n * })\r\n *\r\n * // sendTheBufferOver(buffer)\r\n * // ...\r\n * // const buffer = receiveTheBuffer()\r\n * const board = BoardPacket.readNodeBuffer(buffer)\r\n * // ...\r\n */\r\nexport type Definition = {\r\n  [fieldName: string]: MaybeArray<Field> | MaybeArray<BinaryPacket<Definition>>\r\n}\r\n\r\ntype MaybeArray<T> = T | [itemType: T] | [itemType: T, length: number]\r\n\r\n/**\r\n * Meta-type that converts a `Definition` schema to the type of the actual JavaScript object that will be written into a packet or read from. \\\r\n */\r\ntype ToJson<T extends Definition> = {\r\n  [K in keyof T]: T[K] extends [infer Item]\r\n    ? Item extends BinaryPacket<infer BPDef>\r\n      ? ToJson<BPDef>[]\r\n      : number[]\r\n    : T[K] extends [infer Item, infer Length]\r\n      ? Item extends BinaryPacket<infer BPDef>\r\n        ? ToJson<BPDef>[] & { length: Length }\r\n        : number[] & { length: Length }\r\n      : T[K] extends BinaryPacket<infer BPDef>\r\n        ? ToJson<BPDef>\r\n        : number\r\n}\r\n\r\n/**\r\n * In a JavaScript object, the order of its keys is not strictly defined: sort them by field name. \\\r\n * Thus, we cannot trust iterating over an object keys: we MUST iterate over its entries array. \\\r\n * This is important to make sure that whoever shares BinaryPacket definitions can correctly write/read packets independently of their JS engines.\r\n */\r\nfunction sortEntries(definition: Definition) {\r\n  return Object.entries(definition).sort(([fieldName1], [fieldName2]) =>\r\n    fieldName1.localeCompare(fieldName2)\r\n  )\r\n}\r\n\r\ntype Entries = ReturnType<typeof sortEntries>\r\n\r\n/**\r\n * Helper function that \"inspects\" the entries of a BinaryPacket definition\r\n * and returns useful \"stats\" needed for writing and reading buffers.\r\n *\r\n * This function is ever called only once per BinaryPacket definition.\r\n */\r\nfunction inspectEntries(entries: Entries) {\r\n  // The PacketID is already 1 byte, that's why we aren't starting from 0.\r\n  let minimumByteLength = 1\r\n  let canFastWrite = true\r\n\r\n  for (const [, type] of entries) {\r\n    if (Array.isArray(type)) {\r\n      if (type.length === 2) {\r\n        // Statically-sized array\r\n        const itemSize =\r\n          typeof type[0] === 'object' ? type[0].minimumByteLength : BYTE_SIZE[type[0]]\r\n\r\n        minimumByteLength += type[1] * itemSize\r\n      } else {\r\n        // Dynamically-sized array\r\n        // Adding 1 byte to serialize the array length\r\n        minimumByteLength += 1\r\n        canFastWrite = false\r\n      }\r\n    } else if (type instanceof BinaryPacket) {\r\n      minimumByteLength += type.minimumByteLength\r\n      canFastWrite &&= type.canFastWrite\r\n    } else {\r\n      minimumByteLength += BYTE_SIZE[type]\r\n    }\r\n  }\r\n\r\n  return { minimumByteLength, canFastWrite }\r\n}\r\n\r\n//////////////////////////////////////////////\r\n// The logic here is practically over       //\r\n// Here below there are needed constants    //\r\n// that map a field-type to a functionality //\r\n//////////////////////////////////////////////\r\n\r\nconst BYTE_SIZE = Array(8) as number[]\r\n\r\nBYTE_SIZE[Field.UNSIGNED_INT_8] = 1\r\nBYTE_SIZE[Field.INT_8] = 1\r\n\r\nBYTE_SIZE[Field.UNSIGNED_INT_16] = 2\r\nBYTE_SIZE[Field.INT_16] = 2\r\n\r\nBYTE_SIZE[Field.UNSIGNED_INT_32] = 4\r\nBYTE_SIZE[Field.INT_32] = 4\r\nBYTE_SIZE[Field.FLOAT_32] = 4\r\n\r\nBYTE_SIZE[Field.FLOAT_64] = 8\r\n\r\nconst GET_FUNCTION = Array(8) as ((view: DataView, offset: number) => number)[]\r\n\r\nGET_FUNCTION[Field.UNSIGNED_INT_8] = (view, offset) => view.getUint8(offset)\r\nGET_FUNCTION[Field.INT_8] = (view, offset) => view.getInt8(offset)\r\n\r\nGET_FUNCTION[Field.UNSIGNED_INT_16] = (view, offset) => view.getUint16(offset)\r\nGET_FUNCTION[Field.INT_16] = (view, offset) => view.getInt16(offset)\r\n\r\nGET_FUNCTION[Field.UNSIGNED_INT_32] = (view, offset) => view.getUint32(offset)\r\nGET_FUNCTION[Field.INT_32] = (view, offset) => view.getInt32(offset)\r\nGET_FUNCTION[Field.FLOAT_32] = (view, offset) => view.getFloat32(offset)\r\n\r\nGET_FUNCTION[Field.FLOAT_64] = (view, offset) => view.getFloat64(offset)\r\n\r\nconst SET_FUNCTION = Array(8) as ((view: DataView, value: number, offset: number) => void)[]\r\n\r\nSET_FUNCTION[Field.UNSIGNED_INT_8] = (view, value, offset) => view.setUint8(offset, value)\r\nSET_FUNCTION[Field.INT_8] = (view, value, offset) => view.setInt8(offset, value)\r\n\r\nSET_FUNCTION[Field.UNSIGNED_INT_16] = (view, value, offset) => view.setUint16(offset, value)\r\nSET_FUNCTION[Field.INT_16] = (view, value, offset) => view.setInt16(offset, value)\r\n\r\nSET_FUNCTION[Field.UNSIGNED_INT_32] = (view, value, offset) => view.setUint32(offset, value)\r\nSET_FUNCTION[Field.INT_32] = (view, value, offset) => view.setInt32(offset, value)\r\nSET_FUNCTION[Field.FLOAT_32] = (view, value, offset) => view.setFloat32(offset, value)\r\n\r\nSET_FUNCTION[Field.FLOAT_64] = (view, value, offset) => view.setFloat64(offset, value)\r\n\r\nconst SET_FUNCTION_BUF = Array(8) as ((nodeBuffer: Buffer, value: number, offset: number) => void)[]\r\n\r\nif (hasNodeBuffers) {\r\n  SET_FUNCTION_BUF[Field.UNSIGNED_INT_8] = (view, value, offset) => view.writeUint8(value, offset)\r\n  SET_FUNCTION_BUF[Field.INT_8] = (view, value, offset) => view.writeInt8(value, offset)\r\n\r\n  SET_FUNCTION_BUF[Field.UNSIGNED_INT_16] = (view, value, offset) =>\r\n    view.writeUint16LE(value, offset)\r\n  SET_FUNCTION_BUF[Field.INT_16] = (view, value, offset) => view.writeInt16LE(value, offset)\r\n\r\n  SET_FUNCTION_BUF[Field.UNSIGNED_INT_32] = (view, value, offset) =>\r\n    view.writeUint32LE(value, offset)\r\n  SET_FUNCTION_BUF[Field.INT_32] = (view, value, offset) => view.writeInt32LE(value, offset)\r\n  SET_FUNCTION_BUF[Field.FLOAT_32] = (view, value, offset) => view.writeFloatLE(value, offset)\r\n\r\n  SET_FUNCTION_BUF[Field.FLOAT_64] = (view, value, offset) => view.writeDoubleLE(value, offset)\r\n}\r\n\r\nconst GET_FUNCTION_BUF = Array(8) as ((nodeBuffer: Buffer, offset: number) => number)[]\r\n\r\nif (hasNodeBuffers) {\r\n  GET_FUNCTION_BUF[Field.UNSIGNED_INT_8] = (view, offset) => view.readUint8(offset)\r\n  GET_FUNCTION_BUF[Field.INT_8] = (view, offset) => view.readInt8(offset)\r\n\r\n  GET_FUNCTION_BUF[Field.UNSIGNED_INT_16] = (view, offset) => view.readUint16LE(offset)\r\n  GET_FUNCTION_BUF[Field.INT_16] = (view, offset) => view.readInt16LE(offset)\r\n\r\n  GET_FUNCTION_BUF[Field.UNSIGNED_INT_32] = (view, offset) => view.readUint32LE(offset)\r\n  GET_FUNCTION_BUF[Field.INT_32] = (view, offset) => view.readInt32LE(offset)\r\n  GET_FUNCTION_BUF[Field.FLOAT_32] = (view, offset) => view.readFloatLE(offset)\r\n\r\n  GET_FUNCTION_BUF[Field.FLOAT_64] = (view, offset) => view.readDoubleLE(offset)\r\n}\r\n","export const hasNodeBuffers = typeof Buffer === 'function'\r\n\r\nexport function growDataView(dataview: DataView, newByteLength: number) {\r\n  const resizedBuffer = new ArrayBuffer(newByteLength)\r\n  const amountToCopy = Math.min(dataview.byteLength, resizedBuffer.byteLength)\r\n\r\n  // Treat the buffer as if it was a Float64Array so we can copy 8 bytes at a time, to finish faster\r\n  let length = Math.trunc(amountToCopy / 8)\r\n  new Float64Array(resizedBuffer, 0, length).set(new Float64Array(dataview.buffer, 0, length))\r\n\r\n  // Copy the remaining up to 7 bytes\r\n  const offset = length * 8\r\n  length = amountToCopy - offset\r\n  new Uint8Array(resizedBuffer, offset, length).set(new Uint8Array(dataview.buffer, offset, length))\r\n\r\n  return new DataView(resizedBuffer)\r\n}\r\n\r\nexport function growNodeBuffer(buffer: Buffer, newByteLength: number) {\r\n  const newBuffer = Buffer.allocUnsafe(newByteLength)\r\n  buffer.copy(newBuffer)\r\n  return newBuffer\r\n}\r\n"],"mappings":"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","names":["Field"]}

package/dist/index.mjs

@@ -31,6 +31,12 @@ var Field = /* @__PURE__ */ ((Field2) => {
 function FieldArray(item) {
   return [item];
 }
+function FieldFixedArray(item, length) {
+  if (length < 0 || !Number.isFinite(length)) {
+    throw new RangeError("Length of a FixedArray must be a positive integer.");
+  }
+  return [item, length];
+}
 var BinaryPacket = class _BinaryPacket {
   constructor(packetId, definition) {
     this.packetId = packetId;
@@ -172,7 +178,10 @@ var BinaryPacket = class _BinaryPacket {
     const result = {};
     for (const [name, def] of this.entries) {
       if (Array.isArray(def)) {
-        const length = readFunctions[0 /* UNSIGNED_INT_8 */](dataIn, offsetPointer.offset++);
+        const length = (
+          // def[1] is the length of a statically-sized array, if undefined: must read the length from the buffer as it means it's a dynamically-sized array
+          def[1] ?? readFunctions[0 /* UNSIGNED_INT_8 */](dataIn, offsetPointer.offset++)
+        );
         const array = Array(length);
         const itemType = def[0];
         if (typeof itemType === "object") {
@@ -214,16 +223,28 @@ var BinaryPacket = class _BinaryPacket {
       );
     }
   }
+  /**
+   * Fast write does not support writing dynamically-sized arrays.
+   */
   fastWrite(buffer, dataOut, offsetPointer, writeFunctions) {
     for (const [name, def] of this.entries) {
-      if (typeof def === "object") {
-        ;
-        def.fastWrite(
-          buffer,
-          dataOut[name],
-          offsetPointer,
-          writeFunctions
-        );
+      if (Array.isArray(def)) {
+        const itemType = def[0];
+        const length = def[1];
+        const data = dataOut[name];
+        if (typeof itemType === "object") {
+          for (let i = 0; i < length; ++i) {
+            itemType.fastWrite(buffer, data[i], offsetPointer, writeFunctions);
+          }
+        } else {
+          const itemSize = BYTE_SIZE[itemType];
+          for (let i = 0; i < length; ++i) {
+            writeFunctions[itemType](buffer, data[i], offsetPointer.offset);
+            offsetPointer.offset += itemSize;
+          }
+        }
+      } else if (typeof def === "object") {
+        def.fastWrite(buffer, dataOut[name], offsetPointer, writeFunctions);
       } else {
         writeFunctions[def](buffer, dataOut[name], offsetPointer.offset);
         offsetPointer.offset += BYTE_SIZE[def];
@@ -232,23 +253,28 @@ var BinaryPacket = class _BinaryPacket {
   }
   /**
    * The slow writing path tries writing data into the buffer as fast as the fast writing path does. \
-   * But, if a non-empty array is encountered, the buffer needs to grow, slightly reducing performance.
+   * But, if a non-empty dynamically-sized array is encountered, the buffer needs to grow, slightly reducing performance.
    */
   slowWrite(buffer, dataOut, offsetPointer, byteLength, maxByteLength, writeFunctions, growBufferFunction) {
     for (const [name, def] of this.entries) {
       const data = dataOut[name];
       if (Array.isArray(def)) {
         const length = data.length;
-        writeFunctions[0 /* UNSIGNED_INT_8 */](buffer, length, offsetPointer.offset);
-        offsetPointer.offset += 1;
+        const isDynamicArray = def[1] === void 0;
+        if (isDynamicArray) {
+          writeFunctions[0 /* UNSIGNED_INT_8 */](buffer, length, offsetPointer.offset);
+          offsetPointer.offset += 1;
+        }
         if (length > 0) {
           const itemType = def[0];
           if (typeof itemType === "object") {
-            const neededBytesForElements = length * itemType.minimumByteLength;
-            byteLength += neededBytesForElements;
-            maxByteLength += neededBytesForElements;
-            if (buffer.byteLength < maxByteLength) {
-              buffer = growBufferFunction(buffer, maxByteLength);
+            if (isDynamicArray) {
+              const neededBytesForElements = length * itemType.minimumByteLength;
+              byteLength += neededBytesForElements;
+              maxByteLength += neededBytesForElements;
+              if (buffer.byteLength < maxByteLength) {
+                buffer = growBufferFunction(buffer, maxByteLength);
+              }
             }
             for (const object of data) {
               writeFunctions[0 /* UNSIGNED_INT_8 */](
@@ -271,11 +297,13 @@ var BinaryPacket = class _BinaryPacket {
             }
           } else {
             const itemSize = BYTE_SIZE[itemType];
-            const neededBytesForElements = length * itemSize;
-            byteLength += neededBytesForElements;
-            maxByteLength += neededBytesForElements;
-            if (buffer.byteLength < maxByteLength) {
-              buffer = growBufferFunction(buffer, maxByteLength);
+            if (isDynamicArray) {
+              const neededBytesForElements = length * itemSize;
+              byteLength += neededBytesForElements;
+              maxByteLength += neededBytesForElements;
+              if (buffer.byteLength < maxByteLength) {
+                buffer = growBufferFunction(buffer, maxByteLength);
+              }
             }
             for (const number of data) {
               writeFunctions[itemType](buffer, number, offsetPointer.offset);
@@ -315,8 +343,13 @@ function inspectEntries(entries) {
   let canFastWrite = true;
   for (const [, type] of entries) {
     if (Array.isArray(type)) {
-      minimumByteLength += 1;
-      canFastWrite = false;
+      if (type.length === 2) {
+        const itemSize = typeof type[0] === "object" ? type[0].minimumByteLength : BYTE_SIZE[type[0]];
+        minimumByteLength += type[1] * itemSize;
+      } else {
+        minimumByteLength += 1;
+        canFastWrite = false;
+      }
     } else if (type instanceof BinaryPacket) {
       minimumByteLength += type.minimumByteLength;
       canFastWrite &&= type.canFastWrite;
@@ -338,12 +371,12 @@ BYTE_SIZE[7 /* FLOAT_64 */] = 8;
 var GET_FUNCTION = Array(8);
 GET_FUNCTION[0 /* UNSIGNED_INT_8 */] = (view, offset) => view.getUint8(offset);
 GET_FUNCTION[3 /* INT_8 */] = (view, offset) => view.getInt8(offset);
-GET_FUNCTION[1 /* UNSIGNED_INT_16 */] = (view, offset, le) => view.getUint16(offset, le);
-GET_FUNCTION[4 /* INT_16 */] = (view, offset, le) => view.getInt16(offset, le);
-GET_FUNCTION[2 /* UNSIGNED_INT_32 */] = (view, offset, le) => view.getUint32(offset, le);
-GET_FUNCTION[5 /* INT_32 */] = (view, offset, le) => view.getInt32(offset, le);
-GET_FUNCTION[6 /* FLOAT_32 */] = (view, offset, le) => view.getFloat32(offset, le);
-GET_FUNCTION[7 /* FLOAT_64 */] = (view, offset, le) => view.getFloat64(offset, le);
+GET_FUNCTION[1 /* UNSIGNED_INT_16 */] = (view, offset) => view.getUint16(offset);
+GET_FUNCTION[4 /* INT_16 */] = (view, offset) => view.getInt16(offset);
+GET_FUNCTION[2 /* UNSIGNED_INT_32 */] = (view, offset) => view.getUint32(offset);
+GET_FUNCTION[5 /* INT_32 */] = (view, offset) => view.getInt32(offset);
+GET_FUNCTION[6 /* FLOAT_32 */] = (view, offset) => view.getFloat32(offset);
+GET_FUNCTION[7 /* FLOAT_64 */] = (view, offset) => view.getFloat64(offset);
 var SET_FUNCTION = Array(8);
 SET_FUNCTION[0 /* UNSIGNED_INT_8 */] = (view, value, offset) => view.setUint8(offset, value);
 SET_FUNCTION[3 /* INT_8 */] = (view, value, offset) => view.setInt8(offset, value);
@@ -378,6 +411,7 @@ if (hasNodeBuffers) {
 export {
   BinaryPacket,
   Field,
-  FieldArray
+  FieldArray,
+  FieldFixedArray
 };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/buffers.ts","../src/index.ts"],"sourcesContent":["export const hasNodeBuffers = typeof Buffer === 'function'\r\n\r\nexport function growDataView(dataview: DataView, newByteLength: number) {\r\n  const resizedBuffer = new ArrayBuffer(newByteLength)\r\n  const amountToCopy = Math.min(dataview.byteLength, resizedBuffer.byteLength)\r\n\r\n  // Treat the buffer as if it was a Float64Array so we can copy 8 bytes at a time, to finish faster\r\n  let length = Math.trunc(amountToCopy / 8)\r\n  new Float64Array(resizedBuffer, 0, length).set(new Float64Array(dataview.buffer, 0, length))\r\n\r\n  // Copy the remaining up to 7 bytes\r\n  const offset = length * 8\r\n  length = amountToCopy - offset\r\n  new Uint8Array(resizedBuffer, offset, length).set(new Uint8Array(dataview.buffer, offset, length))\r\n\r\n  return new DataView(resizedBuffer)\r\n}\r\n\r\nexport function growNodeBuffer(buffer: Buffer, newByteLength: number) {\r\n  const newBuffer = Buffer.allocUnsafe(newByteLength)\r\n  buffer.copy(newBuffer)\r\n  return newBuffer\r\n}\r\n","import { growDataView, growNodeBuffer, hasNodeBuffers } from './buffers'\r\n\r\nexport const enum Field {\r\n  /**\r\n   * Defines a 1 byte (8 bits) unsigned integer field. \\\r\n   * (Range: 0 - 255)\r\n   */\r\n  UNSIGNED_INT_8 = 0,\r\n\r\n  /**\r\n   * Defines a 2 bytes (16 bits) unsigned integer field. \\\r\n   * (Range: 0 - 65535)\r\n   */\r\n  UNSIGNED_INT_16,\r\n\r\n  /**\r\n   * Defines a 4 bytes (32 bits) unsigned integer field. \\\r\n   * (Range: 0 - 4294967295)\r\n   */\r\n  UNSIGNED_INT_32,\r\n\r\n  /**\r\n   * Defines a 1 byte (8 bits) signed integer field. \\\r\n   * (Range: -128 - 127)\r\n   */\r\n  INT_8,\r\n\r\n  /**\r\n   * Defines a 2 bytes (16 bits) signed integer field. \\\r\n   * (Range: -32768 - 32767)\r\n   */\r\n  INT_16,\r\n\r\n  /**\r\n   * Defines a 4 bytes (32 bits) signed integer field. \\\r\n   * (Range: -2147483648 - 2147483647)\r\n   */\r\n  INT_32,\r\n\r\n  /**\r\n   * Defines a 4 bytes (32 bits) floating-point field. \\\r\n   */\r\n  FLOAT_32,\r\n\r\n  /**\r\n   * Defines a 8 bytes (64 bits) floating-point field. \\\r\n   */\r\n  FLOAT_64\r\n}\r\n\r\n/**\r\n * Defines an array of a certain type. \\\r\n * As of now, only arrays with at most 256 elements are supported.\r\n */\r\nexport function FieldArray<T extends Field | BinaryPacket<Definition>>(item: T) {\r\n  return [item]\r\n}\r\n\r\nexport class BinaryPacket<T extends Definition> {\r\n  /**\r\n   * Defines a new binary packet. \\\r\n   * Make sure that every `packetId` is unique.\r\n   * @throws RangeError If packetId is negative, floating-point, or greater than 255.\r\n   */\r\n  static define<T extends Definition>(packetId: number, definition?: T) {\r\n    if (packetId < 0 || !Number.isFinite(packetId)) {\r\n      throw new RangeError('Packet IDs must be positive integers.')\r\n    }\r\n\r\n    if (packetId > 255) {\r\n      throw new RangeError(\r\n        'Packet IDs greater than 255 are not supported. Do you REALLY need more than 255 different kinds of packets?'\r\n      )\r\n    }\r\n\r\n    return new BinaryPacket(packetId, definition)\r\n  }\r\n\r\n  /**\r\n   * Reads just the packetId from the given Buffer. \\\r\n   * This method practically just reads the uint8 at offset `byteOffset` (default: 0). \\\r\n   * Useful if the receiving side receives multiple types of packets.\r\n   */\r\n  static readPacketIdNodeBuffer(buffer: Buffer, byteOffset = 0) {\r\n    return buffer.readUint8(byteOffset)\r\n  }\r\n\r\n  /**\r\n   * Reads just the packetId from the given DataView. \\\r\n   * This method practically just reads the uint8 at offset `byteOffset` (default: 0). \\\r\n   * Useful if the receiving side receives multiple types of packets.\r\n   */\r\n  static readPacketIdDataView(dataview: DataView, byteOffset = 0) {\r\n    return dataview.getUint8(byteOffset)\r\n  }\r\n\r\n  /**\r\n   * Reads just the packetId from the given ArrayBuffer. \\\r\n   * This method practically just reads the uint8 at offset `byteOffset`. \\\r\n   * Useful if the receiving side receives multiple types of packets.\r\n   *\r\n   * NOTE: Due to security issues, the `byteOffset` argument cannot be defaulted and must be provided by the user. \\\r\n   * NOTE: For more information read the `readArrayBuffer` method documentation.\r\n   */\r\n  static readPacketIdArrayBuffer(arraybuffer: ArrayBuffer, byteOffset: number) {\r\n    return new Uint8Array(arraybuffer, byteOffset, 1)[0]\r\n  }\r\n\r\n  /**\r\n   * Reads/deserializes from the given Buffer. \\\r\n   * Method available ONLY on NodeJS and Bun.\r\n   *\r\n   * If possible, always prefer reading using this method, as it is much faster than the other ones.\r\n   *\r\n   * NOTE: if you have an ArrayBuffer do not bother wrapping it into a node Buffer yourself. \\\r\n   * NOTE: if you have an ArrayBuffer use the appropriate `readArrayBuffer`.\r\n   */\r\n  readNodeBuffer(\r\n    dataIn: Buffer,\r\n    offsetPointer = { offset: 0 },\r\n    byteLength = dataIn.byteLength\r\n  ): ToJson<T> {\r\n    return this.read(dataIn, offsetPointer, byteLength, GET_FUNCTION_BUF)\r\n  }\r\n\r\n  /**\r\n   * Reads/deserializes from the given DataView.\r\n   *\r\n   * NOTE: if you have an ArrayBuffer do not bother wrapping it into a DataView yourself. \\\r\n   * NOTE: if you have an ArrayBuffer use the appropriate `readArrayBuffer`.\r\n   */\r\n  readDataView(\r\n    dataIn: DataView,\r\n    offsetPointer = { offset: 0 },\r\n    byteLength = dataIn.byteLength\r\n  ): ToJson<T> {\r\n    return this.read(dataIn, offsetPointer, byteLength, GET_FUNCTION)\r\n  }\r\n\r\n  /**\r\n   * Reads/deserializes from the given ArrayBuffer. \\\r\n   * WARNING: this method is practically a HACK.\r\n   *\r\n   * When using this method both the `byteOffset` and `byteLength` are REQUIRED and cannot be defaulted. \\\r\n   * This is to prevent serious bugs and security issues. \\\r\n   * That is because often raw ArrayBuffers come from a pre-allocated buffer pool and do not start at byteOffset 0.\r\n   *\r\n   * NOTE: if you have a node Buffer do not bother wrapping it into an ArrayBuffer yourself. \\\r\n   * NOTE: if you have a node Buffer use the appropriate `readNodeBuffer` as it is much faster and less error prone.\r\n   */\r\n  readArrayBuffer(\r\n    dataIn: ArrayBuffer & { buffer?: undefined },\r\n    byteOffset: number,\r\n    byteLength: number\r\n  ) {\r\n    return this.read(\r\n      hasNodeBuffers\r\n        ? Buffer.from(dataIn, byteOffset, byteLength)\r\n        : new DataView(dataIn, byteOffset, byteLength),\r\n      { offset: 0 }, // The underlying buffer has already been offsetted\r\n      byteLength,\r\n      hasNodeBuffers ? GET_FUNCTION_BUF : GET_FUNCTION\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Writes/serializes the given object into a Buffer. \\\r\n   * Method available ONLY on NodeJS and Bun.\r\n   *\r\n   * If possible, always prefer writing using this method, as it is much faster than the other ones.\r\n   */\r\n  writeNodeBuffer(dataOut: ToJson<T>) {\r\n    const buffer = Buffer.allocUnsafe(this.minimumByteLength)\r\n    return this.write(buffer, dataOut, { offset: 0 }, SET_FUNCTION_BUF, growNodeBuffer)\r\n  }\r\n\r\n  /**\r\n   * Writes/serializes the given object into a DataView. \\\r\n   */\r\n  writeDataView(dataOut: ToJson<T>) {\r\n    const dataview = new DataView(new ArrayBuffer(this.minimumByteLength))\r\n    return this.write(dataview, dataOut, { offset: 0 }, SET_FUNCTION, growDataView)\r\n  }\r\n\r\n  /**\r\n   * Writes/serializes the given object into an ArrayBuffer. \\\r\n   * This method is just a wrapper around either  `writeNodeBuffer` or `writeDataView`. \\\r\n   *\r\n   * This method works with JavaScript standard raw ArrayBuffer(s) and, as such, is very error prone: \\\r\n   * Make sure you're using the returned byteLength and byteOffset fields in the read counterpart. \\\r\n   *\r\n   * Always consider whether is possible to use directly `writeNodeBuffer` or `writeDataView` instead of `writeArrayBuffer`. \\\r\n   * For more information read the `readArrayBuffer` documentation.\r\n   */\r\n  writeArrayBuffer(dataOut: ToJson<T>) {\r\n    const buf = hasNodeBuffers ? this.writeNodeBuffer(dataOut) : this.writeDataView(dataOut)\r\n    return { buffer: buf.buffer, byteLength: buf.byteLength, byteOffset: buf.byteOffset }\r\n  }\r\n\r\n  private readonly entries: Entries\r\n  readonly canFastWrite: boolean\r\n  readonly minimumByteLength: number\r\n\r\n  private constructor(\r\n    private readonly packetId: number,\r\n    definition?: T\r\n  ) {\r\n    this.entries = definition ? sortEntries(definition) : []\r\n    const inspection = inspectEntries(this.entries)\r\n\r\n    this.minimumByteLength = inspection.minimumByteLength\r\n    this.canFastWrite = inspection.canFastWrite\r\n  }\r\n\r\n  private read(\r\n    dataIn: DataView | Buffer,\r\n    offsetPointer: { offset: number },\r\n    byteLength: number,\r\n    readFunctions: typeof GET_FUNCTION | typeof GET_FUNCTION_BUF\r\n  ): ToJson<T> {\r\n    if (byteLength + offsetPointer.offset < this.minimumByteLength) {\r\n      throw new Error(\r\n        `There is no space available to fit a packet of type ${this.packetId} at offset ${offsetPointer.offset}`\r\n      )\r\n    }\r\n\r\n    if (\r\n      readFunctions[Field.UNSIGNED_INT_8](dataIn as any, offsetPointer.offset) !== this.packetId\r\n    ) {\r\n      throw new Error(\r\n        `Data at offset ${offsetPointer.offset} is not a packet of type ${this.packetId}`\r\n      )\r\n    }\r\n\r\n    offsetPointer.offset += 1\r\n    const result: any = {}\r\n\r\n    for (const [name, def] of this.entries) {\r\n      if (Array.isArray(def)) {\r\n        const length = readFunctions[Field.UNSIGNED_INT_8](dataIn as any, offsetPointer.offset++)\r\n        const array = Array(length)\r\n\r\n        const itemType = def[0]\r\n\r\n        if (typeof itemType === 'object') {\r\n          // Array of \"subpackets\"\r\n          for (let i = 0; i < length; ++i) {\r\n            array[i] = itemType.read(dataIn, offsetPointer, byteLength, readFunctions)\r\n          }\r\n        } else {\r\n          // Array of primitives (numbers)\r\n          const itemSize = BYTE_SIZE[itemType]\r\n\r\n          // It seems like looping over each element is actually much faster than using TypedArrays bulk copy.\r\n          // TODO: properly benchmark with various array sizes to see if it's actually the case.\r\n          for (let i = 0; i < length; ++i) {\r\n            array[i] = readFunctions[itemType](dataIn as any, offsetPointer.offset)\r\n            offsetPointer.offset += itemSize\r\n          }\r\n        }\r\n\r\n        result[name] = array\r\n      } else if (typeof def === 'object') {\r\n        // Single \"subpacket\"\r\n        result[name] = def.read(dataIn, offsetPointer, byteLength, readFunctions)\r\n      } else {\r\n        // Single primitive (number)\r\n        result[name] = readFunctions[def](dataIn as any, offsetPointer.offset)\r\n        offsetPointer.offset += BYTE_SIZE[def]\r\n      }\r\n    }\r\n\r\n    return result as ToJson<T>\r\n  }\r\n\r\n  private write<Buf extends DataView | Buffer>(\r\n    buffer: Buf,\r\n    dataOut: ToJson<T>,\r\n    offsetPointer: { offset: number },\r\n    writeFunctions: typeof SET_FUNCTION | typeof SET_FUNCTION_BUF,\r\n    growBufferFunction: (buffer: Buf, newByteLength: number) => Buf\r\n  ): Buf {\r\n    writeFunctions[Field.UNSIGNED_INT_8](buffer as any, this.packetId, offsetPointer.offset)\r\n    offsetPointer.offset += 1\r\n\r\n    if (this.canFastWrite) {\r\n      // If there are no arrays, the minimumByteLength always equals to the full needed byteLength.\r\n      // So we can take the fast path, since we know beforehand that the buffer isn't going to grow.\r\n      this.fastWrite(buffer, dataOut, offsetPointer, writeFunctions)\r\n      return buffer\r\n    } else {\r\n      // If non-empty arrays are encountered, the buffer must grow.\r\n      // If every array is empty, the speed of this path is comparable to the fast path.\r\n      return this.slowWrite(\r\n        buffer,\r\n        dataOut,\r\n        offsetPointer,\r\n        this.minimumByteLength,\r\n        this.minimumByteLength,\r\n        writeFunctions,\r\n        growBufferFunction\r\n      )\r\n    }\r\n  }\r\n\r\n  private fastWrite<Buf extends DataView | Buffer>(\r\n    buffer: Buf,\r\n    dataOut: ToJson<T>,\r\n    offsetPointer: { offset: number },\r\n    writeFunctions: typeof SET_FUNCTION | typeof SET_FUNCTION_BUF\r\n  ) {\r\n    for (const [name, def] of this.entries) {\r\n      if (typeof def === 'object') {\r\n        // Single \"subpacket\"\r\n        // In fastWrite there cannot be arrays, but the cast is needed because TypeScript can't possibly know that.\r\n        ;(def as BinaryPacket<Definition>).fastWrite(\r\n          buffer,\r\n          dataOut[name] as ToJson<Definition>,\r\n          offsetPointer,\r\n          writeFunctions\r\n        )\r\n      } else {\r\n        // Single primitive (number)\r\n        writeFunctions[def](buffer as any, dataOut[name] as number, offsetPointer.offset)\r\n        offsetPointer.offset += BYTE_SIZE[def]\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * The slow writing path tries writing data into the buffer as fast as the fast writing path does. \\\r\n   * But, if a non-empty array is encountered, the buffer needs to grow, slightly reducing performance.\r\n   */\r\n  private slowWrite<Buf extends DataView | Buffer>(\r\n    buffer: Buf,\r\n    dataOut: ToJson<T>,\r\n    offsetPointer: { offset: number },\r\n    byteLength: number,\r\n    maxByteLength: number,\r\n    writeFunctions: typeof SET_FUNCTION | typeof SET_FUNCTION_BUF,\r\n    growBufferFunction: (buffer: Buf, newByteLength: number) => Buf\r\n  ): Buf {\r\n    for (const [name, def] of this.entries) {\r\n      const data = dataOut[name]\r\n\r\n      if (Array.isArray(def)) {\r\n        // Could be both an array of just numbers or \"subpackets\"\r\n        const length = (data as any[]).length\r\n\r\n        writeFunctions[Field.UNSIGNED_INT_8](buffer as any, length, offsetPointer.offset)\r\n        offsetPointer.offset += 1\r\n\r\n        if (length > 0) {\r\n          const itemType = def[0]\r\n\r\n          if (typeof itemType === 'object') {\r\n            // Array of \"subpackets\"\r\n            const neededBytesForElements = length * itemType.minimumByteLength\r\n\r\n            byteLength += neededBytesForElements\r\n            maxByteLength += neededBytesForElements\r\n\r\n            if (buffer.byteLength < maxByteLength) {\r\n              buffer = growBufferFunction(buffer, maxByteLength)\r\n            }\r\n\r\n            for (const object of data as unknown as ToJson<Definition>[]) {\r\n              writeFunctions[Field.UNSIGNED_INT_8](\r\n                buffer as any,\r\n                itemType.packetId,\r\n                offsetPointer.offset\r\n              )\r\n\r\n              offsetPointer.offset += 1\r\n\r\n              buffer = itemType.slowWrite(\r\n                buffer,\r\n                object,\r\n                offsetPointer,\r\n                byteLength,\r\n                maxByteLength,\r\n                writeFunctions,\r\n                growBufferFunction\r\n              )\r\n\r\n              byteLength = offsetPointer.offset\r\n              maxByteLength = buffer.byteLength\r\n            }\r\n          } else {\r\n            // Array of primitives (numbers)\r\n            const itemSize = BYTE_SIZE[itemType]\r\n            const neededBytesForElements = length * itemSize\r\n\r\n            byteLength += neededBytesForElements\r\n            maxByteLength += neededBytesForElements\r\n\r\n            if (buffer.byteLength < maxByteLength) {\r\n              buffer = growBufferFunction(buffer, maxByteLength)\r\n            }\r\n\r\n            // It seems like looping over each element is actually much faster than using TypedArrays bulk copy.\r\n            // TODO: properly benchmark with various array sizes to see if it's actually the case.\r\n            for (const number of data as number[]) {\r\n              writeFunctions[itemType](buffer as any, number, offsetPointer.offset)\r\n              offsetPointer.offset += itemSize\r\n            }\r\n          }\r\n        }\r\n      } else if (typeof def === 'object') {\r\n        // Single \"subpacket\"\r\n        writeFunctions[Field.UNSIGNED_INT_8](buffer as any, def.packetId, offsetPointer.offset)\r\n        offsetPointer.offset += 1\r\n\r\n        buffer = def.slowWrite(\r\n          buffer,\r\n          data as ToJson<Definition>,\r\n          offsetPointer,\r\n          byteLength,\r\n          maxByteLength,\r\n          writeFunctions,\r\n          growBufferFunction\r\n        )\r\n\r\n        byteLength = offsetPointer.offset\r\n        maxByteLength = buffer.byteLength\r\n      } else {\r\n        // Single primitive (number)\r\n        writeFunctions[def](buffer as any, data as number, offsetPointer.offset)\r\n        offsetPointer.offset += BYTE_SIZE[def]\r\n      }\r\n    }\r\n\r\n    return buffer\r\n  }\r\n}\r\n\r\n/**\r\n * BinaryPacket definition: \\\r\n * Any packet can be defined through a \"schema\" object explaining its fields names and types.\r\n *\r\n * @example\r\n * // Imagine we have a game board where each cell is a square and is one unit big.\r\n * // A cell can be then defined by its X and Y coordinates.\r\n * // For simplicity, let's say there cannot be more than 256 cells, so we can use 8 bits for each coordinate.\r\n * const Cell = {\r\n *  x: Field.UNSIGNED_INT_8,\r\n *  y: Field.UNSIGNED_INT_8\r\n * }\r\n *\r\n * // When done with the cell definition we can create its BinaryPacket writer/reader.\r\n * // NOTE: each BinaryPacket needs an unique ID, for identification purposes and error checking.\r\n * const CellPacket = BinaryPacket.define(0, Cell)\r\n *\r\n * // Let's now make the definition of the whole game board.\r\n * // You can also specify arrays of both \"primitive\" fields and other BinaryPackets.\r\n * const Board = {\r\n *  numPlayers: Field.UNSIGNED_INT_8,\r\n *  cells: FieldArray(CellPacket) // equivalent to { cells: [CellPacket] }\r\n * }\r\n *\r\n * // When done with the board definition we can create its BinaryPacket writer/reader.\r\n * // NOTE: each BinaryPacket needs an unique ID, for identification purposes and error checking.\r\n * const BoardPacket = BinaryPacket.define(1, Board)\r\n *\r\n * // And use it.\r\n * const buffer = BoardPacket.writeNodeBuffer({\r\n *  numPlayers: 1,\r\n *  cells: [\r\n *    { x: 0, y: 0 },\r\n *    { x: 1, y: 1 }\r\n *  ]\r\n * })\r\n *\r\n * // sendTheBufferOver(buffer)\r\n * // ...\r\n * // const buffer = receiveTheBuffer()\r\n * const board = BoardPacket.readNodeBuffer(buffer)\r\n * // ...\r\n */\r\nexport type Definition = {\r\n  [fieldName: string]: Field | Field[] | BinaryPacket<Definition> | BinaryPacket<Definition>[]\r\n}\r\n\r\n/**\r\n * Meta-type that converts a `Definition` schema to the type of the actual JavaScript object that will be written into a packet or read from. \\\r\n */\r\ntype ToJson<T extends Definition> = {\r\n  [K in keyof T]: T[K] extends ReadonlyArray<infer Item>\r\n    ? Item extends BinaryPacket<infer BPDef>\r\n      ? ToJson<BPDef>[]\r\n      : number[]\r\n    : T[K] extends BinaryPacket<infer BPDef>\r\n      ? ToJson<BPDef>\r\n      : number\r\n}\r\n\r\n/**\r\n * In a JavaScript object, the order of its keys is not strictly defined: sort them by field name. \\\r\n * Thus, we cannot trust iterating over an object keys: we MUST iterate over its entries array. \\\r\n * This is important to make sure that whoever shares BinaryPacket definitions can correctly write/read packets independently of their JS engines.\r\n */\r\nfunction sortEntries(definition: Definition) {\r\n  return Object.entries(definition).sort(([fieldName1], [fieldName2]) =>\r\n    fieldName1.localeCompare(fieldName2)\r\n  )\r\n}\r\n\r\ntype Entries = ReturnType<typeof sortEntries>\r\n\r\n/**\r\n * Helper function that \"inspects\" the entries of a BinaryPacket definition\r\n * and returns useful \"stats\" needed for writing and reading buffers.\r\n *\r\n * This function is ever called only once per BinaryPacket definition.\r\n */\r\nfunction inspectEntries(entries: Entries) {\r\n  // The PacketID is already 1 byte, that's why we aren't starting from 0.\r\n  let minimumByteLength = 1\r\n  let canFastWrite = true\r\n\r\n  for (const [, type] of entries) {\r\n    if (Array.isArray(type)) {\r\n      // Adding 1 byte to serialize the array length\r\n      minimumByteLength += 1\r\n      canFastWrite = false\r\n    } else if (type instanceof BinaryPacket) {\r\n      minimumByteLength += type.minimumByteLength\r\n      canFastWrite &&= type.canFastWrite\r\n    } else {\r\n      minimumByteLength += BYTE_SIZE[type]\r\n    }\r\n  }\r\n\r\n  return { minimumByteLength, canFastWrite }\r\n}\r\n\r\n//////////////////////////////////////////////\r\n// The logic here is practically over       //\r\n// Here below there are needed constants    //\r\n// that map a field-type to a functionality //\r\n//////////////////////////////////////////////\r\n\r\nconst BYTE_SIZE = Array(8)\r\n\r\nBYTE_SIZE[Field.UNSIGNED_INT_8] = 1\r\nBYTE_SIZE[Field.INT_8] = 1\r\n\r\nBYTE_SIZE[Field.UNSIGNED_INT_16] = 2\r\nBYTE_SIZE[Field.INT_16] = 2\r\n\r\nBYTE_SIZE[Field.UNSIGNED_INT_32] = 4\r\nBYTE_SIZE[Field.INT_32] = 4\r\nBYTE_SIZE[Field.FLOAT_32] = 4\r\n\r\nBYTE_SIZE[Field.FLOAT_64] = 8\r\n\r\nconst GET_FUNCTION: ((view: DataView, offset: number, littleEndian?: boolean) => number)[] =\r\n  Array(8)\r\n\r\nGET_FUNCTION[Field.UNSIGNED_INT_8] = (view, offset) => view.getUint8(offset)\r\nGET_FUNCTION[Field.INT_8] = (view, offset) => view.getInt8(offset)\r\n\r\nGET_FUNCTION[Field.UNSIGNED_INT_16] = (view, offset, le) => view.getUint16(offset, le)\r\nGET_FUNCTION[Field.INT_16] = (view, offset, le) => view.getInt16(offset, le)\r\n\r\nGET_FUNCTION[Field.UNSIGNED_INT_32] = (view, offset, le) => view.getUint32(offset, le)\r\nGET_FUNCTION[Field.INT_32] = (view, offset, le) => view.getInt32(offset, le)\r\nGET_FUNCTION[Field.FLOAT_32] = (view, offset, le) => view.getFloat32(offset, le)\r\n\r\nGET_FUNCTION[Field.FLOAT_64] = (view, offset, le) => view.getFloat64(offset, le)\r\n\r\nconst SET_FUNCTION: ((view: DataView, value: number, offset: number) => void)[] = Array(8)\r\n\r\nSET_FUNCTION[Field.UNSIGNED_INT_8] = (view, value, offset) => view.setUint8(offset, value)\r\nSET_FUNCTION[Field.INT_8] = (view, value, offset) => view.setInt8(offset, value)\r\n\r\nSET_FUNCTION[Field.UNSIGNED_INT_16] = (view, value, offset) => view.setUint16(offset, value)\r\nSET_FUNCTION[Field.INT_16] = (view, value, offset) => view.setInt16(offset, value)\r\n\r\nSET_FUNCTION[Field.UNSIGNED_INT_32] = (view, value, offset) => view.setUint32(offset, value)\r\nSET_FUNCTION[Field.INT_32] = (view, value, offset) => view.setInt32(offset, value)\r\nSET_FUNCTION[Field.FLOAT_32] = (view, value, offset) => view.setFloat32(offset, value)\r\n\r\nSET_FUNCTION[Field.FLOAT_64] = (view, value, offset) => view.setFloat64(offset, value)\r\n\r\nconst SET_FUNCTION_BUF: ((nodeBuffer: Buffer, value: number, offset: number) => void)[] = Array(8)\r\n\r\nif (hasNodeBuffers) {\r\n  SET_FUNCTION_BUF[Field.UNSIGNED_INT_8] = (view, value, offset) => view.writeUint8(value, offset)\r\n  SET_FUNCTION_BUF[Field.INT_8] = (view, value, offset) => view.writeInt8(value, offset)\r\n\r\n  SET_FUNCTION_BUF[Field.UNSIGNED_INT_16] = (view, value, offset) =>\r\n    view.writeUint16LE(value, offset)\r\n  SET_FUNCTION_BUF[Field.INT_16] = (view, value, offset) => view.writeInt16LE(value, offset)\r\n\r\n  SET_FUNCTION_BUF[Field.UNSIGNED_INT_32] = (view, value, offset) =>\r\n    view.writeUint32LE(value, offset)\r\n  SET_FUNCTION_BUF[Field.INT_32] = (view, value, offset) => view.writeInt32LE(value, offset)\r\n  SET_FUNCTION_BUF[Field.FLOAT_32] = (view, value, offset) => view.writeFloatLE(value, offset)\r\n\r\n  SET_FUNCTION_BUF[Field.FLOAT_64] = (view, value, offset) => view.writeDoubleLE(value, offset)\r\n}\r\n\r\nconst GET_FUNCTION_BUF: ((nodeBuffer: Buffer, offset: number) => number)[] = Array(8)\r\n\r\nif (hasNodeBuffers) {\r\n  GET_FUNCTION_BUF[Field.UNSIGNED_INT_8] = (view, offset) => view.readUint8(offset)\r\n  GET_FUNCTION_BUF[Field.INT_8] = (view, offset) => view.readInt8(offset)\r\n\r\n  GET_FUNCTION_BUF[Field.UNSIGNED_INT_16] = (view, offset) => view.readUint16LE(offset)\r\n  GET_FUNCTION_BUF[Field.INT_16] = (view, offset) => view.readInt16LE(offset)\r\n\r\n  GET_FUNCTION_BUF[Field.UNSIGNED_INT_32] = (view, offset) => view.readUint32LE(offset)\r\n  GET_FUNCTION_BUF[Field.INT_32] = (view, offset) => view.readInt32LE(offset)\r\n  GET_FUNCTION_BUF[Field.FLOAT_32] = (view, offset) => view.readFloatLE(offset)\r\n\r\n  GET_FUNCTION_BUF[Field.FLOAT_64] = (view, offset) => view.readDoubleLE(offset)\r\n}\r\n"],"mappings":"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","names":["Field"]}
+{"version":3,"sources":["../src/buffers.ts","../src/index.ts"],"sourcesContent":["export const hasNodeBuffers = typeof Buffer === 'function'\r\n\r\nexport function growDataView(dataview: DataView, newByteLength: number) {\r\n  const resizedBuffer = new ArrayBuffer(newByteLength)\r\n  const amountToCopy = Math.min(dataview.byteLength, resizedBuffer.byteLength)\r\n\r\n  // Treat the buffer as if it was a Float64Array so we can copy 8 bytes at a time, to finish faster\r\n  let length = Math.trunc(amountToCopy / 8)\r\n  new Float64Array(resizedBuffer, 0, length).set(new Float64Array(dataview.buffer, 0, length))\r\n\r\n  // Copy the remaining up to 7 bytes\r\n  const offset = length * 8\r\n  length = amountToCopy - offset\r\n  new Uint8Array(resizedBuffer, offset, length).set(new Uint8Array(dataview.buffer, offset, length))\r\n\r\n  return new DataView(resizedBuffer)\r\n}\r\n\r\nexport function growNodeBuffer(buffer: Buffer, newByteLength: number) {\r\n  const newBuffer = Buffer.allocUnsafe(newByteLength)\r\n  buffer.copy(newBuffer)\r\n  return newBuffer\r\n}\r\n","import { growDataView, growNodeBuffer, hasNodeBuffers } from './buffers'\r\n\r\nexport const enum Field {\r\n  /**\r\n   * Defines a 1 byte (8 bits) unsigned integer field. \\\r\n   * (Range: 0 - 255)\r\n   */\r\n  UNSIGNED_INT_8 = 0,\r\n\r\n  /**\r\n   * Defines a 2 bytes (16 bits) unsigned integer field. \\\r\n   * (Range: 0 - 65535)\r\n   */\r\n  UNSIGNED_INT_16,\r\n\r\n  /**\r\n   * Defines a 4 bytes (32 bits) unsigned integer field. \\\r\n   * (Range: 0 - 4294967295)\r\n   */\r\n  UNSIGNED_INT_32,\r\n\r\n  /**\r\n   * Defines a 1 byte (8 bits) signed integer field. \\\r\n   * (Range: -128 - 127)\r\n   */\r\n  INT_8,\r\n\r\n  /**\r\n   * Defines a 2 bytes (16 bits) signed integer field. \\\r\n   * (Range: -32768 - 32767)\r\n   */\r\n  INT_16,\r\n\r\n  /**\r\n   * Defines a 4 bytes (32 bits) signed integer field. \\\r\n   * (Range: -2147483648 - 2147483647)\r\n   */\r\n  INT_32,\r\n\r\n  /**\r\n   * Defines a 4 bytes (32 bits) floating-point field. \\\r\n   */\r\n  FLOAT_32,\r\n\r\n  /**\r\n   * Defines a 8 bytes (64 bits) floating-point field. \\\r\n   */\r\n  FLOAT_64\r\n}\r\n\r\n/**\r\n * Defines a dynamically-sized array with elements of a certain type. \\\r\n * Dynamically-sized arrays are useful when a packet's field is an array of a non pre-defined length. \\\r\n * Although, this makes dynamically-sized arrays more memory expensive as the internal buffer needs to be grown accordingly.\r\n *\r\n * NOTE: If an array will ALWAYS have the same length, prefer using the `FieldFixedArray` type, for both better performance and memory efficiency. \\\r\n * NOTE: As of now, dynamic arrays can have at most 256 elements.\r\n */\r\nexport function FieldArray<T extends Field | BinaryPacket<Definition>>(item: T): [itemType: T] {\r\n  return [item]\r\n}\r\n\r\n/**\r\n * Defines a statically-sized array with elements of a certain type. \\\r\n * Fixed arrays are useful when a packet's field is an array of a pre-defined length. \\\r\n * Fixed arrays much more memory efficient and performant than non-fixed ones.\r\n *\r\n * NOTE: If an array will not always have the same length, use the `FieldArray` type.\r\n */\r\nexport function FieldFixedArray<T extends Field | BinaryPacket<Definition>, Length extends number>(\r\n  item: T,\r\n  length: Length\r\n): [itemType: T, length: Length] {\r\n  if (length < 0 || !Number.isFinite(length)) {\r\n    throw new RangeError('Length of a FixedArray must be a positive integer.')\r\n  }\r\n\r\n  return [item, length]\r\n}\r\n\r\nexport class BinaryPacket<T extends Definition> {\r\n  /**\r\n   * Defines a new binary packet. \\\r\n   * Make sure that every `packetId` is unique.\r\n   * @throws RangeError If packetId is negative, floating-point, or greater than 255.\r\n   */\r\n  static define<T extends Definition>(packetId: number, definition?: T) {\r\n    if (packetId < 0 || !Number.isFinite(packetId)) {\r\n      throw new RangeError('Packet IDs must be positive integers.')\r\n    }\r\n\r\n    if (packetId > 255) {\r\n      throw new RangeError(\r\n        'Packet IDs greater than 255 are not supported. Do you REALLY need more than 255 different kinds of packets?'\r\n      )\r\n    }\r\n\r\n    return new BinaryPacket(packetId, definition)\r\n  }\r\n\r\n  /**\r\n   * Reads just the packetId from the given Buffer. \\\r\n   * This method practically just reads the uint8 at offset `byteOffset` (default: 0). \\\r\n   * Useful if the receiving side receives multiple types of packets.\r\n   */\r\n  static readPacketIdNodeBuffer(buffer: Buffer, byteOffset = 0) {\r\n    return buffer.readUint8(byteOffset)\r\n  }\r\n\r\n  /**\r\n   * Reads just the packetId from the given DataView. \\\r\n   * This method practically just reads the uint8 at offset `byteOffset` (default: 0). \\\r\n   * Useful if the receiving side receives multiple types of packets.\r\n   */\r\n  static readPacketIdDataView(dataview: DataView, byteOffset = 0) {\r\n    return dataview.getUint8(byteOffset)\r\n  }\r\n\r\n  /**\r\n   * Reads just the packetId from the given ArrayBuffer. \\\r\n   * This method practically just reads the uint8 at offset `byteOffset`. \\\r\n   * Useful if the receiving side receives multiple types of packets.\r\n   *\r\n   * NOTE: Due to security issues, the `byteOffset` argument cannot be defaulted and must be provided by the user. \\\r\n   * NOTE: For more information read the `readArrayBuffer` method documentation.\r\n   */\r\n  static readPacketIdArrayBuffer(arraybuffer: ArrayBuffer, byteOffset: number) {\r\n    return new Uint8Array(arraybuffer, byteOffset, 1)[0]\r\n  }\r\n\r\n  /**\r\n   * Reads/deserializes from the given Buffer. \\\r\n   * Method available ONLY on NodeJS and Bun.\r\n   *\r\n   * If possible, always prefer reading using this method, as it is much faster than the other ones.\r\n   *\r\n   * NOTE: if you have an ArrayBuffer do not bother wrapping it into a node Buffer yourself. \\\r\n   * NOTE: if you have an ArrayBuffer use the appropriate `readArrayBuffer`.\r\n   */\r\n  readNodeBuffer(\r\n    dataIn: Buffer,\r\n    offsetPointer = { offset: 0 },\r\n    byteLength = dataIn.byteLength\r\n  ): ToJson<T> {\r\n    return this.read(dataIn, offsetPointer, byteLength, GET_FUNCTION_BUF)\r\n  }\r\n\r\n  /**\r\n   * Reads/deserializes from the given DataView.\r\n   *\r\n   * NOTE: if you have an ArrayBuffer do not bother wrapping it into a DataView yourself. \\\r\n   * NOTE: if you have an ArrayBuffer use the appropriate `readArrayBuffer`.\r\n   */\r\n  readDataView(\r\n    dataIn: DataView,\r\n    offsetPointer = { offset: 0 },\r\n    byteLength = dataIn.byteLength\r\n  ): ToJson<T> {\r\n    return this.read(dataIn, offsetPointer, byteLength, GET_FUNCTION)\r\n  }\r\n\r\n  /**\r\n   * Reads/deserializes from the given ArrayBuffer. \\\r\n   * WARNING: this method is practically a HACK.\r\n   *\r\n   * When using this method both the `byteOffset` and `byteLength` are REQUIRED and cannot be defaulted. \\\r\n   * This is to prevent serious bugs and security issues. \\\r\n   * That is because often raw ArrayBuffers come from a pre-allocated buffer pool and do not start at byteOffset 0.\r\n   *\r\n   * NOTE: if you have a node Buffer do not bother wrapping it into an ArrayBuffer yourself. \\\r\n   * NOTE: if you have a node Buffer use the appropriate `readNodeBuffer` as it is much faster and less error prone.\r\n   */\r\n  readArrayBuffer(\r\n    dataIn: ArrayBuffer & { buffer?: undefined },\r\n    byteOffset: number,\r\n    byteLength: number\r\n  ) {\r\n    return this.read(\r\n      hasNodeBuffers\r\n        ? Buffer.from(dataIn, byteOffset, byteLength)\r\n        : new DataView(dataIn, byteOffset, byteLength),\r\n      { offset: 0 }, // The underlying buffer has already been offsetted\r\n      byteLength,\r\n      hasNodeBuffers ? GET_FUNCTION_BUF : GET_FUNCTION\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Writes/serializes the given object into a Buffer. \\\r\n   * Method available ONLY on NodeJS and Bun.\r\n   *\r\n   * If possible, always prefer writing using this method, as it is much faster than the other ones.\r\n   */\r\n  writeNodeBuffer(dataOut: ToJson<T>) {\r\n    const buffer = Buffer.allocUnsafe(this.minimumByteLength)\r\n    return this.write(buffer, dataOut, { offset: 0 }, SET_FUNCTION_BUF, growNodeBuffer)\r\n  }\r\n\r\n  /**\r\n   * Writes/serializes the given object into a DataView. \\\r\n   */\r\n  writeDataView(dataOut: ToJson<T>) {\r\n    const dataview = new DataView(new ArrayBuffer(this.minimumByteLength))\r\n    return this.write(dataview, dataOut, { offset: 0 }, SET_FUNCTION, growDataView)\r\n  }\r\n\r\n  /**\r\n   * Writes/serializes the given object into an ArrayBuffer. \\\r\n   * This method is just a wrapper around either  `writeNodeBuffer` or `writeDataView`. \\\r\n   *\r\n   * This method works with JavaScript standard raw ArrayBuffer(s) and, as such, is very error prone: \\\r\n   * Make sure you're using the returned byteLength and byteOffset fields in the read counterpart. \\\r\n   *\r\n   * Always consider whether is possible to use directly `writeNodeBuffer` or `writeDataView` instead of `writeArrayBuffer`. \\\r\n   * For more information read the `readArrayBuffer` documentation.\r\n   */\r\n  writeArrayBuffer(dataOut: ToJson<T>) {\r\n    const buf = hasNodeBuffers ? this.writeNodeBuffer(dataOut) : this.writeDataView(dataOut)\r\n    return { buffer: buf.buffer, byteLength: buf.byteLength, byteOffset: buf.byteOffset }\r\n  }\r\n\r\n  private readonly entries: Entries\r\n  readonly canFastWrite: boolean\r\n  readonly minimumByteLength: number\r\n\r\n  private constructor(\r\n    private readonly packetId: number,\r\n    definition?: T\r\n  ) {\r\n    this.entries = definition ? sortEntries(definition) : []\r\n    const inspection = inspectEntries(this.entries)\r\n\r\n    this.minimumByteLength = inspection.minimumByteLength\r\n    this.canFastWrite = inspection.canFastWrite\r\n  }\r\n\r\n  private read(\r\n    dataIn: DataView | Buffer,\r\n    offsetPointer: { offset: number },\r\n    byteLength: number,\r\n    readFunctions: typeof GET_FUNCTION | typeof GET_FUNCTION_BUF\r\n  ): ToJson<T> {\r\n    if (byteLength + offsetPointer.offset < this.minimumByteLength) {\r\n      throw new Error(\r\n        `There is no space available to fit a packet of type ${this.packetId} at offset ${offsetPointer.offset}`\r\n      )\r\n    }\r\n\r\n    if (\r\n      readFunctions[Field.UNSIGNED_INT_8](dataIn as any, offsetPointer.offset) !== this.packetId\r\n    ) {\r\n      throw new Error(\r\n        `Data at offset ${offsetPointer.offset} is not a packet of type ${this.packetId}`\r\n      )\r\n    }\r\n\r\n    offsetPointer.offset += 1\r\n    const result: any = {}\r\n\r\n    for (const [name, def] of this.entries) {\r\n      if (Array.isArray(def)) {\r\n        const length =\r\n          // def[1] is the length of a statically-sized array, if undefined: must read the length from the buffer as it means it's a dynamically-sized array\r\n          def[1] ?? readFunctions[Field.UNSIGNED_INT_8](dataIn as any, offsetPointer.offset++)\r\n\r\n        const array = Array(length)\r\n\r\n        const itemType = def[0]\r\n\r\n        if (typeof itemType === 'object') {\r\n          // Array of \"subpackets\"\r\n          for (let i = 0; i < length; ++i) {\r\n            array[i] = itemType.read(dataIn, offsetPointer, byteLength, readFunctions)\r\n          }\r\n        } else {\r\n          // Array of primitives (numbers)\r\n          const itemSize = BYTE_SIZE[itemType]\r\n\r\n          // It seems like looping over each element is actually much faster than using TypedArrays bulk copy.\r\n          // TODO: properly benchmark with various array sizes to see if it's actually the case.\r\n          for (let i = 0; i < length; ++i) {\r\n            array[i] = readFunctions[itemType](dataIn as any, offsetPointer.offset)\r\n            offsetPointer.offset += itemSize\r\n          }\r\n        }\r\n\r\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\r\n        result[name] = array\r\n      } else if (typeof def === 'object') {\r\n        // Single \"subpacket\"\r\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\r\n        result[name] = def.read(dataIn, offsetPointer, byteLength, readFunctions)\r\n      } else {\r\n        // Single primitive (number)\r\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\r\n        result[name] = readFunctions[def](dataIn as any, offsetPointer.offset)\r\n        offsetPointer.offset += BYTE_SIZE[def]\r\n      }\r\n    }\r\n\r\n    return result as ToJson<T>\r\n  }\r\n\r\n  private write<Buf extends DataView | Buffer>(\r\n    buffer: Buf,\r\n    dataOut: ToJson<T>,\r\n    offsetPointer: { offset: number },\r\n    writeFunctions: typeof SET_FUNCTION | typeof SET_FUNCTION_BUF,\r\n    growBufferFunction: (buffer: Buf, newByteLength: number) => Buf\r\n  ): Buf {\r\n    writeFunctions[Field.UNSIGNED_INT_8](buffer as any, this.packetId, offsetPointer.offset)\r\n    offsetPointer.offset += 1\r\n\r\n    if (this.canFastWrite) {\r\n      // If there are no arrays, the minimumByteLength always equals to the full needed byteLength.\r\n      // So we can take the fast path, since we know beforehand that the buffer isn't going to grow.\r\n      this.fastWrite(buffer, dataOut, offsetPointer, writeFunctions)\r\n      return buffer\r\n    } else {\r\n      // If non-empty arrays are encountered, the buffer must grow.\r\n      // If every array is empty, the speed of this path is comparable to the fast path.\r\n      return this.slowWrite(\r\n        buffer,\r\n        dataOut,\r\n        offsetPointer,\r\n        this.minimumByteLength,\r\n        this.minimumByteLength,\r\n        writeFunctions,\r\n        growBufferFunction\r\n      )\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Fast write does not support writing dynamically-sized arrays.\r\n   */\r\n  private fastWrite<Buf extends DataView | Buffer>(\r\n    buffer: Buf,\r\n    dataOut: ToJson<T>,\r\n    offsetPointer: { offset: number },\r\n    writeFunctions: typeof SET_FUNCTION | typeof SET_FUNCTION_BUF\r\n  ) {\r\n    for (const [name, def] of this.entries) {\r\n      if (Array.isArray(def)) {\r\n        // Statically-sized array\r\n        const itemType = def[0]\r\n        const length = def[1]!\r\n        const data = dataOut[name] as any[]\r\n\r\n        if (typeof itemType === 'object') {\r\n          for (let i = 0; i < length; ++i) {\r\n            itemType.fastWrite(buffer, data[i] as ToJson<Definition>, offsetPointer, writeFunctions)\r\n          }\r\n        } else {\r\n          const itemSize = BYTE_SIZE[itemType]\r\n\r\n          for (let i = 0; i < length; ++i) {\r\n            writeFunctions[itemType](buffer as any, data[i] as number, offsetPointer.offset)\r\n            offsetPointer.offset += itemSize\r\n          }\r\n        }\r\n      } else if (typeof def === 'object') {\r\n        // Single \"subpacket\"\r\n        // In fastWrite there cannot be arrays, but the cast is needed because TypeScript can't possibly know that.\r\n        def.fastWrite(buffer, dataOut[name] as ToJson<Definition>, offsetPointer, writeFunctions)\r\n      } else {\r\n        // Single primitive (number)\r\n        writeFunctions[def](buffer as any, dataOut[name] as number, offsetPointer.offset)\r\n        offsetPointer.offset += BYTE_SIZE[def]\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * The slow writing path tries writing data into the buffer as fast as the fast writing path does. \\\r\n   * But, if a non-empty dynamically-sized array is encountered, the buffer needs to grow, slightly reducing performance.\r\n   */\r\n  private slowWrite<Buf extends DataView | Buffer>(\r\n    buffer: Buf,\r\n    dataOut: ToJson<T>,\r\n    offsetPointer: { offset: number },\r\n    byteLength: number,\r\n    maxByteLength: number,\r\n    writeFunctions: typeof SET_FUNCTION | typeof SET_FUNCTION_BUF,\r\n    growBufferFunction: (buffer: Buf, newByteLength: number) => Buf\r\n  ): Buf {\r\n    for (const [name, def] of this.entries) {\r\n      const data = dataOut[name]\r\n\r\n      if (Array.isArray(def)) {\r\n        // Could be both an array of just numbers or \"subpackets\"\r\n\r\n        const length = (data as any[]).length\r\n        const isDynamicArray = def[1] === undefined\r\n\r\n        // Check if it is a dynamically-sized array, if it is, the length of the array must be serialized in the buffer before its elements\r\n        // Explicitly check for undefined and not falsy values because it could be a statically-sized array of 0 elements.\r\n        if (isDynamicArray) {\r\n          writeFunctions[Field.UNSIGNED_INT_8](buffer as any, length, offsetPointer.offset)\r\n          offsetPointer.offset += 1\r\n        }\r\n\r\n        if (length > 0) {\r\n          const itemType = def[0]\r\n\r\n          if (typeof itemType === 'object') {\r\n            // Array of \"subpackets\"\r\n\r\n            if (isDynamicArray) {\r\n              const neededBytesForElements = length * itemType.minimumByteLength\r\n\r\n              byteLength += neededBytesForElements\r\n              maxByteLength += neededBytesForElements\r\n\r\n              if (buffer.byteLength < maxByteLength) {\r\n                buffer = growBufferFunction(buffer, maxByteLength)\r\n              }\r\n            }\r\n\r\n            for (const object of data as unknown as ToJson<Definition>[]) {\r\n              writeFunctions[Field.UNSIGNED_INT_8](\r\n                buffer as any,\r\n                itemType.packetId,\r\n                offsetPointer.offset\r\n              )\r\n\r\n              offsetPointer.offset += 1\r\n\r\n              buffer = itemType.slowWrite(\r\n                buffer,\r\n                object,\r\n                offsetPointer,\r\n                byteLength,\r\n                maxByteLength,\r\n                writeFunctions,\r\n                growBufferFunction\r\n              )\r\n\r\n              byteLength = offsetPointer.offset\r\n              maxByteLength = buffer.byteLength\r\n            }\r\n          } else {\r\n            // Array of primitives (numbers)\r\n            const itemSize = BYTE_SIZE[itemType]\r\n\r\n            if (isDynamicArray) {\r\n              const neededBytesForElements = length * itemSize\r\n\r\n              byteLength += neededBytesForElements\r\n              maxByteLength += neededBytesForElements\r\n\r\n              if (buffer.byteLength < maxByteLength) {\r\n                buffer = growBufferFunction(buffer, maxByteLength)\r\n              }\r\n            }\r\n\r\n            // It seems like looping over each element is actually much faster than using TypedArrays bulk copy.\r\n            // TODO: properly benchmark with various array sizes to see if it's actually the case.\r\n            for (const number of data as number[]) {\r\n              writeFunctions[itemType](buffer as any, number, offsetPointer.offset)\r\n              offsetPointer.offset += itemSize\r\n            }\r\n          }\r\n        }\r\n      } else if (typeof def === 'object') {\r\n        // Single \"subpacket\"\r\n        writeFunctions[Field.UNSIGNED_INT_8](buffer as any, def.packetId, offsetPointer.offset)\r\n        offsetPointer.offset += 1\r\n\r\n        buffer = def.slowWrite(\r\n          buffer,\r\n          data as ToJson<Definition>,\r\n          offsetPointer,\r\n          byteLength,\r\n          maxByteLength,\r\n          writeFunctions,\r\n          growBufferFunction\r\n        )\r\n\r\n        byteLength = offsetPointer.offset\r\n        maxByteLength = buffer.byteLength\r\n      } else {\r\n        // Single primitive (number)\r\n        writeFunctions[def](buffer as any, data as number, offsetPointer.offset)\r\n        offsetPointer.offset += BYTE_SIZE[def]\r\n      }\r\n    }\r\n\r\n    return buffer\r\n  }\r\n}\r\n\r\n/**\r\n * BinaryPacket definition: \\\r\n * Any packet can be defined through a \"schema\" object explaining its fields names and types.\r\n *\r\n * @example\r\n * // Imagine we have a game board where each cell is a square and is one unit big.\r\n * // A cell can be then defined by its X and Y coordinates.\r\n * // For simplicity, let's say there cannot be more than 256 cells, so we can use 8 bits for each coordinate.\r\n * const Cell = {\r\n *  x: Field.UNSIGNED_INT_8,\r\n *  y: Field.UNSIGNED_INT_8\r\n * }\r\n *\r\n * // When done with the cell definition we can create its BinaryPacket writer/reader.\r\n * // NOTE: each BinaryPacket needs an unique ID, for identification purposes and error checking.\r\n * const CellPacket = BinaryPacket.define(0, Cell)\r\n *\r\n * // Let's now make the definition of the whole game board.\r\n * // You can also specify arrays of both \"primitive\" fields and other BinaryPackets.\r\n * const Board = {\r\n *  numPlayers: Field.UNSIGNED_INT_8,\r\n *  cells: FieldArray(CellPacket)\r\n * }\r\n *\r\n * // When done with the board definition we can create its BinaryPacket writer/reader.\r\n * // NOTE: each BinaryPacket needs an unique ID, for identification purposes and error checking.\r\n * const BoardPacket = BinaryPacket.define(1, Board)\r\n *\r\n * // And use it.\r\n * const buffer = BoardPacket.writeNodeBuffer({\r\n *  numPlayers: 1,\r\n *  cells: [\r\n *    { x: 0, y: 0 },\r\n *    { x: 1, y: 1 }\r\n *  ]\r\n * })\r\n *\r\n * // sendTheBufferOver(buffer)\r\n * // ...\r\n * // const buffer = receiveTheBuffer()\r\n * const board = BoardPacket.readNodeBuffer(buffer)\r\n * // ...\r\n */\r\nexport type Definition = {\r\n  [fieldName: string]: MaybeArray<Field> | MaybeArray<BinaryPacket<Definition>>\r\n}\r\n\r\ntype MaybeArray<T> = T | [itemType: T] | [itemType: T, length: number]\r\n\r\n/**\r\n * Meta-type that converts a `Definition` schema to the type of the actual JavaScript object that will be written into a packet or read from. \\\r\n */\r\ntype ToJson<T extends Definition> = {\r\n  [K in keyof T]: T[K] extends [infer Item]\r\n    ? Item extends BinaryPacket<infer BPDef>\r\n      ? ToJson<BPDef>[]\r\n      : number[]\r\n    : T[K] extends [infer Item, infer Length]\r\n      ? Item extends BinaryPacket<infer BPDef>\r\n        ? ToJson<BPDef>[] & { length: Length }\r\n        : number[] & { length: Length }\r\n      : T[K] extends BinaryPacket<infer BPDef>\r\n        ? ToJson<BPDef>\r\n        : number\r\n}\r\n\r\n/**\r\n * In a JavaScript object, the order of its keys is not strictly defined: sort them by field name. \\\r\n * Thus, we cannot trust iterating over an object keys: we MUST iterate over its entries array. \\\r\n * This is important to make sure that whoever shares BinaryPacket definitions can correctly write/read packets independently of their JS engines.\r\n */\r\nfunction sortEntries(definition: Definition) {\r\n  return Object.entries(definition).sort(([fieldName1], [fieldName2]) =>\r\n    fieldName1.localeCompare(fieldName2)\r\n  )\r\n}\r\n\r\ntype Entries = ReturnType<typeof sortEntries>\r\n\r\n/**\r\n * Helper function that \"inspects\" the entries of a BinaryPacket definition\r\n * and returns useful \"stats\" needed for writing and reading buffers.\r\n *\r\n * This function is ever called only once per BinaryPacket definition.\r\n */\r\nfunction inspectEntries(entries: Entries) {\r\n  // The PacketID is already 1 byte, that's why we aren't starting from 0.\r\n  let minimumByteLength = 1\r\n  let canFastWrite = true\r\n\r\n  for (const [, type] of entries) {\r\n    if (Array.isArray(type)) {\r\n      if (type.length === 2) {\r\n        // Statically-sized array\r\n        const itemSize =\r\n          typeof type[0] === 'object' ? type[0].minimumByteLength : BYTE_SIZE[type[0]]\r\n\r\n        minimumByteLength += type[1] * itemSize\r\n      } else {\r\n        // Dynamically-sized array\r\n        // Adding 1 byte to serialize the array length\r\n        minimumByteLength += 1\r\n        canFastWrite = false\r\n      }\r\n    } else if (type instanceof BinaryPacket) {\r\n      minimumByteLength += type.minimumByteLength\r\n      canFastWrite &&= type.canFastWrite\r\n    } else {\r\n      minimumByteLength += BYTE_SIZE[type]\r\n    }\r\n  }\r\n\r\n  return { minimumByteLength, canFastWrite }\r\n}\r\n\r\n//////////////////////////////////////////////\r\n// The logic here is practically over       //\r\n// Here below there are needed constants    //\r\n// that map a field-type to a functionality //\r\n//////////////////////////////////////////////\r\n\r\nconst BYTE_SIZE = Array(8) as number[]\r\n\r\nBYTE_SIZE[Field.UNSIGNED_INT_8] = 1\r\nBYTE_SIZE[Field.INT_8] = 1\r\n\r\nBYTE_SIZE[Field.UNSIGNED_INT_16] = 2\r\nBYTE_SIZE[Field.INT_16] = 2\r\n\r\nBYTE_SIZE[Field.UNSIGNED_INT_32] = 4\r\nBYTE_SIZE[Field.INT_32] = 4\r\nBYTE_SIZE[Field.FLOAT_32] = 4\r\n\r\nBYTE_SIZE[Field.FLOAT_64] = 8\r\n\r\nconst GET_FUNCTION = Array(8) as ((view: DataView, offset: number) => number)[]\r\n\r\nGET_FUNCTION[Field.UNSIGNED_INT_8] = (view, offset) => view.getUint8(offset)\r\nGET_FUNCTION[Field.INT_8] = (view, offset) => view.getInt8(offset)\r\n\r\nGET_FUNCTION[Field.UNSIGNED_INT_16] = (view, offset) => view.getUint16(offset)\r\nGET_FUNCTION[Field.INT_16] = (view, offset) => view.getInt16(offset)\r\n\r\nGET_FUNCTION[Field.UNSIGNED_INT_32] = (view, offset) => view.getUint32(offset)\r\nGET_FUNCTION[Field.INT_32] = (view, offset) => view.getInt32(offset)\r\nGET_FUNCTION[Field.FLOAT_32] = (view, offset) => view.getFloat32(offset)\r\n\r\nGET_FUNCTION[Field.FLOAT_64] = (view, offset) => view.getFloat64(offset)\r\n\r\nconst SET_FUNCTION = Array(8) as ((view: DataView, value: number, offset: number) => void)[]\r\n\r\nSET_FUNCTION[Field.UNSIGNED_INT_8] = (view, value, offset) => view.setUint8(offset, value)\r\nSET_FUNCTION[Field.INT_8] = (view, value, offset) => view.setInt8(offset, value)\r\n\r\nSET_FUNCTION[Field.UNSIGNED_INT_16] = (view, value, offset) => view.setUint16(offset, value)\r\nSET_FUNCTION[Field.INT_16] = (view, value, offset) => view.setInt16(offset, value)\r\n\r\nSET_FUNCTION[Field.UNSIGNED_INT_32] = (view, value, offset) => view.setUint32(offset, value)\r\nSET_FUNCTION[Field.INT_32] = (view, value, offset) => view.setInt32(offset, value)\r\nSET_FUNCTION[Field.FLOAT_32] = (view, value, offset) => view.setFloat32(offset, value)\r\n\r\nSET_FUNCTION[Field.FLOAT_64] = (view, value, offset) => view.setFloat64(offset, value)\r\n\r\nconst SET_FUNCTION_BUF = Array(8) as ((nodeBuffer: Buffer, value: number, offset: number) => void)[]\r\n\r\nif (hasNodeBuffers) {\r\n  SET_FUNCTION_BUF[Field.UNSIGNED_INT_8] = (view, value, offset) => view.writeUint8(value, offset)\r\n  SET_FUNCTION_BUF[Field.INT_8] = (view, value, offset) => view.writeInt8(value, offset)\r\n\r\n  SET_FUNCTION_BUF[Field.UNSIGNED_INT_16] = (view, value, offset) =>\r\n    view.writeUint16LE(value, offset)\r\n  SET_FUNCTION_BUF[Field.INT_16] = (view, value, offset) => view.writeInt16LE(value, offset)\r\n\r\n  SET_FUNCTION_BUF[Field.UNSIGNED_INT_32] = (view, value, offset) =>\r\n    view.writeUint32LE(value, offset)\r\n  SET_FUNCTION_BUF[Field.INT_32] = (view, value, offset) => view.writeInt32LE(value, offset)\r\n  SET_FUNCTION_BUF[Field.FLOAT_32] = (view, value, offset) => view.writeFloatLE(value, offset)\r\n\r\n  SET_FUNCTION_BUF[Field.FLOAT_64] = (view, value, offset) => view.writeDoubleLE(value, offset)\r\n}\r\n\r\nconst GET_FUNCTION_BUF = Array(8) as ((nodeBuffer: Buffer, offset: number) => number)[]\r\n\r\nif (hasNodeBuffers) {\r\n  GET_FUNCTION_BUF[Field.UNSIGNED_INT_8] = (view, offset) => view.readUint8(offset)\r\n  GET_FUNCTION_BUF[Field.INT_8] = (view, offset) => view.readInt8(offset)\r\n\r\n  GET_FUNCTION_BUF[Field.UNSIGNED_INT_16] = (view, offset) => view.readUint16LE(offset)\r\n  GET_FUNCTION_BUF[Field.INT_16] = (view, offset) => view.readInt16LE(offset)\r\n\r\n  GET_FUNCTION_BUF[Field.UNSIGNED_INT_32] = (view, offset) => view.readUint32LE(offset)\r\n  GET_FUNCTION_BUF[Field.INT_32] = (view, offset) => view.readInt32LE(offset)\r\n  GET_FUNCTION_BUF[Field.FLOAT_32] = (view, offset) => view.readFloatLE(offset)\r\n\r\n  GET_FUNCTION_BUF[Field.FLOAT_64] = (view, offset) => view.readDoubleLE(offset)\r\n}\r\n"],"mappings":"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","names":["Field"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "binary-packet",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Lightweight and hyper-fast, zero-dependencies, TypeScript-first, schema-based binary packets serialization and deserialization library",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -11,7 +11,8 @@
   "scripts": {
     "build": "tsup",
     "test": "node -r ts-node/register/transpile-only src/tests/reads.test.ts && node -r ts-node/register/transpile-only src/tests/writes.test.ts",
-    "benchmark": "node -r ts-node/register/transpile-only src/tests/benchmark.test.ts"
+    "benchmark": "node -r ts-node/register/transpile-only src/tests/benchmark.test.ts",
+    "lint": "eslint"
   },
   "keywords": [
     "binary-packet",
@@ -45,13 +46,15 @@
   "license": "Apache-2.0",
   "devDependencies": {
     "colors": "^1.4.0",
+    "eslint": "^9.12.0",
     "msgpackr": "^1.11.0",
     "prettier": "^3.3.3",
     "prettier-plugin-organize-imports": "^4.1.0",
     "restructure": "^3.0.2",
     "ts-node": "^10.9.2",
     "tsup": "^8.3.0",
-    "typescript": "^5.6.2"
+    "typescript": "^5.6.2",
+    "typescript-eslint": "^8.8.1"
   },
   "engines": {
     "node": ">=16"