@jsprismarine/prismarine 0.2.0 → 0.3.0

package/dist/Server-DAXmO2Rm.js

@@ -0,0 +1,1864 @@
+import { RakNetListener } from '@jsprismarine/raknet';
+import Chat, { ChatType } from './chat/Chat.es.js';
+import BanManager from './ban/BanManager.es.js';
+import BatchPacket from './network/packet/BatchPacket.es.js';
+import BlockManager from './block/BlockManager.es.js';
+import { BlockMappings } from './block/BlockMappings.es.js';
+import ChatEvent from './events/chat/ChatEvent.es.js';
+import ChatManager from './chat/ChatManager.es.js';
+import { E as Entities } from './Entities-BTndRlb_.js';
+import { Suggestions } from '@jsprismarine/brigadier';
+import CommandParameter, { CommandParameterFlags, CommandParameterType } from './network/type/CommandParameter.es.js';
+import CommandEnum from './network/type/CommandEnum.es.js';
+import Gamemode from './world/Gamemode.es.js';
+import ParseTargetSelector from './utils/ParseTargetSelector.es.js';
+import ParseTildeCaretNotation from './utils/ParseTildeCaretNotation.es.js';
+import CommandManager from './command/CommandManager.es.js';
+import Console from './Console.es.js';
+import { EventManager } from './events/EventManager.es.js';
+import Identifiers from './network/Identifiers.es.js';
+import ItemManager from './item/ItemManager.es.js';
+import AnimateHandler from './network/handler/AnimateHandler.es.js';
+import ClientCacheStatusHandler from './network/handler/ClientCacheStatusHandler.es.js';
+import CommandRequestHandler from './network/handler/CommandRequestHandler.es.js';
+import ContainerCloseHandler from './network/handler/ContainerCloseHandler.es.js';
+import EmoteListHandler from './network/handler/EmoteListHandler.es.js';
+import InteractHandler from './network/handler/InteractHandler.es.js';
+import InventoryTransactionHandler from './network/handler/InventoryTransactionHandler.es.js';
+import LevelSoundEventHandler from './network/handler/LevelSoundEventHandler.es.js';
+import PlayStatusPacket from './network/packet/PlayStatusPacket.es.js';
+import ResourcePacksInfoPacket from './network/packet/ResourcePacksInfoPacket.es.js';
+import PlayStatusType from './network/type/PlayStatusType.es.js';
+import ChangeDimensionPacket from './network/packet/ChangeDimensionPacket.es.js';
+import LevelChunkPacket from './network/packet/LevelChunkPacket.es.js';
+import { MetadataFlag, FlagType } from './entity/Metadata.es.js';
+import ContainerEntry from './inventory/ContainerEntry.es.js';
+import CoordinateUtils from './world/CoordinateUtils.es.js';
+import FormManager from './form/FormManager.es.js';
+import Human from './entity/Human.es.js';
+import MovementType from './network/type/MovementType.es.js';
+import PlayerSetGamemodeEvent from './events/player/PlayerSetGamemodeEvent.es.js';
+import PlayerToggleFlightEvent from './events/player/PlayerToggleFlightEvent.es.js';
+import PlayerToggleSprintEvent from './events/player/PlayerToggleSprintEvent.es.js';
+import TextType from './network/type/TextType.es.js';
+import Timer from './utils/Timer.es.js';
+import Vector3 from './math/Vector3.es.js';
+import WindowManager, { WindowIds } from './inventory/WindowManager.es.js';
+import MobEquipmentHandler from './network/handler/MobEquipmentHandler.es.js';
+import ModalFormResponseHandler from './network/handler/ModalFormResponseHandler.es.js';
+import MovePlayerHandler from './network/handler/MovePlayerHandler.es.js';
+import PacketViolationWarningHandler from './network/handler/PacketViolationWarningHandler.es.js';
+import PlayerActionHandler from './network/handler/PlayerActionHandler.es.js';
+import RequestChunkRadiusHandler from './network/handler/RequestChunkRadiusHandler.es.js';
+import ResourcePackResponseHandler from './network/handler/ResourcePackResponseHandler.es.js';
+import ServerSettingsRequestHandler from './network/handler/ServerSettingsRequestHandler.es.js';
+import SetDefaultGameTypeHandler from './network/handler/SetDefaultGameTypeHandler.es.js';
+import SetLocalPlayerAsInitializedHandler from './network/handler/SetLocalPlayerAsInitializedHandler.es.js';
+import SetPlayerGameTypeHandler from './network/handler/SetPlayerGameTypeHandler.es.js';
+import TextHandler from './network/handler/TextHandler.es.js';
+import TickSyncHandler from './network/handler/TickSyncHandler.es.js';
+import RequestNetworkSettingsHandler from './network/handler/RequestNetworkSettingsHandler.es.js';
+import { P as Packets } from './Packets-CmLdpaty.js';
+import PermissionManager from './permission/PermissionManager.es.js';
+import PluginManager from './plugin/PluginManager.es.js';
+import QueryManager from './query/QueryManager.es.js';
+import RaknetConnectEvent from './events/raknet/RaknetConnectEvent.es.js';
+import RaknetDisconnectEvent from './events/raknet/RaknetDisconnectEvent.es.js';
+import RaknetEncapsulatedPacketEvent from './events/raknet/RaknetEncapsulatedPacketEvent.es.js';
+import SessionManager from './SessionManager.es.js';
+import TickEvent from './events/other/TickEvent.es.js';
+import WorldManager from './world/WorldManager.es.js';
+import NetworkChunkPublisherUpdatePacket from './network/packet/NetworkChunkPublisherUpdatePacket.es.js';
+import PlayerListPacket, { PlayerListAction, PlayerListEntry } from './network/packet/PlayerListPacket.es.js';
+import UpdateAbilitiesPacket, { AbilityLayerType, AbilityLayerFlag, AbilityLayer } from './network/packet/UpdateAbilitiesPacket.es.js';
+import AddPlayerPacket from './network/packet/AddPlayerPacket.es.js';
+import AvailableCommandsPacket from './network/packet/AvailableCommandsPacket.es.js';
+import UpdateAdventureSettingsPacket from './network/packet/UpdateAdventureSettingsPacket.es.js';
+import ChunkRadiusUpdatedPacket from './network/packet/ChunkRadiusUpdatedPacket.es.js';
+import CreativeContentPacket from './network/packet/CreativeContentPacket.es.js';
+import DisconnectPacket from './network/packet/DisconnectPacket.es.js';
+import InventoryContentPacket from './network/packet/InventoryContentPacket.es.js';
+import MobEquipmentPacket from './network/packet/MobEquipmentPacket.es.js';
+import ModalFormRequestPacket from './network/packet/ModalFormRequestPacket.es.js';
+import MovePlayerPacket from './network/packet/MovePlayerPacket.es.js';
+import RemoveActorPacket from './network/packet/RemoveActorPacket.es.js';
+import SetActorDataPacket from './network/packet/SetActorDataPacket.es.js';
+import SetPlayerGameTypePacket from './network/packet/SetPlayerGameTypePacket.es.js';
+import SetTimePacket from './network/packet/SetTimePacket.es.js';
+import TextPacket from './network/packet/TextPacket.es.js';
+import UpdateAttributesPacket from './network/packet/UpdateAttributesPacket.es.js';
+import ToastRequestPacket from './network/packet/ToastRequestPacket.es.js';
+import BlockPosition from './world/BlockPosition.es.js';
+import Chunk from './world/chunk/Chunk.es.js';
+import CommandData from './network/type/CommandData.es.js';
+import Heap from 'heap';
+import Item from './item/Item.es.js';
+import PermissionType from './network/type/PermissionType.es.js';
+import PlayerPermissionType from './network/type/PlayerPermissionType.es.js';
+import UUID from './utils/UUID.es.js';
+import { creativeitems } from '@jsprismarine/bedrock-data';
+import MinecraftSession from './network/MinecraftSession.es.js';
+import assert from 'assert';
+
+class CommandArgument {
+  getReadableType() {
+    return "";
+  }
+  getParameters() {
+    return /* @__PURE__ */ new Set();
+  }
+}
+class CommandArgumentGamemode {
+  name;
+  optional;
+  flags;
+  postfix;
+  constructor(data) {
+    this.name = data?.name ?? "gameMode";
+    this.optional = data?.optional ?? false;
+    this.flags = data?.flags ?? CommandParameterFlags.NONE;
+    this.postfix = data?.postfix ?? null;
+  }
+  parse(reader, _context) {
+    const gm = reader.readString();
+    Gamemode.getGamemodeId(gm);
+    return gm;
+  }
+  async listSuggestions(_context, _builder) {
+    return Suggestions.empty();
+  }
+  getExamples() {
+    return ["survival", "creative", "adventure", "spectator"];
+  }
+  getReadableType() {
+    return this.name;
+  }
+  getParameters() {
+    const gameModeEnum = new CommandEnum();
+    gameModeEnum.enumName = "GameMode";
+    gameModeEnum.enumValues = ["survival", "creative", "adventure", "spectator"];
+    return /* @__PURE__ */ new Set([
+      new CommandParameter({
+        paramName: this.name,
+        isOptional: this.optional,
+        flags: this.flags,
+        enum: gameModeEnum,
+        postfix: this.postfix
+      })
+    ]);
+  }
+}
+class CommandArgumentMob {
+  name;
+  optional;
+  flags;
+  postfix;
+  constructor(data) {
+    this.name = data?.name ?? "entityType";
+    this.optional = data?.optional ?? false;
+    this.flags = data?.flags ?? CommandParameterFlags.NONE;
+    this.postfix = data?.postfix ?? null;
+  }
+  parse(reader, _context) {
+    let str = "";
+    while (true) {
+      if (!reader.canRead())
+        break;
+      const pos = reader.getCursor();
+      const char = reader.read();
+      if (char === " ") {
+        reader.setCursor(pos);
+        break;
+      }
+      str += char;
+    }
+    return str;
+  }
+  async listSuggestions(_context, _builder) {
+    return Suggestions.empty();
+  }
+  getExamples() {
+    return [];
+  }
+  getReadableType() {
+    return this.name;
+  }
+  getParameters() {
+    const entityTypeEnum = new CommandEnum();
+    entityTypeEnum.enumName = "EntityType";
+    entityTypeEnum.enumValues = Object.entries(Entities).map(([, entity]) => entity.MOB_ID);
+    return /* @__PURE__ */ new Set([
+      new CommandParameter({
+        paramName: this.name,
+        isOptional: this.optional,
+        flags: this.flags,
+        enum: entityTypeEnum,
+        postfix: this.postfix
+      })
+    ]);
+  }
+}
+class CommandArgumentEntity {
+  name;
+  optional;
+  flags;
+  postfix;
+  constructor(data) {
+    this.name = data?.name ?? "target";
+    this.optional = data?.optional ?? false;
+    this.flags = data?.flags ?? CommandParameterFlags.NONE;
+    this.postfix = data?.postfix ?? null;
+  }
+  parse(reader, context) {
+    let player = "";
+    while (true) {
+      if (!reader.canRead())
+        break;
+      const pos = reader.getCursor();
+      const char = reader.read();
+      if (char === " ") {
+        reader.setCursor(pos);
+        break;
+      }
+      player += char;
+    }
+    if (player.startsWith("@"))
+      try {
+        return ParseTargetSelector({
+          input: player,
+          source: context.getSource(),
+          entities: context.getSource().getWorld().getEntities()
+        });
+      } catch (error) {
+        if (!error.message.includes("no results"))
+          throw error;
+        return [];
+      }
+    return [context.getSource().getServer().getSessionManager().getPlayerByExactName(player)];
+  }
+  getReadableType() {
+    return this.name;
+  }
+  getParameters() {
+    return /* @__PURE__ */ new Set([
+      new CommandParameter({
+        paramName: this.name,
+        paramType: CommandParameterType.Target,
+        isOptional: this.optional,
+        flags: this.flags,
+        postfix: this.postfix
+      })
+    ]);
+  }
+}
+class CommandArgumentPosition extends Vector3 {
+  name;
+  optional;
+  flags;
+  postfix;
+  constructor(data) {
+    super();
+    this.name = data?.name ?? "position";
+    this.optional = data?.optional ?? false;
+    this.flags = data?.flags ?? CommandParameterFlags.NONE;
+    this.postfix = data?.postfix ?? null;
+  }
+  parse(reader, context) {
+    const getPos = () => {
+      let pos = "";
+      while (true) {
+        if (!reader.canRead())
+          break;
+        const cursor = reader.getCursor();
+        const char = reader.read();
+        if (char === " ") {
+          reader.setCursor(cursor);
+          break;
+        }
+        pos += char;
+      }
+      return pos;
+    };
+    this.setX(
+      ParseTildeCaretNotation({
+        input: getPos(),
+        source: context.getSource(),
+        type: "x"
+      })
+    );
+    reader.skip();
+    this.setY(
+      ParseTildeCaretNotation({
+        input: getPos(),
+        source: context.getSource(),
+        type: "y"
+      })
+    );
+    reader.skip();
+    this.setZ(
+      ParseTildeCaretNotation({
+        input: getPos(),
+        source: context.getSource(),
+        type: "z"
+      })
+    );
+    return this;
+  }
+  getReadableType() {
+    return this.name;
+  }
+  getParameters() {
+    return /* @__PURE__ */ new Set([
+      new CommandParameter({
+        paramName: this.name,
+        paramType: CommandParameterType.Position,
+        isOptional: this.optional,
+        flags: this.flags,
+        postfix: this.postfix
+      })
+    ]);
+  }
+}
+class CommandArgumentCommand {
+  name;
+  optional;
+  flags;
+  postfix;
+  constructor(data) {
+    this.name = data?.name ?? "command";
+    this.optional = data?.optional ?? false;
+    this.flags = data?.flags ?? CommandParameterFlags.NONE;
+    this.postfix = data?.postfix ?? null;
+  }
+  parse(reader, _context) {
+    const command = reader.readString();
+    return command;
+  }
+  getReadableType() {
+    return this.name;
+  }
+  getParameters() {
+    return /* @__PURE__ */ new Set([
+      new CommandParameter({
+        paramName: this.name,
+        paramType: CommandParameterType.Position,
+        isOptional: this.optional,
+        flags: this.flags,
+        postfix: this.postfix
+      })
+    ]);
+  }
+}
+class BooleanArgumentCommand {
+  name;
+  optional;
+  flags;
+  postfix;
+  constructor(data) {
+    this.name = data?.name ?? "boolean";
+    this.optional = data?.optional ?? false;
+    this.flags = data?.flags ?? CommandParameterFlags.NONE;
+    this.postfix = data?.postfix ?? null;
+  }
+  parse(reader, _context) {
+    const boolean = reader.readString();
+    if (boolean === "true")
+      return true;
+    return false;
+  }
+  getReadableType() {
+    return this.name;
+  }
+  getParameters() {
+    const booleanEnum = new CommandEnum();
+    booleanEnum.enumName = "Boolean";
+    booleanEnum.enumValues = ["true", "false"];
+    return /* @__PURE__ */ new Set([
+      new CommandParameter({
+        paramName: this.name,
+        isOptional: this.optional,
+        enum: booleanEnum,
+        flags: this.flags,
+        postfix: this.postfix
+      })
+    ]);
+  }
+}
+class PlayerArgumentCommand {
+  name;
+  optional;
+  flags;
+  postfix;
+  constructor(data) {
+    this.name = data?.name ?? "player";
+    this.optional = data?.optional ?? false;
+    this.flags = data?.flags ?? CommandParameterFlags.NONE;
+    this.postfix = data?.postfix ?? null;
+  }
+  parse(reader, _context) {
+    const player = reader.readString();
+    return player;
+  }
+  getReadableType() {
+    return this.name;
+  }
+  getParameters() {
+    const playerEnum = new CommandEnum();
+    playerEnum.enumName = "Player";
+    try {
+      playerEnum.enumValues = Server.instance.getSessionManager().getAllPlayers().map((player) => player.getName());
+    } catch {
+      playerEnum.enumValues = [];
+    }
+    return /* @__PURE__ */ new Set([
+      new CommandParameter({
+        paramName: this.name,
+        isOptional: this.optional,
+        enum: playerEnum,
+        flags: this.flags,
+        postfix: this.postfix
+      })
+    ]);
+  }
+}
+
+class LoginHandler {
+  static NetID = Identifiers.LoginPacket;
+  async handle(packet, server, connection) {
+    const playStatus = new PlayStatusPacket();
+    if (packet.protocol !== Identifiers.Protocol) {
+      playStatus.status = packet.protocol < Identifiers.Protocol ? PlayStatusType.LoginFailedClient : PlayStatusType.LoginFailedServer;
+      await connection.sendDataPacket(playStatus, true);
+      return;
+    }
+    if (!packet.displayName) {
+      connection.disconnect("Invalid username!", false);
+      return;
+    }
+    const world = server.getWorldManager().getDefaultWorld();
+    const player = new Player(connection, world, server);
+    player.username.name = packet.displayName;
+    player.locale = packet.languageCode;
+    player.randomId = packet.clientRandomId;
+    player.uuid = packet.identity;
+    player.xuid = packet.XUID;
+    player.skin = packet.skin;
+    player.device = packet.device;
+    try {
+      const oldPlayer = server.getSessionManager().getPlayerByExactName(packet.displayName);
+      await oldPlayer.kick("Logged in from another location");
+    } catch {
+    }
+    if (!player.xuid && server.getConfig().getOnlineMode()) {
+      await player.kick("Server is in online-mode!");
+      return;
+    }
+    await player.onEnable();
+    const reason = server.getBanManager().isBanned(player);
+    if (reason !== false) {
+      await player.kick(`You have been banned${reason ? ` for reason: ${reason}` : ""}!`);
+      return;
+    }
+    const session = connection.initPlayerConnection(server, player);
+    await session.sendPlayStatus(PlayStatusType.LoginSuccess);
+    await world.addEntity(player);
+    const resourcePacksInfo = new ResourcePacksInfoPacket();
+    resourcePacksInfo.resourcePackRequired = false;
+    resourcePacksInfo.forceServerPacksEnabled = false;
+    resourcePacksInfo.hasScripts = false;
+    resourcePacksInfo.hasAddonPacks = false;
+    await connection.sendDataPacket(resourcePacksInfo, true);
+  }
+}
+
+const Handlers = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+__proto__: null,
+AnimateHandler,
+ClientCacheStatusHandler,
+CommandRequestHandler,
+ContainerCloseHandler,
+EmoteListHandler,
+InteractHandler,
+InventoryTransactionHandler,
+LevelSoundEventHandler,
+LoginHandler,
+MobEquipmentHandler,
+ModalFormResponseHandler,
+MovePlayerHandler,
+PacketViolationWarningHandler,
+PlayerActionHandler,
+RequestChunkRadiusHandler,
+RequestNetworkSettingsHandler,
+ResourcePackResponseHandler,
+ServerSettingsRequestHandler,
+SetDefaultGameTypeHandler,
+SetLocalPlayerAsInitializedHandler,
+SetPlayerGameTypeHandler,
+TextHandler,
+TickSyncHandler
+}, Symbol.toStringTag, { value: 'Module' }));
+
+class PlayerSession {
+  connection;
+  server;
+  player;
+  chunkSendQueue = [];
+  loadedChunks = /* @__PURE__ */ new Set();
+  loadingChunks = /* @__PURE__ */ new Set();
+  constructor(server, connection, player) {
+    this.server = server;
+    this.connection = connection;
+    this.player = player;
+  }
+  async update(_tick) {
+    if (this.chunkSendQueue.length > 0) {
+      const chunksToSend = this.chunkSendQueue.splice(0, Math.min(this.chunkSendQueue.length, 50));
+      const batch = new BatchPacket();
+      for (const chunk of chunksToSend) {
+        const pk = new LevelChunkPacket();
+        pk.chunkX = chunk.getX();
+        pk.chunkZ = chunk.getZ();
+        pk.clientSubChunkRequestsEnabled = false;
+        pk.subChunkCount = chunk.getTopEmpty() + 4;
+        pk.data = chunk.networkSerialize();
+        batch.addPacket(pk);
+        const hash = Chunk.packXZ(chunk.getX(), chunk.getZ());
+        this.loadedChunks.add(hash);
+        this.loadingChunks.delete(hash);
+      }
+      this.connection.sendBatch(batch, false);
+    }
+    this.player.viewDistance && await this.needNewChunks();
+  }
+  /**
+   * Notify a client about change(s) to the adventure settings.
+   *
+   * @param player - The client-controlled entity
+   */
+  async sendSettings(player) {
+    const target = player ?? this.player;
+    const pk = new UpdateAdventureSettingsPacket();
+    pk.worldImmutable = target.gamemode === Gamemode.Spectator;
+    pk.noAttackingPlayers = target.gamemode === Gamemode.Spectator;
+    pk.noAttackingMobs = target.gamemode === Gamemode.Spectator;
+    pk.autoJump = true;
+    pk.showNameTags = true;
+    await this.connection.sendDataPacket(pk);
+  }
+  async sendAbilities(player) {
+    const target = player ?? this.player;
+    const pk = new UpdateAbilitiesPacket();
+    pk.commandPermission = target.isOp() ? PermissionType.Operator : PermissionType.Normal;
+    pk.playerPermission = target.isOp() ? PlayerPermissionType.Operator : PlayerPermissionType.Member;
+    pk.targetActorUniqueId = target.getRuntimeId();
+    const mainLayer = new AbilityLayer();
+    mainLayer.layerType = AbilityLayerType.BASE;
+    mainLayer.layerFlags = /* @__PURE__ */ new Map([
+      [AbilityLayerFlag.FLY_SPEED, true],
+      [AbilityLayerFlag.WALK_SPEED, true],
+      [AbilityLayerFlag.MAY_FLY, target.getAllowFlight()],
+      [AbilityLayerFlag.FLYING, target.isFlying()],
+      [AbilityLayerFlag.NO_CLIP, target.gamemode === Gamemode.Spectator],
+      [AbilityLayerFlag.OPERATOR_COMMANDS, target.isOp()],
+      [AbilityLayerFlag.TELEPORT, target.isOp()],
+      [AbilityLayerFlag.INVULNERABLE, target.gamemode === Gamemode.Creative],
+      [AbilityLayerFlag.MUTED, false],
+      [AbilityLayerFlag.WORLD_BUILDER, false],
+      [AbilityLayerFlag.INSTABUILD, target.gamemode === Gamemode.Creative],
+      [AbilityLayerFlag.LIGHTNING, false],
+      [AbilityLayerFlag.BUILD, target.gamemode !== Gamemode.Spectator],
+      [AbilityLayerFlag.MINE, target.gamemode !== Gamemode.Spectator],
+      [AbilityLayerFlag.DOORS_AND_SWITCHES, target.gamemode !== Gamemode.Spectator],
+      [AbilityLayerFlag.OPEN_CONTAINERS, target.gamemode !== Gamemode.Spectator],
+      [AbilityLayerFlag.ATTACK_PLAYERS, target.gamemode !== Gamemode.Spectator],
+      [AbilityLayerFlag.ATTACK_MOBS, target.gamemode !== Gamemode.Spectator]
+    ]);
+    mainLayer.flySpeed = 0.05;
+    mainLayer.walkSpeed = 0.1;
+    pk.abilityLayers = [mainLayer];
+    await this.connection.sendDataPacket(pk);
+  }
+  async needNewChunks(forceResend = false, dist) {
+    const currentXChunk = CoordinateUtils.fromBlockToChunk(this.player.getX());
+    const currentZChunk = CoordinateUtils.fromBlockToChunk(this.player.getZ());
+    const viewDistance = this.player.viewDistance || dist || 0;
+    const chunksToSendHeap = new Heap((a, b) => {
+      const distXFirst = Math.abs(a[0] - currentXChunk);
+      const distXSecond = Math.abs(b[0] - currentXChunk);
+      const distZFirst = Math.abs(a[1] - currentZChunk);
+      const distZSecond = Math.abs(b[1] - currentZChunk);
+      return distXFirst + distZFirst > distXSecond + distZSecond ? 1 : -1;
+    });
+    for (let sendXChunk = -viewDistance; sendXChunk <= viewDistance; sendXChunk++) {
+      for (let sendZChunk = -viewDistance; sendZChunk <= viewDistance; sendZChunk++) {
+        if (sendXChunk * sendXChunk + sendZChunk * sendZChunk > viewDistance * viewDistance)
+          continue;
+        const newChunk = [currentXChunk + sendXChunk, currentZChunk + sendZChunk];
+        const hash = Chunk.packXZ(newChunk[0], newChunk[1]);
+        if (forceResend) {
+          chunksToSendHeap.push(newChunk);
+        } else if (!this.loadedChunks.has(hash) && !this.loadingChunks.has(hash)) {
+          chunksToSendHeap.push(newChunk);
+        }
+      }
+    }
+    while (chunksToSendHeap.size() > 0) {
+      const closestChunk = chunksToSendHeap.pop();
+      const hash = Chunk.packXZ(closestChunk[0], closestChunk[1]);
+      if (forceResend) {
+        if (!this.loadedChunks.has(hash) && !this.loadingChunks.has(hash)) {
+          this.loadingChunks.add(hash);
+          await this.requestChunk(closestChunk[0], closestChunk[1]);
+        } else {
+          const loadedChunk = await this.player.getWorld().getChunk(closestChunk[0], closestChunk[1]);
+          await this.sendChunk(loadedChunk);
+        }
+      } else {
+        this.loadingChunks.add(hash);
+        await this.requestChunk(closestChunk[0], closestChunk[1]);
+      }
+    }
+    let unloaded = false;
+    for (const hash of this.loadedChunks) {
+      const [x, z] = Chunk.unpackXZ(hash);
+      if (Math.abs(x - currentXChunk) > viewDistance || Math.abs(z - currentZChunk) > viewDistance) {
+        unloaded = true;
+        this.loadedChunks.delete(hash);
+      }
+    }
+    for (const hash of this.loadingChunks) {
+      const [x, z] = Chunk.unpackXZ(hash);
+      if (Math.abs(x - currentXChunk) > viewDistance || Math.abs(z - currentZChunk) > viewDistance) {
+        this.loadingChunks.delete(hash);
+      }
+    }
+    if (!unloaded && this.chunkSendQueue.length !== 0) {
+      await this.sendNetworkChunkPublisher(dist ?? viewDistance, []);
+    }
+  }
+  async requestChunk(x, z) {
+    const chunk = await this.player.getWorld().getChunk(x, z);
+    this.chunkSendQueue.push(chunk);
+  }
+  /**
+   * Clear the currently loaded and loading chunks.
+   *
+   * @remarks
+   * Usually used for changing dimension, world, etc.
+   */
+  async clearChunks() {
+    this.loadedChunks.clear();
+    this.loadingChunks.clear();
+  }
+  async sendInventory() {
+    const pk = new InventoryContentPacket();
+    pk.items = this.player.getInventory().getItems(true);
+    pk.windowId = WindowIds.INVENTORY;
+    await this.connection.sendDataPacket(pk);
+    await this.sendHandItem(this.player.getInventory().getItemInHand());
+  }
+  async sendCreativeContents(empty = false) {
+    const pk = new CreativeContentPacket();
+    if (empty) {
+      await this.connection.sendDataPacket(pk);
+      return;
+    }
+    const entries = [
+      ...this.player.getServer().getBlockManager().getBlocks(),
+      ...this.player.getServer().getItemManager().getItems()
+    ];
+    creativeitems.forEach((item) => {
+      pk.items.push(
+        ...entries.filter((entry) => {
+          return entry.meta === (item.damage ?? 0) && entry.getId() === item.id;
+        }).map(
+          (entry) => new Item({
+            id: entry.getId(),
+            name: entry.getName(),
+            meta: entry.meta
+          })
+        )
+      );
+    });
+    await this.connection.sendDataPacket(pk);
+  }
+  /**
+   * Sets the item in the player hand.
+   *
+   * @param item - The entity.
+   */
+  async sendHandItem(item) {
+    const pk = new MobEquipmentPacket();
+    pk.runtimeEntityId = this.player.getRuntimeId();
+    pk.item = item;
+    pk.inventorySlot = this.player.getInventory().getHandSlotIndex();
+    pk.hotbarSlot = this.player.getInventory().getHandSlotIndex();
+    pk.windowId = 0;
+    await this.connection.sendDataPacket(pk);
+  }
+  async sendForm(form) {
+    const id = this.player.getFormManager().addForm(form);
+    const pk = new ModalFormRequestPacket();
+    pk.formId = id;
+    pk.formData = form.jsonSerialize();
+    await this.connection.sendDataPacket(pk);
+  }
+  /**
+   * Set the client's current tick.
+   *
+   * @param tick - The tick
+   */
+  async sendTime(tick) {
+    const pk = new SetTimePacket();
+    pk.time = tick;
+    await this.connection.sendDataPacket(pk);
+  }
+  /**
+   * Set the client's gamemode.
+   *
+   * @param gamemode - the numeric gamemode ID
+   */
+  async sendGamemode(gamemode) {
+    const pk = new SetPlayerGameTypePacket();
+    pk.gamemode = gamemode;
+    await this.connection.sendDataPacket(pk);
+  }
+  async sendNetworkChunkPublisher(distance, savedChunks) {
+    const pk = new NetworkChunkPublisherUpdatePacket();
+    pk.position = BlockPosition.fromVector3(this.player);
+    pk.radius = distance << 4;
+    pk.savedChunks = savedChunks;
+    await this.connection.sendDataPacket(pk);
+  }
+  async sendAvailableCommands() {
+    const pk = new AvailableCommandsPacket();
+    this.server.getCommandManager().getCommandsList().forEach((command) => {
+      const commandClass = Array.from(this.server.getCommandManager().getCommands().values()).find(
+        (cmd2) => cmd2.id.split(":")[1] === command[0]
+      );
+      if (!commandClass) {
+        this.player.getServer().getLogger()?.warn(`Can't find corresponding command class for "${command[0]}"`);
+        return;
+      }
+      if (!this.player.getServer().getPermissionManager().can(this.player).execute(commandClass.permission))
+        return;
+      const cmd = new CommandData();
+      cmd.commandName = command[0];
+      cmd.commandDescription = commandClass.description;
+      if (commandClass.aliases.length > 0) {
+        const cmdAliases = new CommandEnum();
+        cmdAliases.enumName = `${command[0]}Aliases`;
+        cmdAliases.enumValues = commandClass.aliases.concat(command[0]);
+        cmd.aliases = cmdAliases;
+      }
+      command[2].forEach((arg, index) => {
+        const parameters = arg.map((parameter) => {
+          const parameters2 = parameter.getParameters();
+          if (parameters2)
+            return Array.from(parameters2.values());
+          if (parameter instanceof CommandArgumentEntity)
+            return [
+              new CommandParameter({
+                paramName: "target",
+                paramType: CommandParameterType.Target
+              })
+            ];
+          if (parameter instanceof CommandArgumentGamemode)
+            return [
+              new CommandParameter({
+                paramName: "gamemode",
+                paramType: CommandParameterType.String
+              })
+            ];
+          if (parameter.constructor.name === "StringArgumentType")
+            return [
+              new CommandParameter({
+                paramName: "value",
+                paramType: CommandParameterType.String
+              })
+            ];
+          if (parameter.constructor.name === "IntegerArgumentType")
+            return [
+              new CommandParameter({
+                paramName: "number",
+                paramType: CommandParameterType.Int
+              })
+            ];
+          this.server.getLogger()?.warn(`Invalid parameter ${parameter.constructor.name}`);
+          return [
+            new CommandParameter({
+              paramName: "value",
+              paramType: CommandParameterType.String
+            })
+          ];
+        }).flat();
+        cmd.overloads[index] = parameters;
+      });
+      pk.commandData.push(cmd);
+    });
+    const playerEnum = new CommandEnum();
+    playerEnum.enumName = "Player";
+    playerEnum.enumValues = this.player.getServer().getSessionManager().getAllPlayers().map((player) => player.getName());
+    pk.softEnums = [playerEnum];
+  }
+  /**
+   * Set the client's maximum view distance.
+   *
+   * @param distance - The view distance
+   */
+  async setViewDistance(distance) {
+    this.player.viewDistance = distance;
+    const pk = new ChunkRadiusUpdatedPacket();
+    pk.radius = distance;
+    await this.connection.sendDataPacket(pk);
+  }
+  async sendAttributes(attributes) {
+    const pk = new UpdateAttributesPacket();
+    pk.runtimeEntityId = this.player.getRuntimeId();
+    pk.attributes = attributes.length > 0 ? attributes : this.player.getAttributeManager().getAttributes();
+    pk.tick = BigInt(0);
+    await this.connection.sendDataPacket(pk);
+  }
+  async sendMetadata() {
+    const pk = new SetActorDataPacket();
+    pk.runtimeEntityId = this.player.getRuntimeId();
+    pk.metadata = this.player.getMetadataManager();
+    pk.tick = BigInt(0);
+    await this.connection.sendDataPacket(pk);
+  }
+  /**
+   * Send a chat message to the client.
+   *
+   * @remarks
+   * Refactor this completely.
+   *
+   * @param message - The message
+   * @param xuid - The source xuid
+   * @param parameters -
+   * @param needsTranslation - If the TextType requires translation
+   * @param type - The text type
+   */
+  async sendMessage(message, xuid = "", parameters = [], needsTranslation = false, type = TextType.Raw) {
+    if (!message)
+      throw new Error("A message is required");
+    const pk = new TextPacket();
+    pk.type = type;
+    pk.sourceName = "";
+    pk.message = message;
+    pk.needsTranslation = needsTranslation;
+    pk.xuid = xuid;
+    pk.platformChatId = "";
+    pk.parameters = parameters;
+    await this.connection.sendDataPacket(pk);
+  }
+  async sendToast(title, body) {
+    if (!title)
+      throw new Error("A toast title is required");
+    if (!body)
+      throw new Error("A toast body is required.");
+    const pk = new ToastRequestPacket();
+    pk.title = title;
+    pk.body = body;
+    await this.connection.sendDataPacket(pk);
+  }
+  async sendChunk(chunk) {
+    const pk = new LevelChunkPacket();
+    pk.chunkX = chunk.getX();
+    pk.chunkZ = chunk.getZ();
+    pk.clientSubChunkRequestsEnabled = false;
+    pk.subChunkCount = chunk.getTopEmpty() + 4;
+    pk.data = chunk.networkSerialize();
+    await this.connection.sendDataPacket(pk, void 0, false);
+    const hash = Chunk.packXZ(chunk.getX(), chunk.getZ());
+    this.loadedChunks.add(hash);
+    this.loadingChunks.delete(hash);
+  }
+  /**
+   * Broadcast the movement to a defined player
+   */
+  async broadcastMove(player, mode = MovementType.Normal) {
+    const pk = new MovePlayerPacket();
+    pk.runtimeEntityId = player.getRuntimeId();
+    pk.positionX = player.getX();
+    pk.positionY = player.getY();
+    pk.positionZ = player.getZ();
+    pk.pitch = player.pitch;
+    pk.yaw = player.yaw;
+    pk.headYaw = player.headYaw;
+    pk.mode = mode;
+    pk.onGround = player.isOnGround();
+    if (mode === MovementType.Teleport) {
+      pk.teleportCause = 0;
+      pk.teleportItemId = 0;
+    }
+    pk.ridingEntityRuntimeId = BigInt(0);
+    pk.tick = BigInt(0);
+    await this.connection.sendDataPacket(pk);
+  }
+  /**
+   * Adds the client to the player list of every player inside
+   * the server and also to the player itself.
+   */
+  async addToPlayerList() {
+    const playerList = new PlayerListPacket();
+    playerList.type = PlayerListAction.TYPE_ADD;
+    const entry = new PlayerListEntry({
+      uuid: UUID.fromString(this.player.uuid),
+      uniqueEntityid: this.player.getRuntimeId(),
+      name: this.player.getName(),
+      xuid: this.player.xuid,
+      platformChatId: "",
+      // TODO: read this value from Login
+      buildPlatform: this.player.device ? this.player.device.os : -1,
+      skin: this.player.skin,
+      isTeacher: false,
+      // TODO: figure out where to read teacher and host
+      isHost: false
+    });
+    playerList.entries.push(entry);
+    await this.server.broadcastPacket(playerList);
+    this.server.getSessionManager().getPlayerList().set(this.player.uuid, entry);
+  }
+  /**
+   * Removes a player from other players list
+   */
+  async removeFromPlayerList() {
+    if (!this.player.uuid)
+      return;
+    const pk = new PlayerListPacket();
+    pk.type = PlayerListAction.TYPE_REMOVE;
+    const entry = new PlayerListEntry({
+      uuid: UUID.fromString(this.player.getUUID())
+    });
+    pk.entries.push(entry);
+    this.server.getSessionManager().getPlayerList().delete(this.player.uuid);
+    await Promise.all(
+      this.server.getSessionManager().getAllPlayers().map(async (player) => player.getNetworkSession().getConnection().sendDataPacket(pk))
+    );
+  }
+  /**
+   * Sends the full player list to the player.
+   */
+  async sendPlayerList() {
+    const playerList = new PlayerListPacket();
+    playerList.type = PlayerListAction.TYPE_ADD;
+    playerList.entries = Array.from(this.server.getSessionManager().getPlayerList().values());
+    await this.connection.sendDataPacket(playerList);
+  }
+  /**
+   * Spawn the player for another player
+   *
+   * @param player - the player to send the AddPlayerPacket to
+   */
+  async sendSpawn(player) {
+    if (!player.getUUID()) {
+      this.server.getLogger()?.error(`UUID for player ${player.getName()} is undefined`);
+      return;
+    }
+    const pk = new AddPlayerPacket();
+    pk.uuid = UUID.fromString(this.player.getUUID());
+    pk.runtimeEntityId = this.player.getRuntimeId();
+    pk.name = this.player.getName();
+    pk.positionX = this.player.getX();
+    pk.positionY = this.player.getY();
+    pk.positionZ = this.player.getZ();
+    pk.motionX = 0;
+    pk.motionY = 0;
+    pk.motionZ = 0;
+    pk.pitch = this.player.pitch;
+    pk.yaw = this.player.yaw;
+    pk.headYaw = this.player.headYaw;
+    pk.item = this.player.getInventory().getItemInHand();
+    pk.deviceId = this.player.device?.id ?? "";
+    pk.metadata = this.player.getMetadataManager();
+    await player.getNetworkSession().getConnection().sendDataPacket(pk);
+  }
+  /**
+   * Despawn the player entity from another player
+   */
+  async sendDespawn(player) {
+    const pk = new RemoveActorPacket();
+    pk.uniqueEntityId = this.player.getRuntimeId();
+    await player.getNetworkSession().getConnection().sendDataPacket(pk);
+  }
+  async sendPlayStatus(status) {
+    const pk = new PlayStatusPacket();
+    pk.status = status;
+    await this.connection.sendDataPacket(pk, true);
+  }
+  async kick(reason = "unknown reason") {
+    const pk = new DisconnectPacket();
+    pk.skipMessage = false;
+    pk.message = reason;
+    await this.connection.sendDataPacket(pk, true);
+  }
+  getConnection() {
+    return this.connection;
+  }
+  getPlayer() {
+    return this.player;
+  }
+}
+
+const VANILLA_DEFAULT_SPAWN_RADIUS = 4;
+class Player extends Human {
+  address;
+  networkSession;
+  permissions;
+  // Only used for metrics
+  joinTimer = new Timer();
+  // TODO: finish implementation
+  windows;
+  connected = false;
+  username = {
+    prefix: "<",
+    suffix: ">",
+    name: ""
+  };
+  locale = "";
+  randomId = 0;
+  uuid = "";
+  xuid = "";
+  skin = null;
+  viewDistance = 0;
+  gamemode = 0;
+  pitch = 0;
+  yaw = 0;
+  headYaw = 0;
+  onGround = false;
+  sprinting = false;
+  flying = false;
+  sneaking = false;
+  allowFight = false;
+  platformChatId = "";
+  device = null;
+  cacheSupport = false;
+  chunkSendQueue = /* @__PURE__ */ new Set();
+  currentChunk = null;
+  forms;
+  chatHandler;
+  /**
+   * Player's constructor.
+   */
+  constructor(connection, world, server) {
+    super(world, server);
+    this.address = connection.getRakNetSession().getAddress();
+    this.networkSession = new PlayerSession(server, connection, this);
+    this.windows = new WindowManager();
+    this.forms = new FormManager();
+    this.permissions = [];
+    this.joinTimer.reset();
+    this.chatHandler = async (evt) => {
+      if (evt.isCancelled())
+        return;
+      if (evt.getChat().getChannel() === "*.everyone" || evt.getChat().getChannel() === "*.ops" && this.isOp() || evt.getChat().getChannel() === `*.player.${this.getName()}`)
+        await this.sendMessage(
+          evt.getChat().getMessage(),
+          evt.getChat().getType(),
+          evt.getChat().getParameters(),
+          evt.getChat().isNeedsTranslation()
+        );
+    };
+    server.getEventManager().on("chat", this.chatHandler);
+  }
+  async onEnable() {
+    this.permissions = await this.getServer().getPermissionManager().getPermissions(this);
+    const playerData = await this.getWorld().getPlayerData(this);
+    await this.setX(playerData.position.x);
+    await this.setY(playerData.position.y);
+    await this.setZ(playerData.position.z);
+    this.pitch = playerData.position.pitch;
+    this.yaw = playerData.position.yaw;
+    playerData.inventory.forEach((item) => {
+      const entry = this.getServer().getItemManager().getItem(item.id) || this.getServer().getBlockManager().getBlock(item.id);
+      if (!entry) {
+        this.getServer().getLogger()?.warn(`Item/block with id ${item.id} is invalid`, "Player/onEnable");
+        return;
+      }
+      this.getInventory().setItem(
+        item.position,
+        new ContainerEntry({
+          item: entry,
+          count: item.count
+        })
+      );
+    });
+    if (!this.connected)
+      this.getServer().getLogger()?.debug(`(Complete player creation took ${this.joinTimer.stop()} ms)`, "Player/onEnable");
+    this.connected = true;
+  }
+  async onDisable() {
+    if (this.connected && this.xuid)
+      await this.getWorld().savePlayerData(this);
+    this.server.getEventManager().removeListener("chat", this.chatHandler);
+    this.connected = false;
+  }
+  /**
+   * Used to match vanilla behavior, will send chunks
+   * with an initial view radius of VANILLA_DEFAULT_SPAWN_RADIUS.
+   */
+  async sendInitialSpawnChunks() {
+    const minX = CoordinateUtils.fromBlockToChunk(this.x) - VANILLA_DEFAULT_SPAWN_RADIUS;
+    const minZ = CoordinateUtils.fromBlockToChunk(this.z) - VANILLA_DEFAULT_SPAWN_RADIUS;
+    const maxX = CoordinateUtils.fromBlockToChunk(this.x) + VANILLA_DEFAULT_SPAWN_RADIUS;
+    const maxZ = CoordinateUtils.fromBlockToChunk(this.z) + VANILLA_DEFAULT_SPAWN_RADIUS;
+    const savedChunks = [];
+    const sendQueue = [];
+    for (let chunkX = minX; chunkX <= maxX; ++chunkX) {
+      for (let chunkZ = minZ; chunkZ <= maxZ; ++chunkZ) {
+        savedChunks.push({ x: chunkX, z: chunkZ });
+        sendQueue.push(this.getWorld().getChunk(chunkX, chunkZ));
+      }
+    }
+    await this.networkSession.sendNetworkChunkPublisher(VANILLA_DEFAULT_SPAWN_RADIUS, savedChunks);
+    const getUniqueChunks = (sendList) => {
+      const xSet = /* @__PURE__ */ new Set();
+      const zSet = /* @__PURE__ */ new Set();
+      for (const coord of sendList) {
+        xSet.add(coord.x);
+        zSet.add(coord.z);
+      }
+      return Math.floor((xSet.size + zSet.size) / 2);
+    };
+    for (let i = 0; i < getUniqueChunks(savedChunks); ++i) {
+      await this.networkSession.sendNetworkChunkPublisher(VANILLA_DEFAULT_SPAWN_RADIUS, []);
+    }
+    for await (const chunk of sendQueue) {
+      await this.networkSession.sendChunk(chunk);
+    }
+  }
+  /**
+   * Change the player's current world.
+   *
+   * @param world - the new world
+   */
+  async setWorld(world) {
+    const dim0 = new ChangeDimensionPacket();
+    dim0.dimension = 0;
+    dim0.position = this;
+    dim0.respawn = false;
+    const dim1 = new ChangeDimensionPacket();
+    dim1.dimension = 1;
+    dim1.position = new Vector3(0, 0, 0);
+    dim1.respawn = false;
+    await this.networkSession.getConnection().sendDataPacket(dim0);
+    await this.networkSession.sendPlayStatus(PlayStatusType.PlayerSpawn);
+    await this.networkSession.getConnection().sendDataPacket(dim1);
+    await this.networkSession.sendPlayStatus(PlayStatusType.PlayerSpawn);
+    await this.getWorld().removeEntity(this);
+    await world.addEntity(this);
+    await super.setWorld.bind(this)(world);
+    await this.setPosition(new Vector3(0, 0, 0));
+    for (let x = -3; x < 3; x++) {
+      for (let z = -3; z < 3; z++) {
+        const pk = new LevelChunkPacket();
+        pk.clientSubChunkRequestsEnabled = false;
+        pk.chunkX = x;
+        pk.chunkZ = z;
+        pk.data = Buffer.from("");
+        pk.subChunkCount = 0;
+        await this.networkSession.getConnection().sendDataPacket(pk);
+      }
+    }
+    await this.networkSession.getConnection().sendDataPacket(dim1);
+    await this.networkSession.sendPlayStatus(PlayStatusType.PlayerSpawn);
+    await this.networkSession.getConnection().sendDataPacket(dim0);
+    await this.networkSession.sendPlayStatus(PlayStatusType.PlayerSpawn);
+    this.currentChunk = null;
+    await this.networkSession.clearChunks();
+    await this.networkSession.needNewChunks();
+    await this.onEnable();
+    await this.networkSession.sendPlayStatus(PlayStatusType.PlayerSpawn);
+  }
+  isOnline() {
+    return this.connected;
+  }
+  async update(tick) {
+    await super.update.bind(this)(tick);
+    await this.networkSession.update(tick);
+    if (tick % (20 * 5 * 60 * 1) === 0) {
+      await this.networkSession.sendTime(tick);
+    }
+    for (const chunk of this.chunkSendQueue) {
+      await this.networkSession.sendNetworkChunkPublisher(this.viewDistance || VANILLA_DEFAULT_SPAWN_RADIUS, []);
+      await this.networkSession.sendChunk(chunk);
+      this.chunkSendQueue.delete(chunk);
+    }
+  }
+  async kick(reason = "unknown reason") {
+    this.getServer().getLogger()?.verbose(`Player with id §b${this.getRuntimeId()}§r was kicked: ${reason}`, "Player/kick");
+    await this.networkSession.kick(reason);
+  }
+  async sendSettings() {
+  }
+  // Return all the players in the same chunk,.
+  // TODO: move to world
+  getPlayersInChunk() {
+    return this.getServer().getSessionManager().getAllPlayers().filter((player) => player.getCurrentChunk() === this.getCurrentChunk());
+  }
+  // TODO: these
+  async sendSpawn() {
+  }
+  async sendDespawn() {
+  }
+  /**
+   * Send a chat message to the client.
+   * @param message - the message
+   */
+  async sendMessage(message, type = TextType.Raw, parameters = [], needsTranslation = false) {
+    await this.networkSession.sendMessage(message, "", parameters, needsTranslation, type);
+  }
+  /**
+   * Send a toast notification (like Xbox Live notifications)
+   * @param title - the toast title
+   * @param body - the toast body
+   */
+  async sendToast(title, body) {
+    await this.networkSession.sendToast(title, body);
+  }
+  async setGamemode(mode) {
+    const event = new PlayerSetGamemodeEvent(this, mode);
+    this.getServer().getEventManager().post(["playerSetGamemode", event]);
+    if (event.isCancelled())
+      return;
+    this.gamemode = event.getGamemode();
+    await this.networkSession.sendGamemode(this.gamemode);
+    if (this.gamemode === Gamemode.Creative || this.gamemode === Gamemode.Spectator)
+      this.allowFight = true;
+    else {
+      this.allowFight = false;
+      await this.setFlying(false);
+    }
+    await this.sendSettings();
+  }
+  getGamemode() {
+    return Gamemode.getGamemodeName(this.gamemode).toLowerCase();
+  }
+  getNetworkSession() {
+    return this.networkSession;
+  }
+  getAddress() {
+    return this.address;
+  }
+  getName() {
+    return this.username.name;
+  }
+  getFormattedUsername() {
+    return `${this.username.prefix}${this.username.name}${this.username.suffix}`;
+  }
+  getPermissions() {
+    return this.permissions;
+  }
+  getUUID() {
+    if (!this.uuid)
+      throw new Error("uuid is missing!");
+    return this.uuid;
+  }
+  getXUID() {
+    if (!this.xuid)
+      throw new Error("xuid is missing!");
+    return this.xuid;
+  }
+  getFormManager() {
+    return this.forms;
+  }
+  getWindows() {
+    return this.windows;
+  }
+  getAllowFlight() {
+    return this.allowFight;
+  }
+  isPlayer() {
+    return true;
+  }
+  /**
+   * Check if the `Player` is an operator.
+   *
+   * @returns `true` if this player is an operator otherwise `false`.
+   */
+  isOp() {
+    return this.getServer().getPermissionManager().isOp(this.getName());
+  }
+  /**
+   * Check if the `Player` is sprinting.
+   *
+   * @returns `true` if this player is sprinting otherwise `false`.
+   */
+  isSprinting() {
+    return this.sprinting;
+  }
+  async setSprinting(sprinting) {
+    if (sprinting === this.isSprinting())
+      return;
+    const event = new PlayerToggleSprintEvent(this, sprinting);
+    this.getServer().getEventManager().post(["playerToggleSprint", event]);
+    if (event.isCancelled())
+      return;
+    this.sprinting = event.getIsSprinting();
+    this.setDataFlag(MetadataFlag.INDEX, MetadataFlag.SPRINTING, this.isSprinting(), FlagType.BYTE);
+    await this.networkSession.sendMetadata();
+  }
+  isFlying() {
+    return this.flying;
+  }
+  async setFlying(flying) {
+    if (flying === this.isFlying())
+      return;
+    if (!this.getAllowFlight()) {
+      this.flying = false;
+      return;
+    }
+    const event = new PlayerToggleFlightEvent(this, flying);
+    this.getServer().getEventManager().post(["playerToggleFlight", event]);
+    if (event.isCancelled())
+      return;
+    this.flying = event.getIsFlying();
+    await this.sendSettings();
+  }
+  isSneaking() {
+    return this.sneaking;
+  }
+  async setSneaking(val) {
+    this.sneaking = val;
+    await this.sendSettings();
+  }
+  isOnGround() {
+    return this.onGround;
+  }
+  async setOnGround(val) {
+    if (val === this.onGround)
+      return;
+    this.onGround = val;
+  }
+  /**
+   * Set the position.
+   *
+   * @remarks
+   * This will notify the player's client about the position change.
+   *
+   * @param position - The position
+   * @param type - The movement type
+   */
+  async setPosition(position, type = MovementType.Normal) {
+    await this.setX(position.getX());
+    await this.setY(position.getY());
+    await this.setZ(position.getZ());
+    await this.networkSession.broadcastMove(this, type);
+  }
+  setCurrentChunk(chunk) {
+    if (this.currentChunk === chunk)
+      return;
+    this.currentChunk = chunk;
+  }
+  getCurrentChunk() {
+    return this.currentChunk;
+  }
+}
+
+class ClientConnection extends MinecraftSession {
+  playerSession = null;
+  hasCompression = false;
+  constructor(session, logger) {
+    super(session, logger);
+  }
+  /**
+   * @internal
+   *
+   * @param server - the server instance
+   * @param player - the player instance
+   * @returns the new player session
+   */
+  initPlayerConnection(server, player) {
+    assert(this.playerSession === null, "Player session was already created");
+    this.playerSession = new PlayerSession(server, this, player);
+    return this.playerSession;
+  }
+  disconnect(reason = "disconnect.disconnected", hideReason = true) {
+    const packet = new DisconnectPacket();
+    packet.skipMessage = hideReason;
+    packet.message = reason;
+    void this.sendDataPacket(packet);
+    this.rakSession.disconnect();
+  }
+  getPlayerSession() {
+    return this.playerSession;
+  }
+  getRakNetSession() {
+    return this.rakSession;
+  }
+}
+
+class PacketRegistry {
+  server;
+  packets = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  constructor(server) {
+    this.server = server;
+  }
+  async onEnable() {
+    await this.registerPackets();
+    await this.registerHandlers();
+  }
+  async onDisable() {
+    this.handlers.clear();
+    this.packets.clear();
+  }
+  /**
+   * Register a packet.
+   * @param packet - the packet.
+   */
+  registerPacket(packet) {
+    if (this.packets.has(packet.NetID))
+      throw new Error(
+        `Packet ${packet.name} is trying to use id ${packet.NetID.toString(16)} which already exists!`
+      );
+    this.packets.set(packet.NetID, packet);
+    this.server.getLogger()?.debug(`Packet with id §b${packet.name}§r registered`, "PacketRegistry/registerPacket");
+  }
+  /**
+   * Get a packet by it's network ID.
+   * @param id - the NetID.
+   */
+  getPacket(id) {
+    if (!this.packets.has(id))
+      throw new Error(`Invalid packet with id ${id}!`);
+    return this.packets.get(id);
+  }
+  /**
+   * Remove a packet from the registry.
+   * @param id - the NetID.
+   */
+  removePacket(id) {
+    this.packets.delete(id);
+  }
+  registerHandler(id, handler) {
+    if (this.handlers.has(id))
+      throw new Error(`Handler with id ${id} already exists!`);
+    this.handlers.set(id, handler);
+    this.server.getLogger()?.debug(`Handler with id §b${handler.constructor.name}§r registered`, "PacketRegistry/registerHandler");
+  }
+  getHandler(id) {
+    if (!this.handlers.has(id))
+      throw new Error(`Invalid handler with id ${id.toString(16)}!`);
+    return this.handlers.get(id);
+  }
+  /**
+   * Merge two handlers.
+   * This is useful if you want to extend a handler without actually replacing it.
+   *
+   * @param handler - the first handler, executed first.
+   * @param handler2 - the second handler.
+   */
+  appendHandler(handler, handler2) {
+    const res = new class Handler {
+      async handle(packet, server, session) {
+        await handler.handle(packet, server, session);
+        await handler2.handle(packet, server, session);
+      }
+    }();
+    return res;
+  }
+  /**
+   * Remove a handler from the registry.
+   * @param id - the handler id.
+   */
+  removeHandler(id) {
+    this.handlers.delete(id);
+  }
+  /**
+   * Dynamically register all packets exported by './Protocol'.
+   */
+  async registerPackets() {
+    const timer = new Timer();
+    Object.entries(Packets).filter(([, value]) => value.name !== "DataPacket" && value.name !== "BatchPacket").map(([, value]) => this.registerPacket(value));
+    this.server.getLogger()?.verbose(
+      `Registered §b${this.packets.size}§r of §b${Array.from(Object.keys(Identifiers)).length - 2}§r packet(s) (took ${timer.stop()} ms)!`,
+      "PacketRegistry/registerPackets"
+    );
+  }
+  /**
+   * Dynamically register all handlers exported by './Handlers'.
+   */
+  async registerHandlers() {
+    const timer = new Timer();
+    Object.entries(Handlers).map(([, value]) => this.registerHandler(value.NetID, new value()));
+    this.server.getLogger()?.verbose(
+      `Registered §b${this.handlers.size}§r packet handler(s) (took ${timer.stop()} ms)!`,
+      "PacketRegistry/registerHandlers"
+    );
+  }
+  /**
+   * Get all packets from the registry.
+   */
+  getPackets() {
+    return this.packets;
+  }
+  /**
+   * Get all handlers from the registry.
+   */
+  getHandlers() {
+    return this.handlers;
+  }
+}
+
+class Server {
+  version;
+  raknet;
+  logger;
+  config;
+  tps = 20;
+  console;
+  eventManager = new EventManager();
+  packetRegistry;
+  sessionManager = new SessionManager();
+  pluginManager;
+  commandManager;
+  worldManager;
+  itemManager;
+  blockManager;
+  queryManager;
+  chatManager;
+  permissionManager;
+  banManager;
+  stopping = false;
+  tickerTimer;
+  static MINECRAFT_TICK_TIME_MS = 1e3 / 20;
+  /**
+   * @deprecated
+   */
+  static instance;
+  constructor({ logger, config, version }) {
+    const advertisedVersion = Identifiers.MinecraftVersions.length <= 1 ? `§ev${Identifiers.MinecraftVersions.at(0)}§r` : `§ev${Identifiers.MinecraftVersions.at(0)}§r-§ev${Identifiers.MinecraftVersions.at(-1)}§r`;
+    logger?.info(
+      `Starting JSPrismarine server version §ev${version}§r for Minecraft: Bedrock Edition ${advertisedVersion} (protocol version §e${Identifiers.Protocol}§r)`,
+      "Server"
+    );
+    this.version = version;
+    this.logger = logger;
+    this.config = config;
+    this.console = new Console(this);
+    this.packetRegistry = new PacketRegistry(this);
+    this.itemManager = new ItemManager(this);
+    this.blockManager = new BlockManager(this);
+    this.worldManager = new WorldManager(this);
+    this.commandManager = new CommandManager(this);
+    this.pluginManager = new PluginManager(this);
+    this.queryManager = new QueryManager(this);
+    this.chatManager = new ChatManager(this);
+    this.permissionManager = new PermissionManager(this);
+    this.banManager = new BanManager(this);
+    Server.instance = this;
+  }
+  async onEnable() {
+    this.config.onEnable();
+    await this.logger.onEnable();
+    await this.permissionManager.onEnable();
+    await this.pluginManager.onEnable();
+    await this.banManager.onEnable();
+    await this.itemManager.onEnable();
+    await this.blockManager.onEnable();
+    await this.commandManager.onEnable();
+  }
+  async onDisable() {
+    await this.commandManager.onDisable();
+    await this.blockManager.onDisable();
+    await this.itemManager.onDisable();
+    await this.banManager.onDisable();
+    await this.pluginManager.onDisable();
+    await this.permissionManager.onDisable();
+    await this.packetRegistry.onDisable();
+    this.config.onDisable();
+    await this.logger.onDisable();
+  }
+  async reload() {
+    await this.onDisable();
+    await this.onEnable();
+  }
+  async bootstrap(serverIp = "0.0.0.0", port = 19132) {
+    await this.onEnable();
+    BlockMappings.initMappings();
+    await this.worldManager.onEnable();
+    await this.packetRegistry.onEnable();
+    this.raknet = new RakNetListener(this.getConfig().getMaxPlayers(), false);
+    this.raknet.start(serverIp, port);
+    this.raknet.on("openConnection", async (session) => {
+      const event = new RaknetConnectEvent(session);
+      await this.eventManager.emit("raknetConnect", event);
+      if (event.isCancelled()) {
+        session.disconnect();
+        return;
+      }
+      const token = session.getAddress().toToken();
+      if (this.sessionManager.has(token)) {
+        this.logger.error(
+          `Another client with token (${token}) is already connected!`,
+          "Server/listen/openConnection"
+        );
+        session.disconnect("Already connected from another location");
+        return;
+      }
+      const timer = new Timer();
+      this.logger.debug(`${token} is attempting to connect`, "Server/listen/openConnection");
+      this.sessionManager.add(token, new ClientConnection(session, this.logger));
+      this.logger.verbose(`New connection handling took ${timer.stop()} ms`, "Server/listen/openConnection");
+    });
+    this.raknet.on("closeConnection", async (inetAddr, reason) => {
+      const event = new RaknetDisconnectEvent(inetAddr, reason);
+      await this.eventManager.emit("raknetDisconnect", event);
+      const time = Date.now();
+      const token = inetAddr.toToken();
+      try {
+        const player = this.sessionManager.getPlayer(token);
+        await player.getNetworkSession().removeFromPlayerList();
+        for (const onlinePlayer of this.sessionManager.getAllPlayers()) {
+          await player.getNetworkSession().sendDespawn(onlinePlayer);
+        }
+        if (player.getName()) {
+          const event2 = new ChatEvent(
+            new Chat(
+              this.console,
+              `§e%multiplayer.player.left`,
+              [player.getName()],
+              true,
+              "*.everyone",
+              ChatType.TRANSLATION
+            )
+          );
+          await this.eventManager.emit("chat", event2);
+        }
+        await player.onDisable();
+        await player.getWorld().removeEntity(player);
+        this.sessionManager.remove(token);
+      } catch (error) {
+        this.logger.debug(
+          `Cannot remove connection from non-existing player (${token})`,
+          "Server/listen/raknetDisconnect"
+        );
+        this.logger.error(error, "Server/listen/raknetDisconnect");
+      }
+      this.logger.debug(`${token} disconnected due to ${reason}`, "Server/listen/raknetDisconnect");
+      this.logger.debug(
+        `Player destruction took about ${Date.now() - time} ms`,
+        "Server/listen/raknetDisconnect"
+      );
+    });
+    this.raknet.on("encapsulated", async (packet, inetAddr) => {
+      const event = new RaknetEncapsulatedPacketEvent(inetAddr, packet);
+      await this.eventManager.emit("raknetEncapsulatedPacket", event);
+      let connection;
+      if ((connection = this.sessionManager.get(inetAddr.toToken()) ?? null) === null) {
+        this.logger.error(`Got a packet from a closed connection (${inetAddr.toToken()})`);
+        return;
+      }
+      try {
+        const batched = new BatchPacket(packet.content);
+        batched.compressed = connection.hasCompression;
+        for (const buf of await batched.asyncDecode()) {
+          const pid = buf[0];
+          if (!this.packetRegistry.getPackets().has(pid)) {
+            this.logger.warn(
+              `Packet 0x${pid.toString(16)} isn't implemented`,
+              "Server/listen/raknetEncapsulatedPacket"
+            );
+            continue;
+          }
+          const packet2 = new (this.packetRegistry.getPackets().get(pid))(buf);
+          try {
+            packet2.decode();
+          } catch (error) {
+            this.logger.error(error);
+            this.logger.error(
+              `Error while decoding packet: ${packet2.constructor.name}: ${error}`,
+              "Server/listen/raknetEncapsulatedPacket"
+            );
+            continue;
+          }
+          try {
+            const handler = this.packetRegistry.getHandler(pid);
+            this.logger.silly(
+              `Received §b${packet2.constructor.name}§r packet`,
+              "Server/listen/raknetEncapsulatedPacket"
+            );
+            await handler.handle(packet2, this, connection.getPlayerSession() ?? connection);
+          } catch (error) {
+            this.logger.error(
+              `Handler error ${packet2.constructor.name}-handler: (${error})`,
+              "Server/listen/raknetEncapsulatedPacket"
+            );
+            this.logger.error(error, "Server/listen/raknetEncapsulatedPacket");
+          }
+        }
+      } catch (error) {
+        this.logger.error(error, "Server/listen/raknetEncapsulatedPacket");
+      }
+    });
+    this.raknet.on("raw", async (buffer, inetAddr) => {
+      try {
+        await this.queryManager.onRaw(buffer, inetAddr);
+      } catch (error) {
+        this.logger.error(error, "Server/listen/raw");
+        this.logger.verbose(`QueryManager failed with error: ${error}`, "Server/listen/raw");
+      }
+    });
+    let tickCount = 0;
+    const tick = () => setTimeout(() => {
+      const event = new TickEvent(tickCount);
+      void this.eventManager.emit("tick", event);
+      for (const world of this.worldManager.getWorlds()) {
+        void world.update(event.getTick());
+      }
+      ++tickCount;
+      tick();
+    }, Server.MINECRAFT_TICK_TIME_MS);
+    this.tickerTimer = tick();
+    this.tickerTimer.unref();
+    this.logger.info(`JSPrismarine is now listening on port §b${port}`, "Server/listen");
+  }
+  /**
+   * Kills the server asynchronously.
+   */
+  async shutdown(options) {
+    if (this.stopping)
+      return;
+    this.stopping = true;
+    this.logger.info("Stopping server", "Server/kill");
+    await this.console.onDisable();
+    clearInterval(this.tickerTimer);
+    try {
+      for (const player of this.sessionManager.getAllPlayers()) {
+        await player.kick("Server closed.");
+      }
+      if (!options?.withoutSaving)
+        await this.worldManager.save();
+      await this.worldManager.onDisable();
+      await this.onDisable();
+      this.raknet.kill();
+      process.exit(options?.crash ? 1 : 0);
+    } catch (error) {
+      this.logger.error(error, "Server/kill");
+      process.exit(1);
+    }
+  }
+  async broadcastPacket(dataPacket) {
+    for (const onlinePlayer of this.sessionManager.getAllPlayers()) {
+      await onlinePlayer.getNetworkSession().getConnection().sendDataPacket(dataPacket);
+    }
+  }
+  getVersion() {
+    return this.version;
+  }
+  getIdentifiers() {
+    return Identifiers;
+  }
+  /**
+   * Returns the query manager
+   */
+  getQueryManager() {
+    return this.queryManager;
+  }
+  /**
+   * Returns the command manager
+   */
+  getCommandManager() {
+    return this.commandManager;
+  }
+  /**
+   * Returns the player manager
+   */
+  getSessionManager() {
+    return this.sessionManager;
+  }
+  /**
+   * Returns the world manager
+   */
+  getWorldManager() {
+    return this.worldManager;
+  }
+  /**
+   * Returns the item manager
+   */
+  getItemManager() {
+    return this.itemManager;
+  }
+  /**
+   * Returns the block manager
+   */
+  getBlockManager() {
+    return this.blockManager;
+  }
+  /**
+   * Returns the logger
+   */
+  getLogger() {
+    return this.logger;
+  }
+  /**
+   * Returns the packet registry
+   */
+  getPacketRegistry() {
+    return this.packetRegistry;
+  }
+  /**
+   * Returns the raknet instance
+   */
+  getRaknet() {
+    return this.raknet;
+  }
+  /**
+   * Returns the plugin manager
+   */
+  getPluginManager() {
+    return this.pluginManager;
+  }
+  /**
+   * Returns the event manager
+   */
+  getEventManager() {
+    return this.eventManager;
+  }
+  /**
+   * Returns the chat manager
+   */
+  getChatManager() {
+    return this.chatManager;
+  }
+  /**
+   * Returns the config
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Returns the console instance
+   */
+  getConsole() {
+    return this.console;
+  }
+  /**
+   * Returns the permission manager
+   */
+  getPermissionManager() {
+    return this.permissionManager;
+  }
+  /**
+   * Returns the ban manager
+   */
+  getBanManager() {
+    return this.banManager;
+  }
+  /**
+   * Returns this Prismarine instance
+   */
+  getServer() {
+    return this;
+  }
+  /**
+   * Returns the current TPS
+   */
+  getTPS() {
+    return this.tps;
+  }
+}
+
+export { BooleanArgumentCommand as B, CommandArgument as C, Handlers as H, LoginHandler as L, Player as P, Server as S, VANILLA_DEFAULT_SPAWN_RADIUS as V, PlayerSession as a, CommandArgumentCommand as b, CommandArgumentEntity as c, CommandArgumentGamemode as d, CommandArgumentMob as e, CommandArgumentPosition as f, PlayerArgumentCommand as g, ClientConnection as h, PacketRegistry as i };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"Server-DAXmO2Rm.js","sources":["../src/command/CommandArguments.ts","../src/network/handler/LoginHandler.ts","../src/network/PlayerSession.ts","../src/Player.ts","../src/network/ClientConnection.ts","../src/network/PacketRegistry.ts","../src/Server.ts"],"sourcesContent":["import * as Entities from '../entity/Entities';\n\nimport type { CommandContext, StringReader } from '@jsprismarine/brigadier';\nimport { Suggestions } from '@jsprismarine/brigadier';\nimport CommandParameter, { CommandParameterFlags, CommandParameterType } from '../network/type/CommandParameter';\n\nimport CommandEnum from '../network/type/CommandEnum';\nimport Gamemode from '../world/Gamemode';\nimport ParseTargetSelector from '../utils/ParseTargetSelector';\nimport ParseTildeCaretNotation from '../utils/ParseTildeCaretNotation';\nimport type Player from '../Player';\nimport { Server } from '../';\nimport Vector3 from '../math/Vector3';\n\nexport abstract class CommandArgument {\n    public getReadableType(): string {\n        return '';\n    }\n    public getParameters(): Set<CommandParameter> | undefined {\n        return new Set();\n    }\n}\n\nexport class CommandArgumentGamemode implements CommandArgument {\n    private name: string;\n    private optional: boolean;\n    private flags: CommandParameterFlags;\n    private postfix: string | null;\n\n    public constructor(data?: { name?: string; optional?: boolean; flags?: CommandParameterFlags; postfix?: string }) {\n        this.name = data?.name ?? 'gameMode';\n        this.optional = data?.optional ?? false;\n        this.flags = data?.flags ?? CommandParameterFlags.NONE;\n        this.postfix = data?.postfix ?? null;\n    }\n\n    public parse(reader: StringReader, _context: CommandContext<Player>) {\n        const gm = reader.readString();\n\n        Gamemode.getGamemodeId(gm);\n        return gm;\n    }\n    public async listSuggestions(_context: any, _builder: any) {\n        // TODO\n        return Suggestions.empty();\n    }\n    public getExamples() {\n        return ['survival', 'creative', 'adventure', 'spectator'];\n    }\n\n    public getReadableType(): string {\n        return this.name;\n    }\n\n    public getParameters(): Set<CommandParameter> {\n        const gameModeEnum = new CommandEnum();\n        gameModeEnum.enumName = 'GameMode';\n\n        // TODO: this should be dynamic\n        gameModeEnum.enumValues = ['survival', 'creative', 'adventure', 'spectator'];\n        return new Set([\n            new CommandParameter({\n                paramName: this.name,\n                isOptional: this.optional,\n                flags: this.flags,\n                enum: gameModeEnum,\n                postfix: this.postfix\n            })\n        ]);\n    }\n}\n\nexport class CommandArgumentMob implements CommandArgument {\n    private name: string;\n    private optional: boolean;\n    private flags: CommandParameterFlags;\n    private postfix: string | null;\n\n    public constructor(data?: { name?: string; optional?: boolean; flags?: CommandParameterFlags; postfix?: string }) {\n        this.name = data?.name ?? 'entityType';\n        this.optional = data?.optional ?? false;\n        this.flags = data?.flags ?? CommandParameterFlags.NONE;\n        this.postfix = data?.postfix ?? null;\n    }\n\n    public parse(reader: StringReader, _context: CommandContext<Player>) {\n        let str = '';\n        while (true) {\n            if (!reader.canRead()) break;\n\n            const pos = reader.getCursor();\n            const char = reader.read();\n            if (char === ' ') {\n                reader.setCursor(pos);\n                break;\n            }\n\n            str += char;\n        }\n\n        return str;\n    }\n    public async listSuggestions(_context: any, _builder: any) {\n        // TODO\n        return Suggestions.empty();\n    }\n    public getExamples() {\n        return [];\n    }\n\n    public getReadableType(): string {\n        return this.name;\n    }\n\n    public getParameters(): Set<CommandParameter> {\n        const entityTypeEnum = new CommandEnum();\n        entityTypeEnum.enumName = 'EntityType';\n        entityTypeEnum.enumValues = Object.entries(Entities).map(([, entity]) => entity.MOB_ID);\n        return new Set([\n            new CommandParameter({\n                paramName: this.name,\n                isOptional: this.optional,\n                flags: this.flags,\n                enum: entityTypeEnum,\n                postfix: this.postfix\n            })\n        ]);\n    }\n}\n\nexport class CommandArgumentEntity implements CommandArgument {\n    private name: string;\n    private optional: boolean;\n    private flags: CommandParameterFlags;\n    private postfix: string | null;\n\n    public constructor(data?: { name?: string; optional?: boolean; flags?: CommandParameterFlags; postfix?: string }) {\n        this.name = data?.name ?? 'target';\n        this.optional = data?.optional ?? false;\n        this.flags = data?.flags ?? CommandParameterFlags.NONE;\n        this.postfix = data?.postfix ?? null;\n    }\n\n    public parse(reader: StringReader, context: CommandContext<Player>) {\n        let player = '';\n        while (true) {\n            if (!reader.canRead()) break;\n\n            const pos = reader.getCursor();\n            const char = reader.read();\n            if (char === ' ') {\n                reader.setCursor(pos);\n                break;\n            }\n\n            player += char;\n        }\n\n        if (player.startsWith('@'))\n            try {\n                return ParseTargetSelector({\n                    input: player,\n                    source: context.getSource(),\n                    entities: context.getSource().getWorld().getEntities()\n                });\n            } catch (error: unknown) {\n                if (!(error as any).message.includes('no results')) throw error;\n                return [];\n            }\n\n        return [context.getSource().getServer().getSessionManager().getPlayerByExactName(player)]; // TODO: by name not exact\n    }\n\n    public getReadableType(): string {\n        return this.name;\n    }\n\n    public getParameters(): Set<CommandParameter> {\n        return new Set([\n            new CommandParameter({\n                paramName: this.name,\n                paramType: CommandParameterType.Target,\n                isOptional: this.optional,\n                flags: this.flags,\n                postfix: this.postfix\n            })\n        ]);\n    }\n}\n\nexport class CommandArgumentPosition extends Vector3 implements CommandArgument {\n    private name: string;\n    private optional: boolean;\n    private flags: CommandParameterFlags;\n    private postfix: string | null;\n\n    public constructor(data?: { name?: string; optional?: boolean; flags?: CommandParameterFlags; postfix?: string }) {\n        super();\n        this.name = data?.name ?? 'position';\n        this.optional = data?.optional ?? false;\n        this.flags = data?.flags ?? CommandParameterFlags.NONE;\n        this.postfix = data?.postfix ?? null;\n    }\n\n    public parse(reader: StringReader, context: CommandContext<Player>) {\n        const getPos = () => {\n            let pos = '';\n            while (true) {\n                if (!reader.canRead()) break;\n\n                const cursor = reader.getCursor();\n                const char = reader.read();\n                if (char === ' ') {\n                    reader.setCursor(cursor);\n                    break;\n                }\n\n                pos += char;\n            }\n            return pos;\n        };\n\n        this.setX(\n            ParseTildeCaretNotation({\n                input: getPos(),\n                source: context.getSource(),\n                type: 'x'\n            })\n        );\n        reader.skip();\n        this.setY(\n            ParseTildeCaretNotation({\n                input: getPos(),\n                source: context.getSource(),\n                type: 'y'\n            })\n        );\n        reader.skip();\n        this.setZ(\n            ParseTildeCaretNotation({\n                input: getPos(),\n                source: context.getSource(),\n                type: 'z'\n            })\n        );\n        return this;\n    }\n\n    public getReadableType(): string {\n        return this.name;\n    }\n\n    public getParameters(): Set<CommandParameter> {\n        return new Set([\n            new CommandParameter({\n                paramName: this.name,\n                paramType: CommandParameterType.Position,\n                isOptional: this.optional,\n                flags: this.flags,\n                postfix: this.postfix\n            })\n        ]);\n    }\n}\n\nexport class CommandArgumentCommand implements CommandArgument {\n    private name: string;\n    private optional: boolean;\n    private flags: CommandParameterFlags;\n    private postfix: string | null;\n\n    public constructor(data?: { name?: string; optional?: boolean; flags?: CommandParameterFlags; postfix?: string }) {\n        this.name = data?.name ?? 'command';\n        this.optional = data?.optional ?? false;\n        this.flags = data?.flags ?? CommandParameterFlags.NONE;\n        this.postfix = data?.postfix ?? null;\n    }\n\n    public parse(reader: StringReader, _context: CommandContext<Player>) {\n        const command = reader.readString();\n\n        return command;\n    }\n\n    public getReadableType(): string {\n        return this.name;\n    }\n\n    public getParameters(): Set<CommandParameter> {\n        return new Set([\n            new CommandParameter({\n                paramName: this.name,\n                paramType: CommandParameterType.Position,\n                isOptional: this.optional,\n                flags: this.flags,\n                postfix: this.postfix\n            })\n        ]);\n    }\n}\n\nexport class BooleanArgumentCommand implements CommandArgument {\n    private name: string;\n    private optional: boolean;\n    private flags: CommandParameterFlags;\n    private postfix: string | null;\n\n    public constructor(data?: { name?: string; optional?: boolean; flags?: CommandParameterFlags; postfix?: string }) {\n        this.name = data?.name ?? 'boolean';\n        this.optional = data?.optional ?? false;\n        this.flags = data?.flags ?? CommandParameterFlags.NONE;\n        this.postfix = data?.postfix ?? null;\n    }\n\n    public parse(reader: StringReader, _context: CommandContext<Player>) {\n        const boolean = reader.readString();\n\n        if (boolean === 'true') return true;\n\n        return false;\n    }\n\n    public getReadableType(): string {\n        return this.name;\n    }\n\n    public getParameters(): Set<CommandParameter> {\n        const booleanEnum = new CommandEnum();\n        booleanEnum.enumName = 'Boolean';\n        booleanEnum.enumValues = ['true', 'false'];\n        return new Set([\n            new CommandParameter({\n                paramName: this.name,\n                isOptional: this.optional,\n                enum: booleanEnum,\n                flags: this.flags,\n                postfix: this.postfix\n            })\n        ]);\n    }\n}\n\nexport class PlayerArgumentCommand implements CommandArgument {\n    private name: string;\n    private optional: boolean;\n    private flags: CommandParameterFlags;\n    private postfix: string | null;\n\n    public constructor(data?: { name?: string; optional?: boolean; flags?: CommandParameterFlags; postfix?: string }) {\n        this.name = data?.name ?? 'player';\n        this.optional = data?.optional ?? false;\n        this.flags = data?.flags ?? CommandParameterFlags.NONE;\n        this.postfix = data?.postfix ?? null;\n    }\n\n    public parse(reader: StringReader, _context: CommandContext<Player>) {\n        const player = reader.readString();\n        return player;\n    }\n\n    public getReadableType(): string {\n        return this.name;\n    }\n\n    public getParameters(): Set<CommandParameter> {\n        const playerEnum = new CommandEnum();\n        playerEnum.enumName = 'Player';\n        try {\n            playerEnum.enumValues = Server.instance\n                .getSessionManager()\n                .getAllPlayers()\n                .map((player) => player.getName());\n        } catch {\n            playerEnum.enumValues = [];\n        }\n\n        return new Set([\n            new CommandParameter({\n                paramName: this.name,\n                isOptional: this.optional,\n                enum: playerEnum,\n                flags: this.flags,\n                postfix: this.postfix\n            })\n        ]);\n    }\n}\n","import type ClientConnection from '../ClientConnection';\nimport Identifiers from '../Identifiers';\nimport type LoginPacket from '../packet/LoginPacket';\nimport { PlayStatusPacket } from '../Packets';\nimport PlayStatusType from '../type/PlayStatusType';\nimport { Player } from '../../';\nimport type PreLoginPacketHandler from './PreLoginPacketHandler';\nimport ResourcePacksInfoPacket from '../packet/ResourcePacksInfoPacket';\nimport type Server from '../../Server';\n\nexport default class LoginHandler implements PreLoginPacketHandler<LoginPacket> {\n    public static NetID = Identifiers.LoginPacket;\n\n    public async handle(packet: LoginPacket, server: Server, connection: ClientConnection): Promise<void> {\n        // TODO: Check if player count >= max players\n\n        const playStatus = new PlayStatusPacket();\n\n        // Kick client if has newer / older client version\n        if (packet.protocol !== Identifiers.Protocol) {\n            playStatus.status =\n                packet.protocol < Identifiers.Protocol\n                    ? PlayStatusType.LoginFailedClient\n                    : PlayStatusType.LoginFailedServer;\n            await connection.sendDataPacket(playStatus, true);\n            return;\n        }\n\n        // Kick the player if their username is invalid\n        if (!packet.displayName) {\n            connection.disconnect('Invalid username!', false);\n            return;\n        }\n\n        // TODO: get rid of this trash\n        const world = server.getWorldManager().getDefaultWorld()!;\n        const player = new Player(connection, world, server);\n        player.username.name = packet.displayName;\n        player.locale = packet.languageCode;\n        player.randomId = packet.clientRandomId;\n        player.uuid = packet.identity;\n        player.xuid = packet.XUID;\n        player.skin = packet.skin;\n        player.device = packet.device;\n\n        // Player with same name is already online\n        try {\n            const oldPlayer = server.getSessionManager().getPlayerByExactName(packet.displayName);\n            await oldPlayer.kick('Logged in from another location');\n        } catch {}\n\n        if (!player.xuid && server.getConfig().getOnlineMode()) {\n            await player.kick('Server is in online-mode!');\n            return;\n        }\n\n        await player.onEnable();\n\n        // TODO: encryption handshake\n\n        const reason = server.getBanManager().isBanned(player);\n        if (reason !== false) {\n            await player.kick(`You have been banned${reason ? ` for reason: ${reason}` : ''}!`);\n            return;\n        }\n\n        // Update the player connection to be recognized as a connected player\n        const session = connection.initPlayerConnection(server, player);\n        await session.sendPlayStatus(PlayStatusType.LoginSuccess);\n\n        await world.addEntity(player);\n\n        // Finalize connection handshake\n        const resourcePacksInfo = new ResourcePacksInfoPacket();\n        resourcePacksInfo.resourcePackRequired = false;\n        resourcePacksInfo.forceServerPacksEnabled = false;\n        resourcePacksInfo.hasScripts = false;\n        resourcePacksInfo.hasAddonPacks = false;\n        await connection.sendDataPacket(resourcePacksInfo, true);\n    }\n}\n","import { CommandArgumentEntity, CommandArgumentGamemode } from '../command/CommandArguments';\nimport CommandParameter, { CommandParameterType } from './type/CommandParameter';\nimport type { ChunkCoord } from './packet/NetworkChunkPublisherUpdatePacket';\nimport NetworkChunkPublisherUpdatePacket from './packet/NetworkChunkPublisherUpdatePacket';\nimport PlayerListPacket, { PlayerListAction, PlayerListEntry } from './packet/PlayerListPacket';\nimport UpdateAbilitiesPacket, {\n    AbilityLayer,\n    AbilityLayerFlag,\n    AbilityLayerType\n} from './packet/UpdateAbilitiesPacket';\n\nimport AddPlayerPacket from './packet/AddPlayerPacket';\nimport type { Attribute } from '../entity/Attribute';\nimport AvailableCommandsPacket from './packet/AvailableCommandsPacket';\nimport { BatchPacket } from './Packets';\nimport BlockPosition from '../world/BlockPosition';\nimport Chunk from '../world/chunk/Chunk';\nimport ChunkRadiusUpdatedPacket from './packet/ChunkRadiusUpdatedPacket';\nimport type ClientConnection from './ClientConnection';\nimport CommandData from './type/CommandData';\nimport CommandEnum from './type/CommandEnum';\nimport CoordinateUtils from '../world/CoordinateUtils';\nimport CreativeContentPacket from './packet/CreativeContentPacket';\nimport DisconnectPacket from './packet/DisconnectPacket';\nimport Gamemode from '../world/Gamemode';\nimport Heap from 'heap';\nimport type IForm from '../form/IForm';\nimport InventoryContentPacket from './packet/InventoryContentPacket';\nimport Item from '../item/Item';\nimport LevelChunkPacket from './packet/LevelChunkPacket';\nimport MobEquipmentPacket from './packet/MobEquipmentPacket';\nimport ModalFormRequestPacket from './packet/ModalFormRequestPacket';\nimport MovePlayerPacket from './packet/MovePlayerPacket';\nimport MovementType from './type/MovementType';\nimport PermissionType from './type/PermissionType';\nimport PlayStatusPacket from './packet/PlayStatusPacket';\nimport type Player from '../Player';\nimport PlayerPermissionType from './type/PlayerPermissionType';\nimport RemoveActorPacket from './packet/RemoveActorPacket';\nimport type Server from '../Server';\nimport SetActorDataPacket from './packet/SetActorDataPacket';\nimport SetPlayerGameTypePacket from './packet/SetPlayerGameTypePacket';\nimport SetTimePacket from './packet/SetTimePacket';\nimport TextPacket from './packet/TextPacket';\nimport TextType from './type/TextType';\nimport ToastRequestPacket from './packet/ToastRequestPacket';\nimport UUID from '../utils/UUID';\nimport UpdateAdventureSettingsPacket from './packet/UpdateAdventureSettingsPacket';\nimport UpdateAttributesPacket from './packet/UpdateAttributesPacket';\nimport { WindowIds } from '../inventory/WindowManager';\nimport { creativeitems } from '@jsprismarine/bedrock-data';\n\nexport default class PlayerSession {\n    private connection: ClientConnection;\n    private readonly server: Server;\n    private player: Player;\n\n    private readonly chunkSendQueue: Chunk[] = [];\n    private readonly loadedChunks: Set<bigint> = new Set();\n    private readonly loadingChunks: Set<bigint> = new Set();\n\n    public constructor(server: Server, connection: ClientConnection, player: Player) {\n        this.server = server;\n        this.connection = connection;\n        this.player = player;\n    }\n\n    public async update(_tick: number): Promise<void> {\n        if (this.chunkSendQueue.length > 0) {\n            const chunksToSend = this.chunkSendQueue.splice(0, Math.min(this.chunkSendQueue.length, 50));\n            const batch = new BatchPacket();\n            for (const chunk of chunksToSend) {\n                const pk = new LevelChunkPacket();\n                pk.chunkX = chunk.getX();\n                pk.chunkZ = chunk.getZ();\n                pk.clientSubChunkRequestsEnabled = false;\n                pk.subChunkCount = chunk.getTopEmpty() + 4;\n                pk.data = chunk.networkSerialize();\n                batch.addPacket(pk);\n\n                const hash = Chunk.packXZ(chunk.getX(), chunk.getZ());\n                this.loadedChunks.add(hash);\n                this.loadingChunks.delete(hash);\n            }\n            this.connection.sendBatch(batch, false);\n        }\n\n        this.player.viewDistance && (await this.needNewChunks());\n    }\n\n    /**\n     * Notify a client about change(s) to the adventure settings.\n     *\n     * @param player - The client-controlled entity\n     */\n    public async sendSettings(player?: Player): Promise<void> {\n        const target = player ?? this.player;\n\n        const pk = new UpdateAdventureSettingsPacket();\n        pk.worldImmutable = target.gamemode === Gamemode.Spectator;\n        pk.noAttackingPlayers = target.gamemode === Gamemode.Spectator;\n        pk.noAttackingMobs = target.gamemode === Gamemode.Spectator;\n        pk.autoJump = true; // TODO: grab this info elsewhere\n        pk.showNameTags = true; // TODO: player may be able to hide them\n\n        await this.connection.sendDataPacket(pk);\n    }\n\n    public async sendAbilities(player?: Player): Promise<void> {\n        const target = player ?? this.player;\n\n        const pk = new UpdateAbilitiesPacket();\n        pk.commandPermission = target.isOp() ? PermissionType.Operator : PermissionType.Normal;\n        pk.playerPermission = target.isOp() ? PlayerPermissionType.Operator : PlayerPermissionType.Member;\n        pk.targetActorUniqueId = target.getRuntimeId();\n\n        const mainLayer = new AbilityLayer();\n        mainLayer.layerType = AbilityLayerType.BASE;\n        mainLayer.layerFlags = new Map([\n            [AbilityLayerFlag.FLY_SPEED, true],\n            [AbilityLayerFlag.WALK_SPEED, true],\n            [AbilityLayerFlag.MAY_FLY, target.getAllowFlight()],\n            [AbilityLayerFlag.FLYING, target.isFlying()],\n            [AbilityLayerFlag.NO_CLIP, target.gamemode === Gamemode.Spectator],\n            [AbilityLayerFlag.OPERATOR_COMMANDS, target.isOp()],\n            [AbilityLayerFlag.TELEPORT, target.isOp()],\n            [AbilityLayerFlag.INVULNERABLE, target.gamemode === Gamemode.Creative],\n            [AbilityLayerFlag.MUTED, false],\n            [AbilityLayerFlag.WORLD_BUILDER, false],\n            [AbilityLayerFlag.INSTABUILD, target.gamemode === Gamemode.Creative],\n            [AbilityLayerFlag.LIGHTNING, false],\n            [AbilityLayerFlag.BUILD, target.gamemode !== Gamemode.Spectator],\n            [AbilityLayerFlag.MINE, target.gamemode !== Gamemode.Spectator],\n            [AbilityLayerFlag.DOORS_AND_SWITCHES, target.gamemode !== Gamemode.Spectator],\n            [AbilityLayerFlag.OPEN_CONTAINERS, target.gamemode !== Gamemode.Spectator],\n            [AbilityLayerFlag.ATTACK_PLAYERS, target.gamemode !== Gamemode.Spectator],\n            [AbilityLayerFlag.ATTACK_MOBS, target.gamemode !== Gamemode.Spectator]\n        ]);\n        mainLayer.flySpeed = 0.05;\n        mainLayer.walkSpeed = 0.1;\n\n        pk.abilityLayers = [mainLayer];\n\n        await this.connection.sendDataPacket(pk);\n    }\n\n    public async needNewChunks(forceResend = false, dist?: number): Promise<void> {\n        const currentXChunk = CoordinateUtils.fromBlockToChunk(this.player.getX());\n        const currentZChunk = CoordinateUtils.fromBlockToChunk(this.player.getZ());\n\n        const viewDistance = this.player.viewDistance || dist || 0;\n\n        const chunksToSendHeap = new Heap((a: number[], b: number[]) => {\n            const distXFirst = Math.abs(a[0]! - currentXChunk);\n            const distXSecond = Math.abs(b[0]! - currentXChunk);\n\n            const distZFirst = Math.abs(a[1]! - currentZChunk);\n            const distZSecond = Math.abs(b[1]! - currentZChunk);\n\n            return distXFirst + distZFirst > distXSecond + distZSecond ? 1 : -1;\n        });\n\n        for (let sendXChunk = -viewDistance; sendXChunk <= viewDistance; sendXChunk++) {\n            for (let sendZChunk = -viewDistance; sendZChunk <= viewDistance; sendZChunk++) {\n                if (sendXChunk * sendXChunk + sendZChunk * sendZChunk > viewDistance * viewDistance) continue; // early exit if chunk is outside of view distance\n                const newChunk = [currentXChunk + sendXChunk, currentZChunk + sendZChunk];\n                const hash = Chunk.packXZ(newChunk[0]!, newChunk[1]!);\n\n                if (forceResend) {\n                    chunksToSendHeap.push(newChunk);\n                } else if (!this.loadedChunks.has(hash) && !this.loadingChunks.has(hash)) {\n                    chunksToSendHeap.push(newChunk);\n                }\n            }\n        }\n\n        while (chunksToSendHeap.size() > 0) {\n            const closestChunk = chunksToSendHeap.pop()!;\n            const hash = Chunk.packXZ(closestChunk[0]!, closestChunk[1]!);\n            if (forceResend) {\n                if (!this.loadedChunks.has(hash) && !this.loadingChunks.has(hash)) {\n                    this.loadingChunks.add(hash);\n                    await this.requestChunk(closestChunk[0]!, closestChunk[1]!);\n                } else {\n                    const loadedChunk = await this.player.getWorld().getChunk(closestChunk[0]!, closestChunk[1]!);\n                    await this.sendChunk(loadedChunk);\n                }\n            } else {\n                this.loadingChunks.add(hash);\n                await this.requestChunk(closestChunk[0]!, closestChunk[1]!);\n            }\n        }\n\n        let unloaded = false;\n\n        for (const hash of this.loadedChunks) {\n            const [x, z] = Chunk.unpackXZ(hash);\n\n            if (Math.abs(x! - currentXChunk) > viewDistance || Math.abs(z! - currentZChunk) > viewDistance) {\n                unloaded = true;\n                this.loadedChunks.delete(hash);\n            }\n        }\n\n        for (const hash of this.loadingChunks) {\n            const [x, z] = Chunk.unpackXZ(hash);\n\n            if (Math.abs(x! - currentXChunk) > viewDistance || Math.abs(z! - currentZChunk) > viewDistance) {\n                this.loadingChunks.delete(hash);\n            }\n        }\n\n        if (!unloaded && this.chunkSendQueue.length !== 0) {\n            await this.sendNetworkChunkPublisher(dist ?? viewDistance, []);\n        }\n    }\n\n    public async requestChunk(x: number, z: number): Promise<void> {\n        const chunk = await this.player.getWorld().getChunk(x, z);\n        this.chunkSendQueue.push(chunk);\n    }\n\n    /**\n     * Clear the currently loaded and loading chunks.\n     *\n     * @remarks\n     * Usually used for changing dimension, world, etc.\n     */\n    public async clearChunks() {\n        this.loadedChunks.clear();\n        this.loadingChunks.clear();\n    }\n\n    public async sendInventory(): Promise<void> {\n        const pk = new InventoryContentPacket();\n        pk.items = this.player.getInventory().getItems(true);\n        pk.windowId = WindowIds.INVENTORY; // Inventory window\n        await this.connection.sendDataPacket(pk);\n        await this.sendHandItem(this.player.getInventory().getItemInHand());\n\n        /* TODO: not working..\n        pk = new InventoryContentPacket();\n        pk.items = []; // TODO\n        pk.windowId = 78; // ArmorInventory window\n        this.sendDataPacket(pk);\n\n        https://github.com/NiclasOlofsson/MiNET/blob/master/src/MiNET/MiNET/Player.cs#L1736\n        // TODO: documentate about\n        0x7c (ui content)\n        0x77 (off hand)\n        */\n    }\n\n    public async sendCreativeContents(empty = false): Promise<void> {\n        const pk = new CreativeContentPacket();\n        if (empty) {\n            await this.connection.sendDataPacket(pk);\n            return;\n        }\n\n        const entries = [\n            ...this.player.getServer().getBlockManager().getBlocks(),\n            ...this.player.getServer().getItemManager().getItems()\n        ];\n\n        // Sort based on PmmP Bedrock-data\n        creativeitems.forEach((item: any) => {\n            pk.items.push(\n                ...entries\n                    .filter((entry: any) => {\n                        return entry.meta === (item.damage ?? 0) && entry.getId() === item.id;\n                    })\n                    .map(\n                        (entry) =>\n                            new Item({\n                                id: entry.getId(),\n                                name: entry.getName(),\n                                meta: entry.meta\n                            })\n                    )\n            );\n        });\n\n        await this.connection.sendDataPacket(pk);\n    }\n\n    /**\n     * Sets the item in the player hand.\n     *\n     * @param item - The entity.\n     */\n    public async sendHandItem(item: Item): Promise<void> {\n        const pk = new MobEquipmentPacket();\n        pk.runtimeEntityId = this.player.getRuntimeId();\n        pk.item = item;\n        pk.inventorySlot = this.player.getInventory().getHandSlotIndex();\n        pk.hotbarSlot = this.player.getInventory().getHandSlotIndex();\n        pk.windowId = 0; // Inventory ID\n        await this.connection.sendDataPacket(pk);\n    }\n\n    public async sendForm(form: IForm): Promise<void> {\n        const id = this.player.getFormManager().addForm(form);\n        const pk = new ModalFormRequestPacket();\n        pk.formId = id;\n        pk.formData = form.jsonSerialize();\n        await this.connection.sendDataPacket(pk);\n    }\n\n    /**\n     * Set the client's current tick.\n     *\n     * @param tick - The tick\n     */\n    public async sendTime(tick: number): Promise<void> {\n        const pk = new SetTimePacket();\n        pk.time = tick;\n        await this.connection.sendDataPacket(pk);\n    }\n\n    /**\n     * Set the client's gamemode.\n     *\n     * @param gamemode - the numeric gamemode ID\n     */\n    public async sendGamemode(gamemode: number): Promise<void> {\n        const pk = new SetPlayerGameTypePacket();\n        pk.gamemode = gamemode;\n        await this.connection.sendDataPacket(pk);\n    }\n\n    public async sendNetworkChunkPublisher(distance: number, savedChunks: ChunkCoord[]): Promise<void> {\n        const pk = new NetworkChunkPublisherUpdatePacket();\n        pk.position = BlockPosition.fromVector3(this.player);\n        pk.radius = distance << 4;\n        pk.savedChunks = savedChunks;\n        await this.connection.sendDataPacket(pk);\n    }\n\n    public async sendAvailableCommands(): Promise<void> {\n        const pk = new AvailableCommandsPacket();\n\n        this.server\n            .getCommandManager()\n            .getCommandsList()\n            .forEach((command) => {\n                const commandClass = Array.from(this.server.getCommandManager().getCommands().values()).find(\n                    (cmd) => cmd.id.split(':')[1] === command[0]\n                );\n\n                if (!commandClass) {\n                    this.player\n                        .getServer()\n                        .getLogger()\n                        ?.warn(`Can't find corresponding command class for \"${command[0]}\"`);\n                    return;\n                }\n\n                if (!this.player.getServer().getPermissionManager().can(this.player).execute(commandClass.permission))\n                    return;\n\n                const cmd = new CommandData();\n                cmd.commandName = command[0];\n                cmd.commandDescription = commandClass.description;\n                if (commandClass.aliases!.length > 0) {\n                    const cmdAliases = new CommandEnum();\n                    cmdAliases.enumName = `${command[0]}Aliases`;\n                    cmdAliases.enumValues = commandClass.aliases!.concat(command[0]);\n                    cmd.aliases = cmdAliases;\n                }\n\n                command[2].forEach((arg, index) => {\n                    const parameters = arg\n                        .map((parameter) => {\n                            const parameters = parameter.getParameters();\n                            if (parameters) return Array.from(parameters.values());\n\n                            if (parameter instanceof CommandArgumentEntity)\n                                return [\n                                    new CommandParameter({\n                                        paramName: 'target',\n                                        paramType: CommandParameterType.Target\n                                    })\n                                ];\n                            if (parameter instanceof CommandArgumentGamemode)\n                                return [\n                                    new CommandParameter({\n                                        paramName: 'gamemode',\n                                        paramType: CommandParameterType.String\n                                    })\n                                ];\n                            if (parameter.constructor.name === 'StringArgumentType')\n                                return [\n                                    new CommandParameter({\n                                        paramName: 'value',\n                                        paramType: CommandParameterType.String\n                                    })\n                                ];\n                            if (parameter.constructor.name === 'IntegerArgumentType')\n                                return [\n                                    new CommandParameter({\n                                        paramName: 'number',\n                                        paramType: CommandParameterType.Int\n                                    })\n                                ];\n\n                            this.server.getLogger()?.warn(`Invalid parameter ${parameter.constructor.name}`);\n                            return [\n                                new CommandParameter({\n                                    paramName: 'value',\n                                    paramType: CommandParameterType.String\n                                })\n                            ];\n                        })\n                        .flat();\n                    cmd.overloads[index] = parameters;\n                });\n                pk.commandData.push(cmd);\n            });\n        const playerEnum = new CommandEnum();\n        playerEnum.enumName = 'Player';\n        playerEnum.enumValues = this.player\n            .getServer()\n            .getSessionManager()\n            .getAllPlayers()\n            .map((player) => player.getName());\n        pk.softEnums = [playerEnum];\n        // TODO: update commands\n        // await this.getConnection().sendDataPacket(pk);\n    }\n\n    /**\n     * Set the client's maximum view distance.\n     *\n     * @param distance - The view distance\n     */\n    public async setViewDistance(distance: number): Promise<void> {\n        this.player.viewDistance = distance;\n        const pk = new ChunkRadiusUpdatedPacket();\n        pk.radius = distance;\n        await this.connection.sendDataPacket(pk);\n    }\n\n    public async sendAttributes(attributes: Attribute[]): Promise<void> {\n        const pk = new UpdateAttributesPacket();\n        pk.runtimeEntityId = this.player.getRuntimeId();\n        pk.attributes = attributes.length > 0 ? attributes : this.player.getAttributeManager().getAttributes();\n        pk.tick = BigInt(0); // TODO\n        await this.connection.sendDataPacket(pk);\n    }\n\n    public async sendMetadata(): Promise<void> {\n        const pk = new SetActorDataPacket();\n        pk.runtimeEntityId = this.player.getRuntimeId();\n        pk.metadata = this.player.getMetadataManager();\n        pk.tick = BigInt(0); // TODO\n        await this.connection.sendDataPacket(pk);\n    }\n\n    /**\n     * Send a chat message to the client.\n     *\n     * @remarks\n     * Refactor this completely.\n     *\n     * @param message - The message\n     * @param xuid - The source xuid\n     * @param parameters -\n     * @param needsTranslation - If the TextType requires translation\n     * @param type - The text type\n     */\n    public async sendMessage(\n        message: string,\n        xuid = '',\n        parameters: string[] = [],\n        needsTranslation = false,\n        type = TextType.Raw\n    ): Promise<void> {\n        if (!message) throw new Error('A message is required');\n\n        const pk = new TextPacket();\n        pk.type = type;\n        pk.sourceName = '';\n        pk.message = message;\n        pk.needsTranslation = needsTranslation;\n        pk.xuid = xuid;\n        pk.platformChatId = ''; // TODO\n        pk.parameters = parameters;\n        await this.connection.sendDataPacket(pk);\n    }\n\n    public async sendToast(title: string, body: string): Promise<void> {\n        if (!title) throw new Error('A toast title is required');\n        if (!body) throw new Error('A toast body is required.');\n\n        const pk = new ToastRequestPacket();\n        pk.title = title;\n        pk.body = body;\n\n        await this.connection.sendDataPacket(pk);\n    }\n\n    public async sendChunk(chunk: Chunk): Promise<void> {\n        const pk = new LevelChunkPacket();\n        pk.chunkX = chunk.getX();\n        pk.chunkZ = chunk.getZ();\n        pk.clientSubChunkRequestsEnabled = false;\n        pk.subChunkCount = chunk.getTopEmpty() + 4; // add the useless layers hack\n        pk.data = chunk.networkSerialize();\n        await this.connection.sendDataPacket(pk, undefined, false);\n\n        const hash = Chunk.packXZ(chunk.getX(), chunk.getZ());\n        this.loadedChunks.add(hash);\n        this.loadingChunks.delete(hash);\n    }\n\n    /**\n     * Broadcast the movement to a defined player\n     */\n    public async broadcastMove(player: Player, mode = MovementType.Normal): Promise<void> {\n        const pk = new MovePlayerPacket();\n        pk.runtimeEntityId = player.getRuntimeId();\n\n        pk.positionX = player.getX();\n        pk.positionY = player.getY();\n        pk.positionZ = player.getZ();\n\n        pk.pitch = player.pitch;\n        pk.yaw = player.yaw;\n        pk.headYaw = player.headYaw;\n\n        pk.mode = mode;\n\n        pk.onGround = player.isOnGround();\n\n        // TODO\n        if (mode === MovementType.Teleport) {\n            pk.teleportCause = 0;\n            pk.teleportItemId = 0;\n        }\n\n        pk.ridingEntityRuntimeId = BigInt(0);\n        pk.tick = BigInt(0); // TODO\n        await this.connection.sendDataPacket(pk);\n    }\n\n    /**\n     * Adds the client to the player list of every player inside\n     * the server and also to the player itself.\n     */\n    public async addToPlayerList(): Promise<void> {\n        const playerList = new PlayerListPacket();\n        playerList.type = PlayerListAction.TYPE_ADD;\n\n        const entry = new PlayerListEntry({\n            uuid: UUID.fromString(this.player.uuid),\n            uniqueEntityid: this.player.getRuntimeId(),\n            name: this.player.getName(),\n            xuid: this.player.xuid,\n            platformChatId: '', // TODO: read this value from Login\n            buildPlatform: this.player.device ? this.player.device.os : -1,\n            skin: this.player.skin!,\n            isTeacher: false, // TODO: figure out where to read teacher and host\n            isHost: false\n        });\n        playerList.entries.push(entry);\n\n        await this.server.broadcastPacket(playerList);\n        this.server.getSessionManager().getPlayerList().set(this.player.uuid, entry);\n    }\n\n    /**\n     * Removes a player from other players list\n     */\n    public async removeFromPlayerList(): Promise<void> {\n        if (!this.player.uuid) return;\n\n        const pk = new PlayerListPacket();\n        pk.type = PlayerListAction.TYPE_REMOVE;\n\n        const entry = new PlayerListEntry({\n            uuid: UUID.fromString(this.player.getUUID())\n        });\n        pk.entries.push(entry);\n\n        this.server.getSessionManager().getPlayerList().delete(this.player.uuid);\n\n        await Promise.all(\n            this.server\n                .getSessionManager()\n                .getAllPlayers()\n                .map(async (player) => player.getNetworkSession().getConnection().sendDataPacket(pk))\n        );\n    }\n\n    /**\n     * Sends the full player list to the player.\n     */\n    public async sendPlayerList(): Promise<void> {\n        const playerList = new PlayerListPacket();\n        playerList.type = PlayerListAction.TYPE_ADD;\n        playerList.entries = Array.from(this.server.getSessionManager().getPlayerList().values());\n        await this.connection.sendDataPacket(playerList);\n    }\n\n    /**\n     * Spawn the player for another player\n     *\n     * @param player - the player to send the AddPlayerPacket to\n     */\n    public async sendSpawn(player: Player): Promise<void> {\n        if (!player.getUUID()) {\n            this.server.getLogger()?.error(`UUID for player ${player.getName()} is undefined`);\n            return;\n        }\n\n        const pk = new AddPlayerPacket();\n        pk.uuid = UUID.fromString(this.player.getUUID()); // TODO: temp solution\n        pk.runtimeEntityId = this.player.getRuntimeId();\n        pk.name = this.player.getName();\n\n        pk.positionX = this.player.getX();\n        pk.positionY = this.player.getY();\n        pk.positionZ = this.player.getZ();\n\n        // TODO: motion\n        pk.motionX = 0;\n        pk.motionY = 0;\n        pk.motionZ = 0;\n\n        pk.pitch = this.player.pitch;\n        pk.yaw = this.player.yaw;\n        pk.headYaw = this.player.headYaw;\n\n        pk.item = this.player.getInventory().getItemInHand();\n\n        pk.deviceId = this.player.device?.id ?? '';\n        pk.metadata = this.player.getMetadataManager();\n        await player.getNetworkSession().getConnection().sendDataPacket(pk);\n        // TODO: await this.sendSettings(player);\n    }\n\n    /**\n     * Despawn the player entity from another player\n     */\n    public async sendDespawn(player: Player): Promise<void> {\n        const pk = new RemoveActorPacket();\n        pk.uniqueEntityId = this.player.getRuntimeId(); // We use runtime as unique\n        await player.getNetworkSession().getConnection().sendDataPacket(pk);\n    }\n\n    public async sendPlayStatus(status: number): Promise<void> {\n        const pk = new PlayStatusPacket();\n        pk.status = status;\n        await this.connection.sendDataPacket(pk, true);\n    }\n\n    public async kick(reason = 'unknown reason'): Promise<void> {\n        const pk = new DisconnectPacket();\n        pk.skipMessage = false;\n        pk.message = reason;\n        await this.connection.sendDataPacket(pk, true);\n    }\n\n    public getConnection(): ClientConnection {\n        return this.connection;\n    }\n\n    public getPlayer(): Player {\n        return this.player;\n    }\n}\n","import { ChangeDimensionPacket, LevelChunkPacket } from './network/Packets';\nimport { FlagType, MetadataFlag } from './entity/Metadata';\nimport type ChatEvent from './events/chat/ChatEvent';\nimport type Chunk from './world/chunk/Chunk';\nimport type { ChunkCoord } from './network/packet/NetworkChunkPublisherUpdatePacket';\nimport type ClientConnection from './network/ClientConnection';\nimport ContainerEntry from './inventory/ContainerEntry';\nimport CoordinateUtils from './world/CoordinateUtils';\nimport type Device from './utils/Device';\nimport FormManager from './form/FormManager';\nimport Gamemode from './world/Gamemode';\nimport Human from './entity/Human';\nimport type { InetAddress } from '@jsprismarine/raknet';\nimport MovementType from './network/type/MovementType';\nimport PlayStatusType from './network/type/PlayStatusType';\nimport PlayerSession from './network/PlayerSession';\nimport PlayerSetGamemodeEvent from './events/player/PlayerSetGamemodeEvent';\nimport PlayerToggleFlightEvent from './events/player/PlayerToggleFlightEvent';\nimport PlayerToggleSprintEvent from './events/player/PlayerToggleSprintEvent';\nimport type Skin from './utils/skin/Skin';\nimport TextType from './network/type/TextType';\nimport Timer from './utils/Timer';\nimport Vector3 from './math/Vector3';\nimport WindowManager from './inventory/WindowManager';\nimport type World from './world/World';\n\nimport type Server from './Server';\n\n// Default spawn view distance used in vanilla\nexport const VANILLA_DEFAULT_SPAWN_RADIUS = 4;\n\nexport default class Player extends Human {\n    private readonly address: InetAddress;\n    private readonly networkSession: PlayerSession;\n    private permissions: string[];\n\n    // Only used for metrics\n    private joinTimer = new Timer();\n\n    // TODO: finish implementation\n    private readonly windows: WindowManager;\n\n    private connected = false;\n    public username = {\n        prefix: '<',\n        suffix: '>',\n        name: ''\n    };\n\n    public locale = '';\n    public randomId = 0;\n\n    public uuid = '';\n    public xuid = '';\n    public skin: Skin | null = null;\n\n    public viewDistance = 0;\n    public gamemode = 0;\n\n    public pitch = 0;\n    public yaw = 0;\n    public headYaw = 0;\n\n    private onGround = false;\n    private sprinting = false;\n    private flying = false;\n    private sneaking = false;\n    private allowFight = false;\n\n    public platformChatId = '';\n\n    public device: Device | null = null;\n\n    public cacheSupport = false;\n\n    public readonly chunkSendQueue = new Set<Chunk>();\n    public currentChunk: bigint | null = null;\n\n    private readonly forms: FormManager;\n\n    private chatHandler: (event: ChatEvent) => void;\n\n    /**\n     * Player's constructor.\n     */\n    public constructor(connection: ClientConnection, world: World, server: Server) {\n        super(world, server);\n        this.address = connection.getRakNetSession().getAddress();\n        this.networkSession = new PlayerSession(server, connection, this);\n        this.windows = new WindowManager();\n        this.forms = new FormManager();\n        this.permissions = [];\n        this.joinTimer.reset();\n\n        // TODO: remove this mess :/\n        this.chatHandler = async (evt: ChatEvent) => {\n            if (evt.isCancelled()) return;\n\n            // TODO: proper channel system\n            if (\n                evt.getChat().getChannel() === '*.everyone' ||\n                (evt.getChat().getChannel() === '*.ops' && this.isOp()) ||\n                evt.getChat().getChannel() === `*.player.${this.getName()}`\n            )\n                await this.sendMessage(\n                    evt.getChat().getMessage(),\n                    evt.getChat().getType() as number as TextType,\n                    evt.getChat().getParameters(),\n                    evt.getChat().isNeedsTranslation()\n                );\n        };\n\n        server.getEventManager().on('chat', this.chatHandler);\n    }\n\n    public async onEnable() {\n        this.permissions = await this.getServer().getPermissionManager().getPermissions(this);\n\n        const playerData = await this.getWorld().getPlayerData(this);\n\n        // void this.setGamemode(Gamemode.getGamemodeId(playerData.gamemode));\n        // TODO: calling this before the player is spawning will create an undefined behavior\n        // this function will send a SetPlayerGameType packet breaking the login sequence\n        // i'll keep this comment while it's broken\n        await this.setX(playerData.position.x);\n        await this.setY(playerData.position.y);\n        await this.setZ(playerData.position.z);\n        this.pitch = playerData.position.pitch;\n        this.yaw = playerData.position.yaw;\n\n        playerData.inventory.forEach((item) => {\n            const entry =\n                this.getServer().getItemManager().getItem(item.id) ||\n                this.getServer().getBlockManager().getBlock(item.id);\n\n            if (!entry) {\n                this.getServer().getLogger()?.warn(`Item/block with id ${item.id} is invalid`, 'Player/onEnable');\n                return;\n            }\n\n            this.getInventory().setItem(\n                item.position,\n                new ContainerEntry({\n                    item: entry,\n                    count: item.count\n                })\n            );\n        });\n\n        if (!this.connected)\n            this.getServer()\n                .getLogger()\n                ?.debug(`(Complete player creation took ${this.joinTimer.stop()} ms)`, 'Player/onEnable');\n        this.connected = true;\n    }\n\n    public async onDisable() {\n        if (this.connected && this.xuid) await this.getWorld().savePlayerData(this);\n        this.server.getEventManager().removeListener('chat', this.chatHandler);\n\n        this.connected = false;\n    }\n\n    /**\n     * Used to match vanilla behavior, will send chunks\n     * with an initial view radius of VANILLA_DEFAULT_SPAWN_RADIUS.\n     */\n    public async sendInitialSpawnChunks(): Promise<void> {\n        const minX = CoordinateUtils.fromBlockToChunk(this.x) - VANILLA_DEFAULT_SPAWN_RADIUS;\n        const minZ = CoordinateUtils.fromBlockToChunk(this.z) - VANILLA_DEFAULT_SPAWN_RADIUS;\n        const maxX = CoordinateUtils.fromBlockToChunk(this.x) + VANILLA_DEFAULT_SPAWN_RADIUS;\n        const maxZ = CoordinateUtils.fromBlockToChunk(this.z) + VANILLA_DEFAULT_SPAWN_RADIUS;\n\n        const savedChunks: ChunkCoord[] = [];\n        const sendQueue: Array<Promise<Chunk>> = [];\n        for (let chunkX = minX; chunkX <= maxX; ++chunkX) {\n            for (let chunkZ = minZ; chunkZ <= maxZ; ++chunkZ) {\n                // TODO: vanilla does not send all of them, but in a range\n                // for example it does send them from x => [-3; 3] and z => [-3; 2]\n                savedChunks.push({ x: chunkX, z: chunkZ });\n                sendQueue.push(this.getWorld().getChunk(chunkX, chunkZ));\n            }\n        }\n\n        await this.networkSession.sendNetworkChunkPublisher(VANILLA_DEFAULT_SPAWN_RADIUS, savedChunks);\n\n        const getUniqueChunks = (sendList: ChunkCoord[]) => {\n            const xSet = new Set<number>();\n            const zSet = new Set<number>();\n\n            for (const coord of sendList) {\n                xSet.add(coord.x);\n                zSet.add(coord.z);\n            }\n\n            return Math.floor((xSet.size + zSet.size) / 2);\n        };\n\n        for (let i = 0; i < getUniqueChunks(savedChunks); ++i) {\n            await this.networkSession.sendNetworkChunkPublisher(VANILLA_DEFAULT_SPAWN_RADIUS, []);\n        }\n\n        for await (const chunk of sendQueue) {\n            await this.networkSession.sendChunk(chunk);\n        }\n    }\n\n    /**\n     * Change the player's current world.\n     *\n     * @param world - the new world\n     */\n    public async setWorld(world: World) {\n        const dim0 = new ChangeDimensionPacket();\n        dim0.dimension = 0;\n        dim0.position = this;\n        dim0.respawn = false;\n\n        const dim1 = new ChangeDimensionPacket();\n        dim1.dimension = 1;\n        dim1.position = new Vector3(0, 0, 0); // TODO: load this properly\n        dim1.respawn = false;\n\n        await this.networkSession.getConnection().sendDataPacket(dim0);\n        await this.networkSession.sendPlayStatus(PlayStatusType.PlayerSpawn);\n        await this.networkSession.getConnection().sendDataPacket(dim1);\n        await this.networkSession.sendPlayStatus(PlayStatusType.PlayerSpawn);\n\n        await this.getWorld().removeEntity(this);\n        await world.addEntity(this);\n        await super.setWorld.bind(this)(world);\n\n        await this.setPosition(new Vector3(0, 0, 0));\n        for (let x = -3; x < 3; x++) {\n            for (let z = -3; z < 3; z++) {\n                const pk = new LevelChunkPacket();\n                pk.clientSubChunkRequestsEnabled = false;\n                pk.chunkX = x; // TODO\n                pk.chunkZ = z; // TODO\n                pk.data = Buffer.from('');\n                pk.subChunkCount = 0;\n                await this.networkSession.getConnection().sendDataPacket(pk);\n            }\n        }\n\n        await this.networkSession.getConnection().sendDataPacket(dim1);\n        await this.networkSession.sendPlayStatus(PlayStatusType.PlayerSpawn);\n        await this.networkSession.getConnection().sendDataPacket(dim0);\n        await this.networkSession.sendPlayStatus(PlayStatusType.PlayerSpawn);\n\n        this.currentChunk = null;\n        await this.networkSession.clearChunks();\n        await this.networkSession.needNewChunks();\n        await this.onEnable();\n        await this.networkSession.sendPlayStatus(PlayStatusType.PlayerSpawn);\n    }\n\n    public isOnline() {\n        return this.connected;\n    }\n\n    public async update(tick: number): Promise<void> {\n        // Call super method\n        await super.update.bind(this)(tick);\n        await this.networkSession.update(tick);\n\n        // TODO: get documentation about timings from vanilla\n        // 1 second / 20 = 1 tick, 20 * 5 = 1 second\n        // 1 second * 60 = 1 minute\n        if (tick % (20 * 5 * 60 * 1) === 0) {\n            await this.networkSession.sendTime(tick);\n        }\n\n        for (const chunk of this.chunkSendQueue) {\n            await this.networkSession.sendNetworkChunkPublisher(this.viewDistance || VANILLA_DEFAULT_SPAWN_RADIUS, []);\n            await this.networkSession.sendChunk(chunk);\n            this.chunkSendQueue.delete(chunk);\n        }\n    }\n\n    public async kick(reason = 'unknown reason'): Promise<void> {\n        this.getServer()\n            .getLogger()\n            ?.verbose(`Player with id §b${this.getRuntimeId()}§r was kicked: ${reason}`, 'Player/kick');\n        await this.networkSession.kick(reason);\n    }\n\n    public async sendSettings(): Promise<void> {\n        /* \n            TODO\n            await Promise.all(\n            this.getServer()\n                .getSessionManager()\n                .getAllPlayers()\n                .map(async (target) => {\n                    await target.getNetworkSession().sendSettings(this);\n                })\n        ); */\n    }\n\n    // Return all the players in the same chunk,.\n    // TODO: move to world\n    public getPlayersInChunk(): Player[] {\n        return this.getServer()\n            .getSessionManager()\n            .getAllPlayers()\n            .filter((player) => player.getCurrentChunk() === this.getCurrentChunk());\n    }\n\n    // TODO: these\n    public async sendSpawn() {}\n    public async sendDespawn() {}\n\n    /**\n     * Send a chat message to the client.\n     * @param message - the message\n     */\n    public async sendMessage(\n        message: string,\n        type: TextType = TextType.Raw,\n        parameters: string[] = [],\n        needsTranslation = false\n    ): Promise<void> {\n        // TODO: Do this properly like java edition,\n        // in other words, the message should be JSON formatted.\n        await this.networkSession.sendMessage(message, '', parameters, needsTranslation, type);\n    }\n\n    /**\n     * Send a toast notification (like Xbox Live notifications)\n     * @param title - the toast title\n     * @param body - the toast body\n     */\n    public async sendToast(title: string, body: string): Promise<void> {\n        await this.networkSession.sendToast(title, body);\n    }\n\n    public async setGamemode(mode: number): Promise<void> {\n        const event = new PlayerSetGamemodeEvent(this, mode);\n        this.getServer().getEventManager().post(['playerSetGamemode', event]);\n        if (event.isCancelled()) return;\n\n        this.gamemode = event.getGamemode();\n        await this.networkSession.sendGamemode(this.gamemode);\n\n        if (this.gamemode === Gamemode.Creative || this.gamemode === Gamemode.Spectator) this.allowFight = true;\n        else {\n            this.allowFight = false;\n            await this.setFlying(false);\n        }\n\n        await this.sendSettings();\n    }\n\n    public getGamemode(): string {\n        return Gamemode.getGamemodeName(this.gamemode).toLowerCase();\n    }\n\n    public getNetworkSession(): PlayerSession {\n        return this.networkSession;\n    }\n\n    public getAddress() {\n        return this.address;\n    }\n\n    public getName(): string {\n        return this.username.name;\n    }\n\n    public getFormattedUsername(): string {\n        return `${this.username.prefix}${this.username.name}${this.username.suffix}`;\n    }\n\n    public getPermissions(): string[] {\n        return this.permissions;\n    }\n\n    public getUUID(): string {\n        if (!this.uuid) throw new Error('uuid is missing!');\n\n        return this.uuid;\n    }\n\n    public getXUID(): string {\n        if (!this.xuid) throw new Error('xuid is missing!');\n\n        return this.xuid;\n    }\n\n    public getFormManager(): FormManager {\n        return this.forms;\n    }\n\n    public getWindows(): WindowManager {\n        return this.windows;\n    }\n\n    public getAllowFlight(): boolean {\n        return this.allowFight;\n    }\n\n    public isPlayer(): boolean {\n        return true;\n    }\n\n    /**\n     * Check if the `Player` is an operator.\n     *\n     * @returns `true` if this player is an operator otherwise `false`.\n     */\n    public isOp(): boolean {\n        return this.getServer().getPermissionManager().isOp(this.getName());\n    }\n\n    /**\n     * Check if the `Player` is sprinting.\n     *\n     * @returns `true` if this player is sprinting otherwise `false`.\n     */\n    public isSprinting() {\n        return this.sprinting;\n    }\n\n    public async setSprinting(sprinting: boolean) {\n        if (sprinting === this.isSprinting()) return;\n\n        const event = new PlayerToggleSprintEvent(this, sprinting);\n        this.getServer().getEventManager().post(['playerToggleSprint', event]);\n        if (event.isCancelled()) return;\n\n        this.sprinting = event.getIsSprinting();\n\n        // TODO: find a better way to put this\n        this.setDataFlag(MetadataFlag.INDEX, MetadataFlag.SPRINTING, this.isSprinting(), FlagType.BYTE);\n\n        await this.networkSession.sendMetadata();\n    }\n\n    public isFlying() {\n        return this.flying;\n    }\n\n    public async setFlying(flying: boolean) {\n        if (flying === this.isFlying()) return;\n        if (!this.getAllowFlight()) {\n            this.flying = false;\n            return;\n        }\n\n        const event = new PlayerToggleFlightEvent(this, flying);\n        this.getServer().getEventManager().post(['playerToggleFlight', event]);\n        if (event.isCancelled()) return;\n\n        this.flying = event.getIsFlying();\n        await this.sendSettings();\n    }\n\n    public isSneaking() {\n        return this.sneaking;\n    }\n\n    public async setSneaking(val: boolean) {\n        this.sneaking = val;\n        await this.sendSettings();\n    }\n\n    public isOnGround() {\n        return this.onGround;\n    }\n\n    public async setOnGround(val: boolean) {\n        if (val === this.onGround) return;\n\n        this.onGround = val;\n    }\n\n    /**\n     * Set the position.\n     *\n     * @remarks\n     * This will notify the player's client about the position change.\n     *\n     * @param position - The position\n     * @param type - The movement type\n     */\n    public async setPosition(position: Vector3, type: MovementType = MovementType.Normal) {\n        await this.setX(position.getX());\n        await this.setY(position.getY());\n        await this.setZ(position.getZ());\n        await this.networkSession.broadcastMove(this, type);\n    }\n\n    public setCurrentChunk(chunk: bigint) {\n        if (this.currentChunk === chunk) return;\n        this.currentChunk = chunk;\n    }\n\n    public getCurrentChunk() {\n        return this.currentChunk!;\n    }\n}\n","import type { Logger, Player, Server } from '../';\nimport { PlayerSession } from '../';\n\nimport { DisconnectPacket } from './Packets';\nimport MinecraftSession from './MinecraftSession';\nimport type { RakNetSession } from '@jsprismarine/raknet';\nimport assert from 'assert';\n\n/**\n * Handles the connection before the player creation itself, very helpful as\n * it helps to not waste resources in case the client trying to connect is simply\n * outdated or sends invalid data during the login handshake.\n */\nexport default class ClientConnection extends MinecraftSession {\n    private playerSession: PlayerSession | null = null;\n    public hasCompression = false;\n\n    public constructor(session: RakNetSession, logger?: Logger) {\n        super(session, logger);\n    }\n\n    /**\n     * @internal\n     *\n     * @param server - the server instance\n     * @param player - the player instance\n     * @returns the new player session\n     */\n    public initPlayerConnection(server: Server, player: Player): PlayerSession {\n        assert(this.playerSession === null, 'Player session was already created');\n\n        this.playerSession = new PlayerSession(server, this, player);\n        return this.playerSession;\n    }\n\n    public disconnect(reason = 'disconnect.disconnected', hideReason = true): void {\n        const packet = new DisconnectPacket();\n        packet.skipMessage = hideReason;\n        packet.message = reason;\n        void this.sendDataPacket(packet);\n\n        // Force RakNet to remove the session\n        // so we don't have to handle the dead session\n        this.rakSession.disconnect();\n    }\n\n    public getPlayerSession(): PlayerSession | null {\n        return this.playerSession;\n    }\n\n    public getRakNetSession(): RakNetSession {\n        return this.rakSession;\n    }\n}\n","import * as Handlers from './Handlers';\nimport * as Packets from './Packets';\n\nimport Identifiers from './Identifiers';\nimport type PacketHandler from './handler/PacketHandler';\nimport type { PlayerSession } from '../';\nimport type PreLoginPacketHandler from './handler/PreLoginPacketHandler';\nimport type Server from '../Server';\nimport Timer from '../utils/Timer';\n\nexport default class PacketRegistry {\n    private server: Server;\n    private readonly packets: Map<number, typeof Packets.DataPacket> = new Map();\n    private readonly handlers: Map<number, PacketHandler<any>> = new Map();\n\n    public constructor(server: Server) {\n        this.server = server;\n    }\n\n    public async onEnable() {\n        await this.registerPackets();\n        await this.registerHandlers();\n    }\n\n    public async onDisable() {\n        this.handlers.clear();\n        this.packets.clear();\n    }\n\n    /**\n     * Register a packet.\n     * @param packet - the packet.\n     */\n    public registerPacket(packet: typeof Packets.DataPacket): void {\n        if (this.packets.has(packet.NetID))\n            throw new Error(\n                `Packet ${packet.name} is trying to use id ${packet.NetID.toString(16)} which already exists!`\n            );\n\n        this.packets.set(packet.NetID, packet);\n        this.server.getLogger()?.debug(`Packet with id §b${packet.name}§r registered`, 'PacketRegistry/registerPacket');\n    }\n\n    /**\n     * Get a packet by it's network ID.\n     * @param id - the NetID.\n     */\n    public getPacket(id: number): any {\n        if (!this.packets.has(id)) throw new Error(`Invalid packet with id ${id}!`);\n\n        return this.packets.get(id)!;\n    }\n\n    /**\n     * Remove a packet from the registry.\n     * @param id - the NetID.\n     */\n    public removePacket(id: number): void {\n        this.packets.delete(id);\n    }\n\n    public registerHandler(id: number, handler: PacketHandler<any>): void {\n        if (this.handlers.has(id)) throw new Error(`Handler with id ${id} already exists!`);\n\n        this.handlers.set(id, handler);\n        this.server\n            .getLogger()\n            ?.debug(`Handler with id §b${handler.constructor.name}§r registered`, 'PacketRegistry/registerHandler');\n    }\n\n    public getHandler(id: number): PacketHandler<any> | PreLoginPacketHandler<any> {\n        if (!this.handlers.has(id)) throw new Error(`Invalid handler with id ${id.toString(16)}!`);\n\n        return this.handlers.get(id)!;\n    }\n\n    /**\n     * Merge two handlers.\n     * This is useful if you want to extend a handler without actually replacing it.\n     *\n     * @param handler - the first handler, executed first.\n     * @param handler2 - the second handler.\n     */\n    public appendHandler(handler: PacketHandler<any>, handler2: PacketHandler<any>): PacketHandler<any> {\n        const res = new (class Handler {\n            public async handle(packet: any, server: Server, session: PlayerSession) {\n                await handler.handle(packet, server, session);\n                await handler2.handle(packet, server, session);\n            }\n        })();\n\n        return res as PacketHandler<any>;\n    }\n\n    /**\n     * Remove a handler from the registry.\n     * @param id - the handler id.\n     */\n    public removeHandler(id: number): void {\n        this.handlers.delete(id);\n    }\n\n    /**\n     * Dynamically register all packets exported by './Protocol'.\n     */\n    private async registerPackets(): Promise<void> {\n        const timer = new Timer();\n\n        // Dynamically register packets\n        // We need to manually ignore DataPacket & BatchPacket\n        Object.entries(Packets)\n            .filter(([, value]) => value.name !== 'DataPacket' && value.name !== 'BatchPacket')\n            .map(([, value]) => this.registerPacket(value));\n\n        this.server\n            .getLogger()\n            ?.verbose(\n                `Registered §b${this.packets.size}§r of §b${\n                    Array.from(Object.keys(Identifiers)).length - 2\n                }§r packet(s) (took ${timer.stop()} ms)!`,\n                'PacketRegistry/registerPackets'\n            );\n    }\n\n    /**\n     * Dynamically register all handlers exported by './Handlers'.\n     */\n    private async registerHandlers(): Promise<void> {\n        const timer = new Timer();\n\n        // Dynamically register handlers\n        Object.entries(Handlers).map(([, value]) => this.registerHandler(value.NetID!, new (value as any)()));\n\n        this.server\n            .getLogger()\n            ?.verbose(\n                `Registered §b${this.handlers.size}§r packet handler(s) (took ${timer.stop()} ms)!`,\n                'PacketRegistry/registerHandlers'\n            );\n    }\n\n    /**\n     * Get all packets from the registry.\n     */\n    public getPackets() {\n        return this.packets;\n    }\n\n    /**\n     * Get all handlers from the registry.\n     */\n    public getHandlers() {\n        return this.handlers;\n    }\n}\n","import { RakNetListener } from '@jsprismarine/raknet';\nimport Chat, { ChatType } from './chat/Chat';\nimport BanManager from './ban/BanManager';\nimport BatchPacket from './network/packet/BatchPacket';\nimport BlockManager from './block/BlockManager';\nimport { BlockMappings } from './block/BlockMappings';\nimport ChatEvent from './events/chat/ChatEvent';\nimport ChatManager from './chat/ChatManager';\nimport ClientConnection from './network/ClientConnection';\nimport CommandManager from './command/CommandManager';\nimport Console from './Console';\nimport type { DataPacket } from './network/Packets';\nimport { EventManager } from './events/EventManager';\nimport Identifiers from './network/Identifiers';\nimport ItemManager from './item/ItemManager';\nimport PacketRegistry from './network/PacketRegistry';\nimport PermissionManager from './permission/PermissionManager';\nimport PluginManager from './plugin/PluginManager';\nimport QueryManager from './query/QueryManager';\nimport RaknetConnectEvent from './events/raknet/RaknetConnectEvent';\nimport RaknetDisconnectEvent from './events/raknet/RaknetDisconnectEvent';\nimport RaknetEncapsulatedPacketEvent from './events/raknet/RaknetEncapsulatedPacketEvent';\nimport SessionManager from './SessionManager';\nimport { TickEvent } from './events/Events';\nimport Timer from './utils/Timer';\nimport WorldManager from './world/WorldManager';\n\nimport type Config from './config/Config';\nimport type LoggerBuilder from './utils/Logger';\nimport type { RakNetSession, InetAddress } from '@jsprismarine/raknet';\n\nexport default class Server {\n    private version!: string;\n    private raknet!: RakNetListener;\n    private readonly logger: LoggerBuilder;\n    private readonly config: Config;\n    private tps = 20;\n    private readonly console: Console;\n    private readonly eventManager = new EventManager();\n    private readonly packetRegistry: PacketRegistry;\n    private readonly sessionManager = new SessionManager();\n    private readonly pluginManager: PluginManager;\n    private readonly commandManager: CommandManager;\n    private readonly worldManager: WorldManager;\n    private readonly itemManager: ItemManager;\n    private readonly blockManager: BlockManager;\n    private readonly queryManager: QueryManager;\n    private readonly chatManager: ChatManager;\n    private readonly permissionManager: PermissionManager;\n    private readonly banManager: BanManager;\n    private stopping = false;\n    private tickerTimer: NodeJS.Timeout | undefined;\n\n    private static readonly MINECRAFT_TICK_TIME_MS = 1000 / 20;\n\n    /**\n     * @deprecated\n     */\n    public static instance: Server;\n\n    public constructor({ logger, config, version }: { logger?: LoggerBuilder; config: Config; version: string }) {\n        const advertisedVersion =\n            Identifiers.MinecraftVersions.length <= 1\n                ? `§ev${Identifiers.MinecraftVersions.at(0)}§r`\n                : `§ev${Identifiers.MinecraftVersions.at(0)}§r-§ev${Identifiers.MinecraftVersions.at(-1)}§r`;\n\n        logger?.info(\n            `Starting JSPrismarine server version §ev${version}§r for Minecraft: Bedrock Edition ${advertisedVersion} (protocol version §e${Identifiers.Protocol}§r)`,\n            'Server'\n        );\n\n        this.version = version;\n        this.logger = logger!;\n        this.config = config;\n        this.console = new Console(this);\n        this.packetRegistry = new PacketRegistry(this);\n        this.itemManager = new ItemManager(this);\n        this.blockManager = new BlockManager(this);\n        this.worldManager = new WorldManager(this);\n        this.commandManager = new CommandManager(this);\n        this.pluginManager = new PluginManager(this);\n        this.queryManager = new QueryManager(this);\n        this.chatManager = new ChatManager(this);\n        this.permissionManager = new PermissionManager(this);\n        this.banManager = new BanManager(this);\n\n        Server.instance = this;\n    }\n\n    private async onEnable(): Promise<void> {\n        this.config.onEnable();\n        await this.logger.onEnable();\n        await this.permissionManager.onEnable();\n        await this.pluginManager.onEnable();\n        await this.banManager.onEnable();\n        await this.itemManager.onEnable();\n        await this.blockManager.onEnable();\n        await this.commandManager.onEnable();\n    }\n\n    private async onDisable(): Promise<void> {\n        await this.commandManager.onDisable();\n        await this.blockManager.onDisable();\n        await this.itemManager.onDisable();\n        await this.banManager.onDisable();\n        await this.pluginManager.onDisable();\n        await this.permissionManager.onDisable();\n        await this.packetRegistry.onDisable();\n        this.config.onDisable();\n        await this.logger.onDisable();\n    }\n\n    public async reload(): Promise<void> {\n        await this.onDisable();\n        await this.onEnable();\n    }\n\n    public async bootstrap(serverIp = '0.0.0.0', port = 19132): Promise<void> {\n        await this.onEnable();\n        BlockMappings.initMappings();\n        await this.worldManager.onEnable();\n        await this.packetRegistry.onEnable();\n\n        this.raknet = new RakNetListener(this.getConfig().getMaxPlayers(), false);\n        this.raknet.start(serverIp, port);\n\n        this.raknet.on('openConnection', async (session: RakNetSession) => {\n            const event = new RaknetConnectEvent(session);\n            await this.eventManager.emit('raknetConnect', event);\n\n            if (event.isCancelled()) {\n                session.disconnect();\n                return;\n            }\n\n            const token = session.getAddress().toToken();\n            if (this.sessionManager.has(token)) {\n                this.logger.error(\n                    `Another client with token (${token}) is already connected!`,\n                    'Server/listen/openConnection'\n                );\n                session.disconnect('Already connected from another location');\n                return;\n            }\n\n            const timer = new Timer();\n            this.logger.debug(`${token} is attempting to connect`, 'Server/listen/openConnection');\n            this.sessionManager.add(token, new ClientConnection(session, this.logger));\n            this.logger.verbose(`New connection handling took ${timer.stop()} ms`, 'Server/listen/openConnection');\n        });\n\n        this.raknet.on('closeConnection', async (inetAddr: InetAddress, reason: string) => {\n            const event = new RaknetDisconnectEvent(inetAddr, reason);\n            await this.eventManager.emit('raknetDisconnect', event);\n\n            const time = Date.now();\n            const token = inetAddr.toToken();\n            try {\n                const player = this.sessionManager.getPlayer(token);\n\n                // De-spawn the player to all online players\n                await player.getNetworkSession().removeFromPlayerList();\n                for (const onlinePlayer of this.sessionManager.getAllPlayers()) {\n                    await player.getNetworkSession().sendDespawn(onlinePlayer);\n                }\n\n                // Sometimes we fail at decoding the username for whatever reason\n                if (player.getName()) {\n                    // Announce disconnection\n                    const event = new ChatEvent(\n                        new Chat(\n                            this.console,\n                            `§e%multiplayer.player.left`,\n                            [player.getName()],\n                            true,\n                            '*.everyone',\n                            ChatType.TRANSLATION\n                        )\n                    );\n                    await this.eventManager.emit('chat', event);\n                }\n\n                await player.onDisable();\n                await player.getWorld().removeEntity(player);\n                this.sessionManager.remove(token);\n            } catch (error: unknown) {\n                this.logger.debug(\n                    `Cannot remove connection from non-existing player (${token})`,\n                    'Server/listen/raknetDisconnect'\n                );\n                this.logger.error(error, 'Server/listen/raknetDisconnect');\n            }\n\n            this.logger.debug(`${token} disconnected due to ${reason}`, 'Server/listen/raknetDisconnect');\n\n            this.logger.debug(\n                `Player destruction took about ${Date.now() - time} ms`,\n                'Server/listen/raknetDisconnect'\n            );\n        });\n\n        this.raknet.on('encapsulated', async (packet: any, inetAddr: InetAddress) => {\n            const event = new RaknetEncapsulatedPacketEvent(inetAddr, packet);\n            await this.eventManager.emit('raknetEncapsulatedPacket', event);\n\n            let connection: ClientConnection | null;\n            if ((connection = this.sessionManager.get(inetAddr.toToken()) ?? null) === null) {\n                this.logger.error(`Got a packet from a closed connection (${inetAddr.toToken()})`);\n                return;\n            }\n\n            try {\n                // Read batch content and handle them\n                const batched = new BatchPacket(packet.content);\n                batched.compressed = connection.hasCompression;\n\n                // Read all packets inside batch and handle them\n                for (const buf of await batched.asyncDecode()) {\n                    const pid = buf[0]!;\n\n                    if (!this.packetRegistry.getPackets().has(pid)) {\n                        this.logger.warn(\n                            `Packet 0x${pid.toString(16)} isn't implemented`,\n                            'Server/listen/raknetEncapsulatedPacket'\n                        );\n                        continue;\n                    }\n\n                    // Get packet from registry\n                    const packet = new (this.packetRegistry.getPackets().get(pid)!)(buf);\n\n                    try {\n                        packet.decode();\n                    } catch (error: unknown) {\n                        this.logger.error(error);\n                        this.logger.error(\n                            `Error while decoding packet: ${packet.constructor.name}: ${error}`,\n                            'Server/listen/raknetEncapsulatedPacket'\n                        );\n                        continue;\n                    }\n\n                    try {\n                        const handler = this.packetRegistry.getHandler(pid);\n                        this.logger.silly(\n                            `Received §b${packet.constructor.name}§r packet`,\n                            'Server/listen/raknetEncapsulatedPacket'\n                        );\n                        await (handler as any).handle(packet, this, connection.getPlayerSession() ?? connection);\n                    } catch (error: unknown) {\n                        this.logger.error(\n                            `Handler error ${packet.constructor.name}-handler: (${error})`,\n                            'Server/listen/raknetEncapsulatedPacket'\n                        );\n                        this.logger.error(error, 'Server/listen/raknetEncapsulatedPacket');\n                    }\n                }\n            } catch (error: unknown) {\n                this.logger.error(error, 'Server/listen/raknetEncapsulatedPacket');\n            }\n        });\n\n        this.raknet.on('raw', async (buffer: Buffer, inetAddr: InetAddress) => {\n            try {\n                await this.queryManager.onRaw(buffer, inetAddr);\n            } catch (error: unknown) {\n                this.logger.error(error, 'Server/listen/raw');\n                this.logger.verbose(`QueryManager failed with error: ${error}`, 'Server/listen/raw');\n            }\n        });\n\n        // TODO: calculate TPS.\n        let tickCount = 0;\n        const tick = () =>\n            setTimeout(() => {\n                const event = new TickEvent(tickCount);\n                void this.eventManager.emit('tick', event);\n\n                for (const world of this.worldManager.getWorlds()) {\n                    void world.update(event.getTick());\n                }\n\n                ++tickCount;\n                tick();\n            }, Server.MINECRAFT_TICK_TIME_MS);\n\n        // Start ticking\n        this.tickerTimer = tick();\n        this.tickerTimer.unref();\n\n        this.logger.info(`JSPrismarine is now listening on port §b${port}`, 'Server/listen');\n    }\n\n    /**\n     * Kills the server asynchronously.\n     */\n    public async shutdown(options?: { withoutSaving?: boolean; crash?: boolean }): Promise<void> {\n        if (this.stopping) return;\n        this.stopping = true;\n\n        this.logger.info('Stopping server', 'Server/kill');\n        await this.console.onDisable();\n\n        clearInterval(this.tickerTimer);\n\n        try {\n            // Kick all online players\n            for (const player of this.sessionManager.getAllPlayers()) {\n                await player.kick('Server closed.');\n            }\n\n            // Save all worlds\n            if (!options?.withoutSaving) await this.worldManager.save();\n\n            await this.worldManager.onDisable();\n            await this.onDisable();\n            this.raknet.kill(); // this.raknet might be undefined if we kill the server really early\n            process.exit(options?.crash ? 1 : 0);\n        } catch (error: unknown) {\n            this.logger.error(error, 'Server/kill');\n            process.exit(1);\n        }\n    }\n\n    public async broadcastPacket<T extends DataPacket>(dataPacket: T): Promise<void> {\n        // Maybe i can improve this by using the UDP broadcast, all unconnected clients\n        // will ignore the connected packet probably, but may cause issues.\n        for (const onlinePlayer of this.sessionManager.getAllPlayers()) {\n            await onlinePlayer.getNetworkSession().getConnection().sendDataPacket(dataPacket);\n        }\n    }\n\n    public getVersion(): string {\n        return this.version;\n    }\n\n    public getIdentifiers() {\n        return Identifiers;\n    }\n\n    /**\n     * Returns the query manager\n     */\n    public getQueryManager(): QueryManager {\n        return this.queryManager;\n    }\n\n    /**\n     * Returns the command manager\n     */\n    public getCommandManager(): CommandManager {\n        return this.commandManager;\n    }\n\n    /**\n     * Returns the player manager\n     */\n    public getSessionManager(): SessionManager {\n        return this.sessionManager;\n    }\n\n    /**\n     * Returns the world manager\n     */\n    public getWorldManager(): WorldManager {\n        return this.worldManager;\n    }\n\n    /**\n     * Returns the item manager\n     */\n    public getItemManager(): ItemManager {\n        return this.itemManager;\n    }\n\n    /**\n     * Returns the block manager\n     */\n    public getBlockManager(): BlockManager {\n        return this.blockManager;\n    }\n\n    /**\n     * Returns the logger\n     */\n    public getLogger(): LoggerBuilder | undefined {\n        return this.logger;\n    }\n\n    /**\n     * Returns the packet registry\n     */\n    public getPacketRegistry(): PacketRegistry {\n        return this.packetRegistry;\n    }\n\n    /**\n     * Returns the raknet instance\n     */\n    public getRaknet() {\n        return this.raknet;\n    }\n\n    /**\n     * Returns the plugin manager\n     */\n    public getPluginManager(): PluginManager {\n        return this.pluginManager;\n    }\n\n    /**\n     * Returns the event manager\n     */\n    public getEventManager(): EventManager {\n        return this.eventManager;\n    }\n\n    /**\n     * Returns the chat manager\n     */\n    public getChatManager(): ChatManager {\n        return this.chatManager;\n    }\n\n    /**\n     * Returns the config\n     */\n    public getConfig(): Config {\n        return this.config;\n    }\n\n    /**\n     * Returns the console instance\n     */\n    public getConsole(): Console {\n        return this.console;\n    }\n\n    /**\n     * Returns the permission manager\n     */\n    public getPermissionManager(): PermissionManager {\n        return this.permissionManager;\n    }\n\n    /**\n     * Returns the ban manager\n     */\n    public getBanManager(): BanManager {\n        return this.banManager;\n    }\n\n    /**\n     * Returns this Prismarine instance\n     */\n    public getServer(): Server {\n        return this;\n    }\n\n    /**\n     * Returns the current TPS\n     */\n    public getTPS(): number {\n        return this.tps;\n    }\n}\n"],"names":["cmd","parameters","event","packet"],"mappings":"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"}