@serenityjs/raknet 0.5.0 → 0.5.1-beta-20240915201114

package/dist/index.js

@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,14 +17,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
 
 // src/index.ts
 var src_exports = {};
@@ -78,10 +71,7 @@ var import_nbt = require("@serenityjs/nbt");
 function Proto(id) {
   return function(target) {
     target.id = id;
-    const metadata = Reflect.getOwnMetadata(
-      "properties",
-      target.prototype
-    );
+    const metadata = Reflect.getOwnMetadata("properties", target.prototype);
     const properties = Object.getOwnPropertyNames(target.prototype);
     if (!properties.includes("serialize"))
       target.prototype.serialize = function() {
@@ -90,10 +80,7 @@ function Proto(id) {
         if (!metadata) return this.getBuffer();
         for (const { name, type, endian, parameter } of metadata) {
           if (parameter) {
-            if (type.prototype === import_nbt.CompoundTag.prototype)
-              throw new Error(
-                "Parameters are not supported for CompoundTag serialization."
-              );
+            if (type.prototype === import_nbt.CompoundTag.prototype) throw new Error("Parameters are not supported for CompoundTag serialization.");
             const value = this[parameter];
             const dtype = type;
             const data = this[name];
@@ -112,52 +99,37 @@ function Proto(id) {
         }
         return this.getBuffer();
       };
-    if (!properties.includes("deserialize"))
-      target.prototype.deserialize = function() {
-        if (this.binary.length === 0) return this;
-        target.id_type.read(this);
-        if (!metadata) return this;
-        for (const { name, type, endian, parameter } of metadata) {
-          if (parameter) {
-            if (type.prototype === import_nbt.CompoundTag.prototype)
-              throw new Error(
-                "Parameters are not supported for CompoundTag deserialization."
-              );
-            const value = this[parameter];
-            const dtype = type;
-            this[name] = dtype.read(
-              this,
-              endian,
-              value
-            );
+    if (!properties.includes("deserialize")) target.prototype.deserialize = function() {
+      if (this.binary.length === 0) return this;
+      target.id_type.read(this);
+      if (!metadata) return this;
+      for (const { name, type, endian, parameter } of metadata) {
+        if (parameter) {
+          if (type.prototype === import_nbt.CompoundTag.prototype) throw new Error("Parameters are not supported for CompoundTag deserialization.");
+          const value = this[parameter];
+          const dtype = type;
+          this[name] = dtype.read(this, endian, value);
+        } else {
+          if (type.prototype === import_nbt.CompoundTag.prototype) {
+            const ctype = type;
+            this[name] = ctype.read(this, endian);
           } else {
-            if (type.prototype === import_nbt.CompoundTag.prototype) {
-              const ctype = type;
-              this[name] = ctype.read(
-                this,
-                endian
-              );
-            } else {
-              const dtype = type;
-              this[name] = dtype.read(
-                this,
-                endian
-              );
-            }
+            const dtype = type;
+            this[name] = dtype.read(this, endian);
           }
         }
-        return this;
-      };
-    if (!properties.includes("getId"))
-      target.prototype.getId = function() {
-        return target.id;
-      };
-    if (!properties.includes("getIdType"))
-      target.prototype.getIdType = function() {
-        return target.id_type;
-      };
+      }
+      return this;
+    };
+    if (!properties.includes("getId")) target.prototype.getId = function() {
+      return target.id;
+    };
+    if (!properties.includes("getIdType")) target.prototype.getIdType = function() {
+      return target.id_type;
+    };
   };
 }
+__name(Proto, "Proto");
 
 // src/decorators/serialize.ts
 var import_binarystream = require("@serenityjs/binarystream");
@@ -165,105 +137,120 @@ function Serialize(type, endian = import_binarystream.Endianness.Big, parameter)
   if (!type) throw new Error("@Serialize() failed, no type provided.");
   return function(target, name) {
     const properties = Reflect.getMetadata("properties", target) || [];
-    properties.push({ name, type, endian, parameter });
+    properties.push({
+      name,
+      type,
+      endian,
+      parameter
+    });
     Reflect.defineMetadata("properties", properties, target);
   };
 }
+__name(Serialize, "Serialize");
 
 // src/proto/types/type.ts
 var import_binarystream2 = require("@serenityjs/binarystream");
-var DataType = class {
+var DataType = class DataType2 {
+  static {
+    __name(this, "DataType");
+  }
   /**
-   * Creates a new data type.
-   */
+  * Creates a new data type.
+  */
   constructor(..._arguments_) {
     return;
   }
   /**
-   * Reads the data type from a binary stream.
-   * @param _stream The binary stream to read from.
-   * @param _endian The endianness to use.
-   * @param _parameter An optional parameter.
-   * @returns The data type.
-   */
+  * Reads the data type from a binary stream.
+  * @param _stream The binary stream to read from.
+  * @param _endian The endianness to use.
+  * @param _parameter An optional parameter.
+  * @returns The data type.
+  */
   static read(_stream, _endian = import_binarystream2.Endianness.Big, _parameter) {
     return;
   }
   /**
-   * Writes the data type to a binary stream.
-   * @param _stream The binary stream to write to.
-   * @param _value The data type to write.
-   * @param _endian The endianness to use.
-   * @param _parameter An optional parameter.
-   */
+  * Writes the data type to a binary stream.
+  * @param _stream The binary stream to write to.
+  * @param _value The data type to write.
+  * @param _endian The endianness to use.
+  * @param _parameter An optional parameter.
+  */
   static write(_stream, _value, _endian = import_binarystream2.Endianness.Big, _parameter) {
     return;
   }
 };
 
 // src/proto/types/magic.ts
-var MagicBuffer = Buffer.from(
-  "\0\xFF\xFF\0\xFE\xFE\xFE\xFE\xFD\xFD\xFD\xFD4Vx",
-  "binary"
-);
-var Magic = class extends DataType {
-  /**
-   * Reads the magic data type from a binary stream.
-   * @param stream The binary stream to read from.
-   * @returns The magic data type.
-   */
+var MagicBuffer = Buffer.from("\0\xFF\xFF\0\xFE\xFE\xFE\xFE\xFD\xFD\xFD\xFD4Vx", "binary");
+var Magic = class Magic2 extends DataType {
+  static {
+    __name(this, "Magic");
+  }
+  /**
+  * Reads the magic data type from a binary stream.
+  * @param stream The binary stream to read from.
+  * @returns The magic data type.
+  */
   static read(stream) {
     return stream.readBuffer(MagicBuffer.length);
   }
   /**
-   * Writes the magic data type to a binary stream.
-   * @param stream The binary stream to write to.
-   */
+  * Writes the magic data type to a binary stream.
+  * @param stream The binary stream to write to.
+  */
   static write(stream) {
     stream.writeBuffer(MagicBuffer);
   }
 };
 
 // src/proto/types/mtu.ts
-var MTU = class extends DataType {
+var MTU = class MTU2 extends DataType {
+  static {
+    __name(this, "MTU");
+  }
   /**
-   * Reads the mtu data type from a binary stream.
-   * @param stream The binary stream to read from.
-   * @returns The mtu data type.
-   */
+  * Reads the mtu data type from a binary stream.
+  * @param stream The binary stream to read from.
+  * @returns The mtu data type.
+  */
   static read(stream) {
     return stream.getBuffer().byteLength;
   }
   /**
-   * Writes the mtu data type to a binary stream.
-   * @param stream The binary stream to write to.
-   * @param value The value to write.
-   */
+  * Writes the mtu data type to a binary stream.
+  * @param stream The binary stream to write to.
+  * @param value The value to write.
+  */
   static write(stream, value) {
     stream.writeBuffer(Buffer.alloc(value - stream.getBuffer().length));
   }
 };
 
 // src/proto/types/address.ts
-var Address = class _Address extends DataType {
+var Address = class Address2 extends DataType {
+  static {
+    __name(this, "Address");
+  }
   /**
-   * The address of the data type.
-   */
+  * The address of the data type.
+  */
   address;
   /**
-   * The port of the data type.
-   */
+  * The port of the data type.
+  */
   port;
   /**
-   * The version of the data type.
-   */
+  * The version of the data type.
+  */
   version;
   /**
-   * Initializes a new instance of the Address data type.
-   * @param address The address of the data type.
-   * @param port The port of the data type.
-   * @param version The version of the data type.
-   */
+  * Initializes a new instance of the Address data type.
+  * @param address The address of the data type.
+  * @param port The port of the data type.
+  * @param version The version of the data type.
+  */
   constructor(address, port, version) {
     super();
     this.address = address;
@@ -271,30 +258,26 @@ var Address = class _Address extends DataType {
     this.version = version;
   }
   /**
-   * Converts the Address data type to a NetworkIdentifier.
-   *
-   * @param identifier The NetworkIdentifier.
-   * @returns The NetworkIdentifier.
-   */
+  * Converts the Address data type to a NetworkIdentifier.
+  *
+  * @param identifier The NetworkIdentifier.
+  * @returns The NetworkIdentifier.
+  */
   static fromIdentifier(identifier) {
-    return new _Address(
-      identifier.address,
-      identifier.port,
-      identifier.family === "IPv4" ? 4 : 6
-    );
+    return new Address2(identifier.address, identifier.port, identifier.family === "IPv4" ? 4 : 6);
   }
   /**
-   * Reads the Address data type from a binary stream.
-   * @param stream The binary stream to read from.
-   * @returns The Address data type.
-   */
+  * Reads the Address data type from a binary stream.
+  * @param stream The binary stream to read from.
+  * @returns The Address data type.
+  */
   static read(stream) {
     const version = stream.readUint8();
     if (version === 4) {
       const addressBuffer = stream.read(4);
       const address = addressBuffer.map((byte) => -byte - 1 & 255).join(".");
       const port = stream.readUShort();
-      return new _Address(address, port, version);
+      return new Address2(address, port, version);
     } else {
       stream.skip(2);
       const port = stream.readUShort();
@@ -302,14 +285,14 @@ var Address = class _Address extends DataType {
       const addressBuffer = stream.read(4);
       const address = addressBuffer.filter((byte) => byte !== 255).join(".");
       stream.skip(4);
-      return new _Address(address, port, version);
+      return new Address2(address, port, version);
     }
   }
   /**
-   * Writes the Address data type to a binary stream.
-   * @param stream The binary stream to write to.
-   * @param value The value to write.
-   */
+  * Writes the Address data type to a binary stream.
+  * @param stream The binary stream to write to.
+  * @param value The value to write.
+  */
   static write(stream, value) {
     const { address, port, version } = value;
     stream.writeUint8(version);
@@ -325,7 +308,8 @@ var Address = class _Address extends DataType {
 var import_binarystream3 = require("@serenityjs/binarystream");
 
 // src/enums/packet.ts
-var Packet = /* @__PURE__ */ ((Packet2) => {
+var Packet;
+(function(Packet2) {
   Packet2[Packet2["ConnectedPing"] = 0] = "ConnectedPing";
   Packet2[Packet2["UnconnectedPing"] = 1] = "UnconnectedPing";
   Packet2[Packet2["ConnectedPong"] = 3] = "ConnectedPong";
@@ -342,36 +326,36 @@ var Packet = /* @__PURE__ */ ((Packet2) => {
   Packet2[Packet2["FrameSet"] = 128] = "FrameSet";
   Packet2[Packet2["Nack"] = 160] = "Nack";
   Packet2[Packet2["Ack"] = 192] = "Ack";
-  return Packet2;
-})(Packet || {});
+})(Packet || (Packet = {}));
 
 // src/enums/bit-flags.ts
-var Bitflags = /* @__PURE__ */ ((Bitflags2) => {
+var Bitflags;
+(function(Bitflags2) {
   Bitflags2[Bitflags2["Valid"] = 128] = "Valid";
   Bitflags2[Bitflags2["Ack"] = 64] = "Ack";
   Bitflags2[Bitflags2["Nak"] = 32] = "Nak";
   Bitflags2[Bitflags2["Split"] = 16] = "Split";
-  return Bitflags2;
-})(Bitflags || {});
+})(Bitflags || (Bitflags = {}));
 
 // src/enums/priority.ts
-var Priority = /* @__PURE__ */ ((Priority2) => {
+var Priority;
+(function(Priority2) {
   Priority2[Priority2["Normal"] = 0] = "Normal";
   Priority2[Priority2["Immediate"] = 1] = "Immediate";
-  return Priority2;
-})(Priority || {});
+})(Priority || (Priority = {}));
 
 // src/enums/status.ts
-var Status = /* @__PURE__ */ ((Status2) => {
+var Status;
+(function(Status2) {
   Status2[Status2["Connecting"] = 0] = "Connecting";
   Status2[Status2["Connected"] = 1] = "Connected";
   Status2[Status2["Disconnecting"] = 2] = "Disconnecting";
   Status2[Status2["Disconnected"] = 3] = "Disconnected";
-  return Status2;
-})(Status || {});
+})(Status || (Status = {}));
 
 // src/enums/reliability.ts
-var Reliability = /* @__PURE__ */ ((Reliability2) => {
+var Reliability;
+(function(Reliability2) {
   Reliability2[Reliability2["Unreliable"] = 0] = "Unreliable";
   Reliability2[Reliability2["UnreliableSequenced"] = 1] = "UnreliableSequenced";
   Reliability2[Reliability2["Reliable"] = 2] = "Reliable";
@@ -380,122 +364,124 @@ var Reliability = /* @__PURE__ */ ((Reliability2) => {
   Reliability2[Reliability2["UnreliableWithAckReceipt"] = 5] = "UnreliableWithAckReceipt";
   Reliability2[Reliability2["ReliableWithAckReceipt"] = 6] = "ReliableWithAckReceipt";
   Reliability2[Reliability2["ReliableOrderedWithAckReceipt"] = 7] = "ReliableOrderedWithAckReceipt";
-  return Reliability2;
-})(Reliability || {});
+})(Reliability || (Reliability = {}));
 
 // src/proto/types/frame.ts
-var Frame = class _Frame extends DataType {
+var Frame = class Frame2 extends DataType {
+  static {
+    __name(this, "Frame");
+  }
   /**
-   * The reliability of the frame.
-   */
+  * The reliability of the frame.
+  */
   reliability;
   /**
-   * The reliable index of the frame.
-   */
+  * The reliable index of the frame.
+  */
   reliableIndex;
   /**
-   * The sequence index of the frame.
-   */
+  * The sequence index of the frame.
+  */
   sequenceIndex;
   /**
-   * The order index of the frame.
-   */
+  * The order index of the frame.
+  */
   orderIndex;
   /**
-   * The order channel of the frame.
-   */
+  * The order channel of the frame.
+  */
   orderChannel;
   /**
-   * The split size of the frame.
-   */
+  * The split size of the frame.
+  */
   splitSize;
   /**
-   * The split id of the frame.
-   */
+  * The split id of the frame.
+  */
   splitId;
   /**
-   * The split index of the frame.
-   */
+  * The split index of the frame.
+  */
   splitIndex;
   /**
-   * The payload of the frame.
-   */
+  * The payload of the frame.
+  */
   payload;
   /**
-   * Checks if the frame is split.
-   * @returns True if the frame is split; otherwise, false.
-   */
+  * Checks if the frame is split.
+  * @returns True if the frame is split; otherwise, false.
+  */
   isSplit() {
     return this.splitSize > 0;
   }
   /**
-   * Checks if the frame is reliable.
-   * @returns True if the frame is reliable; otherwise, false.
-   */
+  * Checks if the frame is reliable.
+  * @returns True if the frame is reliable; otherwise, false.
+  */
   isReliable() {
     const values = [
-      2 /* Reliable */,
-      3 /* ReliableOrdered */,
-      4 /* ReliableSequenced */,
-      6 /* ReliableWithAckReceipt */,
-      7 /* ReliableOrderedWithAckReceipt */
+      Reliability.Reliable,
+      Reliability.ReliableOrdered,
+      Reliability.ReliableSequenced,
+      Reliability.ReliableWithAckReceipt,
+      Reliability.ReliableOrderedWithAckReceipt
     ];
     return values.includes(this.reliability);
   }
   /**
-   * Checks if the frame is sequenced.
-   * @returns True if the frame is sequenced; otherwise, false.
-   */
+  * Checks if the frame is sequenced.
+  * @returns True if the frame is sequenced; otherwise, false.
+  */
   isSequenced() {
     const values = [
-      4 /* ReliableSequenced */,
-      1 /* UnreliableSequenced */
+      Reliability.ReliableSequenced,
+      Reliability.UnreliableSequenced
     ];
     return values.includes(this.reliability);
   }
   /**
-   * Checks if the frame is ordered.
-   * @returns True if the frame is ordered; otherwise, false.
-   */
+  * Checks if the frame is ordered.
+  * @returns True if the frame is ordered; otherwise, false.
+  */
   isOrdered() {
     const values = [
-      1 /* UnreliableSequenced */,
-      3 /* ReliableOrdered */,
-      4 /* ReliableSequenced */,
-      7 /* ReliableOrderedWithAckReceipt */
+      Reliability.UnreliableSequenced,
+      Reliability.ReliableOrdered,
+      Reliability.ReliableSequenced,
+      Reliability.ReliableOrderedWithAckReceipt
     ];
     return values.includes(this.reliability);
   }
   /**
-   * Checks if the frame is order exclusive.
-   * @returns True if the frame is order exclusive; otherwise, false.
-   */
+  * Checks if the frame is order exclusive.
+  * @returns True if the frame is order exclusive; otherwise, false.
+  */
   isOrderExclusive() {
     const values = [
-      3 /* ReliableOrdered */,
-      7 /* ReliableOrderedWithAckReceipt */
+      Reliability.ReliableOrdered,
+      Reliability.ReliableOrderedWithAckReceipt
     ];
     return values.includes(this.reliability);
   }
   /**
-   * Gets the byte length of the frame.
-   * @returns The byte length of the frame.
-   */
+  * Gets the byte length of the frame.
+  * @returns The byte length of the frame.
+  */
   getByteLength() {
     return 3 + this.payload.byteLength + (this.isReliable() ? 3 : 0) + (this.isSequenced() ? 3 : 0) + (this.isOrdered() ? 4 : 0) + (this.isSplit() ? 10 : 0);
   }
   /**
-   * Reads the Frame data type from a binary stream.
-   * @param stream The binary stream to read from.
-   * @returns The Frame data type.
-   */
+  * Reads the Frame data type from a binary stream.
+  * @param stream The binary stream to read from.
+  * @returns The Frame data type.
+  */
   static read(stream) {
     const frames = [];
     do {
-      const frame = new _Frame();
+      const frame = new Frame2();
       const header = stream.readUint8();
       frame.reliability = (header & 224) >> 5;
-      const split = (header & 16 /* Split */) !== 0;
+      const split = (header & Bitflags.Split) !== 0;
       const length = Math.ceil(stream.readUint16() / 8);
       if (frame.isReliable()) {
         frame.reliableIndex = stream.readUint24(import_binarystream3.Endianness.Little);
@@ -518,14 +504,12 @@ var Frame = class _Frame extends DataType {
     return frames;
   }
   /**
-   * Writes the Frame data type to a binary stream.
-   * @param stream The binary stream to write to.
-   */
+  * Writes the Frame data type to a binary stream.
+  * @param stream The binary stream to write to.
+  */
   static write(stream, value) {
     for (const frame of value) {
-      stream.writeUint8(
-        frame.reliability << 5 | (frame.isSplit() ? 16 /* Split */ : 0)
-      );
+      stream.writeUint8(frame.reliability << 5 | (frame.isSplit() ? Bitflags.Split : 0));
       stream.writeUint16(frame.payload.byteLength << 3);
       if (frame.isReliable()) {
         stream.writeUint24(frame.reliableIndex, import_binarystream3.Endianness.Little);
@@ -548,21 +532,24 @@ var Frame = class _Frame extends DataType {
 };
 
 // src/proto/types/system-address.ts
-var SystemAddress = class extends DataType {
+var SystemAddress = class SystemAddress2 extends DataType {
+  static {
+    __name(this, "SystemAddress");
+  }
   /**
-   * Converts the Address data type to a NetworkIdentifier.
-   *
-   * @param identifier The NetworkIdentifier.
-   * @returns The NetworkIdentifier.
-   */
+  * Converts the Address data type to a NetworkIdentifier.
+  *
+  * @param identifier The NetworkIdentifier.
+  * @returns The NetworkIdentifier.
+  */
   static fromIdentifier(identifier) {
     return new Address(identifier.address, identifier.port, identifier.version);
   }
   /**
-   * Reads the Address data type from a binary stream.
-   * @param stream The binary stream to read from.
-   * @returns The Address data type.
-   */
+  * Reads the Address data type from a binary stream.
+  * @param stream The binary stream to read from.
+  * @returns The Address data type.
+  */
   static read(stream) {
     const addresses = [];
     for (let index = 0; index < 20; index++) {
@@ -572,64 +559,72 @@ var SystemAddress = class extends DataType {
     return addresses;
   }
   /**
-   * Writes the Address data type to a binary stream.
-   * @param stream The binary stream to write to.
-   * @param value The value to write.
-   */
+  * Writes the Address data type to a binary stream.
+  * @param stream The binary stream to write to.
+  * @param value The value to write.
+  */
   static write(stream) {
     const addresses = [
-      { address: "127.0.0.1", port: 0, version: 4 }
+      {
+        address: "127.0.0.1",
+        port: 0,
+        version: 4
+      }
     ];
     for (let index = 0; index < 20; index++) {
-      Address.write(
-        stream,
-        addresses[index] || { address: "0.0.0.0", port: 0, version: 4 }
-      );
+      Address.write(stream, addresses[index] || {
+        address: "0.0.0.0",
+        port: 0,
+        version: 4
+      });
     }
   }
 };
 
 // src/proto/data/base.ts
 var import_binarystream4 = require("@serenityjs/binarystream");
-var BasePacket = class extends import_binarystream4.BinaryStream {
+var BasePacket = class BasePacket2 extends import_binarystream4.BinaryStream {
+  static {
+    __name(this, "BasePacket");
+  }
   /**
-   * The packet id.
-   */
+  * The packet id.
+  */
   static id;
   /**
-   * The packet id data type.
-   */
+  * The packet id data type.
+  */
   static id_type = import_binarystream4.Uint8;
   /**
-   * Flushes the binary stream.
-   */
+  * Flushes the binary stream.
+  */
   flush() {
     this.binary = [];
   }
   /**
-   * Gets the packet id.
-   * @returns The packet id.
-   */
+  * Gets the packet id.
+  * @returns The packet id.
+  */
   getId() {
     throw new Error("BasePacket.getId() is not implemented.");
   }
   /**
-   * Gets the packet id data type.
-   * @returns The packet id data type.
-   */
+  * Gets the packet id data type.
+  * @returns The packet id data type.
+  */
   getIdType() {
     throw new Error("BasePacket.getIdType() is not implemented.");
   }
   /**
-   * Serializes the packet.
-   * @returns The serialized packet.
-   */
+  * Serializes the packet.
+  * @returns The serialized packet.
+  */
   serialize() {
     throw new Error("BasePacket.serialize() is not implemented.");
   }
   /**
-   * Deserializes the packet.
-   */
+  * Deserializes the packet.
+  */
   deserialize() {
     throw new Error("BasePacket.deserialize() is not implemented.");
   }
@@ -637,211 +632,481 @@ var BasePacket = class extends import_binarystream4.BinaryStream {
 
 // src/proto/data/unconnected-ping.ts
 var import_binarystream5 = require("@serenityjs/binarystream");
-var UnconnectedPing = class extends BasePacket {
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var UnconnectedPing = class UnconnectedPing2 extends BasePacket {
+  static {
+    __name(this, "UnconnectedPing");
+  }
+  /**
+  * The timestamp of the ping.
+  */
   timestamp;
+  /**
+  * The magic bytes of the ping.
+  */
   magic;
+  /**
+  * The client guid of the ping.
+  */
   client;
 };
-__decorateClass([
-  Serialize(import_binarystream5.Long)
-], UnconnectedPing.prototype, "timestamp", 2);
-__decorateClass([
-  Serialize(Magic)
-], UnconnectedPing.prototype, "magic", 2);
-__decorateClass([
-  Serialize(import_binarystream5.Long)
-], UnconnectedPing.prototype, "client", 2);
-UnconnectedPing = __decorateClass([
-  Proto(1 /* UnconnectedPing */)
+_ts_decorate([
+  Serialize(import_binarystream5.Long),
+  _ts_metadata("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], UnconnectedPing.prototype, "timestamp", void 0);
+_ts_decorate([
+  Serialize(Magic),
+  _ts_metadata("design:type", typeof Buffer === "undefined" ? Object : Buffer)
+], UnconnectedPing.prototype, "magic", void 0);
+_ts_decorate([
+  Serialize(import_binarystream5.Long),
+  _ts_metadata("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], UnconnectedPing.prototype, "client", void 0);
+UnconnectedPing = _ts_decorate([
+  Proto(Packet.UnconnectedPing)
 ], UnconnectedPing);
 
 // src/proto/data/unconnected-pong.ts
 var import_binarystream6 = require("@serenityjs/binarystream");
-var UnconnectedPong = class extends BasePacket {
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var UnconnectedPong = class UnconnectedPong2 extends BasePacket {
+  static {
+    __name(this, "UnconnectedPong");
+  }
+  /**
+  * The timestamp of the pong.
+  */
   timestamp;
+  /**
+  * The server guid of the pong.
+  */
   guid;
+  /**
+  * The magic bytes of the pong.
+  */
   magic;
+  /**
+  * The server message of the pong.
+  */
   message;
 };
-__decorateClass([
-  Serialize(import_binarystream6.Long)
-], UnconnectedPong.prototype, "timestamp", 2);
-__decorateClass([
-  Serialize(import_binarystream6.Long)
-], UnconnectedPong.prototype, "guid", 2);
-__decorateClass([
-  Serialize(Magic)
-], UnconnectedPong.prototype, "magic", 2);
-__decorateClass([
-  Serialize(import_binarystream6.String16)
-], UnconnectedPong.prototype, "message", 2);
-UnconnectedPong = __decorateClass([
-  Proto(28 /* UnconnectedPong */)
+_ts_decorate2([
+  Serialize(import_binarystream6.Long),
+  _ts_metadata2("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], UnconnectedPong.prototype, "timestamp", void 0);
+_ts_decorate2([
+  Serialize(import_binarystream6.Long),
+  _ts_metadata2("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], UnconnectedPong.prototype, "guid", void 0);
+_ts_decorate2([
+  Serialize(Magic),
+  _ts_metadata2("design:type", typeof Buffer === "undefined" ? Object : Buffer)
+], UnconnectedPong.prototype, "magic", void 0);
+_ts_decorate2([
+  Serialize(import_binarystream6.String16),
+  _ts_metadata2("design:type", String)
+], UnconnectedPong.prototype, "message", void 0);
+UnconnectedPong = _ts_decorate2([
+  Proto(Packet.UnconnectedPong)
 ], UnconnectedPong);
 
 // src/proto/data/open-connection-request-1.ts
 var import_binarystream7 = require("@serenityjs/binarystream");
-var OpenConnectionRequest1 = class extends BasePacket {
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+var OpenConnectionRequest1 = class OpenConnectionRequest12 extends BasePacket {
+  static {
+    __name(this, "OpenConnectionRequest1");
+  }
+  /**
+  * The magic bytes of the request.
+  */
   magic;
+  /**
+  * The protocol version of the request.
+  */
   protocol;
+  /**
+  * The maximum transfer unit of the request.
+  */
   mtu;
 };
-__decorateClass([
-  Serialize(Magic)
-], OpenConnectionRequest1.prototype, "magic", 2);
-__decorateClass([
-  Serialize(import_binarystream7.Uint8)
-], OpenConnectionRequest1.prototype, "protocol", 2);
-__decorateClass([
-  Serialize(MTU)
-], OpenConnectionRequest1.prototype, "mtu", 2);
-OpenConnectionRequest1 = __decorateClass([
-  Proto(5 /* OpenConnectionRequest1 */)
+_ts_decorate3([
+  Serialize(Magic),
+  _ts_metadata3("design:type", typeof Buffer === "undefined" ? Object : Buffer)
+], OpenConnectionRequest1.prototype, "magic", void 0);
+_ts_decorate3([
+  Serialize(import_binarystream7.Uint8),
+  _ts_metadata3("design:type", Number)
+], OpenConnectionRequest1.prototype, "protocol", void 0);
+_ts_decorate3([
+  Serialize(MTU),
+  _ts_metadata3("design:type", Number)
+], OpenConnectionRequest1.prototype, "mtu", void 0);
+OpenConnectionRequest1 = _ts_decorate3([
+  Proto(Packet.OpenConnectionRequest1)
 ], OpenConnectionRequest1);
 
 // src/proto/data/open-connection-reply-1.ts
 var import_binarystream8 = require("@serenityjs/binarystream");
-var OpenConnectionReply1 = class extends BasePacket {
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+var OpenConnectionReply1 = class OpenConnectionReply12 extends BasePacket {
+  static {
+    __name(this, "OpenConnectionReply1");
+  }
+  /**
+  * The magic bytes of the reply.
+  */
   magic;
+  /**
+  * The server guid of the reply.
+  */
   guid;
+  /**
+  * If raknet is using security.
+  */
   security;
+  /**
+  * The maximum transfer unit of the reply.
+  */
   mtu;
 };
-__decorateClass([
-  Serialize(Magic)
-], OpenConnectionReply1.prototype, "magic", 2);
-__decorateClass([
-  Serialize(import_binarystream8.Long)
-], OpenConnectionReply1.prototype, "guid", 2);
-__decorateClass([
-  Serialize(import_binarystream8.Bool)
-], OpenConnectionReply1.prototype, "security", 2);
-__decorateClass([
-  Serialize(import_binarystream8.Short)
-], OpenConnectionReply1.prototype, "mtu", 2);
-OpenConnectionReply1 = __decorateClass([
-  Proto(6 /* OpenConnectionReply1 */)
+_ts_decorate4([
+  Serialize(Magic),
+  _ts_metadata4("design:type", typeof Buffer === "undefined" ? Object : Buffer)
+], OpenConnectionReply1.prototype, "magic", void 0);
+_ts_decorate4([
+  Serialize(import_binarystream8.Long),
+  _ts_metadata4("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], OpenConnectionReply1.prototype, "guid", void 0);
+_ts_decorate4([
+  Serialize(import_binarystream8.Bool),
+  _ts_metadata4("design:type", Boolean)
+], OpenConnectionReply1.prototype, "security", void 0);
+_ts_decorate4([
+  Serialize(import_binarystream8.Short),
+  _ts_metadata4("design:type", Number)
+], OpenConnectionReply1.prototype, "mtu", void 0);
+OpenConnectionReply1 = _ts_decorate4([
+  Proto(Packet.OpenConnectionReply1)
 ], OpenConnectionReply1);
 
 // src/proto/data/open-connection-request-2.ts
 var import_binarystream9 = require("@serenityjs/binarystream");
-var OpenConnectionRequest2 = class extends BasePacket {
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+var OpenConnectionRequest2 = class OpenConnectionRequest22 extends BasePacket {
+  static {
+    __name(this, "OpenConnectionRequest2");
+  }
+  /**
+  * The magic bytes of the request.
+  */
   magic;
+  /**
+  * The protocol version of the request.
+  */
   address;
+  /**
+  * The mtu of the request.
+  */
   mtu;
+  /**
+  * The client guid of the request.
+  */
   client;
 };
-__decorateClass([
-  Serialize(Magic)
-], OpenConnectionRequest2.prototype, "magic", 2);
-__decorateClass([
-  Serialize(Address)
-], OpenConnectionRequest2.prototype, "address", 2);
-__decorateClass([
-  Serialize(import_binarystream9.Short)
-], OpenConnectionRequest2.prototype, "mtu", 2);
-__decorateClass([
-  Serialize(import_binarystream9.Long)
-], OpenConnectionRequest2.prototype, "client", 2);
-OpenConnectionRequest2 = __decorateClass([
-  Proto(7 /* OpenConnectionRequest2 */)
+_ts_decorate5([
+  Serialize(Magic),
+  _ts_metadata5("design:type", typeof Buffer === "undefined" ? Object : Buffer)
+], OpenConnectionRequest2.prototype, "magic", void 0);
+_ts_decorate5([
+  Serialize(Address),
+  _ts_metadata5("design:type", typeof Address === "undefined" ? Object : Address)
+], OpenConnectionRequest2.prototype, "address", void 0);
+_ts_decorate5([
+  Serialize(import_binarystream9.Short),
+  _ts_metadata5("design:type", Number)
+], OpenConnectionRequest2.prototype, "mtu", void 0);
+_ts_decorate5([
+  Serialize(import_binarystream9.Long),
+  _ts_metadata5("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], OpenConnectionRequest2.prototype, "client", void 0);
+OpenConnectionRequest2 = _ts_decorate5([
+  Proto(Packet.OpenConnectionRequest2)
 ], OpenConnectionRequest2);
 
 // src/proto/data/open-connection-reply-2.ts
 var import_binarystream10 = require("@serenityjs/binarystream");
-var OpenConnectionReply2 = class extends BasePacket {
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+var OpenConnectionReply2 = class OpenConnectionReply22 extends BasePacket {
+  static {
+    __name(this, "OpenConnectionReply2");
+  }
+  /**
+  * The magic bytes of the reply.
+  */
   magic;
+  /**
+  * The server guid of the reply.
+  */
   guid;
+  /**
+  * Client adrress.
+  */
   address;
+  /**
+  * The maximum transfer unit of the reply.
+  */
   mtu;
+  /**
+  * If raknet is using encryption.
+  */
   encryption;
 };
-__decorateClass([
-  Serialize(Magic)
-], OpenConnectionReply2.prototype, "magic", 2);
-__decorateClass([
-  Serialize(import_binarystream10.Long)
-], OpenConnectionReply2.prototype, "guid", 2);
-__decorateClass([
-  Serialize(Address)
-], OpenConnectionReply2.prototype, "address", 2);
-__decorateClass([
-  Serialize(import_binarystream10.Short)
-], OpenConnectionReply2.prototype, "mtu", 2);
-__decorateClass([
-  Serialize(import_binarystream10.Bool)
-], OpenConnectionReply2.prototype, "encryption", 2);
-OpenConnectionReply2 = __decorateClass([
-  Proto(8 /* OpenConnectionReply2 */)
+_ts_decorate6([
+  Serialize(Magic),
+  _ts_metadata6("design:type", typeof Buffer === "undefined" ? Object : Buffer)
+], OpenConnectionReply2.prototype, "magic", void 0);
+_ts_decorate6([
+  Serialize(import_binarystream10.Long),
+  _ts_metadata6("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], OpenConnectionReply2.prototype, "guid", void 0);
+_ts_decorate6([
+  Serialize(Address),
+  _ts_metadata6("design:type", typeof Address === "undefined" ? Object : Address)
+], OpenConnectionReply2.prototype, "address", void 0);
+_ts_decorate6([
+  Serialize(import_binarystream10.Short),
+  _ts_metadata6("design:type", Number)
+], OpenConnectionReply2.prototype, "mtu", void 0);
+_ts_decorate6([
+  Serialize(import_binarystream10.Bool),
+  _ts_metadata6("design:type", Boolean)
+], OpenConnectionReply2.prototype, "encryption", void 0);
+OpenConnectionReply2 = _ts_decorate6([
+  Proto(Packet.OpenConnectionReply2)
 ], OpenConnectionReply2);
 
 // src/proto/data/connected-pong.ts
 var import_binarystream11 = require("@serenityjs/binarystream");
-var ConnectedPong = class extends BasePacket {
+function _ts_decorate7(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+var ConnectedPong = class ConnectedPong2 extends BasePacket {
+  static {
+    __name(this, "ConnectedPong");
+  }
+  /**
+  * The timestamp of the ping.
+  */
   pingTimestamp;
+  /**
+  * The timestamp of the pong.
+  */
   timestamp;
 };
-__decorateClass([
-  Serialize(import_binarystream11.Long)
-], ConnectedPong.prototype, "pingTimestamp", 2);
-__decorateClass([
-  Serialize(import_binarystream11.Long)
-], ConnectedPong.prototype, "timestamp", 2);
-ConnectedPong = __decorateClass([
-  Proto(3 /* ConnectedPong */)
+_ts_decorate7([
+  Serialize(import_binarystream11.Long),
+  _ts_metadata7("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], ConnectedPong.prototype, "pingTimestamp", void 0);
+_ts_decorate7([
+  Serialize(import_binarystream11.Long),
+  _ts_metadata7("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], ConnectedPong.prototype, "timestamp", void 0);
+ConnectedPong = _ts_decorate7([
+  Proto(Packet.ConnectedPong)
 ], ConnectedPong);
 
 // src/proto/data/connected-ping.ts
 var import_binarystream12 = require("@serenityjs/binarystream");
-var ConnectedPing = class extends BasePacket {
+function _ts_decorate8(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate8, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+var ConnectedPing = class ConnectedPing2 extends BasePacket {
+  static {
+    __name(this, "ConnectedPing");
+  }
+  /**
+  * The timestamp of the ping.
+  */
   timestamp;
 };
-__decorateClass([
-  Serialize(import_binarystream12.Long)
-], ConnectedPing.prototype, "timestamp", 2);
-ConnectedPing = __decorateClass([
-  Proto(0 /* ConnectedPing */)
+_ts_decorate8([
+  Serialize(import_binarystream12.Long),
+  _ts_metadata8("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], ConnectedPing.prototype, "timestamp", void 0);
+ConnectedPing = _ts_decorate8([
+  Proto(Packet.ConnectedPing)
 ], ConnectedPing);
 
 // src/proto/data/connection-request.ts
 var import_binarystream13 = require("@serenityjs/binarystream");
-var ConnectionRequest = class extends BasePacket {
+function _ts_decorate9(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate9, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+var ConnectionRequest = class ConnectionRequest2 extends BasePacket {
+  static {
+    __name(this, "ConnectionRequest");
+  }
+  /**
+  * The client guid of the request.
+  */
   client;
+  /**
+  * The timestamp of the request.
+  */
   timestamp;
 };
-__decorateClass([
-  Serialize(import_binarystream13.Long)
-], ConnectionRequest.prototype, "client", 2);
-__decorateClass([
-  Serialize(import_binarystream13.Long)
-], ConnectionRequest.prototype, "timestamp", 2);
-ConnectionRequest = __decorateClass([
-  Proto(9 /* ConnectionRequest */)
+_ts_decorate9([
+  Serialize(import_binarystream13.Long),
+  _ts_metadata9("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], ConnectionRequest.prototype, "client", void 0);
+_ts_decorate9([
+  Serialize(import_binarystream13.Long),
+  _ts_metadata9("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], ConnectionRequest.prototype, "timestamp", void 0);
+ConnectionRequest = _ts_decorate9([
+  Proto(Packet.ConnectionRequest)
 ], ConnectionRequest);
 
 // src/proto/data/frame-set.ts
 var import_binarystream14 = require("@serenityjs/binarystream");
-var FrameSet = class extends BasePacket {
+function _ts_decorate10(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate10, "_ts_decorate");
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata10, "_ts_metadata");
+var FrameSet = class FrameSet2 extends BasePacket {
+  static {
+    __name(this, "FrameSet");
+  }
+  /**
+  * The sequence of the frame set.
+  */
   sequence;
+  /**
+  * The frames of the frame set.
+  */
   frames;
 };
-__decorateClass([
-  Serialize(import_binarystream14.Uint24, import_binarystream14.Endianness.Little)
-], FrameSet.prototype, "sequence", 2);
-__decorateClass([
-  Serialize(Frame)
-], FrameSet.prototype, "frames", 2);
-FrameSet = __decorateClass([
-  Proto(128 /* FrameSet */)
+_ts_decorate10([
+  Serialize(import_binarystream14.Uint24, import_binarystream14.Endianness.Little),
+  _ts_metadata10("design:type", Number)
+], FrameSet.prototype, "sequence", void 0);
+_ts_decorate10([
+  Serialize(Frame),
+  _ts_metadata10("design:type", typeof Array === "undefined" ? Object : Array)
+], FrameSet.prototype, "frames", void 0);
+FrameSet = _ts_decorate10([
+  Proto(Packet.FrameSet)
 ], FrameSet);
 
 // src/proto/data/ack.ts
 var import_binarystream15 = require("@serenityjs/binarystream");
-var Ack = class extends BasePacket {
+function _ts_decorate11(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate11, "_ts_decorate");
+var Ack = class Ack2 extends BasePacket {
+  static {
+    __name(this, "Ack");
+  }
   sequences = [];
   // Override encode due to custom logic, maybe move into own type?
   serialize() {
-    this.writeUint8(Ack.id);
+    this.writeUint8(Ack2.id);
     const stream = new import_binarystream15.BinaryStream();
     const count = this.sequences.length;
     let records = 0;
@@ -902,17 +1167,27 @@ var Ack = class extends BasePacket {
     return this;
   }
 };
-Ack = __decorateClass([
-  Proto(192 /* Ack */)
+Ack = _ts_decorate11([
+  Proto(Packet.Ack)
 ], Ack);
 
 // src/proto/data/nack.ts
 var import_binarystream16 = require("@serenityjs/binarystream");
-var Nack = class extends BasePacket {
+function _ts_decorate12(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate12, "_ts_decorate");
+var Nack = class Nack2 extends BasePacket {
+  static {
+    __name(this, "Nack");
+  }
   sequences = [];
   // Override encode due to custom logic, maybe move into own type?
   serialize() {
-    this.writeUint8(Nack.id);
+    this.writeUint8(Nack2.id);
     const stream = new import_binarystream16.BinaryStream();
     const count = this.sequences.length;
     let records = 0;
@@ -973,87 +1248,178 @@ var Nack = class extends BasePacket {
     return this;
   }
 };
-Nack = __decorateClass([
-  Proto(160 /* Nack */)
+Nack = _ts_decorate12([
+  Proto(Packet.Nack)
 ], Nack);
 
 // src/proto/data/disconnect.ts
-var Disconnect = class extends BasePacket {
+function _ts_decorate13(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate13, "_ts_decorate");
+var Disconnect = class Disconnect2 extends BasePacket {
+  static {
+    __name(this, "Disconnect");
+  }
 };
-Disconnect = __decorateClass([
-  Proto(21 /* Disconnect */)
+Disconnect = _ts_decorate13([
+  Proto(Packet.Disconnect)
 ], Disconnect);
 
 // src/proto/data/incompatible-protocol.ts
 var import_binarystream17 = require("@serenityjs/binarystream");
-var IncompatibleProtocolVersion = class extends BasePacket {
+function _ts_decorate14(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata11(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata11, "_ts_metadata");
+var IncompatibleProtocolVersion = class IncompatibleProtocolVersion2 extends BasePacket {
+  static {
+    __name(this, "IncompatibleProtocolVersion");
+  }
   protocol;
   magic;
   guid;
 };
-__decorateClass([
-  Serialize(import_binarystream17.Uint8)
-], IncompatibleProtocolVersion.prototype, "protocol", 2);
-__decorateClass([
-  Serialize(Magic)
-], IncompatibleProtocolVersion.prototype, "magic", 2);
-__decorateClass([
-  Serialize(import_binarystream17.Uint64)
-], IncompatibleProtocolVersion.prototype, "guid", 2);
-IncompatibleProtocolVersion = __decorateClass([
-  Proto(25 /* IncompatibleProtocolVersion */)
+_ts_decorate14([
+  Serialize(import_binarystream17.Uint8),
+  _ts_metadata11("design:type", Number)
+], IncompatibleProtocolVersion.prototype, "protocol", void 0);
+_ts_decorate14([
+  Serialize(Magic),
+  _ts_metadata11("design:type", typeof Buffer === "undefined" ? Object : Buffer)
+], IncompatibleProtocolVersion.prototype, "magic", void 0);
+_ts_decorate14([
+  Serialize(import_binarystream17.Uint64),
+  _ts_metadata11("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], IncompatibleProtocolVersion.prototype, "guid", void 0);
+IncompatibleProtocolVersion = _ts_decorate14([
+  Proto(Packet.IncompatibleProtocolVersion)
 ], IncompatibleProtocolVersion);
 
 // src/proto/data/connection-request-accepted.ts
 var import_binarystream18 = require("@serenityjs/binarystream");
-var ConnectionRequestAccepted = class extends BasePacket {
+function _ts_decorate15(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_metadata12(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata12, "_ts_metadata");
+var ConnectionRequestAccepted = class ConnectionRequestAccepted2 extends BasePacket {
+  static {
+    __name(this, "ConnectionRequestAccepted");
+  }
+  /**
+  * The client address of the request.
+  */
   address;
+  /**
+  * The system index of the request.
+  */
   systemIndex;
+  /**
+  * The system address of the request.
+  */
   systemAddress;
+  /**
+  * The request timestamp of the request.
+  */
   requestTimestamp;
+  /**
+  * The timestamp of the request.
+  */
   timestamp;
 };
-__decorateClass([
-  Serialize(Address)
-], ConnectionRequestAccepted.prototype, "address", 2);
-__decorateClass([
-  Serialize(import_binarystream18.Short)
-], ConnectionRequestAccepted.prototype, "systemIndex", 2);
-__decorateClass([
-  Serialize(SystemAddress)
-], ConnectionRequestAccepted.prototype, "systemAddress", 2);
-__decorateClass([
-  Serialize(import_binarystream18.Long)
-], ConnectionRequestAccepted.prototype, "requestTimestamp", 2);
-__decorateClass([
-  Serialize(import_binarystream18.Long)
-], ConnectionRequestAccepted.prototype, "timestamp", 2);
-ConnectionRequestAccepted = __decorateClass([
-  Proto(16 /* ConnectionRequestAccepted */)
+_ts_decorate15([
+  Serialize(Address),
+  _ts_metadata12("design:type", typeof Address === "undefined" ? Object : Address)
+], ConnectionRequestAccepted.prototype, "address", void 0);
+_ts_decorate15([
+  Serialize(import_binarystream18.Short),
+  _ts_metadata12("design:type", Number)
+], ConnectionRequestAccepted.prototype, "systemIndex", void 0);
+_ts_decorate15([
+  Serialize(SystemAddress),
+  _ts_metadata12("design:type", typeof Array === "undefined" ? Object : Array)
+], ConnectionRequestAccepted.prototype, "systemAddress", void 0);
+_ts_decorate15([
+  Serialize(import_binarystream18.Long),
+  _ts_metadata12("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], ConnectionRequestAccepted.prototype, "requestTimestamp", void 0);
+_ts_decorate15([
+  Serialize(import_binarystream18.Long),
+  _ts_metadata12("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], ConnectionRequestAccepted.prototype, "timestamp", void 0);
+ConnectionRequestAccepted = _ts_decorate15([
+  Proto(Packet.ConnectionRequestAccepted)
 ], ConnectionRequestAccepted);
 
 // src/proto/data/new-incoming-connection.ts
 var import_binarystream19 = require("@serenityjs/binarystream");
-var NewIncomingConnection = class extends BasePacket {
+function _ts_decorate16(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata13(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata13, "_ts_metadata");
+var NewIncomingConnection = class NewIncomingConnection2 extends BasePacket {
+  static {
+    __name(this, "NewIncomingConnection");
+  }
+  /**
+  * the server adress of the reply.
+  */
   serverAddress;
+  /**
+  * unknown what this is used for.
+  */
   internalAddress;
+  /**
+  * The incoming timestamp of the reply.
+  */
   incomingTimestamp;
+  /**
+  * The server timestamp of the reply.
+  */
   serverTimestamp;
 };
-__decorateClass([
-  Serialize(Address)
-], NewIncomingConnection.prototype, "serverAddress", 2);
-__decorateClass([
-  Serialize(Address)
-], NewIncomingConnection.prototype, "internalAddress", 2);
-__decorateClass([
-  Serialize(import_binarystream19.Long)
-], NewIncomingConnection.prototype, "incomingTimestamp", 2);
-__decorateClass([
-  Serialize(import_binarystream19.Long)
-], NewIncomingConnection.prototype, "serverTimestamp", 2);
-NewIncomingConnection = __decorateClass([
-  Proto(19 /* NewIncomingConnection */)
+_ts_decorate16([
+  Serialize(Address),
+  _ts_metadata13("design:type", String)
+], NewIncomingConnection.prototype, "serverAddress", void 0);
+_ts_decorate16([
+  Serialize(Address),
+  _ts_metadata13("design:type", String)
+], NewIncomingConnection.prototype, "internalAddress", void 0);
+_ts_decorate16([
+  Serialize(import_binarystream19.Long),
+  _ts_metadata13("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], NewIncomingConnection.prototype, "incomingTimestamp", void 0);
+_ts_decorate16([
+  Serialize(import_binarystream19.Long),
+  _ts_metadata13("design:type", typeof BigInt === "undefined" ? Object : BigInt)
+], NewIncomingConnection.prototype, "serverTimestamp", void 0);
+NewIncomingConnection = _ts_decorate16([
+  Proto(Packet.NewIncomingConnection)
 ], NewIncomingConnection);
 
 // src/server/raknet.ts
@@ -1073,30 +1439,33 @@ var DGRAM_MTU_OVERHEAD = 36;
 
 // src/server/connection.ts
 var import_binarystream20 = require("@serenityjs/binarystream");
-var Connection = class {
+var Connection = class Connection2 {
+  static {
+    __name(this, "Connection");
+  }
   /**
-   * The server instance
-   */
+  * The server instance
+  */
   server;
   /**
-   * The status of the connection
-   */
-  status = 0 /* Connecting */;
+  * The status of the connection
+  */
+  status = Status.Connecting;
   /**
-   * The last update time of the connection
-   */
+  * The last update time of the connection
+  */
   lastUpdate = Date.now();
   /**
-   * The network identifier of the connection
-   */
+  * The network identifier of the connection
+  */
   rinfo;
   /**
-   * The GUID of the connection
-   */
+  * The GUID of the connection
+  */
   guid;
   /**
-   * The maximum transmission unit of the connection
-   */
+  * The maximum transmission unit of the connection
+  */
   mtu;
   // Inputs
   receivedFrameSequences = /* @__PURE__ */ new Set();
@@ -1115,134 +1484,127 @@ var Connection = class {
   outputsplitIndex = 0;
   outputReliableIndex = 0;
   /**
-   * Creates a new connection
-   * @param server The server instance
-   * @param rinfo The remote info
-   * @param guid The GUID
-   * @param mtu The maximum transmission unit
-   */
+  * Creates a new connection
+  * @param server The server instance
+  * @param rinfo The remote info
+  * @param guid The GUID
+  * @param mtu The maximum transmission unit
+  */
   constructor(server, rinfo, guid, mtu) {
     this.server = server;
     this.rinfo = rinfo;
     this.guid = guid;
     this.mtu = mtu;
-    this.inputOrderIndex = Array.from({ length: 32 }).fill(0);
+    this.inputOrderIndex = Array.from({
+      length: 32
+    }).fill(0);
     for (let index = 0; index < 32; index++) {
       this.inputOrderingQueue.set(index, /* @__PURE__ */ new Map());
     }
-    this.inputHighestSequenceIndex = Array.from({ length: 32 }).fill(0);
-    this.outputOrderIndex = Array.from({ length: 32 }).fill(0);
-    this.outputSequenceIndex = Array.from({ length: 32 }).fill(0);
+    this.inputHighestSequenceIndex = Array.from({
+      length: 32
+    }).fill(0);
+    this.outputOrderIndex = Array.from({
+      length: 32
+    }).fill(0);
+    this.outputSequenceIndex = Array.from({
+      length: 32
+    }).fill(0);
   }
   /**
-   * Ticks the connection
-   */
+  * Ticks the connection
+  */
   tick() {
     if (this.lastUpdate + 5e3 < Date.now()) {
-      this.server.logger.warn(
-        `Detected stale connection from \xA7c${this.rinfo.address}\xA7r:\xA7c${this.rinfo.port}\xA7r, disconnecting...`
-      );
+      this.server.logger.warn(`Detected stale connection from \xA7c${this.rinfo.address}\xA7r:\xA7c${this.rinfo.port}\xA7r, disconnecting...`);
       return this.disconnect();
     }
-    if (this.status === 2 /* Disconnecting */ || this.status === 3 /* Disconnected */)
-      return;
+    if (this.status === Status.Disconnecting || this.status === Status.Disconnected) return;
     if (this.receivedFrameSequences.size > 0) {
       const ack = new Ack();
-      ack.sequences = [...this.receivedFrameSequences];
-      for (const sequence of this.receivedFrameSequences)
-        this.receivedFrameSequences.delete(sequence);
+      ack.sequences = [
+        ...this.receivedFrameSequences
+      ];
+      for (const sequence of this.receivedFrameSequences) this.receivedFrameSequences.delete(sequence);
       this.server.send(ack.serialize(), this.rinfo);
     }
     if (this.lostFrameSequences.size > 0) {
       const nack = new Nack();
-      nack.sequences = [...this.lostFrameSequences];
-      for (const sequence of this.lostFrameSequences)
-        this.lostFrameSequences.delete(sequence);
+      nack.sequences = [
+        ...this.lostFrameSequences
+      ];
+      for (const sequence of this.lostFrameSequences) this.lostFrameSequences.delete(sequence);
       this.server.send(nack.serialize(), this.rinfo);
     }
     return this.sendQueue(this.outputFrames.size);
   }
   /**
-   * Disconnects the connection
-   */
+  * Disconnects the connection
+  */
   disconnect() {
-    this.status = 2 /* Disconnecting */;
+    this.status = Status.Disconnecting;
     const disconnect = new Disconnect();
     const frame = new Frame();
-    frame.reliability = 3 /* ReliableOrdered */;
+    frame.reliability = Reliability.ReliableOrdered;
     frame.orderChannel = 0;
     frame.payload = disconnect.serialize();
-    this.sendFrame(frame, 1 /* Immediate */);
+    this.sendFrame(frame, Priority.Immediate);
     void this.server.emit("disconnect", this);
     this.server.connections.delete(this);
-    this.status = 3 /* Disconnected */;
+    this.status = Status.Disconnected;
   }
   /**
-   * Handles incoming packets
-   * @param buffer The packet buffer
-   */
+  * Handles incoming packets
+  * @param buffer The packet buffer
+  */
   incoming(buffer) {
     this.lastUpdate = Date.now();
     const header = buffer[0] & 240;
     switch (header) {
       default: {
         const id = header.toString(16).length === 1 ? "0" + header.toString(16) : header.toString(16);
-        this.server.logger.debug(
-          `Received unknown online packet 0x${id} from ${this.rinfo.address}:${this.rinfo.port}!`
-        );
-        return void this.server.emit(
-          "error",
-          new Error(
-            `Received unknown online packet 0x${id} from ${this.rinfo.address}:${this.rinfo.port}!`
-          )
-        );
+        this.server.logger.debug(`Received unknown online packet 0x${id} from ${this.rinfo.address}:${this.rinfo.port}!`);
+        return void this.server.emit("error", new Error(`Received unknown online packet 0x${id} from ${this.rinfo.address}:${this.rinfo.port}!`));
       }
-      case 192 /* Ack */: {
+      case Packet.Ack: {
         this.ack(buffer);
         break;
       }
-      case 160 /* Nack */: {
+      case Packet.Nack: {
         this.nack(buffer);
         break;
       }
-      case 128 /* Valid */: {
+      case Bitflags.Valid: {
         this.handleIncomingFrameSet(buffer);
         break;
       }
     }
   }
   /**
-   * Handles incoming batch packets
-   * @param buffer The packet buffer
-   */
+  * Handles incoming batch packets
+  * @param buffer The packet buffer
+  */
   incomingBatch(buffer) {
     const header = buffer[0];
-    if (this.status === 0 /* Connecting */) {
+    if (this.status === Status.Connecting) {
       switch (header) {
         default: {
           const id = header.toString(16).length === 1 ? "0" + header.toString(16) : header.toString(16);
-          this.server.logger.debug(
-            `Received unknown online packet 0x${id} from ${this.rinfo.address}:${this.rinfo.port}!`
-          );
-          return void this.server.emit(
-            "error",
-            new Error(
-              `Received unknown online packet 0x${id} from ${this.rinfo.address}:${this.rinfo.port}!`
-            )
-          );
+          this.server.logger.debug(`Received unknown online packet 0x${id} from ${this.rinfo.address}:${this.rinfo.port}!`);
+          return void this.server.emit("error", new Error(`Received unknown online packet 0x${id} from ${this.rinfo.address}:${this.rinfo.port}!`));
         }
-        case 21 /* Disconnect */: {
-          this.status = 2 /* Disconnecting */;
+        case Packet.Disconnect: {
+          this.status = Status.Disconnecting;
           this.server.connections.delete(this);
-          this.status = 3 /* Disconnected */;
+          this.status = Status.Disconnected;
           break;
         }
-        case 9 /* ConnectionRequest */: {
+        case Packet.ConnectionRequest: {
           this.handleIncomingConnectionRequest(buffer);
           break;
         }
-        case 19 /* NewIncomingConnection */: {
-          this.status = 1 /* Connected */;
+        case Packet.NewIncomingConnection: {
+          this.status = Status.Connected;
           void this.server.emit("connect", this);
           break;
         }
@@ -1252,24 +1614,17 @@ var Connection = class {
     switch (header) {
       default: {
         const id = header.toString(16).length === 1 ? "0" + header.toString(16) : header.toString(16);
-        this.server.logger.debug(
-          `Received unknown online packet 0x${id} from ${this.rinfo.address}:${this.rinfo.port}!`
-        );
-        return void this.server.emit(
-          "error",
-          new Error(
-            `Received unknown online packet 0x${id} from ${this.rinfo.address}:${this.rinfo.port}!`
-          )
-        );
+        this.server.logger.debug(`Received unknown online packet 0x${id} from ${this.rinfo.address}:${this.rinfo.port}!`);
+        return void this.server.emit("error", new Error(`Received unknown online packet 0x${id} from ${this.rinfo.address}:${this.rinfo.port}!`));
       }
-      case 21 /* Disconnect */: {
-        this.status = 2 /* Disconnecting */;
+      case Packet.Disconnect: {
+        this.status = Status.Disconnecting;
         void this.server.emit("disconnect", this);
         this.server.connections.delete(this);
-        this.status = 3 /* Disconnected */;
+        this.status = Status.Disconnected;
         break;
       }
-      case 0 /* ConnectedPing */: {
+      case Packet.ConnectedPing: {
         return this.handleIncomingConnectedPing(buffer);
       }
       case 254: {
@@ -1278,65 +1633,47 @@ var Connection = class {
     }
   }
   /**
-   * Handles incoming acks
-   * @param buffer The packet buffer
-   */
+  * Handles incoming acks
+  * @param buffer The packet buffer
+  */
   ack(buffer) {
     const ack = new Ack(buffer).deserialize();
     for (const sequence of ack.sequences) {
-      if (!this.outputBackup.has(sequence))
-        this.server.logger.debug(
-          `Received ack for unknown sequence ${sequence} from ${this.rinfo.address}:${this.rinfo.port}.`
-        );
+      if (!this.outputBackup.has(sequence)) this.server.logger.debug(`Received ack for unknown sequence ${sequence} from ${this.rinfo.address}:${this.rinfo.port}.`);
       this.outputBackup.delete(sequence);
     }
   }
   /**
-   * Handles incoming nacks
-   * @param buffer The packet buffer
-   */
+  * Handles incoming nacks
+  * @param buffer The packet buffer
+  */
   nack(buffer) {
     const nack = new Nack(buffer).deserialize();
     for (const sequence of nack.sequences) {
       const frames = this.outputBackup.get(sequence) ?? [];
       for (const frame of frames) {
-        this.sendFrame(frame, 1 /* Immediate */);
+        this.sendFrame(frame, Priority.Immediate);
       }
     }
   }
   /**
-   * Handles incoming framesets
-   * @param buffer The packet buffer
-   */
+  * Handles incoming framesets
+  * @param buffer The packet buffer
+  */
   handleIncomingFrameSet(buffer) {
     const frameset = new FrameSet(buffer).deserialize();
     if (this.receivedFrameSequences.has(frameset.sequence)) {
-      this.server.logger.debug(
-        `Received duplicate frameset ${frameset.sequence} from ${this.rinfo.address}:${this.rinfo.port}!`
-      );
-      return void this.server.emit(
-        "error",
-        new Error(
-          `Recieved duplicate frameset ${frameset.sequence} from ${this.rinfo.address}:${this.rinfo.port}!`
-        )
-      );
+      this.server.logger.debug(`Received duplicate frameset ${frameset.sequence} from ${this.rinfo.address}:${this.rinfo.port}!`);
+      return void this.server.emit("error", new Error(`Recieved duplicate frameset ${frameset.sequence} from ${this.rinfo.address}:${this.rinfo.port}!`));
     }
     this.lostFrameSequences.delete(frameset.sequence);
     if (frameset.sequence < this.lastInputSequence || frameset.sequence === this.lastInputSequence) {
-      this.server.logger.debug(
-        `Received out of order frameset ${frameset.sequence} from ${this.rinfo.address}:${this.rinfo.port}!`
-      );
-      return void this.server.emit(
-        "error",
-        new Error(
-          `Recieved out of order frameset ${frameset.sequence} from ${this.rinfo.address}:${this.rinfo.port}!`
-        )
-      );
+      this.server.logger.debug(`Received out of order frameset ${frameset.sequence} from ${this.rinfo.address}:${this.rinfo.port}!`);
+      return void this.server.emit("error", new Error(`Recieved out of order frameset ${frameset.sequence} from ${this.rinfo.address}:${this.rinfo.port}!`));
     }
     this.receivedFrameSequences.add(frameset.sequence);
     if (frameset.sequence - this.lastInputSequence > 1) {
-      for (let index = this.lastInputSequence + 1; index < frameset.sequence; index++)
-        this.lostFrameSequences.add(index);
+      for (let index = this.lastInputSequence + 1; index < frameset.sequence; index++) this.lostFrameSequences.add(index);
     }
     this.lastInputSequence = frameset.sequence;
     for (const frame of frameset.frames) {
@@ -1344,22 +1681,15 @@ var Connection = class {
     }
   }
   /**
-   * Handles incoming frames
-   * @param frame The frame
-   */
+  * Handles incoming frames
+  * @param frame The frame
+  */
   handleFrame(frame) {
     if (frame.isSplit()) return this.handleFragment(frame);
     if (frame.isSequenced()) {
       if (frame.sequenceIndex < this.inputHighestSequenceIndex[frame.orderChannel] || frame.orderIndex < this.inputOrderIndex[frame.orderChannel]) {
-        this.server.logger.debug(
-          `Recieved out of order frame ${frame.sequenceIndex} from ${this.rinfo.address}:${this.rinfo.port}!`
-        );
-        return void this.server.emit(
-          "error",
-          new Error(
-            `Recieved out of order frame ${frame.sequenceIndex} from ${this.rinfo.address}:${this.rinfo.port}!`
-          )
-        );
+        this.server.logger.debug(`Recieved out of order frame ${frame.sequenceIndex} from ${this.rinfo.address}:${this.rinfo.port}!`);
+        return void this.server.emit("error", new Error(`Recieved out of order frame ${frame.sequenceIndex} from ${this.rinfo.address}:${this.rinfo.port}!`));
       }
       this.inputHighestSequenceIndex[frame.orderChannel] = frame.sequenceIndex + 1;
       return this.incomingBatch(frame.payload);
@@ -1369,9 +1699,7 @@ var Connection = class {
         this.inputOrderIndex[frame.orderChannel] = frame.orderIndex + 1;
         this.incomingBatch(frame.payload);
         let index = this.inputOrderIndex[frame.orderChannel];
-        const outOfOrderQueue = this.inputOrderingQueue.get(
-          frame.orderChannel
-        );
+        const outOfOrderQueue = this.inputOrderingQueue.get(frame.orderChannel);
         for (; outOfOrderQueue.has(index); index++) {
           const frame2 = outOfOrderQueue.get(index);
           if (!frame2) break;
@@ -1390,9 +1718,9 @@ var Connection = class {
     }
   }
   /**
-   * Handles fragmented frames
-   * @param frame The frame
-   */
+  * Handles fragmented frames
+  * @param frame The frame
+  */
   handleFragment(frame) {
     if (this.fragmentsQueue.has(frame.splitId)) {
       const fragment = this.fragmentsQueue.get(frame.splitId);
@@ -1415,18 +1743,20 @@ var Connection = class {
         return this.handleFrame(nframe);
       }
     } else {
-      this.fragmentsQueue.set(
-        frame.splitId,
-        /* @__PURE__ */ new Map([[frame.splitIndex, frame]])
-      );
+      this.fragmentsQueue.set(frame.splitId, /* @__PURE__ */ new Map([
+        [
+          frame.splitIndex,
+          frame
+        ]
+      ]));
     }
   }
   /**
-   * Sends a frame to the connection.
-   *
-   * @param frame - The frame to send
-   * @param priority - The priority of the frame
-   */
+  * Sends a frame to the connection.
+  *
+  * @param frame - The frame to send
+  * @param priority - The priority of the frame
+  */
   sendFrame(frame, priority) {
     if (frame.isSequenced()) {
       frame.orderIndex = this.outputOrderIndex[frame.orderChannel];
@@ -1459,34 +1789,36 @@ var Connection = class {
     }
   }
   /**
-   * Adds a frame to the output queue
-   * @param frame The frame
-   * @param priority The priority
-   */
+  * Adds a frame to the output queue
+  * @param frame The frame
+  * @param priority The priority
+  */
   queueFrame(frame, priority) {
     let length = DGRAM_HEADER_SIZE;
     for (const frame2 of this.outputFrames) length += frame2.getByteLength();
     if (length + frame.getByteLength() > this.mtu - DGRAM_MTU_OVERHEAD)
       this.sendQueue(this.outputFrames.size);
     this.outputFrames.add(frame);
-    if (priority === 1 /* Immediate */) return this.sendQueue(1);
+    if (priority === Priority.Immediate) return this.sendQueue(1);
   }
   /**
-   * Sends the output frame queue
-   */
+  * Sends the output frame queue
+  */
   sendQueue(amount) {
     if (this.outputFrames.size === 0) return;
     const frameset = new FrameSet();
     frameset.sequence = this.outputSequence++;
-    frameset.frames = [...this.outputFrames].slice(0, amount);
+    frameset.frames = [
+      ...this.outputFrames
+    ].slice(0, amount);
     this.outputBackup.set(frameset.sequence, frameset.frames);
     for (const frame of frameset.frames) this.outputFrames.delete(frame);
     return this.server.send(frameset.serialize(), this.rinfo);
   }
   /**
-   * Handles an incoming connection request
-   * @param buffer The packet buffer
-   */
+  * Handles an incoming connection request
+  * @param buffer The packet buffer
+  */
   handleIncomingConnectionRequest(buffer) {
     const request = new ConnectionRequest(buffer).deserialize();
     const accepted = new ConnectionRequestAccepted();
@@ -1496,15 +1828,15 @@ var Connection = class {
     accepted.requestTimestamp = request.timestamp;
     accepted.timestamp = BigInt(Date.now());
     const frame = new Frame();
-    frame.reliability = 3 /* ReliableOrdered */;
+    frame.reliability = Reliability.ReliableOrdered;
     frame.orderChannel = 0;
     frame.payload = accepted.serialize();
-    return this.sendFrame(frame, 0 /* Normal */);
+    return this.sendFrame(frame, Priority.Normal);
   }
   /**
-   * Handles an incoming connected ping
-   * @param buffer The packet buffer
-   */
+  * Handles an incoming connected ping
+  * @param buffer The packet buffer
+  */
   handleIncomingConnectedPing(buffer) {
     const ping = new ConnectedPing(buffer).deserialize();
     const pong = new ConnectedPong();
@@ -1512,53 +1844,54 @@ var Connection = class {
     pong.pingTimestamp = ping.timestamp;
     pong.timestamp = BigInt(Date.now());
     const frame = new Frame();
-    frame.reliability = 3 /* ReliableOrdered */;
+    frame.reliability = Reliability.ReliableOrdered;
     frame.orderChannel = 0;
     frame.payload = pong.serialize();
-    this.sendFrame(frame, 0 /* Normal */);
+    this.sendFrame(frame, Priority.Normal);
   }
 };
 
 // src/server/offline.ts
-var Offline = class {
+var Offline = class Offline2 {
+  static {
+    __name(this, "Offline");
+  }
   /**
-   * The raknet server instance
-   */
+  * The raknet server instance
+  */
   static server;
   /**
-   * Handles all incoming offline datagrams from remote clients
-   * @param buffer The packet buffer from the remote client
-   * @param rinfo The remote client information
-   */
+  * Handles all incoming offline datagrams from remote clients
+  * @param buffer The packet buffer from the remote client
+  * @param rinfo The remote client information
+  */
   static handle(buffer, rinfo) {
     const header = buffer[0];
     if (!header) throw new Error("Invalid offline packet header");
     switch (header) {
-      case 1 /* UnconnectedPing */: {
+      case Packet.UnconnectedPing: {
         this.unconnectedPing(buffer, rinfo);
         break;
       }
-      case 5 /* OpenConnectionRequest1 */: {
+      case Packet.OpenConnectionRequest1: {
         this.openConnectionRequest1(buffer, rinfo);
         break;
       }
-      case 7 /* OpenConnectionRequest2 */: {
+      case Packet.OpenConnectionRequest2: {
         this.openConnectionRequest2(buffer, rinfo);
         break;
       }
       default: {
         const id = header.toString(16).length === 1 ? "0" + header.toString(16) : header.toString(16);
-        this.server.logger.debug(
-          `Received an unknown offline packet identifier "0x${id}" from ${rinfo.address}:${rinfo.port}`
-        );
+        this.server.logger.debug(`Received an unknown offline packet identifier "0x${id}" from ${rinfo.address}:${rinfo.port}`);
       }
     }
   }
   /**
-   * Handles an unconnected ping packet
-   * @param buffer The packet buffer from the remote client
-   * @param rinfo The remote client information
-   */
+  * Handles an unconnected ping packet
+  * @param buffer The packet buffer from the remote client
+  * @param rinfo The remote client information
+  */
   static unconnectedPing(buffer, rinfo) {
     const ping = new UnconnectedPing(buffer).deserialize();
     const pong = new UnconnectedPong();
@@ -1566,7 +1899,6 @@ var Offline = class {
     pong.guid = this.server.guid;
     pong.message = [
       "MCPE",
-      // MCEE = Minecraft: Education Edition
       this.server.message ?? "Raknet Server",
       this.server.protocol ?? 100,
       this.server.version ?? "1.0.0",
@@ -1582,19 +1914,17 @@ var Offline = class {
     this.server.send(pong.serialize(), rinfo);
   }
   /**
-   * Handles an open connection request 1 packet
-   * @param buffer The packet buffer from the remote client
-   * @param rinfo The remote client information
-   */
+  * Handles an open connection request 1 packet
+  * @param buffer The packet buffer from the remote client
+  * @param rinfo The remote client information
+  */
   static openConnectionRequest1(buffer, rinfo) {
     const request = new OpenConnectionRequest1(buffer).deserialize();
     if (request.protocol !== RAKNET_PROTOCOL) {
       const incompatible = new IncompatibleProtocolVersion();
       incompatible.protocol = RAKNET_PROTOCOL;
       incompatible.guid = this.server.guid;
-      this.server.logger.warn(
-        `Refusing connection from ${rinfo.address}:${rinfo.port} due to incompatible protocol version v${request.protocol}, expected v${RAKNET_PROTOCOL}.`
-      );
+      this.server.logger.warn(`Refusing connection from ${rinfo.address}:${rinfo.port} due to incompatible protocol version v${request.protocol}, expected v${RAKNET_PROTOCOL}.`);
       return this.server.send(incompatible.serialize(), rinfo);
     }
     const reply = new OpenConnectionReply1();
@@ -1605,38 +1935,30 @@ var Offline = class {
     return this.server.send(reply.serialize(), rinfo);
   }
   /**
-   * Handles an open connection request 2 packet
-   * @param buffer The packet buffer from the remote client
-   * @param rinfo The remote client information
-   */
+  * Handles an open connection request 2 packet
+  * @param buffer The packet buffer from the remote client
+  * @param rinfo The remote client information
+  */
   static openConnectionRequest2(buffer, rinfo) {
     const request = new OpenConnectionRequest2(buffer).deserialize();
     if (request.address.port !== this.server.port) {
-      return this.server.logger.warn(
-        `Refusing connection from ${rinfo.address}:${rinfo.port} due to mismatched port.`
-      );
+      return this.server.logger.warn(`Refusing connection from ${rinfo.address}:${rinfo.port} due to mismatched port.`);
     }
     if (request.mtu < this.server.minMtuSize || request.mtu > this.server.maxMtuSize) {
-      return this.server.logger.warn(
-        `Refusing connection from ${rinfo.address}:${rinfo.port} due to invalid mtu size.`
-      );
+      return this.server.logger.warn(`Refusing connection from ${rinfo.address}:${rinfo.port} due to invalid mtu size.`);
     }
-    const connection = [...this.server.connections.values()].find(
-      (x) => x.rinfo.address === rinfo.address && x.rinfo.port === rinfo.port
-    );
+    const connection = [
+      ...this.server.connections.values()
+    ].find((x) => x.rinfo.address === rinfo.address && x.rinfo.port === rinfo.port);
     if (connection) {
-      return this.server.logger.warn(
-        `Refusing connection from ${rinfo.address}:${rinfo.port} due to already established connection.`
-      );
+      return this.server.logger.warn(`Refusing connection from ${rinfo.address}:${rinfo.port} due to already established connection.`);
     }
     const reply = new OpenConnectionReply2();
     reply.guid = this.server.guid;
     reply.address = Address.fromIdentifier(rinfo);
     reply.mtu = request.mtu;
     reply.encryption = false;
-    this.server.logger.debug(
-      `Establishing connection from ${rinfo.address}:${rinfo.port} with mtu size of ${request.mtu}.`
-    );
+    this.server.logger.debug(`Establishing connection from ${rinfo.address}:${rinfo.port} with mtu size of ${request.mtu}.`);
     this.server.connections.add(
       // Build a new connection instance
       new Connection(this.server, rinfo, request.client, request.mtu)
@@ -1646,68 +1968,71 @@ var Offline = class {
 };
 
 // src/server/raknet.ts
-var Server = class extends import_emitter.Emitter {
+var Server = class Server2 extends import_emitter.Emitter {
+  static {
+    __name(this, "Server");
+  }
   /**
-   * The server tick interval
-   */
+  * The server tick interval
+  */
   interval = null;
   /**
-   * The raknet server logger
-   */
+  * The raknet server logger
+  */
   logger = new import_logger.Logger("Raknet", import_logger.LoggerColors.CyanBright);
   /**
-   * The server socket
-   */
+  * The server socket
+  */
   socket = (0, import_node_dgram.createSocket)("udp4");
   /**
-   * The server address
-   */
+  * The server address
+  */
   address;
   /**
-   * The server port
-   */
+  * The server port
+  */
   port;
   /**
-   * The server guid
-   */
+  * The server guid
+  */
   guid = BigInt(Math.floor(Math.random() * 2 ** 64));
   /**
-   * The server connections
-   */
+  * The server connections
+  */
   connections = /* @__PURE__ */ new Set();
   /**
-   * The server max mtu size
-   */
+  * The server max mtu size
+  */
   maxMtuSize;
   /**
-   * The server min mtu size
-   */
+  * The server min mtu size
+  */
   minMtuSize;
   /**
-   * The server protocol
-   */
+  * The server protocol
+  */
   protocol = null;
   /**
-   * The server version
-   */
+  * The server version
+  */
   version = null;
   /**
-   * The server message
-   */
+  * The server message
+  */
   message = null;
   /**
-   * The server max connections
-   */
+  * The server max connections
+  */
   maxConnections = null;
   /**
-   * Weather the server is alive
-   */
+  * Weather the server is alive
+  */
   alive = true;
   /**
-   * Creates a new raknet server
-   * @param address the server address
-   * @param port the server port
-   */
+  * Creates a new raknet server
+  * @param address the server address
+  * @param port the server port
+  */
   constructor(address, port = 19132, mtuMaxSize = MAX_MTU_SIZE, mtuMinSize = MIN_MTU_SIZE) {
     super();
     this.address = address;
@@ -1719,20 +2044,20 @@ var Server = class extends import_emitter.Emitter {
     Offline.server = this;
   }
   /**
-   * Starts the server
-   */
+  * Starts the server
+  */
   start() {
     this.socket.bind(this.port, this.address);
-    const tick = () => setTimeout(() => {
+    const tick = /* @__PURE__ */ __name(() => setTimeout(() => {
       if (!this.alive || !this.interval) return;
       for (const connection of this.connections) connection.tick();
       return tick();
-    }, RAKNET_TICK_LEN);
+    }, RAKNET_TICK_LEN), "tick");
     this.interval = tick().unref();
   }
   /**
-   * Stops the server
-   */
+  * Stops the server
+  */
   stop() {
     try {
       if (this.interval) this.interval = null;
@@ -1744,10 +2069,10 @@ var Server = class extends import_emitter.Emitter {
   handle(buffer, rinfo) {
     const header = buffer[0];
     if (!header) throw new Error("Invalid packet header");
-    const offline = (header & 128 /* Valid */) === 0;
-    const connection = [...this.connections.values()].find(
-      (x) => x.rinfo.address === rinfo.address && x.rinfo.port === rinfo.port
-    );
+    const offline = (header & Bitflags.Valid) === 0;
+    const connection = [
+      ...this.connections.values()
+    ].find((x) => x.rinfo.address === rinfo.address && x.rinfo.port === rinfo.port);
     if (offline)
       return Offline.handle(buffer, rinfo);
     if (!offline && connection)