revbot.js 0.0.13 → 0.0.15-build-test

package/dist/struct/dmChannel.cjs

@@ -0,0 +1,1320 @@
+"use strict";
+var __create = Object.create;
+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 __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __pow = Math.pow;
+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 __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);
+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());
+  });
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+
+// src/struct/dmChannel.ts
+var dmChannel_exports = {};
+__export(dmChannel_exports, {
+  DMChannel: () => DMChannel3
+});
+module.exports = __toCommonJS(dmChannel_exports);
+
+// src/utils/bitField.ts
+var DEFAULT_BIT = 0;
+var _BitField = class _BitField {
+  constructor(bits = DEFAULT_BIT) {
+    this.bitfield = DEFAULT_BIT;
+    this.bitfield = this.self.resolve(bits);
+  }
+  /**
+   * Resolves a bitfield or an array of bitfields into a single number.
+   * @param bit The bitfield or array of bitfields to resolve.
+   * @returns The resolved bitfield as a number.
+   */
+  static resolve(bit) {
+    if (bit instanceof _BitField) return bit.bitfield;
+    if (typeof bit === "number" && bit >= DEFAULT_BIT) return bit;
+    if (Array.isArray(bit)) {
+      return bit.map((p) => this.resolve(p)).reduce((prev, p) => prev | p, DEFAULT_BIT);
+    }
+    if (typeof this.FLAGS[bit] !== "undefined") return this.FLAGS[bit];
+    throw new Error("BITFIELD_INVALID");
+  }
+  /**
+   * Returns the class that this instance belongs to.
+   * @returns The class of the bitfield.
+   */
+  get self() {
+    return this.constructor;
+  }
+  /**
+   * Checks if any of the bits in the bitfield are set.
+   * @param bit The bitfield or array of bitfields to check.
+   * @returns True if any bits are set, false otherwise.
+   */
+  any(bit) {
+    bit = this.self.resolve(bit);
+    return (this.bitfield & bit) !== DEFAULT_BIT;
+  }
+  /**
+   * checks if a specific permission is set.
+   */
+  has(bit) {
+    bit = this.self.resolve(bit);
+    return (this.bitfield & bit) === bit;
+  }
+  /**
+   * Returns an array of all the Permissions that are set in the bitfield.
+   * @returns An array of flag names.
+   */
+  toArray() {
+    return Object.keys(this.self.FLAGS).filter((bit) => this.has(bit));
+  }
+  add(...bits) {
+    let total = 0;
+    for (const bit of bits) {
+      total |= this.self.resolve(bit);
+    }
+    if (Object.isFrozen(this)) {
+      return new this.self(this.bitfield | total);
+    }
+    this.bitfield |= total;
+    return this;
+  }
+  remove(...bits) {
+    let total = 0;
+    for (const bit of bits) {
+      total |= this.self.resolve(bit);
+    }
+    if (Object.isFrozen(this)) {
+      return new this.self(this.bitfield & ~total);
+    }
+    this.bitfield &= ~total;
+    return this;
+  }
+  freeze() {
+    return Object.freeze(this);
+  }
+  valueOf() {
+    return this.bitfield;
+  }
+  /**
+   *
+   * @returns A record of all flags and their boolean values indicating whether they are set.
+   */
+  serialize() {
+    const serialized = {};
+    for (const [flag, bit] of Object.entries(this.self.FLAGS)) {
+      serialized[flag] = this.has(bit);
+    }
+    return serialized;
+  }
+  *[Symbol.iterator]() {
+    yield* __yieldStar(this.toArray());
+  }
+};
+_BitField.FLAGS = {};
+var BitField = _BitField;
+
+// src/struct/base.ts
+var Base = class _Base {
+  /**
+   * Creates a new Base instance.
+   *
+   * @param {client} client - The client instance.
+   */
+  constructor(client3) {
+    this.client = client3;
+  }
+  /**
+   * Compares this object with another to determine if they are equal.
+   *
+   * @param {this | null} [obj] - The object to compare with.
+   * @returns {boolean} `true` if the objects are equal, otherwise `false`.
+   */
+  equals(obj) {
+    if (!obj) return false;
+    for (const key in obj) {
+      const a = obj[key], b = this[key];
+      if (a instanceof _Base && !a.equals(b)) return false;
+      if (a instanceof BitField && a.bitfield !== b.bitfield)
+        return false;
+      if (typeof a === "object" && a !== null) continue;
+      if (a !== b) return false;
+    }
+    return true;
+  }
+  /**
+   * Updates the object with new data and returns a clone of the object.
+   *
+   * @param {PartialObject} data - The data to update the object with.
+   * @param {string[]} [clear] - Fields to clear in the object.
+   * @returns {this} A clone of the updated object.
+   */
+  _update(data, clear) {
+    const clone = this._clone();
+    this._patch(data, clear);
+    return clone;
+  }
+  /**
+   * Patches the object with new data.
+   *
+   * @param {PartialObject} data - The data to patch the object with.
+   * @param {string[]} [_clear] - Fields to clear in the object.
+   * @returns {this} The updated object.
+   * @protected
+   */
+  _patch(data, _clear) {
+    if ("id" in data) this.id = data.id;
+    if ("_id" in data) {
+      if (typeof data._id === "string") this.id = data._id;
+      if (typeof data._id === "object") this.id = data._id.user;
+    }
+    return this;
+  }
+  /**
+   * Creates a deep clone of the object.
+   *
+   * @returns {this} A clone of the object.
+   */
+  _clone() {
+    const clone = Object.assign(Object.create(this), this);
+    for (const key in clone) {
+      const prop = clone[key];
+      if (prop instanceof _Base) clone[key] = prop._clone();
+    }
+    return clone;
+  }
+};
+
+// 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/utils/permissions.ts
+var ChannelPermissions = class extends BitField {
+  constructor(bits) {
+    super(bits);
+  }
+  static resolve(bit) {
+    return super.resolve(bit);
+  }
+};
+ChannelPermissions.FLAGS = {
+  VIEW_CHANNEL: __pow(1, 0),
+  SEND_MESSAGE: __pow(1, 22),
+  MANAGE_MESSAGE: __pow(1, 2),
+  MANAGE_CHANNEL: __pow(1, 3),
+  VOICE_CALL: __pow(1, 4),
+  INVITE_OTHERS: __pow(1, 5),
+  EMBED_LINKS: __pow(1, 6),
+  UPLOAD_FILES: __pow(1, 7)
+};
+var UserPermissions = class extends BitField {
+  constructor(bits) {
+    super(bits);
+  }
+  static resolve(bit) {
+    return super.resolve(bit);
+  }
+};
+UserPermissions.FLAGS = {
+  ACCESS: __pow(1, 0),
+  VIEW_PROFILE: __pow(1, 1),
+  SEND_MESSAGES: __pow(1, 2),
+  INVITE: __pow(1, 3)
+};
+var ServerPermissions = class extends BitField {
+  constructor(bits) {
+    super(bits);
+  }
+  static resolve(bit) {
+    return super.resolve(bit);
+  }
+};
+ServerPermissions.FLAGS = {
+  VIEW_SERVER: __pow(1, 0),
+  MANAGE_ROLES: __pow(1, 1),
+  MANAGE_CHANNELS: __pow(1, 2),
+  MANAGE_SERVER: __pow(1, 3),
+  KICK_MEMBERS: __pow(1, 4),
+  BAN_MEMBERS: __pow(1, 5),
+  CHANGE_NICKNAME: __pow(1, 12),
+  MANAGE_NICKNAMES: __pow(1, 13),
+  CHANGE_AVATAR: __pow(1, 14),
+  REMOVE_AVATARS: __pow(1, 15)
+};
+var FullPermissions = class extends BitField {
+  constructor(bits) {
+    super(bits);
+  }
+  static resolve(bit) {
+    return super.resolve(bit);
+  }
+};
+FullPermissions.FLAGS = {
+  // * Generic permissions
+  /// Manage the channel or channels on the server
+  ManageChannel: __pow(2, 0),
+  /// Manage the server
+  ManageServer: __pow(2, 1),
+  /// Manage permissions on servers or channels
+  ManagePermissions: __pow(2, 2),
+  /// Manage roles on server
+  ManageRole: __pow(2, 3),
+  /// Manage server customisation (includes emoji)
+  ManageCustomisation: __pow(2, 4),
+  // * Member permissions
+  /// Kick other members below their ranking
+  KickMembers: __pow(2, 6),
+  /// Ban other members below their ranking
+  BanMembers: __pow(2, 7),
+  /// Timeout other members below their ranking
+  TimeoutMembers: __pow(2, 8),
+  /// Assign roles to members below their ranking
+  AssignRoles: __pow(2, 9),
+  /// Change own nickname
+  ChangeNickname: __pow(2, 10),
+  /// Change or remove other's nicknames below their ranking
+  ManageNicknames: __pow(2, 11),
+  /// Change own avatar
+  ChangeAvatar: __pow(2, 12),
+  /// Remove other's avatars below their ranking
+  RemoveAvatars: __pow(2, 13),
+  // * Channel permissions
+  /// View a channel
+  ViewChannel: __pow(2, 20),
+  /// Read a channel's past message history
+  ReadMessageHistory: __pow(2, 21),
+  /// Send a message in a channel
+  SendMessage: __pow(2, 22),
+  /// Delete messages in a channel
+  ManageMessages: __pow(2, 23),
+  /// Manage webhook entries on a channel
+  ManageWebhooks: __pow(2, 24),
+  /// Create invites to this channel
+  InviteOthers: __pow(2, 25),
+  /// Send embedded content in this channel
+  SendEmbeds: __pow(2, 26),
+  /// Send attachments and media in this channel
+  UploadFiles: __pow(2, 27),
+  /// Masquerade messages using custom nickname and avatar
+  Masquerade: __pow(2, 28),
+  /// React to messages with emoji
+  React: __pow(2, 29),
+  // * Voice permissions
+  /// Connect to a voice channel
+  Connect: __pow(2, 30),
+  /// Speak in a voice call
+  Speak: __pow(2, 31),
+  /// Share video in a voice call
+  Video: __pow(2, 32),
+  /// Mute other members with lower ranking in a voice call
+  MuteMembers: __pow(2, 33),
+  /// Deafen other members with lower ranking in a voice call
+  DeafenMembers: __pow(2, 34),
+  /// Move members between voice channels
+  MoveMembers: __pow(2, 35),
+  // * Mention permissions
+  /// Mention @everyone or @online
+  MentionEveryone: __pow(2, 37),
+  /// Mention a role
+  MentionRoles: __pow(2, 38),
+  // * Grant all permissions
+  /// Safely grant all permissions
+  GrantAll: 4503599627370495
+};
+var DEFAULT_PERMISSION_DM = new ChannelPermissions([
+  "VIEW_CHANNEL",
+  "VIEW_CHANNEL",
+  "MANAGE_CHANNEL",
+  "VOICE_CALL",
+  "EMBED_LINKS",
+  "UPLOAD_FILES"
+]).freeze();
+
+// src/utils/badges.ts
+var Badges = class extends BitField {
+  constructor(bits) {
+    super(bits);
+  }
+  static resolve(bit) {
+    return super.resolve(bit);
+  }
+};
+Badges.FLAGS = {
+  DEVELOPER: 1 << 0,
+  TRANSLATOR: 1 << 1,
+  SUPPORTER: 1 << 2,
+  RESPONSIBLE_DISCLOSURE: 1 << 3,
+  REVOLT_TEAM: 1 << 4,
+  EARLY_ADOPTER: 1 << 8
+};
+
+// src/struct/message.ts
+var Message = class extends Base {
+  /**
+   * Creates a new Message instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {APIMessage} data - The raw data for the message from the API.
+   */
+  constructor(client3, data) {
+    super(client3);
+    /** The type of the message (e.g., TEXT, SYSTEM). */
+    this.type = "TEXT";
+    /** The content of the message. */
+    this.content = "";
+    /** The ID of the channel where the message was sent. */
+    this.channelId = "";
+    /** The ID of the user who authored the message. */
+    this.authorId = "";
+    /** An array of embeds included in the message. */
+    this.embeds = [];
+    /** An array of file attachments included in the message. */
+    this.attachments = [];
+    /** Mentions included in the message. */
+    this.mentions = new Mentions(this, []);
+    /** The timestamp of when the message was last edited, or `null` if not edited. */
+    this.editedTimestamp = null;
+    /** the reactions and count on a message */
+    this.reactions = /* @__PURE__ */ new Map();
+    this._patch(data);
+  }
+  /**
+   * Updates the message instance with new data from the API.
+   *
+   * @param {APIMessage} data - The raw data for the message from the API.
+   * @returns {this} The updated message instance.
+   * @protected
+   */
+  _patch(data) {
+    super._patch(data);
+    if (Array.isArray(data.embeds)) {
+      this.embeds = data.embeds;
+    }
+    if (Array.isArray(data.attachments)) {
+      this.attachments = data.attachments;
+    }
+    if (Array.isArray(data.mentions)) {
+      this.mentions = new Mentions(this, data.mentions);
+    }
+    if (data.author) {
+      this.authorId = data.author;
+    }
+    if (data.channel) {
+      this.channelId = data.channel;
+    }
+    if (typeof data.content === "string") {
+      this.content = data.content;
+    }
+    if (data.system) {
+      this.type = data.system.type.toUpperCase();
+    }
+    if (data.edited) {
+      this.editedTimestamp = Date.parse(data.edited);
+    }
+    return this;
+  }
+  /**
+   * Gets the creation date of the message.
+   *
+   * @returns {Date} The date when the message was created.
+   */
+  get createdAt() {
+    return UUID.timestampOf(this.id);
+  }
+  /**
+   * Gets the creation timestamp of the message in milliseconds.
+   *
+   * @returns {number} The timestamp of when the message was created.
+   */
+  get createdTimestamp() {
+    return this.createdAt.getTime();
+  }
+  /**
+   * Gets the date when the message was last edited.
+   *
+   * @returns {Date | null} The date of the last edit, or `null` if not edited.
+   */
+  get editedAt() {
+    return this.editedTimestamp ? new Date(this.editedTimestamp) : null;
+  }
+  /**
+   * Checks if the message is a system message.
+   *
+   * @returns {boolean} `true` if the message is a system message, otherwise `false`.
+   */
+  get system() {
+    return this.type !== "TEXT";
+  }
+  /**
+   * Retrieves the author of the message.
+   *
+   * @returns {User | null} The user who authored the message, or `null` if not found.
+   */
+  get author() {
+    var _a;
+    return (_a = this.client.users.cache.get(this.authorId)) != null ? _a : null;
+  }
+  /**
+   * Retrieves the channel where the message was sent.
+   *
+   * @returns {TextChannel | DMChannel | GroupChannel} The channel instance.
+   */
+  get channel() {
+    return this.client.channels.cache.get(this.channelId);
+  }
+  /**
+   * Retrieves the server ID associated with the message, if any.
+   *
+   * @returns {string | null} The server ID, or `null` if the message is not in a server.
+   */
+  get serverId() {
+    const channel = this.channel;
+    return channel.inServer() ? channel.serverId : null;
+  }
+  /**
+   * Retrieves the server associated with the message, if any.
+   *
+   * @returns {Server | null} The server instance, or `null` if not found.
+   */
+  get server() {
+    var _a;
+    return (_a = this.client.servers.cache.get(this.serverId)) != null ? _a : null;
+  }
+  /**
+   * Retrieves the server member who authored the message, if any.
+   *
+   * @returns {ServerMember | null} The server member instance, or `null` if not found.
+   */
+  get member() {
+    var _a, _b;
+    return (_b = (_a = this.server) == null ? void 0 : _a.members.cache.get(this.authorId)) != null ? _b : null;
+  }
+  /**
+   * Gets the URL of the message.
+   *
+   * @returns {string} The URL of the message.
+   */
+  get url() {
+    return `https://app.revolt.chat/${this.serverId ? `server/${this.serverId}` : ""}/channel/${this.channelId}/${this.id}`;
+  }
+  /**
+   * Acknowledges the message.
+   *
+   * @returns {Promise<void>} A promise that resolves when the message is acknowledged.
+   */
+  ack() {
+    return this.channel.messages.ack(this);
+  }
+  /**
+   * Deletes the message.
+   *
+   * @returns {Promise<void>} A promise that resolves when the message is deleted.
+   */
+  delete() {
+    return this.channel.messages.delete(this);
+  }
+  /**
+   * Replies to the message.
+   *
+   * @param {string} content - The content of the reply.
+   * @param {boolean} [mention=true] - Whether to mention the original message author.
+   * @returns {Promise<Message>} A promise that resolves with the sent reply message.
+   */
+  reply(content, mention = true) {
+    return this.channel.messages.send(__spreadProps(__spreadValues({}, typeof content === "object" ? content : { content }), {
+      replies: [{ id: this.id, mention }]
+    }));
+  }
+  /**
+   * Edits the message.
+   *
+   * @param {MessageEditOptions | string} options - The new content or edit options.
+   * @returns {Promise<void>} A promise that resolves when the message is edited.
+   */
+  edit(options) {
+    return this.channel.messages.edit(this, options);
+  }
+  /**
+   * Fetches the latest data for the message.
+   *
+   * @returns {Promise<Message>} A promise that resolves with the updated message instance.
+   */
+  fetch() {
+    return this.channel.messages.fetch(this.id);
+  }
+  /**
+   * Adds a reaction to the message.
+   *
+   * @param {string} emoji - The emoji to react with.
+   * @returns {Promise<void>} A promise that resolves when the reaction is added.
+   */
+  addReaction(emoji) {
+    return this.channel.messages.addReaction(this, emoji);
+  }
+  /**
+   * Removes a reaction from the message.
+   *
+   * @param {string} emoji - The emoji to remove the reaction for.
+   * @param {object} [options] - Options for removing the reaction.
+   * @param {string} [options.user_id] - The user ID to remove the reaction for. If not provided, removes the reaction for the current user.
+   * @param {boolean} [options.remove_all=false] - Whether to remove all of the specified reaction for the message.
+   * @returns {Promise<void>} A promise that resolves when the reaction is removed.
+   */
+  removeReaction(emoji, options) {
+    var _a, _b;
+    return this.channel.messages.removeReaction(
+      this,
+      emoji,
+      (_a = options == null ? void 0 : options.user_id) != null ? _a : void 0,
+      (_b = options == null ? void 0 : options.remove_all) != null ? _b : false
+    );
+  }
+  /**
+   * Removes all reactions from the message.
+   *
+   * @returns {Promise<void>} A promise that resolves when all reactions are removed.
+   */
+  removeAllReactions() {
+    return this.channel.messages.removeAllReactions(this);
+  }
+  /**
+   * Checks if the message is in a server.
+   *
+   * @returns {boolean} `true` if the message is in a server, otherwise `false`.
+   */
+  inServer() {
+    return this.channel.inServer();
+  }
+  /**
+   * Converts the message to a string representation.
+   *
+   * @returns {string} The content of the message.
+   */
+  toString() {
+    return this.content;
+  }
+};
+
+// src/managers/baseManager.ts
+var BaseManager = class {
+  constructor(client3) {
+    this.client = client3;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  _add(raw) {
+    if (!this.holds) throw new Error("Holds is not defined");
+    const obj = new this.holds(this.client, raw);
+    this.cache.set(obj.id, obj);
+    return obj;
+  }
+  _remove(id) {
+    this.cache.delete(id);
+  }
+  resolve(resolvable) {
+    var _a;
+    const id = this.resolveId(resolvable);
+    if (id) return (_a = this.cache.get(id)) != null ? _a : null;
+    return null;
+  }
+  resolveId(resolvable) {
+    var _a;
+    if (resolvable == null) return null;
+    if (typeof resolvable === "string") return resolvable;
+    if (this.holds && resolvable instanceof this.holds) return resolvable.id;
+    const raw = resolvable;
+    if (typeof raw === "object" && "_id" in raw) (_a = raw._id) != null ? _a : null;
+    return null;
+  }
+  valueOf() {
+    return this.cache;
+  }
+};
+
+// src/managers/messageManager.ts
+var import_node_buffer = require("buffer");
+var import_stream = require("stream");
+var import_form_data = __toESM(require("form-data"), 1);
+var import_axios = __toESM(require("axios"), 1);
+var MessageManager = class extends BaseManager {
+  constructor(channel) {
+    super(channel.client);
+    this.channel = channel;
+    this.holds = Message;
+  }
+  /**
+   *
+   * @param content The content to send. Can be a string or an object with the following properties:
+   * - content: The content of the message
+   * - replies: An array of message IDs to reply to
+   * - attachments: An array of attachment URLs, Files, or ReadStreams
+   * - embeds: An array of MessageEmbed objects
+   * @returns Promise that resolves to the sent message
+   */
+  send(content) {
+    return __async(this, null, function* () {
+      if (typeof content === "string") content = { content };
+      let attachments = [];
+      let embeds = [];
+      if (Array.isArray(content.attachments)) {
+        const promises = content.attachments.map((att) => __async(this, null, function* () {
+          const data = new import_form_data.default();
+          if (typeof att === "string") {
+            const readableStream = yield import_axios.default.get(att, {
+              responseType: "stream"
+            });
+            data.append("file", readableStream.data, {
+              filename: att.split("/").pop()
+            });
+          }
+          if (att instanceof import_stream.Readable) {
+            data.append("file", att);
+          }
+          if (att instanceof import_node_buffer.File) {
+            const buffer = Buffer.from(yield att.arrayBuffer());
+            data.append("file", buffer, { filename: att.name });
+          }
+          yield this.client.cdn.post("/attachments", data).then((attachment) => {
+            const { id } = attachment;
+            attachments.push(id);
+          });
+        }));
+        yield Promise.all(promises);
+      }
+      if (Array.isArray(content.embeds)) {
+        const promises = content.embeds.map((embed) => __async(this, null, function* () {
+          const json = yield embed.toJSONWithMedia(this.client);
+          embeds.push(json);
+        }));
+        yield Promise.all(promises);
+      }
+      const resp = yield this.client.api.post(
+        `/channels/${this.channel.id}/messages`,
+        {
+          body: __spreadProps(__spreadValues({}, content), { attachments, embeds, nonce: UUID.generate() })
+        }
+      );
+      return this._add(resp);
+    });
+  }
+  /**
+   * acknowledge a message to mark it as read (not important for bots)
+   * @param message The message to acknowledge
+   * @returns Promise that resolves when the message is acknowledged
+   */
+  ack(message) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(message);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.put(`/channels/${this.channel.id}/ack/${id}`);
+    });
+  }
+  /**
+   * bulk delete messages from the channel
+   * @param messages The messages to delete. Can be an array of message IDs or a Map of message IDs to Message objects.
+   * @returns Promise that resolves when the messages are deleted
+   */
+  bulkDelete(messages) {
+    return __async(this, null, function* () {
+      let ids = [];
+      if (typeof messages === "number") {
+        messages = yield this.fetch(messages);
+        ids = messages instanceof Map ? [...messages.keys()] : [];
+      } else if (messages instanceof Map) {
+        ids = [...messages.keys()];
+      } else {
+        ids = messages.map((m) => this.resolveId(m)).filter(Boolean);
+      }
+      yield this.client.api.delete(`/channels/${this.channel.id}/messages/bulk`, {
+        body: JSON.stringify({ ids })
+      });
+    });
+  }
+  /**
+   * delete a message from the channel
+   * @param message The message to delete. Can be a Message object or a message ID.
+   * @returns Promise that resolves when the message is deleted
+   */
+  delete(message) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(message);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.delete(`/channels/${this.channel.id}/messages/${id}`);
+    });
+  }
+  /**
+   * edit a message in the channel
+   * @param message The message to edit. Can be a Message object or a message ID.
+   * @param options The options to edit the message with. Can be a string or an object with the following properties:
+   * - content: The new content of the message
+   * - attachments: An array of attachment URLs
+   * - embeds: An array of MessageEmbed objects
+   * @returns Promise that resolves when the message is edited
+   */
+  edit(message, options) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(message);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      if (typeof options === "string") options = { content: options };
+      yield this.client.api.patch(`/channels/${this.channel.id}/messages/${id}`, {
+        body: options
+      });
+    });
+  }
+  /**
+   * search for messages in the channel
+   * @param query The query to search for. Can be a string or an object with the following properties:
+   * - query: The query to search for
+   * - limit: The maximum number of messages to return
+   * - before: The message ID to start searching from (exclusive)
+   * - after: The message ID to stop searching at (exclusive)
+   * - sort: The sort order of the results (asc or desc)
+   * @returns Promise that resolves to a Map of message IDs to Message objects
+   */
+  search(query) {
+    return __async(this, null, function* () {
+      if (typeof query === "string") query = { query };
+      const response = yield this.client.api.post(
+        `/channels/${this.channel.id}/search`,
+        {
+          query
+        }
+      );
+      return response.reduce((coll, cur) => {
+        const msg = this._add(cur);
+        coll.set(msg.id, msg);
+        return coll;
+      }, /* @__PURE__ */ new Map());
+    });
+  }
+  fetch(query) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(query);
+      if (id) {
+        const data = yield this.client.api.get(
+          `/channels/${this.channel.id}/messages/${id}`
+        );
+        return this._add(data);
+      }
+      if (typeof query === "number") query = { limit: query };
+      else if (typeof query === "undefined") query = { limit: 100 };
+      const messages = yield this.client.api.get(
+        `/channels/${this.channel.id}/messages`,
+        { query: JSON.stringify(query) }
+      );
+      return messages.reduce((coll, cur) => {
+        const msg = this._add(cur);
+        coll.set(msg.id, msg);
+        return coll;
+      }, /* @__PURE__ */ new Map());
+    });
+  }
+  /**
+   * add a reaction to a message
+   * @param message The message to react to. Can be a Message object or a message ID.
+   * @param emoji emoji to react with. Can be a string or an Emoji object.
+   * @returns Promise that resolves when the reaction is added
+   */
+  addReaction(message, emoji) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(message);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      if (emoji instanceof Emoji) emoji = emoji.id;
+      else if (typeof emoji !== "string") {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.put(
+        `/channels/${this.channel.id}/messages/${id}/reactions/${emoji}`
+      );
+    });
+  }
+  /**
+   *
+   * @param message The message to unreact. Can be a Message object or a message ID.
+   * @param emoji the emoji to unreact with. Can be a string or an Emoji object.
+   * @param user_id The user ID to remove the reaction for. If not provided, removes the reaction for the current user.
+   * @param remove_all Whether to remove all of the specified reaction for the message. Defaults to false.
+   * @returns Promise that resolves when the reaction is removed
+   */
+  removeReaction(message, emoji, user_id, remove_all = false) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(message);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      if (emoji instanceof Emoji) emoji = emoji.id;
+      else if (typeof emoji !== "string") {
+        throw new TypeError("INVALID_TYPE");
+      }
+      const queryString = user_id ? `?user_id=${user_id}&remove_all=${remove_all}` : `?remove_all=${remove_all}`;
+      yield this.client.api.delete(
+        `/channels/${this.channel.id}/messages/${id}/reactions/${emoji}${queryString}`
+      );
+    });
+  }
+  /**
+   * remove all reactions from a message
+   * @param message The message to remove reactions from. Can be a Message object or a message ID.
+   * @returns Promise that resolves when the reactions are removed
+   */
+  removeAllReactions(message) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(message);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.delete(
+        `/channels/${this.channel.id}/messages/${id}/reactions`
+      );
+    });
+  }
+};
+
+// src/struct/channel.ts
+var Channel = class extends Base {
+  constructor() {
+    super(...arguments);
+    this.type = "UNKNOWN";
+  }
+  /**
+   * Gets the timestamp (in milliseconds) when the channel was created.
+   *
+   * @returns {number} The timestamp of the channel's creation.
+   */
+  get createdTimestamp() {
+    return this.createdAt.getTime();
+  }
+  /**
+   * Gets the date and time when the channel was created.
+   *
+   * @returns {Date} The creation date of the channel.
+   */
+  get createdAt() {
+    return UUID.timestampOf(this.id);
+  }
+  /**
+   * Deletes the current channel instance from the client's channel collection.
+   *
+   * This method interacts with the client's channel management system to remove
+   * the channel. Once deleted, the channel will no longer be accessible through
+   * the client.
+   *
+   * @returns {Promise<void>} A promise that resolves when the channel has been successfully deleted.
+   *
+   * @example
+   * ```typescript
+   * const channel = client.channels.get('1234567890');
+   * if (channel) {
+   *   await channel.delete();
+   *   console.log('Channel deleted successfully.');
+   * }
+   * ```
+   */
+  delete() {
+    return this.client.channels.delete(this);
+  }
+  /**
+   * Checks if the channel is a text-based channel.
+   *
+   * @returns {boolean} True if the channel is a text-based channel, otherwise false.
+   */
+  isText() {
+    return "messages" in this;
+  }
+  /**
+   * Checks if the channel is a voice channel.
+   *
+   * @returns {boolean} True if the channel is a voice channel, otherwise false.
+   */
+  isVoice() {
+    return this.type === "VOICE" /* VOICE */;
+  }
+  /**
+   * Checks if the channel is a group channel.
+   *
+   * @returns {boolean} True if the channel is a group channel, otherwise false.
+   */
+  isGroup() {
+    return this.type === "GROUP" /* GROUP */;
+  }
+  /**
+   * Checks if the channel is part of a server.
+   *
+   * @returns {boolean} True if the channel is a server channel, otherwise false.
+   */
+  inServer() {
+    return "serverId" in this;
+  }
+  /**
+   * Converts the channel to a string representation.
+   *
+   * @returns {string} A string representation of the channel in the format `<#channelId>`.
+   */
+  toString() {
+    return `<#${this.id}>`;
+  }
+  /**
+   * Fetches the latest data for the channel from the client's channel collection.
+   *
+   * @param {boolean} [force=true] - Whether to force a fetch even if the channel is cached.
+   * @returns {Promise<Channel>} A promise that resolves with the updated channel instance.
+   */
+  fetch(force = true) {
+    return this.client.channels.fetch(this, { force });
+  }
+};
+
+// src/struct/mentions.ts
+var Mentions = class {
+  /**
+   * Creates a new Mentions instance.
+   *
+   * @param {Message} message - The message associated with the mentions.
+   * @param {string[]} _users - An array of user IDs mentioned in the message.
+   */
+  constructor(message, _users) {
+    this.message = message;
+    this._users = _users;
+    this.client = message.client;
+  }
+  /**
+   * Checks if a specific user is mentioned in the message.
+   *
+   * @param {UserResolvable} user - The user to check.
+   * @returns {boolean} `true` if the user is mentioned, otherwise `false`.
+   * @throws {TypeError} Throws an error if the user cannot be resolved.
+   *
+   * @example
+   * ```typescript
+   * if (mentions.has(someUser)) {
+   *   console.log("User is mentioned!");
+   * }
+   * ```
+   */
+  has(user) {
+    const id = this.client.users.resolveId(user);
+    if (!id) throw new TypeError("INVALID_TYPE");
+    return this._users.includes(id);
+  }
+  /**
+   * Retrieves the server members mentioned in the message.
+   *
+   * @returns {Map<string, ServerMember> | null} A map of user IDs to `ServerMember` instances, or `null` if the message is not in a server.
+   *
+   * @example
+   * ```typescript
+   * const members = mentions.members;
+   * if (members) {
+   *   members.forEach(member => console.log(member.displayName));
+   * }
+   * ```
+   */
+  get members() {
+    const server = this.message.server;
+    if (!server) return null;
+    const members = /* @__PURE__ */ new Map();
+    for (const userId of this._users) {
+      const member = server.members.cache.get(userId);
+      if (member) members.set(member.id, member);
+    }
+    return members;
+  }
+  /**
+   * Retrieves the users mentioned in the message.
+   *
+   * @returns {Map<string, User>} A map of user IDs to `User` instances.
+   *
+   * @example
+   * ```typescript
+   * const users = mentions.users;
+   * users.forEach(user => console.log(user.username));
+   * ```
+   */
+  get users() {
+    const users = /* @__PURE__ */ new Map();
+    for (const userId of this._users) {
+      const user = this.client.users.cache.get(userId);
+      if (user) users.set(user.id, user);
+    }
+    return users;
+  }
+};
+
+// src/struct/messageEmbed.ts
+var import_axios2 = __toESM(require("axios"), 1);
+var import_form_data2 = __toESM(require("form-data"), 1);
+var import_node_buffer2 = require("buffer");
+
+// src/struct/emoji.ts
+var Emoji = class extends Base {
+  /**
+   * Creates a new Emoji instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {Emoji} data - The raw data for the emoji.
+   */
+  constructor(client3, data) {
+    super(client3);
+    /** The parent object of the emoji, which can be a server or other entity. */
+    this.parent = null;
+    /** The ID of the user who created the emoji, or `null` if not available. */
+    this.creator_id = null;
+    /** The name of the emoji, or `null` if not set. */
+    this.name = null;
+    this._patch(data);
+  }
+  /**
+   * Retrieves the user who created the emoji.
+   *
+   * @returns {User | null} The creator of the emoji, or `null` if not found.
+   */
+  get creator() {
+    var _a;
+    return (_a = this.client.users.cache.get(this.creator_id)) != null ? _a : null;
+  }
+  /**
+   * Retrieves the server associated with the emoji, if any.
+   *
+   * @returns {Server | null} The server instance, or `null` if the emoji is not associated with a server.
+   */
+  get server() {
+    var _a;
+    if (!this.parent) return null;
+    return (_a = this.client.servers.cache.get(this.parent.id)) != null ? _a : null;
+  }
+};
+
+// src/client/baseClient.ts
+var import_node_events = require("events");
+
+// src/rest/restClient.ts
+var import_axios4 = require("axios");
+
+// src/rest/restUtils/rateLimitQueue.ts
+var import_axios3 = __toESM(require("axios"), 1);
+
+// src/rest/CDNClient.ts
+var import_axios5 = require("axios");
+
+// src/struct/dmChannel.ts
+var DMChannel3 = class extends Channel {
+  /**
+   * Creates a new DMChannel instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {APIDirectChannel} data - The raw data for the DM channel from the API.
+   */
+  constructor(client3, data) {
+    super(client3);
+    /** The type of the channel, which is always `DM` for direct message channels. */
+    this.type = "DM" /* DM */;
+    /** The default permissions for the DM channel. */
+    this.permissions = DEFAULT_PERMISSION_DM;
+    /** Manages the messages in this DM channel. */
+    this.messages = new MessageManager(this);
+    /** The ID of the last message sent in this DM channel, if any. */
+    this.lastMessageId = null;
+    this._patch(data);
+  }
+  /**
+   * Updates the DM channel instance with new data from the API.
+   *
+   * @param {APIDirectChannel} data - The raw data for the DM channel from the API.
+   * @returns {this} The updated DM channel instance.
+   * @protected
+   */
+  _patch(data) {
+    super._patch(data);
+    if (typeof data.active === "boolean") this.active = data.active;
+    if (data.last_message_id) this.lastMessageId = data.last_message_id;
+    return this;
+  }
+  /**
+   * Retrieves the last message sent in this DM channel.
+   *
+   * @returns {Message | null} The last message, or `null` if no message exists.
+   */
+  get lastMessage() {
+    var _a;
+    if (!this.lastMessageId) return null;
+    return (_a = this.messages.cache.get(this.lastMessageId)) != null ? _a : null;
+  }
+  /**
+   * Deletes multiple messages from this DM channel.
+   *
+   * @param {MessageResolvable[] | Map<string, Message> | number} messages - The messages to delete. This can be an array of message resolvables, a map of messages, or a number indicating how many recent messages to delete.
+   * @returns {Promise<void>} A promise that resolves when the messages have been successfully deleted.
+   *
+   * @example
+   * ```typescript
+   * await dmChannel.bulkDelete(10); // Deletes the last 10 messages.
+   * ```
+   */
+  bulkDelete(messages) {
+    return this.messages.bulkDelete(messages);
+  }
+  /**
+   * Sends a message to this DM channel.
+   *
+   * @param {MessageOptions | string} options - The message content or options for the message.
+   * @returns {Promise<Message>} A promise that resolves with the sent message.
+   *
+   * @example
+   * ```typescript
+   * await dmChannel.send("Hello, world!");
+   * ```
+   */
+  send(options) {
+    return this.messages.send(options);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DMChannel
+});
+//# sourceMappingURL=dmChannel.cjs.map