@serenityjs/raknet 1.0.0

package/dist/index.js

@@ -0,0 +1,1743 @@
+"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);
+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 = {};
+__export(src_exports, {
+  Ack: () => Ack,
+  Address: () => Address,
+  BasePacket: () => BasePacket,
+  Bitflags: () => Bitflags,
+  ConnectedPing: () => ConnectedPing,
+  ConnectedPong: () => ConnectedPong,
+  Connection: () => Connection,
+  ConnectionRequest: () => ConnectionRequest,
+  ConnectionRequestAccepted: () => ConnectionRequestAccepted,
+  DataType: () => DataType,
+  Disconnect: () => Disconnect,
+  Frame: () => Frame,
+  FrameSet: () => FrameSet,
+  MTU: () => MTU,
+  Magic: () => Magic,
+  MaxMtuSize: () => MaxMtuSize,
+  MinMtuSize: () => MinMtuSize,
+  Nack: () => Nack,
+  Offline: () => Offline,
+  OpenConnectionReply1: () => OpenConnectionReply1,
+  OpenConnectionReply2: () => OpenConnectionReply2,
+  OpenConnectionRequest1: () => OpenConnectionRequest1,
+  OpenConnectionRequest2: () => OpenConnectionRequest2,
+  Packet: () => Packet,
+  Priority: () => Priority,
+  Proto: () => Proto,
+  Protocol: () => Protocol,
+  RaknetServer: () => RaknetServer,
+  RaknetTPS: () => RaknetTPS,
+  RaknetTickLength: () => RaknetTickLength,
+  Reliability: () => Reliability,
+  Serialize: () => Serialize,
+  Status: () => Status,
+  SystemAddress: () => SystemAddress,
+  UnconnectedPing: () => UnconnectedPing,
+  UnconnectedPong: () => UnconnectedPong,
+  udpHeaderSize: () => udpHeaderSize
+});
+module.exports = __toCommonJS(src_exports);
+var import_reflect_metadata = require("reflect-metadata");
+
+// src/decorators/proto.ts
+function Proto(id) {
+  return function(target) {
+    target.id = id;
+    const metadata = Reflect.getOwnMetadata(
+      "properties",
+      target.prototype
+    );
+    const properties = Object.getOwnPropertyNames(target.prototype);
+    if (!properties.includes("serialize"))
+      target.prototype.serialize = function() {
+        this.flush();
+        target.id_type.write(this, target.id);
+        if (!metadata)
+          return this.getBuffer();
+        for (const { name, type, endian, parameter } of metadata) {
+          if (parameter) {
+            const value = this[parameter];
+            type.write(this, this[name], endian, value);
+          } else {
+            type.write(this, this[name], endian);
+          }
+        }
+        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) {
+            const value = this[parameter];
+            this[name] = type.read(
+              this,
+              endian,
+              value
+            );
+          } else {
+            this[name] = type.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;
+      };
+  };
+}
+
+// src/decorators/serialize.ts
+var import_binarystream = require("@serenityjs/binarystream");
+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 });
+    Reflect.defineMetadata("properties", properties, target);
+  };
+}
+
+// src/proto/data/type.ts
+var import_binarystream2 = require("@serenityjs/binarystream");
+var DataType = class {
+  /**
+   * 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.
+   */
+  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.
+   */
+  static write(_stream, _value, _endian = import_binarystream2.Endianness.Big, _parameter) {
+    return;
+  }
+};
+
+// src/proto/data/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.
+   */
+  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.
+   */
+  static write(stream) {
+    stream.writeBuffer(MagicBuffer);
+  }
+};
+
+// src/proto/data/mtu.ts
+var MTU = class extends DataType {
+  /**
+   * 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.
+   */
+  static write(stream, value) {
+    stream.writeBuffer(Buffer.alloc(value - stream.getBuffer().length));
+  }
+};
+
+// src/proto/data/address.ts
+var Address = class _Address extends DataType {
+  /**
+   * The address of the data type.
+   */
+  address;
+  /**
+   * The port of the data type.
+   */
+  port;
+  /**
+   * 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.
+   */
+  constructor(address, port, version) {
+    super();
+    this.address = address;
+    this.port = port;
+    this.version = version;
+  }
+  /**
+   * 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.
+   */
+  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);
+    } else {
+      stream.skip(2);
+      const port = stream.readUShort();
+      stream.skip(16);
+      const addressBuffer = stream.read(4);
+      const address = addressBuffer.filter((byte) => byte !== 255).join(".");
+      stream.skip(4);
+      return new _Address(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.
+   */
+  static write(stream, value) {
+    const { address, port, version } = value;
+    stream.writeUint8(version);
+    const addressBits = address.split(".", 4);
+    for (const bit of addressBits) {
+      stream.writeUint8(Number(bit));
+    }
+    stream.writeUShort(port);
+  }
+};
+
+// src/proto/data/frame.ts
+var import_binarystream3 = require("@serenityjs/binarystream");
+
+// src/enums/packet.ts
+var Packet = /* @__PURE__ */ ((Packet2) => {
+  Packet2[Packet2["ConnectedPing"] = 0] = "ConnectedPing";
+  Packet2[Packet2["UnconnectedPing"] = 1] = "UnconnectedPing";
+  Packet2[Packet2["ConnectedPong"] = 3] = "ConnectedPong";
+  Packet2[Packet2["OpenConnectionRequest1"] = 5] = "OpenConnectionRequest1";
+  Packet2[Packet2["OpenConnectionReply1"] = 6] = "OpenConnectionReply1";
+  Packet2[Packet2["OpenConnectionRequest2"] = 7] = "OpenConnectionRequest2";
+  Packet2[Packet2["OpenConnectionReply2"] = 8] = "OpenConnectionReply2";
+  Packet2[Packet2["ConnectionRequest"] = 9] = "ConnectionRequest";
+  Packet2[Packet2["ConnectionRequestAccepted"] = 16] = "ConnectionRequestAccepted";
+  Packet2[Packet2["NewIncomingConnection"] = 19] = "NewIncomingConnection";
+  Packet2[Packet2["Disconnect"] = 21] = "Disconnect";
+  Packet2[Packet2["IncompatibleProtocolVersion"] = 25] = "IncompatibleProtocolVersion";
+  Packet2[Packet2["UnconnectedPong"] = 28] = "UnconnectedPong";
+  Packet2[Packet2["FrameSet"] = 128] = "FrameSet";
+  Packet2[Packet2["Nack"] = 160] = "Nack";
+  Packet2[Packet2["Ack"] = 192] = "Ack";
+  return Packet2;
+})(Packet || {});
+
+// src/enums/bit-flags.ts
+var Bitflags = /* @__PURE__ */ ((Bitflags2) => {
+  Bitflags2[Bitflags2["Valid"] = 128] = "Valid";
+  Bitflags2[Bitflags2["Ack"] = 64] = "Ack";
+  Bitflags2[Bitflags2["Nak"] = 32] = "Nak";
+  Bitflags2[Bitflags2["Split"] = 16] = "Split";
+  return Bitflags2;
+})(Bitflags || {});
+
+// src/enums/priority.ts
+var Priority = /* @__PURE__ */ ((Priority2) => {
+  Priority2[Priority2["Normal"] = 0] = "Normal";
+  Priority2[Priority2["Immediate"] = 1] = "Immediate";
+  return Priority2;
+})(Priority || {});
+
+// src/enums/status.ts
+var Status = /* @__PURE__ */ ((Status2) => {
+  Status2[Status2["Connecting"] = 0] = "Connecting";
+  Status2[Status2["Connected"] = 1] = "Connected";
+  Status2[Status2["Disconnecting"] = 2] = "Disconnecting";
+  Status2[Status2["Disconnected"] = 3] = "Disconnected";
+  return Status2;
+})(Status || {});
+
+// src/enums/reliability.ts
+var Reliability = /* @__PURE__ */ ((Reliability2) => {
+  Reliability2[Reliability2["Unreliable"] = 0] = "Unreliable";
+  Reliability2[Reliability2["UnreliableSequenced"] = 1] = "UnreliableSequenced";
+  Reliability2[Reliability2["Reliable"] = 2] = "Reliable";
+  Reliability2[Reliability2["ReliableOrdered"] = 3] = "ReliableOrdered";
+  Reliability2[Reliability2["ReliableSequenced"] = 4] = "ReliableSequenced";
+  Reliability2[Reliability2["UnreliableWithAckReceipt"] = 5] = "UnreliableWithAckReceipt";
+  Reliability2[Reliability2["ReliableWithAckReceipt"] = 6] = "ReliableWithAckReceipt";
+  Reliability2[Reliability2["ReliableOrderedWithAckReceipt"] = 7] = "ReliableOrderedWithAckReceipt";
+  return Reliability2;
+})(Reliability || {});
+
+// src/proto/data/frame.ts
+var Frame = class _Frame extends DataType {
+  /**
+   * The reliability of the frame.
+   */
+  reliability;
+  /**
+   * The reliable index of the frame.
+   */
+  reliableIndex;
+  /**
+   * The sequence index of the frame.
+   */
+  sequenceIndex;
+  /**
+   * The order index of the frame.
+   */
+  orderIndex;
+  /**
+   * The order channel of the frame.
+   */
+  orderChannel;
+  /**
+   * The fragment size of the frame.
+   */
+  fragmentSize;
+  /**
+   * The fragment id of the frame.
+   */
+  fragmentId;
+  /**
+   * The fragment index of the frame.
+   */
+  fragmentIndex;
+  /**
+   * The payload of the frame.
+   */
+  payload;
+  /**
+   * Checks if the frame is fragmented.
+   * @returns True if the frame is fragmented; otherwise, false.
+   */
+  isFragmented() {
+    return this.fragmentSize > 0;
+  }
+  /**
+   * 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 */
+    ];
+    return values.includes(this.reliability);
+  }
+  /**
+   * Checks if the frame is sequenced.
+   * @returns True if the frame is sequenced; otherwise, false.
+   */
+  isSequenced() {
+    const values = [
+      4 /* ReliableSequenced */,
+      1 /* UnreliableSequenced */
+    ];
+    return values.includes(this.reliability);
+  }
+  /**
+   * 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 */
+    ];
+    return values.includes(this.reliability);
+  }
+  /**
+   * Checks if the frame is order exclusive.
+   * @returns True if the frame is order exclusive; otherwise, false.
+   */
+  isOrderExclusive() {
+    const values = [
+      3 /* ReliableOrdered */,
+      7 /* ReliableOrderedWithAckReceipt */
+    ];
+    return values.includes(this.reliability);
+  }
+  /**
+   * 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.isFragmented() ? 10 : 0);
+  }
+  /**
+   * 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 header = stream.readByte();
+      frame.reliability = (header & 224) >> 5;
+      const length = Math.ceil(stream.readShort() / 8);
+      if (frame.isReliable()) {
+        frame.reliableIndex = stream.readUint24(import_binarystream3.Endianness.Little);
+      }
+      if (frame.isSequenced()) {
+        frame.sequenceIndex = stream.readUint24(import_binarystream3.Endianness.Little);
+      }
+      if (frame.isOrdered()) {
+        frame.orderIndex = stream.readUint24(import_binarystream3.Endianness.Little);
+        frame.orderChannel = stream.readByte();
+      }
+      if ((header & 16 /* Split */) > 0) {
+        frame.fragmentSize = stream.readInt32();
+        frame.fragmentId = stream.readShort();
+        frame.fragmentIndex = stream.readInt32();
+      }
+      frame.payload = stream.readBuffer(length);
+      frames.push(frame);
+    } while (!stream.cursorAtEnd());
+    return frames;
+  }
+  /**
+   * 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.writeByte(
+        frame.reliability << 5 | (frame.isFragmented() ? 16 /* Split */ : 0)
+      );
+      stream.writeShort(frame.payload.byteLength << 3);
+      if (frame.isReliable()) {
+        stream.writeUint24(frame.reliableIndex, import_binarystream3.Endianness.Little);
+      }
+      if (frame.isSequenced()) {
+        stream.writeUint24(frame.sequenceIndex, import_binarystream3.Endianness.Little);
+      }
+      if (frame.isOrdered()) {
+        stream.writeUint24(frame.orderIndex, import_binarystream3.Endianness.Little);
+        stream.writeByte(frame.orderChannel);
+      }
+      if (frame.isFragmented()) {
+        stream.writeInt32(frame.fragmentSize);
+        stream.writeShort(frame.fragmentId);
+        stream.writeInt32(frame.fragmentIndex);
+      }
+      stream.writeBuffer(frame.payload);
+    }
+  }
+};
+
+// src/proto/data/system-address.ts
+var SystemAddress = class extends DataType {
+  /**
+   * 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.
+   */
+  static read(stream) {
+    const addresses = [];
+    for (let index = 0; index < 20; index++) {
+      const address = Address.read(stream);
+      addresses.push(address);
+    }
+    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.
+   */
+  static write(stream) {
+    const addresses = [
+      { 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 }
+      );
+    }
+  }
+};
+
+// src/proto/packet/base.ts
+var import_binarystream4 = require("@serenityjs/binarystream");
+var BasePacket = class extends import_binarystream4.BinaryStream {
+  /**
+   * The packet id.
+   */
+  static id;
+  /**
+   * The packet id data type.
+   */
+  static id_type = import_binarystream4.Uint8;
+  /**
+   * Flushes the binary stream.
+   */
+  flush() {
+    this.binary = [];
+  }
+  /**
+   * 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.
+   */
+  getIdType() {
+    throw new Error("BasePacket.getIdType() is not implemented.");
+  }
+  /**
+   * Serializes the packet.
+   * @returns The serialized packet.
+   */
+  serialize() {
+    throw new Error("BasePacket.serialize() is not implemented.");
+  }
+  /**
+   * Deserializes the packet.
+   */
+  deserialize() {
+    throw new Error("BasePacket.deserialize() is not implemented.");
+  }
+};
+
+// src/proto/packet/unconnected-ping.ts
+var import_binarystream5 = require("@serenityjs/binarystream");
+var UnconnectedPing = class extends BasePacket {
+  timestamp;
+  magic;
+  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 */)
+], UnconnectedPing);
+
+// src/proto/packet/unconnected-pong.ts
+var import_binarystream6 = require("@serenityjs/binarystream");
+var UnconnectedPong = class extends BasePacket {
+  timestamp;
+  guid;
+  magic;
+  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 */)
+], UnconnectedPong);
+
+// src/proto/packet/open-connection-request-1.ts
+var import_binarystream7 = require("@serenityjs/binarystream");
+var OpenConnectionRequest1 = class extends BasePacket {
+  magic;
+  protocol;
+  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 */)
+], OpenConnectionRequest1);
+
+// src/proto/packet/open-connection-reply-1.ts
+var import_binarystream8 = require("@serenityjs/binarystream");
+var OpenConnectionReply1 = class extends BasePacket {
+  magic;
+  guid;
+  security;
+  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 */)
+], OpenConnectionReply1);
+
+// src/proto/packet/open-connection-request-2.ts
+var import_binarystream9 = require("@serenityjs/binarystream");
+var OpenConnectionRequest2 = class extends BasePacket {
+  magic;
+  address;
+  mtu;
+  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 */)
+], OpenConnectionRequest2);
+
+// src/proto/packet/open-connection-reply-2.ts
+var import_binarystream10 = require("@serenityjs/binarystream");
+var OpenConnectionReply2 = class extends BasePacket {
+  magic;
+  guid;
+  address;
+  mtu;
+  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 */)
+], OpenConnectionReply2);
+
+// src/proto/packet/connected-pong.ts
+var import_binarystream11 = require("@serenityjs/binarystream");
+var ConnectedPong = class extends BasePacket {
+  pingTimestamp;
+  timestamp;
+};
+__decorateClass([
+  Serialize(import_binarystream11.Long)
+], ConnectedPong.prototype, "pingTimestamp", 2);
+__decorateClass([
+  Serialize(import_binarystream11.Long)
+], ConnectedPong.prototype, "timestamp", 2);
+ConnectedPong = __decorateClass([
+  Proto(3 /* ConnectedPong */)
+], ConnectedPong);
+
+// src/proto/packet/connected-ping.ts
+var import_binarystream12 = require("@serenityjs/binarystream");
+var ConnectedPing = class extends BasePacket {
+  timestamp;
+};
+__decorateClass([
+  Serialize(import_binarystream12.Long)
+], ConnectedPing.prototype, "timestamp", 2);
+ConnectedPing = __decorateClass([
+  Proto(0 /* ConnectedPing */)
+], ConnectedPing);
+
+// src/proto/packet/connection-request.ts
+var import_binarystream13 = require("@serenityjs/binarystream");
+var ConnectionRequest = class extends BasePacket {
+  client;
+  timestamp;
+};
+__decorateClass([
+  Serialize(import_binarystream13.Long)
+], ConnectionRequest.prototype, "client", 2);
+__decorateClass([
+  Serialize(import_binarystream13.Long)
+], ConnectionRequest.prototype, "timestamp", 2);
+ConnectionRequest = __decorateClass([
+  Proto(9 /* ConnectionRequest */)
+], ConnectionRequest);
+
+// src/proto/packet/frame-set.ts
+var import_binarystream14 = require("@serenityjs/binarystream");
+var FrameSet = class extends BasePacket {
+  sequence;
+  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 */)
+], FrameSet);
+
+// src/proto/packet/ack.ts
+var import_binarystream15 = require("@serenityjs/binarystream");
+var Ack = class extends BasePacket {
+  sequences = [];
+  // Override encode due to custom logic, maybe move into own type?
+  serialize() {
+    this.writeUint8(Ack.id);
+    const stream = new import_binarystream15.BinaryStream();
+    const count = this.sequences.length;
+    let records = 0;
+    if (count > 0) {
+      let cursor = 0;
+      let start = this.sequences[0];
+      let last = this.sequences[0];
+      while (cursor < count) {
+        const current = this.sequences[cursor++];
+        const diff = current - last;
+        if (diff === 1) {
+          last = current;
+        } else if (diff > 1) {
+          if (start === last) {
+            stream.writeBool(true);
+            stream.writeUint24(start, import_binarystream15.Endianness.Little);
+            start = last = current;
+          } else {
+            stream.writeBool(false);
+            stream.writeUint24(start, import_binarystream15.Endianness.Little);
+            stream.writeUint24(last, import_binarystream15.Endianness.Little);
+            start = last = current;
+          }
+          ++records;
+        }
+      }
+      if (start === last) {
+        stream.writeBool(true);
+        stream.writeUint24(start, import_binarystream15.Endianness.Little);
+      } else {
+        stream.writeBool(false);
+        stream.writeUint24(start, import_binarystream15.Endianness.Little);
+        stream.writeUint24(last, import_binarystream15.Endianness.Little);
+      }
+      ++records;
+      this.writeUShort(records);
+      this.writeBuffer(stream.getBuffer());
+    }
+    return this.getBuffer();
+  }
+  // Override decode due to custom logic, maybe move into own type?
+  deserialize() {
+    this.readUint8();
+    this.sequences = [];
+    const recordCount = this.readUShort();
+    for (let index = 0; index < recordCount; index++) {
+      const range = this.readBool();
+      if (range) {
+        this.sequences.push(this.readUint24(import_binarystream15.Endianness.Little));
+      } else {
+        const start = this.readUint24(import_binarystream15.Endianness.Little);
+        const end = this.readUint24(import_binarystream15.Endianness.Little);
+        for (let index2 = start; index2 <= end; index2++) {
+          this.sequences.push(index2);
+        }
+      }
+    }
+    return this;
+  }
+};
+Ack = __decorateClass([
+  Proto(192 /* Ack */)
+], Ack);
+
+// src/proto/packet/nack.ts
+var import_binarystream16 = require("@serenityjs/binarystream");
+var Nack = class extends BasePacket {
+  sequences = [];
+  // Override encode due to custom logic, maybe move into own type?
+  serialize() {
+    this.writeUint8(Nack.id);
+    const stream = new import_binarystream16.BinaryStream();
+    const count = this.sequences.length;
+    let records = 0;
+    if (count > 0) {
+      let cursor = 0;
+      let start = this.sequences[0];
+      let last = this.sequences[0];
+      while (cursor < count) {
+        const current = this.sequences[cursor++];
+        const diff = current - last;
+        if (diff === 1) {
+          last = current;
+        } else if (diff > 1) {
+          if (start === last) {
+            stream.writeBool(true);
+            stream.writeUint24(start, import_binarystream16.Endianness.Little);
+            start = last = current;
+          } else {
+            stream.writeBool(false);
+            stream.writeUint24(start, import_binarystream16.Endianness.Little);
+            stream.writeUint24(last, import_binarystream16.Endianness.Little);
+            start = last = current;
+          }
+          ++records;
+        }
+      }
+      if (start === last) {
+        stream.writeBool(true);
+        stream.writeUint24(start, import_binarystream16.Endianness.Little);
+      } else {
+        stream.writeBool(false);
+        stream.writeUint24(start, import_binarystream16.Endianness.Little);
+        stream.writeUint24(last, import_binarystream16.Endianness.Little);
+      }
+      ++records;
+      this.writeUShort(records);
+      this.writeBuffer(stream.getBuffer());
+    }
+    return this.getBuffer();
+  }
+  // Override decode due to custom logic, maybe move into own type?
+  deserialize() {
+    this.readUint8();
+    this.sequences = [];
+    const recordCount = this.readUShort();
+    for (let index = 0; index < recordCount; index++) {
+      const range = this.readBool();
+      if (range) {
+        this.sequences.push(this.readUint24(import_binarystream16.Endianness.Little));
+      } else {
+        const start = this.readUint24(import_binarystream16.Endianness.Little);
+        const end = this.readUint24(import_binarystream16.Endianness.Little);
+        for (let index2 = start; index2 <= end; index2++) {
+          this.sequences.push(index2);
+        }
+      }
+    }
+    return this;
+  }
+};
+Nack = __decorateClass([
+  Proto(160 /* Nack */)
+], Nack);
+
+// src/proto/packet/disconnect.ts
+var Disconnect = class extends BasePacket {
+};
+Disconnect = __decorateClass([
+  Proto(21 /* Disconnect */)
+], Disconnect);
+
+// src/proto/packet/connection-request-accepted.ts
+var import_binarystream17 = require("@serenityjs/binarystream");
+var ConnectionRequestAccepted = class extends BasePacket {
+  address;
+  systemIndex;
+  systemAddress;
+  requestTimestamp;
+  timestamp;
+};
+__decorateClass([
+  Serialize(Address)
+], ConnectionRequestAccepted.prototype, "address", 2);
+__decorateClass([
+  Serialize(import_binarystream17.Short)
+], ConnectionRequestAccepted.prototype, "systemIndex", 2);
+__decorateClass([
+  Serialize(SystemAddress)
+], ConnectionRequestAccepted.prototype, "systemAddress", 2);
+__decorateClass([
+  Serialize(import_binarystream17.Long)
+], ConnectionRequestAccepted.prototype, "requestTimestamp", 2);
+__decorateClass([
+  Serialize(import_binarystream17.Long)
+], ConnectionRequestAccepted.prototype, "timestamp", 2);
+ConnectionRequestAccepted = __decorateClass([
+  Proto(16 /* ConnectionRequestAccepted */)
+], ConnectionRequestAccepted);
+
+// src/server/raknet.ts
+var import_node_dgram = require("dgram");
+var import_emitter = require("@serenityjs/emitter");
+var import_logger = require("@serenityjs/logger");
+
+// src/constants/raknet.ts
+var Protocol = 11;
+var RaknetTPS = 100;
+var RaknetTickLength = 1 / RaknetTPS;
+var udpHeaderSize = 28;
+var MinMtuSize = 400;
+var MaxMtuSize = 1492;
+
+// src/server/connection.ts
+var import_binarystream18 = require("@serenityjs/binarystream");
+var Connection = class {
+  /**
+   * The server instance
+   */
+  server;
+  /**
+   * The status of the connection
+   */
+  status = 0 /* Connecting */;
+  /**
+   * The network identifier of the connection
+   */
+  identifier;
+  /**
+   * The GUID of the connection
+   */
+  guid;
+  /**
+   * The maximum transmission unit of the connection
+   */
+  mtu;
+  // Inputs
+  receivedFrameSequences = /* @__PURE__ */ new Set();
+  lostFrameSequences = /* @__PURE__ */ new Set();
+  inputHighestSequenceIndex;
+  fragmentsQueue = /* @__PURE__ */ new Map();
+  inputOrderIndex;
+  inputOrderingQueue = /* @__PURE__ */ new Map();
+  lastInputSequence = -1;
+  // Outputs
+  outputBackupQueue = /* @__PURE__ */ new Map();
+  outputOrderIndex;
+  outputSequenceIndex;
+  outputFrameQueue;
+  outputSequence = 0;
+  outputReliableIndex = 0;
+  outputFragmentIndex = 0;
+  /**
+   * Creates a new connection
+   * @param server The server instance
+   * @param identifier The network identifier
+   * @param guid The GUID
+   * @param mtu The maximum transmission unit
+   */
+  constructor(server, identifier, guid, mtu) {
+    this.server = server;
+    this.identifier = identifier;
+    this.guid = guid;
+    this.mtu = mtu;
+    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.outputFrameQueue = new FrameSet();
+    this.outputFrameQueue.frames = [];
+    this.outputOrderIndex = Array.from({ length: 32 }).fill(0);
+    this.outputSequenceIndex = Array.from({ length: 32 }).fill(0);
+  }
+  /**
+   * Ticks the connection
+   */
+  tick() {
+    if (this.status === 2 /* Disconnecting */ || this.status === 3 /* Disconnected */)
+      return;
+    if (this.receivedFrameSequences.size > 0) {
+      const ack = new Ack();
+      ack.sequences = [...this.receivedFrameSequences].map((x) => {
+        this.receivedFrameSequences.delete(x);
+        return x;
+      });
+      this.send(ack.serialize());
+    }
+    if (this.lostFrameSequences.size > 0) {
+      const pk = new Nack();
+      pk.sequences = [...this.lostFrameSequences].map((x) => {
+        this.lostFrameSequences.delete(x);
+        return x;
+      });
+      this.send(pk.serialize());
+    }
+    return this.sendFrameQueue();
+  }
+  /**
+   * Sends a buffer to the connection
+   */
+  send(buffer) {
+    this.server.send(buffer, this.identifier);
+  }
+  /**
+   * Disconnects the connection
+   */
+  disconnect() {
+    this.status = 2 /* Disconnecting */;
+    const disconnect = new Disconnect();
+    const frame = new Frame();
+    frame.reliability = 0 /* Unreliable */;
+    frame.orderChannel = 0;
+    frame.payload = disconnect.serialize();
+    this.sendFrame(frame, 1 /* Immediate */);
+    void this.server.emit("disconnect", this);
+    const key = `${this.identifier.address}:${this.identifier.port}:${this.identifier.version}`;
+    this.server.connections.delete(key);
+    this.status = 3 /* Disconnected */;
+  }
+  /**
+   * Handles incoming packets
+   * @param buffer The packet buffer
+   */
+  incoming(buffer) {
+    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.identifier.address}:${this.identifier.port}!`
+        );
+        return void this.server.emit(
+          "error",
+          new Error(
+            `Received unknown online packet 0x${id} from ${this.identifier.address}:${this.identifier.port}!`
+          )
+        );
+      }
+      case 192 /* Ack */: {
+        this.handleIncomingAck(buffer);
+        break;
+      }
+      case 160 /* Nack */: {
+        this.handleIncomingNack(buffer);
+        break;
+      }
+      case 128 /* Valid */: {
+        this.handleIncomingFrameSet(buffer);
+        break;
+      }
+    }
+  }
+  /**
+   * Handles incoming batch packets
+   * @param buffer The packet buffer
+   */
+  incomingBatch(buffer) {
+    const header = buffer[0];
+    if (this.status === 0 /* 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.identifier.address}:${this.identifier.port}!`
+          );
+          return void this.server.emit(
+            "error",
+            new Error(
+              `Received unknown online packet 0x${id} from ${this.identifier.address}:${this.identifier.port}!`
+            )
+          );
+        }
+        case 21 /* Disconnect */: {
+          this.status = 2 /* Disconnecting */;
+          const key = `${this.identifier.address}:${this.identifier.port}:${this.identifier.version}`;
+          this.server.connections.delete(key);
+          this.status = 3 /* Disconnected */;
+          break;
+        }
+        case 9 /* ConnectionRequest */: {
+          this.handleIncomingConnectionRequest(buffer);
+          break;
+        }
+        case 19 /* NewIncomingConnection */: {
+          this.status = 1 /* Connected */;
+          void this.server.emit("connect", this);
+          break;
+        }
+      }
+      return;
+    }
+    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.identifier.address}:${this.identifier.port}!`
+        );
+        return void this.server.emit(
+          "error",
+          new Error(
+            `Received unknown online packet 0x${id} from ${this.identifier.address}:${this.identifier.port}!`
+          )
+        );
+      }
+      case 21 /* Disconnect */: {
+        this.status = 2 /* Disconnecting */;
+        void this.server.emit("disconnect", this);
+        const key = `${this.identifier.address}:${this.identifier.port}:${this.identifier.version}`;
+        this.server.connections.delete(key);
+        this.status = 3 /* Disconnected */;
+        break;
+      }
+      case 0 /* ConnectedPing */: {
+        return this.handleIncomingConnectedPing(buffer);
+      }
+      case 254: {
+        void this.server.emit("encapsulated", this, buffer);
+      }
+    }
+  }
+  /**
+   * Handles incoming acks
+   * @param buffer The packet buffer
+   */
+  handleIncomingAck(buffer) {
+    const ack = new Ack(buffer).deserialize();
+    if (ack.sequences.length > 0) {
+      for (const sequence of ack.sequences) {
+        this.outputBackupQueue.delete(sequence);
+      }
+    }
+  }
+  /**
+   * Handles incoming nacks
+   * @param buffer The packet buffer
+   */
+  handleIncomingNack(buffer) {
+    const nack = new Nack(buffer).deserialize();
+    if (nack.sequences.length > 0) {
+      for (const sequence of nack.sequences) {
+        if (this.outputBackupQueue.has(sequence)) {
+          const frames = this.outputBackupQueue.get(sequence);
+          for (const frame of frames) {
+            this.sendFrame(frame, 1 /* Immediate */);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * 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.identifier.address}:${this.identifier.port}!`
+      );
+      return void this.server.emit(
+        "error",
+        new Error(
+          `Recieved duplicate frameset ${frameset.sequence} from ${this.identifier.address}:${this.identifier.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.identifier.address}:${this.identifier.port}!`
+      );
+      return void this.server.emit(
+        "error",
+        new Error(
+          `Recieved out of order frameset ${frameset.sequence} from ${this.identifier.address}:${this.identifier.port}!`
+        )
+      );
+    }
+    this.receivedFrameSequences.add(frameset.sequence);
+    const diff = frameset.sequence - this.lastInputSequence;
+    if (diff !== 1) {
+      for (let index = this.lastInputSequence + 1; index < frameset.sequence; index++) {
+        if (!this.receivedFrameSequences.has(index)) {
+          this.lostFrameSequences.add(index);
+        }
+      }
+    }
+    this.lastInputSequence = frameset.sequence;
+    for (const frame of frameset.frames) {
+      this.handleFrame(frame);
+    }
+  }
+  /**
+   * Handles incoming frames
+   * @param frame The frame
+   */
+  handleFrame(frame) {
+    if (frame.isFragmented())
+      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.identifier.address}:${this.identifier.port}!`
+        );
+        return void this.server.emit(
+          "error",
+          new Error(
+            `Recieved out of order frame ${frame.sequenceIndex} from ${this.identifier.address}:${this.identifier.port}!`
+          )
+        );
+      }
+      this.inputHighestSequenceIndex[frame.orderChannel] = frame.sequenceIndex + 1;
+      return this.incomingBatch(frame.payload);
+    } else if (frame.isOrdered()) {
+      if (frame.orderIndex === this.inputOrderIndex[frame.orderChannel]) {
+        this.inputHighestSequenceIndex[frame.orderChannel] = 0;
+        this.inputOrderIndex[frame.orderChannel] = frame.orderIndex + 1;
+        this.incomingBatch(frame.payload);
+        let index = this.inputOrderIndex[frame.orderChannel];
+        const outOfOrderQueue = this.inputOrderingQueue.get(
+          frame.orderChannel
+        );
+        for (; outOfOrderQueue.has(index); index++) {
+          this.incomingBatch(outOfOrderQueue.get(index).payload);
+          outOfOrderQueue.delete(index);
+        }
+        this.inputOrderingQueue.set(frame.orderChannel, outOfOrderQueue);
+        this.inputOrderIndex[frame.orderChannel] = index;
+      } else if (frame.orderIndex > this.inputOrderIndex[frame.orderChannel]) {
+        const unordered = this.inputOrderingQueue.get(frame.orderChannel);
+        unordered.set(frame.orderIndex, frame);
+      }
+    } else {
+      return this.incomingBatch(frame.payload);
+    }
+  }
+  /**
+   * Handles fragmented frames
+   * @param frame The frame
+   */
+  handleFragment(frame) {
+    if (this.fragmentsQueue.has(frame.fragmentId)) {
+      const value = this.fragmentsQueue.get(frame.fragmentId);
+      value.set(frame.fragmentIndex, frame);
+      if (value.size === frame.fragmentSize) {
+        const stream = new import_binarystream18.BinaryStream();
+        for (let index = 0; index < value.size; index++) {
+          const splitPacket = value.get(index);
+          stream.writeBuffer(splitPacket.payload);
+        }
+        const newFrame = new Frame();
+        newFrame.reliability = frame.reliability;
+        newFrame.reliableIndex = frame.reliableIndex;
+        newFrame.sequenceIndex = frame.sequenceIndex;
+        newFrame.orderIndex = frame.orderIndex;
+        newFrame.orderChannel = frame.orderChannel;
+        newFrame.payload = stream.getBuffer();
+        this.fragmentsQueue.delete(frame.fragmentId);
+        return this.handleFrame(newFrame);
+      }
+    } else {
+      this.fragmentsQueue.set(
+        frame.fragmentId,
+        /* @__PURE__ */ new Map([[frame.fragmentIndex, 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];
+      frame.sequenceIndex = this.outputSequenceIndex[frame.orderChannel]++;
+    } else if (frame.isOrderExclusive()) {
+      frame.orderIndex = this.outputOrderIndex[frame.orderChannel]++;
+      this.outputSequenceIndex[frame.orderChannel] = 0;
+    }
+    frame.reliableIndex = this.outputReliableIndex++;
+    const maxSize = this.mtu - 6 - 23;
+    if (frame.payload.byteLength > maxSize) {
+      const buffer = Buffer.from(frame.payload);
+      const fragmentId = this.outputFragmentIndex++ % 65536;
+      for (let index = 0; index < buffer.byteLength; index += maxSize) {
+        if (index !== 0)
+          frame.reliableIndex = this.outputReliableIndex++;
+        frame.payload = buffer.subarray(index, index + maxSize);
+        frame.fragmentIndex = index / maxSize;
+        frame.fragmentId = fragmentId;
+        frame.fragmentSize = Math.ceil(buffer.byteLength / maxSize);
+        this.addFrameToQueue(frame, priority | 0 /* Normal */);
+      }
+    } else {
+      return this.addFrameToQueue(frame, priority);
+    }
+  }
+  /**
+   * Adds a frame to the output queue
+   * @param frame The frame
+   * @param priority The priority
+   */
+  addFrameToQueue(frame, priority) {
+    let length = 4;
+    for (const queuedFrame of this.outputFrameQueue.frames) {
+      length += queuedFrame.getByteLength();
+    }
+    if (length + frame.getByteLength() > this.mtu - 36) {
+      this.sendFrameQueue();
+    }
+    this.outputFrameQueue.frames.push(frame);
+    if (priority === 1 /* Immediate */)
+      return this.sendFrameQueue();
+  }
+  /**
+   * Sends the output frame queue
+   */
+  sendFrameQueue() {
+    if (this.outputFrameQueue.frames.length > 0) {
+      this.outputFrameQueue.sequence = this.outputSequence++;
+      this.sendFrameSet(this.outputFrameQueue);
+      this.outputFrameQueue = new FrameSet();
+      this.outputFrameQueue.frames = [];
+    }
+  }
+  /**
+   * Sends a frame set to the connection
+   * @param frameset The frame set
+   */
+  sendFrameSet(frameset) {
+    this.send(frameset.serialize());
+    this.outputBackupQueue.set(
+      frameset.sequence,
+      frameset.frames.filter((frame) => frame.isReliable())
+    );
+  }
+  /**
+   * Handles an incoming connection request
+   * @param buffer The packet buffer
+   */
+  handleIncomingConnectionRequest(buffer) {
+    const request = new ConnectionRequest(buffer).deserialize();
+    const accepted = new ConnectionRequestAccepted();
+    accepted.address = Address.fromIdentifier(this.identifier);
+    accepted.systemIndex = 0;
+    accepted.systemAddress = [];
+    accepted.requestTimestamp = request.timestamp;
+    accepted.timestamp = BigInt(Date.now());
+    const frame = new Frame();
+    frame.reliability = 0 /* Unreliable */;
+    frame.orderChannel = 0;
+    frame.payload = accepted.serialize();
+    return this.sendFrame(frame, 0 /* Normal */);
+  }
+  /**
+   * Handles an incoming connected ping
+   * @param buffer The packet buffer
+   */
+  handleIncomingConnectedPing(buffer) {
+    const ping = new ConnectedPing(buffer).deserialize();
+    const pong = new ConnectedPong();
+    pong.timestamp = ping.timestamp;
+    pong.pingTimestamp = ping.timestamp;
+    pong.timestamp = BigInt(Date.now());
+    const frame = new Frame();
+    frame.reliability = 0 /* Unreliable */;
+    frame.orderChannel = 0;
+    frame.payload = pong.serialize();
+    this.sendFrame(frame, 0 /* Normal */);
+  }
+};
+
+// src/server/offline.ts
+var Offline = class {
+  /**
+   * The server instance
+   */
+  static server;
+  /**
+   * Handles all incoming offline packets
+   * @param buffer The packet buffer
+   * @param identifier The network identifier
+   */
+  static incoming(buffer, identifier) {
+    const header = buffer[0];
+    switch (header) {
+      default: {
+        const id = header.toString(16).length === 1 ? "0" + header.toString(16) : header.toString(16);
+        return void this.server.emit(
+          "error",
+          new Error(
+            `Unknown packet header "0x${id}" from ${identifier.address}:${identifier.port}`
+          )
+        );
+      }
+      case 1 /* UnconnectedPing */: {
+        this.handleUnconnectedPing(buffer, identifier);
+        break;
+      }
+      case 5 /* OpenConnectionRequest1 */: {
+        this.handleOpenConnectionRequest1(buffer, identifier);
+        break;
+      }
+      case 7 /* OpenConnectionRequest2 */: {
+        this.handleOpenConnectionRequest2(buffer, identifier);
+        break;
+      }
+    }
+  }
+  /**
+   * Handles an unconnected ping
+   * @param buffer The packet buffer
+   * @param identifier The network identifier
+   */
+  static handleUnconnectedPing(buffer, identifier) {
+    const ping = new UnconnectedPing(buffer).deserialize();
+    const pong = new UnconnectedPong();
+    pong.timestamp = ping.timestamp;
+    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",
+      this.server.connections.size,
+      this.server.maxConnections ?? 10,
+      this.server.guid,
+      "SerenityJS",
+      "Survival",
+      1,
+      this.server.port,
+      this.server.port + 1
+    ].join(";") + ";";
+    return this.server.send(pong.serialize(), identifier);
+  }
+  /**
+   * Handles an open connection request 1
+   * @param buffer The packet buffer
+   * @param identifier The network identifier
+   */
+  static handleOpenConnectionRequest1(buffer, identifier) {
+    const request = new OpenConnectionRequest1(buffer).deserialize();
+    if (request.protocol !== Protocol) {
+      return;
+    }
+    const reply = new OpenConnectionReply1();
+    reply.guid = this.server.guid;
+    reply.security = false;
+    const size = request.getBuffer().byteLength + udpHeaderSize;
+    reply.mtu = size > MaxMtuSize ? MaxMtuSize : size;
+    return this.server.send(reply.serialize(), identifier);
+  }
+  /**
+   * Handles an open connection request 2
+   * @param buffer The packet buffer
+   * @param identifier The network identifier
+   */
+  static handleOpenConnectionRequest2(buffer, identifier) {
+    const request = new OpenConnectionRequest2(buffer).deserialize();
+    const key = `${identifier.address}:${identifier.port}:${identifier.version}`;
+    const reply = new OpenConnectionReply2();
+    reply.guid = this.server.guid;
+    reply.address = Address.fromIdentifier(identifier);
+    reply.mtu = request.mtu;
+    reply.encryption = false;
+    const connection = new Connection(
+      this.server,
+      identifier,
+      request.client,
+      request.mtu
+    );
+    this.server.connections.set(key, connection);
+    return this.server.send(reply.serialize(), identifier);
+  }
+};
+
+// src/server/raknet.ts
+var RaknetServer = class extends import_emitter.Emitter {
+  /**
+   * The server tick interval
+   */
+  interval = null;
+  /**
+   * The raknet server logger
+   */
+  logger;
+  /**
+   * The server socket
+   */
+  socket;
+  /**
+   * The server address
+   */
+  address;
+  /**
+   * The server port
+   */
+  port;
+  /**
+   * The server guid
+   */
+  guid;
+  /**
+   * The server connections
+   */
+  connections;
+  /**
+   * The server protocol
+   */
+  protocol = null;
+  /**
+   * The server version
+   */
+  version = null;
+  /**
+   * The server message
+   */
+  message = null;
+  /**
+   * The server max connections
+   */
+  maxConnections = null;
+  /**
+   * Creates a new raknet server
+   * @param address the server address
+   * @param port the server port
+   */
+  constructor(address, port = 19132) {
+    super();
+    this.logger = new import_logger.Logger("Raknet", import_logger.LoggerColors.CyanBright);
+    this.socket = (0, import_node_dgram.createSocket)("udp4");
+    this.address = address;
+    this.port = port;
+    this.guid = BigInt(Math.floor(Math.random() * 2 ** 64));
+    this.connections = /* @__PURE__ */ new Map();
+    Offline.server = this;
+  }
+  /**
+   * Starts the server
+   */
+  start() {
+    try {
+      this.socket.bind(this.port, this.address);
+      this.socket.on("message", this.incoming.bind(this));
+      this.socket.on("error", (error) => this.emit("error", error));
+      const tick = () => setTimeout(() => {
+        for (const [, connection] of this.connections) {
+          connection.tick();
+        }
+        tick();
+      }, RaknetTickLength);
+      this.interval = tick().unref();
+    } catch {
+      this.logger.error(
+        `Failed to bind to the address and port, make sure the address and port are not in use.`
+      );
+      void this.emit(
+        "error",
+        new Error(
+          "Failed to bind to the address and port, make sure the address and port are not in use."
+        )
+      );
+    }
+  }
+  /**
+   * Stops the server
+   */
+  stop() {
+    try {
+      if (this.interval)
+        clearInterval(this.interval);
+      this.socket.close();
+    } catch {
+      void this.emit("error", new Error("Failed to close the server"));
+    }
+  }
+  /**
+   * Sends a buffer to the specified network identifier
+   * @param buffer the buffer to send
+   * @param identifier the network identifier to send the buffer to
+   */
+  send(buffer, identifier) {
+    this.socket.send(buffer, identifier.port, identifier.address);
+  }
+  /**
+   * Handles incoming packets
+   * @param buffer the packet buffer
+   * @param rinfo the remote info
+   */
+  incoming(buffer, rinfo) {
+    try {
+      const { address, port, family } = rinfo;
+      const version = family === "IPv4" ? 4 : 6;
+      const identifier = { address, port, version };
+      const key = `${address}:${port}:${version}`;
+      const connection = this.connections.get(key);
+      if (connection && (buffer[0] & 128 /* Valid */) !== 0)
+        return connection.incoming(buffer);
+      if ((buffer[0] & 128 /* Valid */) !== 0) {
+        this.logger.debug(
+          `Received a valid packet without a valid connection from ${key}`
+        );
+        return void this.emit(
+          "error",
+          new Error(
+            "Received a valid packet without a valid connection from " + key
+          )
+        );
+      }
+      return Offline.incoming(buffer, identifier);
+    } catch (reason) {
+      this.logger.error(
+        `Failed to handle incoming packet from ${rinfo.address}:${rinfo.port}, "${reason.message}"`
+      );
+      void this.emit("error", reason);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Ack,
+  Address,
+  BasePacket,
+  Bitflags,
+  ConnectedPing,
+  ConnectedPong,
+  Connection,
+  ConnectionRequest,
+  ConnectionRequestAccepted,
+  DataType,
+  Disconnect,
+  Frame,
+  FrameSet,
+  MTU,
+  Magic,
+  MaxMtuSize,
+  MinMtuSize,
+  Nack,
+  Offline,
+  OpenConnectionReply1,
+  OpenConnectionReply2,
+  OpenConnectionRequest1,
+  OpenConnectionRequest2,
+  Packet,
+  Priority,
+  Proto,
+  Protocol,
+  RaknetServer,
+  RaknetTPS,
+  RaknetTickLength,
+  Reliability,
+  Serialize,
+  Status,
+  SystemAddress,
+  UnconnectedPing,
+  UnconnectedPong,
+  udpHeaderSize
+});