@colyseus/core/build/index.cjs

Multiplayer Framework for Node.js.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// packages/core/src/index.ts
var index_exports = {};
__export(index_exports, {
  ClientArray: () => import_Transport.ClientArray,
  ClientState: () => import_Transport.ClientState,
  Clock: () => import_timer.ClockTimer,
  CloseCode: () => import_shared_types.CloseCode,
  Deferred: () => import_Utils.Deferred,
  Delayed: () => import_timer.Delayed,
  ErrorCode: () => import_shared_types.ErrorCode,
  LobbyRoom: () => import_LobbyRoom.LobbyRoom,
  LocalPresence: () => import_LocalPresence.LocalPresence,
  OnAuthException: () => import_RoomExceptions.OnAuthException,
  OnCreateException: () => import_RoomExceptions.OnCreateException,
  OnDisposeException: () => import_RoomExceptions.OnDisposeException,
  OnJoinException: () => import_RoomExceptions.OnJoinException,
  OnLeaveException: () => import_RoomExceptions.OnLeaveException,
  OnMessageException: () => import_RoomExceptions.OnMessageException,
  Protocol: () => import_shared_types.Protocol,
  QueueRoom: () => import_QueueRoom.QueueRoom,
  RegisteredHandler: () => import_RegisteredHandler.RegisteredHandler,
  RelayRoom: () => import_RelayRoom.RelayRoom,
  Room: () => import_Room.Room,
  RoomInternalState: () => import_Room.RoomInternalState,
  SchemaSerializer: () => import_SchemaSerializer.SchemaSerializer,
  Server: () => import_Server.Server,
  ServerError: () => import_ServerError.ServerError,
  SimulationIntervalException: () => import_RoomExceptions.SimulationIntervalException,
  TimedEventException: () => import_RoomExceptions.TimedEventException,
  Transport: () => import_Transport.Transport,
  __globalEndpoints: () => import_router.__globalEndpoints,
  connectClientToRoom: () => import_Transport.connectClientToRoom,
  createEndpoint: () => import_router.createEndpoint,
  createInternalContext: () => import_router.createInternalContext,
  createMiddleware: () => import_router.createMiddleware,
  createNodeMatchmakingMiddleware: () => import_node.createNodeMatchmakingMiddleware,
  createRouter: () => import_router.createRouter,
  debugAndPrintError: () => import_Debug.debugAndPrintError,
  debugConnection: () => import_Debug.debugConnection,
  debugDriver: () => import_Debug.debugDriver,
  debugError: () => import_Debug.debugError,
  debugMatchMaking: () => import_Debug.debugMatchMaking,
  debugMessage: () => import_Debug.debugMessage,
  debugPatch: () => import_Debug.debugPatch,
  debugPresence: () => import_Debug.debugPresence,
  defineRoom: () => import_Server.defineRoom,
  defineServer: () => import_Server.defineServer,
  dynamicImport: () => import_Utils.dynamicImport,
  generateId: () => import_Utils.generateId,
  getBearerToken: () => import_Utils.getBearerToken,
  getMessageBytes: () => import_Protocol.getMessageBytes,
  initializeRoomCache: () => import_driver.initializeRoomCache,
  isDevMode: () => import_DevMode.isDevMode,
  logger: () => import_Logger.logger,
  matchMaker: () => matchMaker,
  registerRoomDefinitions: () => import_Server.registerRoomDefinitions,
  requestFromIPC: () => import_IPC.requestFromIPC,
  room: () => import_Room.room,
  setDevMode: () => import_DevMode.setDevMode,
  spliceOne: () => import_Utils.spliceOne,
  subscribeIPC: () => import_IPC.subscribeIPC,
  subscribeLobby: () => import_Lobby.subscribeLobby,
  toNodeHandler: () => import_router.toNodeHandler,
  unregisterRoomDefinitions: () => import_Server.unregisterRoomDefinitions,
  updateLobby: () => import_Lobby.updateLobby,
  validate: () => import_Room.validate
});
module.exports = __toCommonJS(index_exports);
var import_timer = require("@colyseus/timer");
var import_shared_types = require("@colyseus/shared-types");
var import_Server = require("./Server.cjs");
var import_Room = require("./Room.cjs");
var import_Protocol = require("./Protocol.cjs");
var import_RegisteredHandler = require("./matchmaker/RegisteredHandler.cjs");
var import_ServerError = require("./errors/ServerError.cjs");
var import_RoomExceptions = require("./errors/RoomExceptions.cjs");
var matchMaker = __toESM(require("./MatchMaker.cjs"), 1);
var import_Lobby = require("./matchmaker/Lobby.cjs");
var import_node = require("./router/node.cjs");
__reExport(index_exports, require("./matchmaker/LocalDriver/LocalDriver.cjs"), module.exports);
var import_driver = require("./matchmaker/driver.cjs");
var import_Transport = require("./Transport.cjs");
var import_Presence = require("./presence/Presence.cjs");
var import_LocalPresence = require("./presence/LocalPresence.cjs");
var import_Serializer = require("./serializer/Serializer.cjs");
var import_SchemaSerializer = require("./serializer/SchemaSerializer.cjs");
var import_Utils = require("./utils/Utils.cjs");
var import_DevMode = require("./utils/DevMode.cjs");
var import_IPC = require("./IPC.cjs");
var import_Debug = require("./Debug.cjs");
var import_LobbyRoom = require("./rooms/LobbyRoom.cjs");
var import_RelayRoom = require("./rooms/RelayRoom.cjs");
var import_QueueRoom = require("./rooms/QueueRoom.cjs");
var import_router = require("./router/index.cjs");
var import_Logger = require("./Logger.cjs");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  ClientArray,
  ClientState,
  Clock,
  CloseCode,
  Deferred,
  Delayed,
  ErrorCode,
  LobbyRoom,
  LocalPresence,
  OnAuthException,
  OnCreateException,
  OnDisposeException,
  OnJoinException,
  OnLeaveException,
  OnMessageException,
  Protocol,
  QueueRoom,
  RegisteredHandler,
  RelayRoom,
  Room,
  RoomInternalState,
  SchemaSerializer,
  Server,
  ServerError,
  SimulationIntervalException,
  TimedEventException,
  Transport,
  __globalEndpoints,
  connectClientToRoom,
  createEndpoint,
  createInternalContext,
  createMiddleware,
  createNodeMatchmakingMiddleware,
  createRouter,
  debugAndPrintError,
  debugConnection,
  debugDriver,
  debugError,
  debugMatchMaking,
  debugMessage,
  debugPatch,
  debugPresence,
  defineRoom,
  defineServer,
  dynamicImport,
  generateId,
  getBearerToken,
  getMessageBytes,
  initializeRoomCache,
  isDevMode,
  logger,
  matchMaker,
  registerRoomDefinitions,
  requestFromIPC,
  room,
  setDevMode,
  spliceOne,
  subscribeIPC,
  subscribeLobby,
  toNodeHandler,
  unregisterRoomDefinitions,
  updateLobby,
  validate,
  ...require("./matchmaker/LocalDriver/LocalDriver.cjs")
});