revbot.js 0.0.13 → 0.0.15-build-test

package/dist/client/events/eventManager.cjs

@@ -0,0 +1,657 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/client/events/eventManager.ts
+var eventManager_exports = {};
+__export(eventManager_exports, {
+  EventManager: () => EventManager
+});
+module.exports = __toCommonJS(eventManager_exports);
+
+// src/client/events/index.ts
+var events_exports = {};
+__export(events_exports, {
+  BulkMessageDelete: () => BulkMessageDelete,
+  ChannelCreate: () => ChannelCreate,
+  ChannelDelete: () => ChannelDelete,
+  ChannelGroupJoin: () => ChannelGroupJoin,
+  ChannelGroupLeave: () => ChannelGroupLeave,
+  ChannelStartTyping: () => ChannelStartTyping,
+  ChannelStopTyping: () => ChannelStopTyping,
+  ChannelUpdate: () => ChannelUpdate,
+  Message: () => Message,
+  MessageDelete: () => MessageDelete,
+  MessageReact: () => MessageReact,
+  MessageUnreact: () => MessageUnreact,
+  MessageUpdate: () => MessageUpdate,
+  ServerCreate: () => ServerCreate,
+  ServerDelete: () => ServerDelete,
+  ServerMemberJoin: () => ServerMemberJoin,
+  ServerMemberLeave: () => ServerMemberLeave,
+  ServerMemberUpdate: () => ServerMemberUpdate,
+  ServerRoleDelete: () => ServerRoleDelete,
+  ServerRoleUpdate: () => ServerRoleUpdate,
+  ServerUpdate: () => ServerUpdate,
+  UserUpdate: () => UserUpdate
+});
+
+// src/utils/UUID.ts
+var import_crypto = require("crypto");
+var _UUID = class _UUID extends null {
+  static get PROG() {
+    return (0, import_crypto.randomBytes)(1).readUInt8() / 255;
+  }
+  static time(now = Date.now()) {
+    let mod, result = "";
+    for (let i = this.TIME_LENGTH; i > 0; i--) {
+      mod = now % this.ENCODING_LENGTH;
+      result = this.ENCODING.charAt(mod) + result;
+      now = (now - mod) / this.ENCODING_LENGTH;
+    }
+    return result;
+  }
+  static hash() {
+    let result = "";
+    for (let i = this.RANDOM_LENGTH; i > 0; i--) {
+      let random = Math.floor(this.PROG * this.ENCODING_LENGTH);
+      if (random === this.ENCODING_LENGTH) {
+        random = this.ENCODING_LENGTH - 1;
+      }
+      result = this.ENCODING.charAt(random) + result;
+    }
+    return result;
+  }
+  static generate(timestamp = Date.now()) {
+    return this.time(timestamp) + this.hash();
+  }
+  static timestampOf(id) {
+    const timestamp = id.slice(0, this.TIME_LENGTH).split("").reverse().reduce((carry, char, index) => {
+      const encodingIndex = this.ENCODING.indexOf(char);
+      if (encodingIndex === -1) {
+        throw new Error("invalid character found: " + char);
+      }
+      return carry += encodingIndex * Math.pow(this.ENCODING_LENGTH, index);
+    }, 0);
+    return new Date(timestamp);
+  }
+};
+_UUID.ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+_UUID.ENCODING_LENGTH = _UUID.ENCODING.length;
+_UUID.RANDOM_LENGTH = 16;
+_UUID.TIME_LENGTH = 10;
+_UUID.TIME_MAX = Math.pow(2, 48) - 1;
+var UUID = _UUID;
+
+// src/utils/constants.ts
+var SYSTEM_USER_ID = "0".repeat(UUID.TIME_LENGTH + UUID.RANDOM_LENGTH);
+
+// src/client/events/event.ts
+var Event = class {
+  /**
+   * Creates a new Event instance.
+   *
+   * @param {client} client - The client instance.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+};
+
+// src/client/events/bulkMessageDelete.ts
+var BulkMessageDelete = class extends Event {
+  /**
+   * Handles the bulk message delete event.
+   *
+   * @param {{ ids: string[] }} data - The data for the event, containing the IDs of the deleted messages.
+   */
+  handle(data) {
+    this.client.emit("messageDeleteBulk" /* MESSAGE_DELETE_BULK */, data.ids);
+  }
+};
+
+// src/client/events/channelCreate.ts
+var ChannelCreate = class extends Event {
+  /**
+   * Handles the channel creation event.
+   *
+   * @param {API.Channel} data - The raw data for the created channel from the API.
+   * @returns {Promise<{ channel: unknown }>} A promise that resolves with the created channel.
+   */
+  handle(data) {
+    return __async(this, null, function* () {
+      var _a;
+      const channel = this.client.channels._add(data);
+      if (channel) {
+        if (channel.inServer()) {
+          const server = (_a = channel.server) != null ? _a : yield this.client.servers.fetch(channel.serverId);
+          server.channels.cache.set(channel.id, channel);
+        }
+        this.client.emit("channelCreate" /* CHANNEL_CREATE */, channel);
+      }
+      return { channel };
+    });
+  }
+};
+
+// src/client/events/channelDelete.ts
+var ChannelDelete = class extends Event {
+  /**
+   * Handles the channel deletion event.
+   *
+   * @param {{ id: string }} data - The data for the event, containing the ID of the deleted channel.
+   * @returns {{ channel: unknown }} An object containing the deleted channel, or `undefined` if not found.
+   */
+  handle(data) {
+    var _a;
+    const channel = this.client.channels.cache.get(data.id);
+    if (channel) {
+      if (channel.inServer()) {
+        (_a = channel.server) == null ? void 0 : _a.channels.cache.delete(channel.id);
+      }
+      this.client.emit("channelDelete" /* CHANNEL_DELETE */, channel);
+    }
+    return { channel };
+  }
+};
+
+// src/client/events/channelGroupJoin.ts
+var ChannelGroupJoin = class extends Event {
+  /**
+   * Handles the group channel join event.
+   *
+   * @param {{ id: string; user: string }} data - The data for the event, containing the channel ID and user ID.
+   * @returns {Promise<{ channel: unknown; user: unknown }>} A promise that resolves with the updated channel and user.
+   */
+  handle(data) {
+    return __async(this, null, function* () {
+      const channel = this.client.channels.cache.get(data.id);
+      const user = yield this.client.users.fetch(data.user, { force: false });
+      if (channel == null ? void 0 : channel.isGroup()) {
+        channel.users.set(user.id, user);
+        this.client.emit("groupJoin" /* GROUP_JOIN */, channel, user);
+      }
+      return { channel, user };
+    });
+  }
+};
+
+// src/client/events/channelGroupLeave.ts
+var ChannelGroupLeave = class extends Event {
+  /**
+   * Handles the group channel leave event.
+   *
+   * @param {{ id: string; user: string }} data - The data for the event, containing the channel ID and user ID.
+   * @returns {Promise<{ channel: unknown; user: unknown }>} A promise that resolves with the updated channel and user.
+   */
+  handle(data) {
+    return __async(this, null, function* () {
+      const channel = this.client.channels.cache.get(data.id);
+      const user = yield this.client.users.fetch(data.user, { force: false });
+      if (channel == null ? void 0 : channel.isGroup()) {
+        channel.users.delete(data.user);
+        this.client.emit("groupLeave" /* GROUP_LEAVE */, channel, user);
+      }
+      return { channel, user };
+    });
+  }
+};
+
+// src/client/events/channelStarttyping.ts
+var ChannelStartTyping = class extends Event {
+  /**
+   * Handles the typing start event.
+   *
+   * @param {{ id: string; user: string }} data - The data for the event, containing the channel ID and user ID.
+   * @returns {{ channel: unknown; user: unknown }} An object containing the channel and user involved in the event.
+   */
+  handle(data) {
+    const channel = this.client.channels.cache.get(data.id);
+    const user = this.client.users.cache.get(data.user);
+    if ((channel == null ? void 0 : channel.isText()) && user) {
+      this.client.emit("typingStart" /* TYPING_START */, channel, user);
+    }
+    return { channel, user };
+  }
+};
+
+// src/client/events/channelStopTyping.ts
+var ChannelStopTyping = class extends Event {
+  /**
+   * Handles the typing stop event.
+   *
+   * @param {{ id: string; user: string }} data - The data for the event, containing the channel ID and user ID.
+   * @returns {{ channel: unknown; user: unknown }} An object containing the channel and user involved in the event.
+   */
+  handle(data) {
+    const channel = this.client.channels.cache.get(data.id);
+    const user = this.client.users.cache.get(data.user);
+    if ((channel == null ? void 0 : channel.isText()) && user) {
+      this.client.emit("typingStop" /* TYPING_STOP */, channel, user);
+    }
+    return { channel, user };
+  }
+};
+
+// src/client/events/channelUpdate.ts
+var ChannelUpdate = class extends Event {
+  /**
+   * Handles the channel update event.
+   *
+   * @param {{ id: string; data: API.Channel; clear: API.FieldsChannel }} data - The data for the event, containing the channel ID, updated data, and fields to clear.
+   * @returns {void}
+   */
+  handle(data) {
+    const channel = this.client.channels.cache.get(data.id);
+    const oldChannel = channel == null ? void 0 : channel._update(data.data);
+    if (channel && oldChannel && !channel.equals(oldChannel)) {
+      this.client.emit("channelUpdate" /* CHANNEL_UPDATE */, oldChannel, channel);
+    }
+  }
+};
+
+// src/client/events/message.ts
+var Message = class extends Event {
+  /**
+   * Handles the message event.
+   *
+   * @param {API.Message} data - The raw data for the message from the API.
+   * @returns {Promise<{ message: unknown }>} A promise that resolves with the created message, or an empty object if the channel is not text-based.
+   */
+  handle(data) {
+    return __async(this, null, function* () {
+      const channel = this.client.channels.cache.get(data.channel);
+      if (channel == null ? void 0 : channel.isText()) {
+        const message = channel.messages._add(data);
+        if (data.author !== SYSTEM_USER_ID && !data.webhook) {
+          yield this.client.users.fetch(data.author, { force: false });
+        }
+        this.client.emit("message" /* MESSAGE */, message);
+        return { message };
+      }
+      return {};
+    });
+  }
+};
+
+// src/client/events/messageDelete.ts
+var MessageDelete = class extends Event {
+  /**
+   * Handles the message deletion event.
+   *
+   * @param {{ id: string; channel: string }} data - The data for the event, containing the message ID and channel ID.
+   * @returns {{ message: unknown } | {}} An object containing the deleted message, or an empty object if the channel is not text-based or the message is not found.
+   */
+  handle(data) {
+    const channel = this.client.channels.cache.get(data.channel);
+    if (channel == null ? void 0 : channel.isText()) {
+      const message = channel.messages.cache.get(data.id);
+      if (message) {
+        channel.messages._remove(message.id);
+        this.client.emit("messageDelete" /* MESSAGE_DELETE */, message);
+      }
+      return { message };
+    }
+    return {};
+  }
+};
+
+// src/client/events/messageUpdate.ts
+var MessageUpdate = class extends Event {
+  /**
+   * Handles the message update event.
+   *
+   * @param {{ id: string; channel: string; data: API.Message }} data - The data for the event, containing the message ID, channel ID, and updated message data.
+   * @returns {void}
+   */
+  handle(data) {
+    const channel = this.client.channels.cache.get(data.channel);
+    if (!(channel == null ? void 0 : channel.isText())) return;
+    const message = channel == null ? void 0 : channel.messages.cache.get(data.id);
+    const oldMessage = message == null ? void 0 : message._update(data.data);
+    if (oldMessage && message && !message.equals(oldMessage)) {
+      this.client.emit("messageUpdate" /* MESSAGE_UPDATE */, oldMessage, message);
+    }
+  }
+};
+
+// src/client/events/serverCreate.ts
+var ServerCreate = class extends Event {
+  /**
+   * Handles the server creation event.
+   *
+   * @param {API.Server} data - The raw data for the created server from the API.
+   * @returns {Promise<void>} A promise that resolves when the server is added and members are optionally fetched.
+   */
+  handle(data) {
+    return __async(this, null, function* () {
+      const server = this.client.servers._add(data);
+      if (this.client.options.fetchMembers) {
+        yield server.members.fetch();
+      }
+      this.client.emit("serverCreate" /* SERVER_CREATE */, server);
+    });
+  }
+};
+
+// src/client/events/serverDelete.ts
+var ServerDelete = class extends Event {
+  /**
+   * Handles the server deletion event.
+   *
+   * @param {API.Server} data - The raw data for the deleted server from the API.
+   * @returns {{ server: unknown }} An object containing the deleted server, or `undefined` if not found.
+   */
+  handle(data) {
+    const server = this.client.servers.cache.get(data._id);
+    if (server) {
+      this.client.servers._remove(server.id);
+      this.client.emit("serverDelete" /* SERVER_DELETE */, server);
+    }
+    return { server };
+  }
+};
+
+// src/client/events/serverMemberJoin.ts
+var ServerMemberJoin = class extends Event {
+  /**
+   * Handles the server member join event.
+   *
+   * @param {{ id: string; user: string }} data - The data for the event, containing the server ID and user ID.
+   * @returns {Promise<{ member: unknown }>} A promise that resolves with the joined member.
+   */
+  handle(data) {
+    return __async(this, null, function* () {
+      let server = this.client.servers.cache.get(data.id);
+      if (!server) {
+        server = yield this.client.servers.fetch(data.id);
+        this.client.emit("serverCreate" /* SERVER_CREATE */, server);
+      }
+      const member = yield server.members.fetch(data.user);
+      server.members.cache.set(member.id, member);
+      this.client.emit("serverMemberJoin" /* SERVER_MEMBER_JOIN */, member);
+      return { member };
+    });
+  }
+};
+
+// src/client/events/serverMemberLeave.ts
+var ServerMemberLeave = class extends Event {
+  /**
+   * Handles the server member leave event.
+   *
+   * @param {{ id: string; user: string }} data - The data for the event, containing the server ID and user ID.
+   * @returns {{ server: unknown; member?: unknown }} An object containing the server and the member who left, or just the server if the member is not found.
+   */
+  handle(data) {
+    const server = this.client.servers.cache.get(data.id);
+    if (server) {
+      const member = server.members.cache.get(data.user);
+      if (member) {
+        server.members._remove(member.id);
+        this.client.emit("serverMemberLeave" /* SERVER_MEMBER_LEAVE */, member);
+      }
+      return { server, member };
+    }
+    return { server };
+  }
+};
+
+// src/client/events/serverMemberUpdate.ts
+var ServerMemberUpdate = class extends Event {
+  /**
+   * Handles the server member update event.
+   *
+   * @param {{ id: string; data: API.Member }} data - The data for the event, containing the server ID and updated member data.
+   * @returns {void}
+   */
+  handle(data) {
+    const updateData = __spreadProps(__spreadValues({}, data.data), {
+      _id: { server: data.id.server, user: data.id.user }
+    });
+    const server = this.client.servers.cache.get(data.id.server);
+    const member = server == null ? void 0 : server.members.cache.get(data.id.user);
+    const oldMember = member == null ? void 0 : member._update(updateData);
+    if (oldMember && member && (!member.equals(oldMember) || areRolesDifferent(member.roles, oldMember.roles))) {
+      this.client.emit("serverMemberUpdate" /* SERVER_MEMBER_UPDATE */, oldMember, member);
+    }
+  }
+};
+function areRolesDifferent(rolesA, rolesB) {
+  const idsA = rolesA.map((role) => role.id).sort();
+  const idsB = rolesB.map((role) => role.id).sort();
+  return idsA.length !== idsB.length || !idsA.every((id, index) => id === idsB[index]);
+}
+
+// src/client/events/serverRoleDelete.ts
+var ServerRoleDelete = class extends Event {
+  /**
+   * Handles the server role deletion event.
+   *
+   * @param {{ id: string; role_id: string }} data - The data for the event, containing the server ID and role ID.
+   * @returns {{ role: unknown } | {}} An object containing the deleted role, or an empty object if the role or server is not found.
+   */
+  handle(data) {
+    const server = this.client.servers.cache.get(data.id);
+    if (server) {
+      const role = server.roles.cache.get(data.role_id);
+      if (role) {
+        server.roles._remove(role.id);
+        this.client.emit("roleDelete" /* ROLE_DELETE */, role);
+      }
+      return { role };
+    }
+    return {};
+  }
+};
+
+// src/client/events/serverRoleUpdate.ts
+var ServerRoleUpdate = class extends Event {
+  /**
+   * Handles the server role update event.
+   *
+   * @param {{ id: string; role_id: string; data: API.Role & { _id: string }; clear: API.FieldsRole[] }} data - The data for the event, containing the server ID, role ID, updated role data, and fields to clear.
+   * @returns {void}
+   */
+  handle(data) {
+    const server = this.client.servers.cache.get(data.id);
+    if (!server) return;
+    const role = server.roles.cache.get(data.role_id);
+    const oldRole = role == null ? void 0 : role._update(data.data, data.clear);
+    if (role && oldRole && !role.equals(oldRole)) {
+      this.client.emit("roleUpdate" /* ROLE_UPDATE */, oldRole, role);
+    }
+  }
+};
+
+// src/client/events/serverupdate.ts
+var ServerUpdate = class extends Event {
+  /**
+   * Handles the server update event.
+   *
+   * @param {{ id: string; data: API.Server; clear: API.FieldsServer[] }} data - The data for the event, containing the server ID, updated server data, and fields to clear.
+   * @returns {void}
+   */
+  handle(data) {
+    const server = this.client.servers.cache.get(data.id);
+    const oldServer = server == null ? void 0 : server._update(data.data, data.clear);
+    if (oldServer && server && !oldServer.equals(server)) {
+      this.client.emit("serverUpdate" /* SERVER_UPDATE */, oldServer, server);
+    }
+  }
+};
+
+// src/client/events/userUpdate.ts
+var UserUpdate = class extends Event {
+  /**
+   * Handles the user update event.
+   *
+   * @param {{ id: string; data: API.User; clear: API.FieldsUser[] }} data - The data for the event, containing the user ID, updated user data, and fields to clear.
+   * @returns {void}
+   */
+  handle(data) {
+    const user = data.id === this.client.user.id ? this.client.user : this.client.users.cache.get(data.id);
+    const oldUser = user == null ? void 0 : user._update(data.data, data.clear);
+    if (user && oldUser && !user.equals(oldUser)) {
+      this.client.emit("userUpdate" /* USER_UPDATE */, oldUser, user);
+    }
+  }
+};
+
+// src/client/events/messageReact.ts
+var MessageReact = class extends Event {
+  /**
+   * Handles the message reaction event.
+   *
+   * @param {MessageReactData} data - The data for the event, containing the message ID, channel ID, user ID, and emoji ID.
+   * @returns {Promise<unknown>} A promise that resolves with an empty object.
+   */
+  handle(data) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const channel = this.client.channels.cache.get(data.channel_id);
+      if (channel == null ? void 0 : channel.isText()) {
+        let message = channel.messages.cache.get(data.id) ? channel.messages.cache.get(data.id) : yield channel.messages.fetch(data.id);
+        if (message) {
+          if ((_a = message.reactions.get(data.emoji_id)) == null ? void 0 : _a.indexOf(data.user_id)) return;
+          if (!((_b = message.reactions.get(data.emoji_id)) == null ? void 0 : _b.push(data.user_id)))
+            message.reactions.set(data.emoji_id, [data.user_id]);
+          this.client.emit("messageReact" /* MESSAGE_REACT */, message);
+        }
+      }
+      return {};
+    });
+  }
+};
+
+// src/client/events/messageUnreact.ts
+var MessageUnreact = class extends Event {
+  /**
+   * Handles the message reaction removal event.
+   *
+   * @param {MessageReactData} data - The data for the event, containing the message ID, channel ID, user ID, and emoji ID.
+   * @returns {Promise<unknown>} A promise that resolves with an empty object.
+   */
+  handle(data) {
+    return __async(this, null, function* () {
+      const channel = this.client.channels.cache.get(data.channel_id);
+      if (channel == null ? void 0 : channel.isText()) {
+        let message = channel.messages.cache.get(data.id) ? channel.messages.cache.get(data.id) : yield channel.messages.fetch(data.id);
+        if (message) {
+          const reaction = message.reactions.get(data.emoji_id);
+          if (reaction) {
+            const index = reaction.indexOf(data.user_id);
+            if (index !== -1) {
+              reaction.splice(index, 1);
+            }
+            if (reaction.length === 0) {
+              message.reactions.delete(data.emoji_id);
+            }
+          }
+          this.client.emit("messageUnreact" /* MESSAGE_REACT_REMOVE */, message);
+        }
+      }
+      return {};
+    });
+  }
+};
+
+// src/client/events/eventManager.ts
+var _events;
+var EventManager = class {
+  /**
+   * Creates a new EventManager instance.
+   *
+   * @param {client} client - The client instance.
+   */
+  constructor(client) {
+    this.client = client;
+    /** A map of registered events, keyed by their names. */
+    __privateAdd(this, _events, /* @__PURE__ */ new Map());
+    for (const Event2 of Object.values(events_exports)) {
+      this.register(Event2);
+    }
+  }
+  /**
+   * Registers an event with the manager.
+   *
+   * @param {new (client: client) => CustomEvent} Event - The event class to register.
+   */
+  register(Event2) {
+    __privateGet(this, _events).set(Event2.name.replace(/Events$/, ""), new Event2(this.client));
+  }
+  /**
+   * Retrieves a registered event by its name.
+   *
+   * @param {string} name - The name of the event to retrieve.
+   * @returns {CustomEvent | null} The event instance, or `null` if not found.
+   */
+  get(name) {
+    var _a;
+    return (_a = __privateGet(this, _events).get(name)) != null ? _a : null;
+  }
+};
+_events = new WeakMap();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventManager
+});
+//# sourceMappingURL=eventManager.cjs.map