binary-packet 1.0.0

package/dist/index.js

@@ -0,0 +1,385 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BinaryPacket: () => BinaryPacket,
+  Field: () => Field,
+  FieldArray: () => FieldArray
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/buffers.ts
+var hasNodeBuffers = typeof Buffer === "function";
+function growDataView(dataview, newByteLength) {
+  const resizedBuffer = new ArrayBuffer(newByteLength);
+  const amountToCopy = Math.min(dataview.byteLength, resizedBuffer.byteLength);
+  let length = Math.trunc(amountToCopy / 8);
+  new Float64Array(resizedBuffer, 0, length).set(new Float64Array(dataview.buffer, 0, length));
+  const offset = length * 8;
+  length = amountToCopy - offset;
+  new Uint8Array(resizedBuffer, offset, length).set(new Uint8Array(dataview.buffer, offset, length));
+  return new DataView(resizedBuffer);
+}
+function growNodeBuffer(buffer, newByteLength) {
+  const newBuffer = Buffer.allocUnsafe(newByteLength);
+  buffer.copy(newBuffer);
+  return newBuffer;
+}
+
+// src/index.ts
+var Field = /* @__PURE__ */ ((Field2) => {
+  Field2[Field2["UNSIGNED_INT_8"] = 0] = "UNSIGNED_INT_8";
+  Field2[Field2["UNSIGNED_INT_16"] = 1] = "UNSIGNED_INT_16";
+  Field2[Field2["UNSIGNED_INT_32"] = 2] = "UNSIGNED_INT_32";
+  Field2[Field2["INT_8"] = 3] = "INT_8";
+  Field2[Field2["INT_16"] = 4] = "INT_16";
+  Field2[Field2["INT_32"] = 5] = "INT_32";
+  Field2[Field2["FLOAT_32"] = 6] = "FLOAT_32";
+  Field2[Field2["FLOAT_64"] = 7] = "FLOAT_64";
+  return Field2;
+})(Field || {});
+function FieldArray(item) {
+  return [item];
+}
+var BinaryPacket = class _BinaryPacket {
+  constructor(packetId, definition) {
+    this.packetId = packetId;
+    this.entries = definition ? sortEntries(definition) : [];
+    const inspection = inspectEntries(this.entries);
+    this.minimumByteLength = inspection.minimumByteLength;
+    this.canFastWrite = inspection.canFastWrite;
+  }
+  /**
+   * Defines a new binary packet. \
+   * Make sure that every `packetId` is unique.
+   * @throws RangeError If packetId is negative, floating-point, or greater than 255.
+   */
+  static define(packetId, definition) {
+    if (packetId < 0 || !Number.isFinite(packetId)) {
+      throw new RangeError("Packet IDs must be positive integers.");
+    }
+    if (packetId > 255) {
+      throw new RangeError(
+        "Packet IDs greater than 255 are not supported. Do you REALLY need more than 255 different kinds of packets?"
+      );
+    }
+    return new _BinaryPacket(packetId, definition);
+  }
+  entries;
+  canFastWrite;
+  minimumByteLength;
+  /**
+   * Reads/deserializes from the given Buffer. \
+   * Method available ONLY on NodeJS and Bun.
+   *
+   * If possible, always prefer reading using this method, as it is much faster than the other ones.
+   *
+   * NOTE: if you have an ArrayBuffer do not bother wrapping it into a node Buffer yourself. \
+   * NOTE: if you have an ArrayBuffer use the appropriate `readArrayBuffer`.
+   */
+  readNodeBuffer(dataIn, offsetPointer = { offset: 0 }, byteLength = dataIn.byteLength) {
+    return this.read(dataIn, offsetPointer, byteLength, GET_FUNCTION_BUF);
+  }
+  /**
+   * Reads/deserializes from the given DataView.
+   *
+   * NOTE: if you have an ArrayBuffer do not bother wrapping it into a DataView yourself. \
+   * NOTE: if you have an ArrayBuffer use the appropriate `readArrayBuffer`.
+   */
+  readDataView(dataIn, offsetPointer = { offset: 0 }, byteLength = dataIn.byteLength) {
+    return this.read(dataIn, offsetPointer, byteLength, GET_FUNCTION);
+  }
+  /**
+   * Reads/deserializes from the given ArrayBuffer. \
+   * WARNING: this method is practically a HACK.
+   *
+   * When using this method both the `byteOffset` and `byteLength` are REQUIRED and cannot be defaulted. \
+   * This is to prevent serious bugs and security issues. \
+   * That is because often raw ArrayBuffers come from a pre-allocated buffer pool and do not start at byteOffset 0.
+   *
+   * NOTE: if you have a node Buffer do not bother wrapping it into an ArrayBuffer yourself. \
+   * NOTE: if you have a node Buffer use the appropriate `readNodeBuffer` as it is much faster and less error prone.
+   */
+  readArrayBuffer(dataIn, byteOffset, byteLength) {
+    return this.read(
+      hasNodeBuffers ? Buffer.from(dataIn, byteOffset, byteLength) : new DataView(dataIn, byteOffset, byteLength),
+      { offset: 0 },
+      // The underlying buffer has already been offsetted
+      byteLength,
+      hasNodeBuffers ? GET_FUNCTION_BUF : GET_FUNCTION
+    );
+  }
+  /**
+   * Writes/serializes the given object into a Buffer. \
+   * Method available ONLY on NodeJS and Bun.
+   *
+   * If possible, always prefer writing using this method, as it is much faster than the other ones.
+   */
+  writeNodeBuffer(dataOut) {
+    const buffer = Buffer.allocUnsafe(this.minimumByteLength);
+    return this.write(buffer, dataOut, { offset: 0 }, SET_FUNCTION_BUF, growNodeBuffer);
+  }
+  /**
+   * Writes/serializes the given object into a DataView. \
+   */
+  writeDataView(dataOut) {
+    const dataview = new DataView(new ArrayBuffer(this.minimumByteLength));
+    return this.write(dataview, dataOut, { offset: 0 }, SET_FUNCTION, growDataView);
+  }
+  /**
+   * Writes/serializes the given object into an ArrayBuffer. \
+   * This method is just a wrapper around either  `writeNodeBuffer` or `writeDataView`. \
+   *
+   * This method works with JavaScript standard raw ArrayBuffer(s) and, as such, is very error prone: \
+   * Make sure you're using the returned byteLength and byteOffset fields in the read counterpart. \
+   *
+   * Always consider whether is possible to use directly `writeNodeBuffer` or `writeDataView` instead of `writeArrayBuffer`. \
+   * For more information read the `readArrayBuffer` documentation.
+   */
+  writeArrayBuffer(dataOut) {
+    const buf = hasNodeBuffers ? this.writeNodeBuffer(dataOut) : this.writeDataView(dataOut);
+    return { buffer: buf.buffer, byteLength: buf.byteLength, byteOffset: buf.byteOffset };
+  }
+  read(dataIn, offsetPointer, byteLength, readFunctions) {
+    if (byteLength + offsetPointer.offset < this.minimumByteLength) {
+      throw new Error(
+        `There is no space available to fit a packet of type ${this.packetId} at offset ${offsetPointer.offset}`
+      );
+    }
+    if (readFunctions[0 /* UNSIGNED_INT_8 */](dataIn, offsetPointer.offset) !== this.packetId) {
+      throw new Error(
+        `Data at offset ${offsetPointer.offset} is not a packet of type ${this.packetId}`
+      );
+    }
+    offsetPointer.offset += 1;
+    const result = {};
+    for (const [name, def] of this.entries) {
+      if (Array.isArray(def)) {
+        const length = readFunctions[0 /* UNSIGNED_INT_8 */](dataIn, offsetPointer.offset++);
+        const array = Array(length);
+        const itemType = def[0];
+        if (typeof itemType === "object") {
+          for (let i = 0; i < length; ++i) {
+            array[i] = itemType.read(dataIn, offsetPointer, byteLength, readFunctions);
+          }
+        } else {
+          const itemSize = BYTE_SIZE[itemType];
+          for (let i = 0; i < length; ++i) {
+            array[i] = readFunctions[itemType](dataIn, offsetPointer.offset);
+            offsetPointer.offset += itemSize;
+          }
+        }
+        result[name] = array;
+      } else if (typeof def === "object") {
+        result[name] = def.read(dataIn, offsetPointer, byteLength, readFunctions);
+      } else {
+        result[name] = readFunctions[def](dataIn, offsetPointer.offset);
+        offsetPointer.offset += BYTE_SIZE[def];
+      }
+    }
+    return result;
+  }
+  write(buffer, dataOut, offsetPointer, writeFunctions, growBufferFunction) {
+    writeFunctions[0 /* UNSIGNED_INT_8 */](buffer, this.packetId, offsetPointer.offset);
+    offsetPointer.offset += 1;
+    if (this.canFastWrite) {
+      this.fastWrite(buffer, dataOut, offsetPointer, writeFunctions);
+      return buffer;
+    } else {
+      return this.slowWrite(
+        buffer,
+        dataOut,
+        offsetPointer,
+        this.minimumByteLength,
+        this.minimumByteLength,
+        writeFunctions,
+        growBufferFunction
+      );
+    }
+  }
+  fastWrite(buffer, dataOut, offsetPointer, writeFunctions) {
+    for (const [name, def] of this.entries) {
+      if (typeof def === "object") {
+        ;
+        def.fastWrite(
+          buffer,
+          dataOut[name],
+          offsetPointer,
+          writeFunctions
+        );
+      } else {
+        writeFunctions[def](buffer, dataOut[name], offsetPointer.offset);
+        offsetPointer.offset += BYTE_SIZE[def];
+      }
+    }
+  }
+  /**
+   * 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.
+   */
+  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;
+        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);
+            }
+            for (const object of data) {
+              writeFunctions[0 /* UNSIGNED_INT_8 */](
+                buffer,
+                itemType.packetId,
+                offsetPointer.offset
+              );
+              offsetPointer.offset += 1;
+              buffer = itemType.slowWrite(
+                buffer,
+                object,
+                offsetPointer,
+                byteLength,
+                maxByteLength,
+                writeFunctions,
+                growBufferFunction
+              );
+              byteLength = offsetPointer.offset;
+              maxByteLength = buffer.byteLength;
+            }
+          } else {
+            const itemSize = BYTE_SIZE[itemType];
+            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);
+              offsetPointer.offset += itemSize;
+            }
+          }
+        }
+      } else if (typeof def === "object") {
+        writeFunctions[0 /* UNSIGNED_INT_8 */](buffer, def.packetId, offsetPointer.offset);
+        offsetPointer.offset += 1;
+        buffer = def.slowWrite(
+          buffer,
+          data,
+          offsetPointer,
+          byteLength,
+          maxByteLength,
+          writeFunctions,
+          growBufferFunction
+        );
+        byteLength = offsetPointer.offset;
+        maxByteLength = buffer.byteLength;
+      } else {
+        writeFunctions[def](buffer, data, offsetPointer.offset);
+        offsetPointer.offset += BYTE_SIZE[def];
+      }
+    }
+    return buffer;
+  }
+};
+function sortEntries(definition) {
+  return Object.entries(definition).sort(
+    ([fieldName1], [fieldName2]) => fieldName1.localeCompare(fieldName2)
+  );
+}
+function inspectEntries(entries) {
+  let minimumByteLength = 1;
+  let canFastWrite = true;
+  for (const [, type] of entries) {
+    if (Array.isArray(type)) {
+      minimumByteLength += 1;
+      canFastWrite = false;
+    } else if (type instanceof BinaryPacket) {
+      minimumByteLength += type.minimumByteLength;
+      canFastWrite &&= type.canFastWrite;
+    } else {
+      minimumByteLength += BYTE_SIZE[type];
+    }
+  }
+  return { minimumByteLength, canFastWrite };
+}
+var BYTE_SIZE = Array(8);
+BYTE_SIZE[0 /* UNSIGNED_INT_8 */] = 1;
+BYTE_SIZE[3 /* INT_8 */] = 1;
+BYTE_SIZE[1 /* UNSIGNED_INT_16 */] = 2;
+BYTE_SIZE[4 /* INT_16 */] = 2;
+BYTE_SIZE[2 /* UNSIGNED_INT_32 */] = 4;
+BYTE_SIZE[5 /* INT_32 */] = 4;
+BYTE_SIZE[6 /* FLOAT_32 */] = 4;
+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);
+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);
+SET_FUNCTION[1 /* UNSIGNED_INT_16 */] = (view, value, offset) => view.setUint16(offset, value);
+SET_FUNCTION[4 /* INT_16 */] = (view, value, offset) => view.setInt16(offset, value);
+SET_FUNCTION[2 /* UNSIGNED_INT_32 */] = (view, value, offset) => view.setUint32(offset, value);
+SET_FUNCTION[5 /* INT_32 */] = (view, value, offset) => view.setInt32(offset, value);
+SET_FUNCTION[6 /* FLOAT_32 */] = (view, value, offset) => view.setFloat32(offset, value);
+SET_FUNCTION[7 /* FLOAT_64 */] = (view, value, offset) => view.setFloat64(offset, value);
+var SET_FUNCTION_BUF = Array(8);
+if (hasNodeBuffers) {
+  SET_FUNCTION_BUF[0 /* UNSIGNED_INT_8 */] = (view, value, offset) => view.writeUint8(value, offset);
+  SET_FUNCTION_BUF[3 /* INT_8 */] = (view, value, offset) => view.writeInt8(value, offset);
+  SET_FUNCTION_BUF[1 /* UNSIGNED_INT_16 */] = (view, value, offset) => view.writeUint16LE(value, offset);
+  SET_FUNCTION_BUF[4 /* INT_16 */] = (view, value, offset) => view.writeInt16LE(value, offset);
+  SET_FUNCTION_BUF[2 /* UNSIGNED_INT_32 */] = (view, value, offset) => view.writeUint32LE(value, offset);
+  SET_FUNCTION_BUF[5 /* INT_32 */] = (view, value, offset) => view.writeInt32LE(value, offset);
+  SET_FUNCTION_BUF[6 /* FLOAT_32 */] = (view, value, offset) => view.writeFloatLE(value, offset);
+  SET_FUNCTION_BUF[7 /* FLOAT_64 */] = (view, value, offset) => view.writeDoubleLE(value, offset);
+}
+var GET_FUNCTION_BUF = Array(8);
+if (hasNodeBuffers) {
+  GET_FUNCTION_BUF[0 /* UNSIGNED_INT_8 */] = (view, offset) => view.readUint8(offset);
+  GET_FUNCTION_BUF[3 /* INT_8 */] = (view, offset) => view.readInt8(offset);
+  GET_FUNCTION_BUF[1 /* UNSIGNED_INT_16 */] = (view, offset) => view.readUint16LE(offset);
+  GET_FUNCTION_BUF[4 /* INT_16 */] = (view, offset) => view.readInt16LE(offset);
+  GET_FUNCTION_BUF[2 /* UNSIGNED_INT_32 */] = (view, offset) => view.readUint32LE(offset);
+  GET_FUNCTION_BUF[5 /* INT_32 */] = (view, offset) => view.readInt32LE(offset);
+  GET_FUNCTION_BUF[6 /* FLOAT_32 */] = (view, offset) => view.readFloatLE(offset);
+  GET_FUNCTION_BUF[7 /* FLOAT_64 */] = (view, offset) => view.readDoubleLE(offset);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BinaryPacket,
+  Field,
+  FieldArray
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +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  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  /**\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 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"]}