vimcord 1.0.0

package/dist/index.cjs

@@ -0,0 +1,4203 @@
+"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 __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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseCommandBuilder: () => BaseCommandBuilder,
+  BetterContainer: () => BetterContainer,
+  BetterEmbed: () => BetterEmbed,
+  BetterModal: () => BetterModal,
+  CLI: () => CLI,
+  CommandType: () => CommandType,
+  ContextCommandBuilder: () => ContextCommandBuilder,
+  DynaSend: () => DynaSend,
+  EventBuilder: () => EventBuilder,
+  LogLevel: () => LogLevel,
+  Logger: () => Logger,
+  MissingPermissionReason: () => MissingPermissionReason,
+  MongoDatabase: () => MongoDatabase,
+  MongoSchemaBuilder: () => MongoSchemaBuilder,
+  PaginationTimeoutType: () => PaginationTimeoutType,
+  PaginationType: () => PaginationType,
+  Paginator: () => Paginator,
+  PrefixCommandBuilder: () => PrefixCommandBuilder,
+  Prompt: () => Prompt,
+  PromptResolveType: () => PromptResolveType,
+  RateLimitScope: () => RateLimitScope,
+  SendMethod: () => SendMethod,
+  SlashCommandBuilder: () => SlashCommandBuilder,
+  StatusType: () => StatusType,
+  Vimcord: () => Vimcord,
+  VimcordCLI: () => VimcordCLI,
+  VimcordCommandManager: () => VimcordCommandManager,
+  VimcordContextCommandManager: () => VimcordContextCommandManager,
+  VimcordEventManager: () => VimcordEventManager,
+  VimcordPrefixCommandManager: () => VimcordPrefixCommandManager,
+  VimcordSlashCommandManager: () => VimcordSlashCommandManager,
+  VimcordStatusManager: () => VimcordStatusManager,
+  __zero: () => __zero,
+  cleanMention: () => cleanMention,
+  clientInstances: () => clientInstances,
+  createClient: () => createClient,
+  createMongoSchema: () => createMongoSchema,
+  createToolsConfig: () => createToolsConfig,
+  createVimcordAppConfig: () => createVimcordAppConfig,
+  createVimcordContextCommandConfig: () => createVimcordContextCommandConfig,
+  createVimcordPrefixCommandConfig: () => createVimcordPrefixCommandConfig,
+  createVimcordSlashCommandConfig: () => createVimcordSlashCommandConfig,
+  createVimcordStaffConfig: () => createVimcordStaffConfig,
+  createVimcordStatusConfig: () => createVimcordStatusConfig,
+  defineGlobalToolsConfig: () => defineGlobalToolsConfig,
+  dynaSend: () => dynaSend,
+  fetchChannel: () => fetchChannel,
+  fetchGuild: () => fetchGuild,
+  fetchMember: () => fetchMember,
+  fetchMessage: () => fetchMessage,
+  fetchRole: () => fetchRole,
+  fetchUser: () => fetchUser,
+  formatThousands: () => formatThousands,
+  getCallerFileName: () => getCallerFileName,
+  getClientInstances: () => getClientInstances,
+  getFirstMentionId: () => getFirstMentionId,
+  getMessageMention: () => getMessageMention,
+  getProcessDir: () => getProcessDir,
+  globalVimcordToolsConfig: () => globalVimcordToolsConfig,
+  importModulesFromDir: () => importModulesFromDir,
+  initCLI: () => initCLI,
+  isMentionOrSnowflake: () => isMentionOrSnowflake,
+  logger: () => logger,
+  pickRandom: () => pickRandom,
+  prompt: () => prompt,
+  retryExponentialBackoff: () => retryExponentialBackoff,
+  sendCommandErrorEmbed: () => sendCommandErrorEmbed,
+  useClient: () => useClient,
+  useMongoDatabase: () => useMongoDatabase,
+  useReadyClient: () => useReadyClient,
+  validateCommandPermissions: () => validateCommandPermissions
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/command.base.ts
+var CommandType = /* @__PURE__ */ ((CommandType3) => {
+  CommandType3[CommandType3["Slash"] = 0] = "Slash";
+  CommandType3[CommandType3["Prefix"] = 1] = "Prefix";
+  CommandType3[CommandType3["Context"] = 2] = "Context";
+  return CommandType3;
+})(CommandType || {});
+var MissingPermissionReason = /* @__PURE__ */ ((MissingPermissionReason2) => {
+  MissingPermissionReason2[MissingPermissionReason2["User"] = 0] = "User";
+  MissingPermissionReason2[MissingPermissionReason2["Bot"] = 1] = "Bot";
+  MissingPermissionReason2[MissingPermissionReason2["Role"] = 2] = "Role";
+  MissingPermissionReason2[MissingPermissionReason2["UserBlacklisted"] = 3] = "UserBlacklisted";
+  MissingPermissionReason2[MissingPermissionReason2["RoleBlacklisted"] = 4] = "RoleBlacklisted";
+  MissingPermissionReason2[MissingPermissionReason2["NotInGuild"] = 5] = "NotInGuild";
+  MissingPermissionReason2[MissingPermissionReason2["NotGuildOwner"] = 6] = "NotGuildOwner";
+  MissingPermissionReason2[MissingPermissionReason2["NotBotOwner"] = 7] = "NotBotOwner";
+  MissingPermissionReason2[MissingPermissionReason2["NotBotStaff"] = 8] = "NotBotStaff";
+  return MissingPermissionReason2;
+})(MissingPermissionReason || {});
+var RateLimitScope = /* @__PURE__ */ ((RateLimitScope2) => {
+  RateLimitScope2[RateLimitScope2["User"] = 0] = "User";
+  RateLimitScope2[RateLimitScope2["Guild"] = 1] = "Guild";
+  RateLimitScope2[RateLimitScope2["Channel"] = 2] = "Channel";
+  RateLimitScope2[RateLimitScope2["Global"] = 3] = "Global";
+  return RateLimitScope2;
+})(RateLimitScope || {});
+
+// src/validators/permissions.validator.ts
+var import_discord = require("discord.js");
+function __existsAndTrue(value) {
+  return value !== void 0 && value;
+}
+function validateCommandPermissions(permissions, client, user, command) {
+  const inGuild = "guild" in user;
+  const missingUserPermissions = [];
+  const missingBotPermissions = [];
+  const missingRoles = [];
+  if (permissions.user?.length && inGuild) {
+    for (const permission of permissions.user) {
+      if (!user.permissions.has(permission)) {
+        missingUserPermissions.push(permission);
+      }
+    }
+    if (missingUserPermissions.length) {
+      return { validated: false, failReason: 0 /* User */, missingUserPermissions };
+    }
+  }
+  if (permissions.bot?.length && inGuild && user.guild.members.me) {
+    for (const permission of permissions.bot) {
+      if (!user.guild.members.me.permissions.has(permission)) {
+        missingBotPermissions.push(permission);
+      }
+    }
+    if (missingBotPermissions.length) {
+      return { validated: false, failReason: 1 /* Bot */, missingBotPermissions };
+    }
+  }
+  if (permissions.roles?.length && inGuild) {
+    for (const role of permissions.roles) {
+      if (!user.roles.cache.has(role)) {
+        missingRoles.push(role);
+      }
+    }
+    if (missingRoles.length) {
+      return { validated: false, failReason: 2 /* Role */, missingRoles };
+    }
+  }
+  if (permissions.userBlacklist?.length) {
+    if (permissions.userBlacklist.includes(user.id)) {
+      return { validated: false, failReason: 3 /* UserBlacklisted */, blacklistedUser: user.id };
+    }
+  }
+  if (permissions.roleBlacklist?.length && inGuild) {
+    if (user.roles.cache.some((role) => permissions.roleBlacklist.includes(role.id))) {
+      return { validated: false, failReason: 4 /* RoleBlacklisted */, blacklistedRole: user.id };
+    }
+  }
+  if (__existsAndTrue(permissions.guildOnly) && !inGuild) {
+    return { validated: false, failReason: 5 /* NotInGuild */ };
+  }
+  if (__existsAndTrue(permissions.guildOwnerOnly) && inGuild && user.id !== user.guild.ownerId) {
+    return { validated: false, failReason: 6 /* NotGuildOwner */ };
+  }
+  if (__existsAndTrue(permissions.botOwnerOnly) && user.id !== client.config.staff.ownerId) {
+    return { validated: false, failReason: 7 /* NotBotOwner */ };
+  }
+  if (__existsAndTrue(permissions.botStaffOnly)) {
+    if (!client.config.staff.superUsers.includes(user.id)) {
+      return { validated: false, failReason: 8 /* NotBotStaff */ };
+    }
+    if (inGuild) {
+      for (const [k, role] of user.roles.cache) {
+        if (!user.roles.cache.has(role.id)) {
+          missingRoles.push(role.id);
+        }
+      }
+      if (missingRoles.length) {
+        return { validated: false, failReason: 8 /* NotBotStaff */, missingRoles };
+      }
+    }
+    if (command instanceof import_discord.BaseInteraction && command.isCommand()) {
+      let commandName = null;
+      if (command.isChatInputCommand()) {
+        const subcommand = command.options.getSubcommand();
+        commandName = `${command.commandName}${subcommand ? ` ${subcommand}` : ""}`;
+      } else {
+        commandName = command.commandName;
+      }
+      if (!client.config.staff.bypassers.some(
+        (bypass) => bypass.commandName.toLowerCase() === commandName.toLowerCase() && bypass.userIds.includes(user.id)
+      )) {
+        return { validated: false, failReason: 8 /* NotBotStaff */ };
+      }
+    }
+    if (typeof command === "string" && !client.config.staff.bypassers.some(
+      (bypass) => bypass.commandName.toLowerCase() === command.toLowerCase() && bypass.userIds.includes(user.id)
+    )) {
+      return { validated: false, failReason: 8 /* NotBotStaff */ };
+    }
+  }
+  return { validated: true };
+}
+
+// src/builders/baseCommand.builder.ts
+var import_node_crypto = require("crypto");
+var import_lodash = __toESM(require("lodash"));
+var BaseCommandBuilder = class {
+  uuid = (0, import_node_crypto.randomUUID)();
+  commandType;
+  client;
+  enabled;
+  conditions;
+  permissions;
+  metadata;
+  rateLimit;
+  beforeExecute;
+  execute;
+  afterExecute;
+  onRateLimit;
+  onMissingPermissions;
+  onConditionsNotMet;
+  onUsedWhenDisabled;
+  onError;
+  globalRateLimitData = { executions: 0, timestamp: 0 };
+  userRateLimitData = /* @__PURE__ */ new Map();
+  guildRateLimitData = /* @__PURE__ */ new Map();
+  channelRateLimitData = /* @__PURE__ */ new Map();
+  constructor(type, config) {
+    this.commandType = type;
+    this.enabled = config?.enabled ?? true;
+    this.conditions = config?.conditions;
+    this.permissions = config?.permissions;
+    this.metadata = config?.metadata;
+    this.rateLimit = config?.rateLimit;
+    this.beforeExecute = config?.beforeExecute;
+    this.execute = config?.execute;
+    this.afterExecute = config?.afterExecute;
+    this.onRateLimit = config?.onRateLimit;
+    this.onMissingPermissions = config?.onMissingPermissions;
+    this.onConditionsNotMet = config?.onConditionsNotMet;
+    this.onUsedWhenDisabled = config?.onUsedWhenDisabled;
+    this.onError = config?.onError;
+    this.validateBaseConfig();
+  }
+  validateBaseConfig() {
+    if (this.rateLimit) {
+      if (this.rateLimit.max <= 0) {
+        throw new Error("DJSSlashCommandBuilder: Rate limit max must be greater than 0");
+      }
+      if (this.rateLimit.interval <= 0) {
+        throw new Error("DJSSlashCommandBuilder: Rate limit interval must be greater than 0");
+      }
+    }
+  }
+  toConfig() {
+    return {
+      enabled: this.enabled,
+      conditions: this.conditions,
+      permissions: this.permissions,
+      metadata: this.metadata,
+      rateLimit: this.rateLimit,
+      beforeExecute: this.beforeExecute,
+      execute: this.execute,
+      afterExecute: this.afterExecute,
+      onMissingPermissions: this.onMissingPermissions,
+      onConditionsNotMet: this.onConditionsNotMet,
+      onUsedWhenDisabled: this.onUsedWhenDisabled,
+      onRateLimit: this.onRateLimit,
+      onError: this.onError
+    };
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+    return this;
+  }
+  addConditions(...conditions) {
+    if (!this.conditions) this.conditions = [];
+    this.conditions.push(...conditions);
+    return this;
+  }
+  setConditions(conditions) {
+    this.conditions = conditions;
+    return this;
+  }
+  setPermissions(permissions) {
+    this.permissions = import_lodash.default.merge(this.permissions, permissions);
+    return this;
+  }
+  setMetadata(metadata) {
+    this.metadata = import_lodash.default.merge(this.metadata, metadata);
+    return this;
+  }
+  setRateLimit(options) {
+    this.rateLimit = options;
+    return this;
+  }
+  setBeforeExecute(callback) {
+    this.beforeExecute = callback;
+    return this;
+  }
+  setExecute(callback) {
+    this.execute = callback;
+    return this;
+  }
+  setAfterExecute(callback) {
+    this.afterExecute = callback;
+    return this;
+  }
+  setOnRateLimit(callback) {
+    this.onRateLimit = callback;
+    return this;
+  }
+  setOnMissingPermissions(callback) {
+    this.onMissingPermissions = callback;
+    return this;
+  }
+  setOnConditionsNotMet(callback) {
+    this.onConditionsNotMet = callback;
+    return this;
+  }
+  setOnUsedWhenDisabled(callback) {
+    this.onUsedWhenDisabled = callback;
+    return this;
+  }
+  setOnError(callback) {
+    this.onError = callback;
+    return this;
+  }
+  getRateLimitInfo(user, guild, channel) {
+    if (!this.rateLimit) return null;
+    let rateLimitData;
+    switch (this.rateLimit.scope) {
+      case 0 /* User */:
+        if (!user) return null;
+        rateLimitData = this.userRateLimitData.get(user.id) ?? { executions: 0, timestamp: 0 };
+        break;
+      case 1 /* Guild */:
+        if (!guild) return null;
+        rateLimitData = this.guildRateLimitData.get(guild.id) ?? { executions: 0, timestamp: 0 };
+        break;
+      case 2 /* Channel */:
+        if (!channel) return null;
+        rateLimitData = this.channelRateLimitData.get(channel.id) ?? { executions: 0, timestamp: 0 };
+        break;
+      case 3 /* Global */:
+        rateLimitData = this.globalRateLimitData;
+        break;
+      default:
+        return null;
+    }
+    return { ...rateLimitData, isLimited: this.isRateLimited(user, guild, channel, false) };
+  }
+  isRateLimited(user, guild, channel, updateExecutions = true) {
+    if (!this.rateLimit) return false;
+    const now = Date.now();
+    let rateLimitData;
+    switch (this.rateLimit.scope) {
+      case 0 /* User */:
+        if (!user) return false;
+        rateLimitData = this.userRateLimitData.get(user.id) ?? { executions: 0, timestamp: 0 };
+        if (now - rateLimitData.timestamp >= this.rateLimit.interval) {
+          rateLimitData.executions = 0;
+          rateLimitData.timestamp = now;
+        }
+        if (updateExecutions) rateLimitData.executions++;
+        this.userRateLimitData.set(user.id, rateLimitData);
+        break;
+      case 1 /* Guild */:
+        if (!guild) return false;
+        rateLimitData = this.guildRateLimitData.get(guild.id) ?? { executions: 0, timestamp: 0 };
+        if (now - rateLimitData.timestamp >= this.rateLimit.interval) {
+          rateLimitData.executions = 0;
+          rateLimitData.timestamp = now;
+        }
+        if (updateExecutions) rateLimitData.executions++;
+        this.guildRateLimitData.set(guild.id, rateLimitData);
+        break;
+      case 2 /* Channel */:
+        if (!channel) return false;
+        rateLimitData = this.guildRateLimitData.get(channel.id) ?? { executions: 0, timestamp: 0 };
+        if (now - rateLimitData.timestamp >= this.rateLimit.interval) {
+          rateLimitData.executions = 0;
+          rateLimitData.timestamp = now;
+        }
+        if (updateExecutions) rateLimitData.executions++;
+        this.channelRateLimitData.set(channel.id, rateLimitData);
+        break;
+      case 3 /* Global */:
+        rateLimitData = this.globalRateLimitData;
+        if (now - rateLimitData.timestamp >= this.rateLimit.interval) {
+          rateLimitData.executions = 0;
+          rateLimitData.timestamp = now;
+        }
+        if (updateExecutions) rateLimitData.executions++;
+        this.globalRateLimitData = rateLimitData;
+        break;
+    }
+    return rateLimitData.executions >= this.rateLimit.max;
+  }
+  checkPermissions(client, user, command) {
+    if (!this.permissions) return { validated: true };
+    return validateCommandPermissions(this.permissions, client, user, command);
+  }
+  async checkConditions(...args) {
+    if (!this.conditions?.length) return true;
+    const results = await Promise.all(this.conditions.map((condition) => condition(...args)));
+    return results.every(Boolean);
+  }
+  async _runPreflight(clientConfig, command, ...args) {
+    try {
+      if (!this.enabled) {
+        await clientConfig.onUsedWhenDisabled?.(...args);
+        await this.onUsedWhenDisabled?.(...args);
+        return;
+      }
+      if (this.isRateLimited(args[1]?.member || args[1]?.author, args[1].guild, args[1].channel)) {
+        await clientConfig.onRateLimit?.(...args);
+        await this.rateLimit?.onRateLimit?.(...args);
+        return;
+      }
+      const permissionResults = this.checkPermissions(
+        args[0],
+        args[1]?.member || args[1]?.author || args[1]?.user,
+        command
+      );
+      if (!permissionResults.validated) {
+        await clientConfig.onMissingPermissions?.(permissionResults, ...args);
+        await this.onMissingPermissions?.(permissionResults, ...args);
+        return;
+      }
+      if (!await this.checkConditions(...args)) {
+        await clientConfig.onConditionsNotMet?.(...args);
+        await this.onConditionsNotMet?.(...args);
+        return;
+      }
+    } catch (err) {
+      if (this.onError) {
+        return this.onError(err, ...args);
+      } else if (clientConfig.onError) {
+        return clientConfig.onError(err, ...args);
+      } else {
+        throw err;
+      }
+    }
+  }
+  async _runCabinCheck(clientConfig, ...args) {
+    try {
+      await clientConfig.beforeExecute?.(...args);
+      await this.beforeExecute?.(...args);
+    } catch (err) {
+      if (this.onError) {
+        return this.onError(err, ...args);
+      } else if (clientConfig.onError) {
+        return clientConfig.onError(err, ...args);
+      } else {
+        throw err;
+      }
+    }
+  }
+  async _runFlyAndLand(clientConfig, ...args) {
+    try {
+      const result = await this.execute?.(...args);
+      await clientConfig?.afterExecute?.(result, ...args);
+      await this.afterExecute?.(result, ...args);
+    } catch (err) {
+      if (this.onError) {
+        return this.onError(err, ...args);
+      } else if (clientConfig.onError) {
+        return clientConfig.onError(err, ...args);
+      } else {
+        throw err;
+      }
+    }
+  }
+};
+
+// src/builders/contextCommand.builder.ts
+var import_discord2 = require("discord.js");
+var import_lodash2 = __toESM(require("lodash"));
+var ContextCommandBuilder = class extends BaseCommandBuilder {
+  builder;
+  deferReply;
+  deployment;
+  constructor(config) {
+    super(2 /* Context */, config);
+    this.setBuilder(config.builder);
+    this.deferReply = config?.deferReply;
+    this.deployment = config?.deployment;
+    this.validateConfig();
+  }
+  validateBuilder() {
+    if (!this.builder.name) {
+      throw new Error("VContextCommandBuilder: Command name is required");
+    }
+    try {
+      this.builder.toJSON();
+    } catch (err) {
+      throw new Error("VContextCommandBuilder: Invalid command builder", { cause: err });
+    }
+  }
+  validateConfig() {
+  }
+  toConfig() {
+    return {
+      ...super.toConfig(),
+      builder: this.builder,
+      deferReply: this.deferReply,
+      deployment: this.deployment
+    };
+  }
+  setBuilder(builder) {
+    if (typeof builder === "function") {
+      this.builder = builder(new import_discord2.ContextMenuCommandBuilder());
+    } else {
+      this.builder = builder;
+    }
+    this.validateBuilder();
+    return this;
+  }
+  setDeferReply(defer) {
+    this.deferReply = defer;
+    return this;
+  }
+  setDeployment(deployment) {
+    this.deployment = import_lodash2.default.merge(this.deployment, deployment);
+    return this;
+  }
+  async executeCommand(client, interaction) {
+    try {
+      await this._runPreflight(client.config.contextCommands, interaction, client, interaction);
+      await this._runCabinCheck(client.config.contextCommands, client, interaction);
+      if (this.deferReply && !interaction.replied && !interaction.deferred) {
+        await interaction.deferReply(typeof this.deferReply === "object" ? this.deferReply : void 0);
+      }
+      return this._runFlyAndLand(client.config.contextCommands, client, interaction);
+    } catch (err) {
+      if (this.onError) {
+        return this.onError(err, client, interaction);
+      } else if (client.config.contextCommands.onError) {
+        return client.config.contextCommands.onError(err, client, interaction);
+      } else {
+        throw err;
+      }
+    } finally {
+      if (client.config.contextCommands.logExecution) {
+        client.logger.commandExecuted(this.builder.name, interaction.user.username, interaction.guild?.name);
+      }
+    }
+  }
+};
+
+// src/utils/dir.ts
+var import_jstools = __toESM(require("jstools"));
+var import_node_path = __toESM(require("path"));
+function getProcessDir() {
+  const mainPath = process.argv[1];
+  if (!mainPath) return "";
+  return import_node_path.default.dirname(mainPath);
+}
+async function importModulesFromDir(dir, fnPrefix) {
+  const cwd = getProcessDir();
+  const MODULE_RELATIVE_PATH = import_node_path.default.join(cwd, dir);
+  const MODULE_LOG_PATH = dir;
+  const files = import_jstools.default.readDir(MODULE_RELATIVE_PATH, { recursive: true }).filter(
+    (fn) => fn.endsWith(`${fnPrefix ? `.${fnPrefix}` : ""}.js`) || fn.endsWith(`${fnPrefix ? `.${fnPrefix}` : ""}.ts`)
+  );
+  if (!files.length) {
+    return [];
+  }
+  const modules = await Promise.all(
+    files.map(async (fn) => {
+      let _path = import_node_path.default.join(MODULE_RELATIVE_PATH, fn);
+      let _logPath = `./${import_node_path.default.join(MODULE_LOG_PATH, fn)}`;
+      let _module;
+      try {
+        delete require.cache[require.resolve(_path)];
+        _module = require(_path);
+      } catch (err) {
+        console.warn(`Failed to import module at '${_logPath}'`, err);
+        _module = null;
+      }
+      return { module: _module, path: _logPath };
+    })
+  );
+  const filteredModules = modules.filter((m) => m.module);
+  if (!filteredModules.length) {
+    console.warn(`No valid modules were found in directory '${dir}'`);
+  }
+  return filteredModules;
+}
+function getCallerFileName() {
+  const stack = new Error().stack?.split("\n");
+  return stack?.at(4)?.split("at file")?.at(1)?.split("/").at(-1)?.split(":").at(0)?.split(".").at(0);
+}
+
+// src/builders/event.builder.ts
+var import_node_crypto2 = require("crypto");
+var import_lodash3 = __toESM(require("lodash"));
+var EventBuilder = class _EventBuilder {
+  uuid = (0, import_node_crypto2.randomUUID)();
+  event;
+  name = getCallerFileName() || this.uuid;
+  enabled;
+  once;
+  priority;
+  conditions;
+  metadata;
+  deployment;
+  rateLimit;
+  beforeExecute;
+  execute;
+  afterExecute;
+  onError;
+  rateLimitData = { executions: 0, timestamp: 0 };
+  static create(event, name) {
+    return new _EventBuilder({ event, name });
+  }
+  constructor(config) {
+    this.event = config.event;
+    this.name = config.name || this.name;
+    this.enabled = config.enabled ?? true;
+    this.once = config.once ?? false;
+    this.priority = config.priority ?? 0;
+    this.conditions = config.conditions;
+    this.metadata = config.metadata;
+    this.deployment = config.deployment;
+    this.rateLimit = config.rateLimit;
+    this.beforeExecute = config.beforeExecute;
+    this.execute = config.execute;
+    this.afterExecute = config.afterExecute;
+    this.onError = config.onError;
+    this.validate();
+  }
+  validate() {
+    if (!this.event) {
+      throw new Error("Event name is required");
+    }
+    if (this.priority !== void 0 && this.priority < 0) {
+      throw new Error("Priority must be non-negative");
+    }
+    if (this.rateLimit) {
+      if (this.rateLimit.max <= 0) {
+        throw new Error("Rate limit max must be greater than 0");
+      }
+      if (this.rateLimit.interval <= 0) {
+        throw new Error("Rate limit interval must be greater than 0");
+      }
+    }
+    if (!this.execute) {
+      throw new Error("Execute function is required");
+    }
+  }
+  clone() {
+    return new _EventBuilder(this.toConfig());
+  }
+  toConfig() {
+    return {
+      event: this.event,
+      name: this.name,
+      enabled: this.enabled,
+      once: this.once,
+      priority: this.priority,
+      conditions: this.conditions,
+      metadata: this.metadata,
+      deployment: this.deployment,
+      rateLimit: this.rateLimit,
+      beforeExecute: this.beforeExecute,
+      execute: this.execute,
+      afterExecute: this.afterExecute,
+      onError: this.onError
+    };
+  }
+  setEvent(event) {
+    this.event = event;
+    return this;
+  }
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+    return this;
+  }
+  enable() {
+    return this.setEnabled(true);
+  }
+  disable() {
+    return this.setEnabled(false);
+  }
+  setOnce(once = true) {
+    this.once = once;
+    return this;
+  }
+  setPriority(priority) {
+    this.priority = priority;
+    return this;
+  }
+  addCondition(condition) {
+    if (!this.conditions) this.conditions = [];
+    this.conditions.push(condition);
+    return this;
+  }
+  setConditions(conditions) {
+    this.conditions = conditions;
+    return this;
+  }
+  setMetadata(metadata) {
+    this.metadata = import_lodash3.default.merge(this.metadata, metadata);
+    return this;
+  }
+  setDeployment(deployment) {
+    this.deployment = import_lodash3.default.merge(this.deployment, deployment);
+    return this;
+  }
+  setRateLimit(options) {
+    this.rateLimit = options;
+    return this;
+  }
+  setBeforeExecute(beforeExecute) {
+    this.beforeExecute = beforeExecute;
+    return this;
+  }
+  setExecute(execute) {
+    this.execute = execute;
+    return this;
+  }
+  setAfterExecute(afterExecute) {
+    this.afterExecute = afterExecute;
+    return this;
+  }
+  setOnError(onError) {
+    this.onError = onError;
+    return this;
+  }
+  getRateLimitInfo() {
+    if (!this.rateLimit) return null;
+    return { ...this.rateLimitData, isLimited: this.isRateLimited(false) };
+  }
+  resetRateLimit() {
+    this.rateLimitData = { executions: 0, timestamp: 0 };
+    return this;
+  }
+  isRateLimited(updateExecutions = true) {
+    if (!this.rateLimit) return false;
+    const now = Date.now();
+    if (now - this.rateLimitData.timestamp >= this.rateLimit.interval) {
+      this.rateLimitData.executions = 0;
+      this.rateLimitData.timestamp = now;
+    }
+    if (updateExecutions) {
+      this.rateLimitData.executions++;
+    }
+    return this.rateLimitData.executions >= this.rateLimit.max;
+  }
+  async checkConditions(...args) {
+    if (!this.conditions?.length) return true;
+    const results = await Promise.all(this.conditions.map((condition) => condition(...args)));
+    return results.every(Boolean);
+  }
+  async executeEvent(...args) {
+    try {
+      if (!this.enabled) {
+        return;
+      }
+      if (this.isRateLimited()) {
+        if (this.rateLimit?.onRateLimit) {
+          return await this.rateLimit.onRateLimit(...args);
+        }
+        return;
+      }
+      if (!await this.checkConditions(...args)) {
+        return;
+      }
+      if (this.beforeExecute) {
+        await this.beforeExecute(...args);
+      }
+      const result = await this.execute?.(...args);
+      if (this.afterExecute) {
+        await this.afterExecute(result, ...args);
+      }
+      return result;
+    } catch (err) {
+      if (this.onError) {
+        return await this.onError(err, ...args);
+      }
+      console.error(`Error in event '${this.name}':`, err);
+      throw err;
+    }
+  }
+};
+
+// src/builders/prefixCommand.builder.ts
+var PrefixCommandBuilder = class extends BaseCommandBuilder {
+  name;
+  aliases;
+  description;
+  constructor(config) {
+    super(1 /* Prefix */, config);
+    this.name = config.name;
+    this.description = config.description;
+    this.validateConfig();
+  }
+  validateConfig() {
+  }
+  toConfig() {
+    return {
+      ...super.toConfig(),
+      name: this.name,
+      description: this.description
+    };
+  }
+  async executeCommand(client, message) {
+    try {
+      await this._runPreflight(client.config.prefixCommands, this.name, client, message);
+      await this._runCabinCheck(client.config.prefixCommands, client, message);
+      return this._runFlyAndLand(client.config.prefixCommands, client, message);
+    } catch (err) {
+      this.onError?.(err, client, message);
+      client.config.prefixCommands.onError?.(err, client, message);
+      throw err;
+    } finally {
+      if (client.config.prefixCommands.logExecution) {
+        client.logger.commandExecuted(this.name, message.author.username, message.guild?.name);
+      }
+    }
+  }
+};
+
+// src/builders/slashCommand.builder.ts
+var import_discord3 = require("discord.js");
+var import_lodash4 = __toESM(require("lodash"));
+var SlashCommandBuilder = class extends BaseCommandBuilder {
+  builder;
+  deferReply;
+  deployment;
+  routes = /* @__PURE__ */ new Map();
+  onUnknownRouteHandler;
+  constructor(config) {
+    super(0 /* Slash */, config);
+    this.setBuilder(config.builder);
+    this.setRoutes(...config.routes ?? []);
+    this.deferReply = config?.deferReply;
+    this.deployment = config?.deployment;
+    this.validateConfig();
+  }
+  validateBuilder() {
+    if (!this.builder.name) {
+      throw new Error("VSlashCommandBuilder: Command name is required");
+    }
+    if (!this.builder.description) {
+      throw new Error("VSlashCommandBuilder: Command description is required");
+    }
+    try {
+      this.builder.toJSON();
+    } catch (err) {
+      throw new Error("VSlashCommandBuilder: Invalid command builder", { cause: err });
+    }
+  }
+  validateConfig() {
+  }
+  toConfig() {
+    return {
+      ...super.toConfig(),
+      builder: this.builder,
+      deferReply: this.deferReply,
+      deployment: this.deployment,
+      routes: this.routes.size ? Array.from(this.routes.entries()).map(([k, v]) => ({ name: k, handler: v })) : void 0,
+      onUnknownRouteHandler: this.onUnknownRouteHandler
+    };
+  }
+  setBuilder(builder) {
+    if (typeof builder === "function") {
+      this.builder = builder(new import_discord3.SlashCommandBuilder());
+    } else {
+      this.builder = builder;
+    }
+    this.validateBuilder();
+    return this;
+  }
+  setDeferReply(defer) {
+    this.deferReply = defer;
+    return this;
+  }
+  setDeployment(deployment) {
+    this.deployment = import_lodash4.default.merge(this.deployment, deployment);
+    return this;
+  }
+  setRoutes(...routes) {
+    if (routes.length) {
+      for (const route of routes) {
+        this.routes.set(route.name.toLowerCase(), route.handler);
+      }
+    } else {
+      this.routes = /* @__PURE__ */ new Map();
+    }
+    return this;
+  }
+  addRoutes(...routes) {
+    for (const route of routes) {
+      this.routes.set(route.name.toLowerCase(), route.handler);
+    }
+    return this;
+  }
+  setUnknownRouteHandler(handler) {
+    this.onUnknownRouteHandler = handler;
+    return this;
+  }
+  async executeCommand(client, interaction) {
+    try {
+      await this._runPreflight(client.config.slashCommands, interaction, client, interaction);
+      await this._runCabinCheck(client.config.slashCommands, client, interaction);
+      if (this.deferReply && !interaction.replied && !interaction.deferred) {
+        await interaction.deferReply(typeof this.deferReply === "object" ? this.deferReply : void 0);
+      }
+      if (this.routes.size) {
+        const subCommand = interaction.options.getSubcommand();
+        const route = this.routes.get(subCommand);
+        if (route) {
+          const result = await route(client, interaction);
+          await this.afterExecute?.(result, client, interaction);
+          return result;
+        } else if (this.onUnknownRouteHandler) {
+          const result = await this.onUnknownRouteHandler?.(client, interaction);
+          await this.afterExecute?.(result, client, interaction);
+          return result;
+        }
+      }
+      return this._runFlyAndLand(client.config.slashCommands, client, interaction);
+    } catch (err) {
+      this.onError?.(err, client, interaction);
+      client.config.slashCommands.onError?.(err, client, interaction);
+      throw err;
+    } finally {
+      if (client.config.slashCommands.logExecution) {
+        client.logger.commandExecuted(this.builder.name, interaction.user.username, interaction.guild?.name);
+      }
+    }
+  }
+};
+
+// src/client.ts
+var import_discord10 = require("discord.js");
+var import_dotenv = __toESM(require("dotenv"));
+
+// src/configs/tools.config.ts
+var import_lodash5 = __toESM(require("lodash"));
+var globalVimcordToolsConfig = {
+  devMode: false,
+  embedColor: [],
+  embedColorDev: [],
+  timeouts: {
+    pagination: 6e4,
+    prompt: 3e4,
+    modalSubmit: 6e4
+  },
+  paginator: {
+    notAParticipantMessage: "You are not allowed to use this!",
+    jumpableThreshold: 5,
+    longThreshold: 4,
+    buttons: {
+      first: { label: "\u25C0\u25C0", emoji: { name: "\u23EE\uFE0F", id: "\u23EE\uFE0F" } },
+      back: { label: "\u25C0", emoji: { name: "\u25C0\uFE0F", id: "\u25C0\uFE0F" } },
+      jump: { label: "\u{1F4C4}", emoji: { name: "\u{1F4C4}", id: "\u{1F4C4}" } },
+      next: { label: "\u25B6", emoji: { name: "\u25B6\uFE0F", id: "\u25B6\uFE0F" } },
+      last: { label: "\u25B6\u25B6", emoji: { name: "\u23ED\uFE0F", id: "\u23ED\uFE0F" } }
+    }
+  },
+  prompt: {
+    defaultTitle: "Are you sure?",
+    defaultDescription: "Make sure you know what you're doing!",
+    confirmLabel: "Confirm",
+    rejectLabel: "Cancel"
+  }
+};
+function defineGlobalToolsConfig(options) {
+  Object.assign(globalVimcordToolsConfig, import_lodash5.default.merge(globalVimcordToolsConfig, options));
+}
+function createToolsConfig(options) {
+  return import_lodash5.default.merge(globalVimcordToolsConfig, options);
+}
+
+// src/configs/app.config.ts
+var import_lodash6 = __toESM(require("lodash"));
+var defaultConfig = {
+  devMode: process.argv.includes("--dev"),
+  name: "Discord Bot",
+  appVersion: "1.0.0",
+  verbose: false,
+  disableBanner: false
+};
+function createVimcordAppConfig(options = {}) {
+  return import_lodash6.default.merge(defaultConfig, options);
+}
+
+// src/configs/staff.config.ts
+var import_lodash7 = __toESM(require("lodash"));
+var defaultConfig2 = {
+  ownerId: null,
+  superUsers: [],
+  superUserRoles: [],
+  bypassers: [],
+  bypassesGuildAdmin: {
+    allBotStaff: false,
+    botOwner: false,
+    superUsers: false,
+    bypassers: false
+  },
+  guild: {
+    id: null,
+    inviteUrl: null,
+    channels: {}
+  }
+};
+function createVimcordStaffConfig(options = {}) {
+  return import_lodash7.default.merge(defaultConfig2, options);
+}
+
+// src/configs/slashCommand.config.ts
+var import_lodash8 = __toESM(require("lodash"));
+var defaultConfig3 = {
+  logExecution: true
+};
+function createVimcordSlashCommandConfig(options = {}) {
+  return import_lodash8.default.merge(defaultConfig3, options);
+}
+
+// src/configs/prefixCommand.config.ts
+var import_lodash9 = __toESM(require("lodash"));
+var defaultConfig4 = {
+  enabled: true,
+  defaultPrefix: "!",
+  allowMentionAsPrefix: true,
+  allowCaseInsensitiveCommandNames: true,
+  logExecution: true
+};
+function createVimcordPrefixCommandConfig(options = {}) {
+  return import_lodash9.default.merge(defaultConfig4, options);
+}
+
+// src/configs/contextCommand.config.ts
+var import_lodash10 = __toESM(require("lodash"));
+var defaultConfig5 = {
+  enabled: true,
+  logExecution: true
+};
+function createVimcordContextCommandConfig(options = {}) {
+  return import_lodash10.default.merge(defaultConfig5, options);
+}
+
+// src/tools/Logger.ts
+var import_chalk = __toESM(require("chalk"));
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["SUCCESS"] = 2] = "SUCCESS";
+  LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+var DEFAULT_COLORS = {
+  primary: "#5865F2",
+  success: "#57F287",
+  warn: "#FEE75C",
+  danger: "#ED4245",
+  muted: "#747F8D",
+  text: "#FFFFFF"
+};
+var Logger = class {
+  logPrefixEmoji;
+  logPrefix;
+  minLevel;
+  showTimestamp;
+  colorScheme;
+  constructor(options) {
+    const { prefixEmoji = null, prefix = null, minLevel = 0 /* DEBUG */, showTimestamp = true } = options || {};
+    this.logPrefixEmoji = prefixEmoji;
+    this.logPrefix = prefix;
+    this.minLevel = minLevel;
+    this.showTimestamp = showTimestamp;
+    this.colorScheme = {
+      ...DEFAULT_COLORS,
+      ...options?.colors
+    };
+  }
+  formatTimestamp() {
+    if (!this.showTimestamp) return "";
+    const now = /* @__PURE__ */ new Date();
+    const time = now.toLocaleTimeString("en-US", {
+      hour12: false,
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    });
+    return import_chalk.default.hex(this.colorScheme.muted)(`[${time}]`);
+  }
+  formatPrefix() {
+    if (!this.logPrefix) return "";
+    return import_chalk.default.bold.hex(this.colorScheme.primary)(
+      `${this.logPrefixEmoji ? `${this.logPrefixEmoji} ` : ""}${this.logPrefix}`
+    );
+  }
+  shouldLog(level) {
+    return level >= this.minLevel;
+  }
+  get prefixEmoji() {
+    return this.logPrefixEmoji;
+  }
+  get prefix() {
+    return this.logPrefix;
+  }
+  get colors() {
+    return this.colorScheme;
+  }
+  extend(extras) {
+    for (const [key, fn] of Object.entries(extras)) {
+      if (typeof fn === "function") {
+        this[key] = function(...args) {
+          return fn.call(this, ...args);
+        };
+      }
+    }
+    return this;
+  }
+  setPrefix(prefix) {
+    this.logPrefix = prefix;
+    return this;
+  }
+  setPrefixEmoji(prefixEmoji) {
+    this.logPrefixEmoji = prefixEmoji;
+    return this;
+  }
+  setMinLevel(minLevel) {
+    this.minLevel = minLevel;
+    return this;
+  }
+  setShowTimestamp(show) {
+    this.showTimestamp = show;
+    return this;
+  }
+  setColors(colors) {
+    this.colorScheme = {
+      ...DEFAULT_COLORS,
+      ...colors
+    };
+    return this;
+  }
+  log(message, ...args) {
+    console.log(this.formatTimestamp(), this.formatPrefix(), message, ...args);
+  }
+  debug(message, ...args) {
+    if (!this.shouldLog(0 /* DEBUG */)) return;
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      import_chalk.default.hex(this.colorScheme.muted)("DEBUG"),
+      import_chalk.default.dim(message),
+      ...args
+    );
+  }
+  info(message, ...args) {
+    if (!this.shouldLog(1 /* INFO */)) return;
+    console.log(this.formatTimestamp(), this.formatPrefix(), import_chalk.default.hex("#87CEEB")("INFO"), message, ...args);
+  }
+  success(message, ...args) {
+    if (!this.shouldLog(2 /* SUCCESS */)) return;
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      import_chalk.default.bold.hex(this.colorScheme.success)("\u2713 SUCCESS"),
+      import_chalk.default.hex(this.colorScheme.success)(message),
+      ...args
+    );
+  }
+  warn(message, ...args) {
+    if (!this.shouldLog(3 /* WARN */)) return;
+    console.warn(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      import_chalk.default.bold.hex(this.colorScheme.warn)("\u26A0 WARN"),
+      import_chalk.default.hex(this.colorScheme.warn)(message),
+      ...args
+    );
+  }
+  error(message, error, ...args) {
+    if (!this.shouldLog(4 /* ERROR */)) return;
+    console.error(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      import_chalk.default.bold.hex(this.colorScheme.danger)("\u2715 ERROR"),
+      import_chalk.default.hex(this.colorScheme.danger)(message),
+      ...args
+    );
+    if (error && error.stack) {
+      console.error(import_chalk.default.dim(error.stack));
+    }
+  }
+  loader(message) {
+    const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    let i = 0;
+    const interval = setInterval(() => {
+      process.stdout.write(
+        `\r${this.formatTimestamp()} ${this.formatPrefix()} ${import_chalk.default.hex(this.colorScheme.warn)(frames[i])} ${message}`
+      );
+      i = (i + 1) % frames.length;
+    }, 100);
+    return (newMessage) => {
+      clearInterval(interval);
+      process.stdout.write(
+        `\r${this.formatTimestamp()} ${this.formatPrefix()} ${import_chalk.default.hex(this.colorScheme.success)("\u2713")} ${newMessage || message}
+`
+      );
+    };
+  }
+  table(title, data) {
+    console.log(this.formatTimestamp(), this.formatPrefix(), import_chalk.default.bold(title));
+    Object.entries(data).forEach(([key, value]) => {
+      const formattedKey = import_chalk.default.hex(this.colorScheme.warn)(`  ${key}`);
+      const formattedValue = import_chalk.default.hex(this.colorScheme.muted)(value);
+      console.log(`${formattedKey.padEnd(25)} ${formattedValue}`);
+    });
+  }
+  section(title) {
+    const line = "\u2500".repeat(Math.max(30, title.length + 4));
+    console.log(import_chalk.default.hex(this.colorScheme.muted)(`
+\u250C\u2500${line}\u2500\u2510`));
+    console.log(
+      import_chalk.default.hex(this.colorScheme.muted)("\u2502  ") + import_chalk.default.bold.hex(this.colorScheme.text)(title.padEnd(line.length)) + import_chalk.default.hex(this.colorScheme.muted)("  \u2502")
+    );
+    console.log(import_chalk.default.hex(this.colorScheme.muted)(`\u2514\u2500${line}\u2500\u2518`));
+  }
+};
+var logger = new Logger();
+
+// src/tools/utils.ts
+function __zero(str) {
+  return str?.length ? str : "0";
+}
+function isMentionOrSnowflake(str) {
+  return str ? str.match(/<@[#&]?[\d]{6,}>/) || str.match(/\d{6,}/) ? true : false : false;
+}
+function cleanMention(str) {
+  return str ? str.replaceAll(/[<@#&>]/g, "").trim() : void 0;
+}
+async function getMessageMention(message, content, type, index = 0, idOnly) {
+  const args = content?.split(" ");
+  const arg = isMentionOrSnowflake(args?.[index]) ? cleanMention(args?.[index]) : void 0;
+  switch (type) {
+    case "user":
+      const userMention2 = message.mentions.users.at(index) || null;
+      if (!userMention2 && arg) {
+        return idOnly ? arg : await fetchUser(message.client, arg);
+      } else {
+        return idOnly ? userMention2?.id || null : userMention2;
+      }
+    case "member":
+      if (!message.guild) return null;
+      const member = await fetchMember(message.guild, message.mentions.users.at(index)?.id ?? arg);
+      return idOnly ? member?.id || null : member;
+    case "channel":
+      const channelMention = message.mentions.channels.at(index) || null;
+      if (!channelMention && arg) {
+        return idOnly ? arg : message.guild ? await fetchChannel(message.guild, arg) : message.client.channels.cache.get(__zero(arg)) ?? message.client.channels.fetch(__zero(arg));
+      } else {
+        return idOnly ? channelMention?.id || null : channelMention;
+      }
+    case "role":
+      const roleMention = message.mentions.roles.at(index) || null;
+      if (!roleMention && arg) {
+        return idOnly ? arg : message.guild ? await fetchRole(message.guild, arg) : null;
+      } else {
+        return idOnly ? roleMention?.id || null : roleMention;
+      }
+    default:
+      return null;
+  }
+}
+function getFirstMentionId(options) {
+  let mentionId = "";
+  if (options.message) {
+    switch (options.type) {
+      case "user":
+        mentionId = options.message.mentions.users.first()?.id || "";
+        break;
+      case "channel":
+        mentionId = options.message.mentions.channels.first()?.id || "";
+        break;
+      case "role":
+        mentionId = options.message.mentions.roles.first()?.id || "";
+        break;
+    }
+  }
+  const firstArg = options.content?.split(" ")[0] || "";
+  return mentionId || isMentionOrSnowflake(firstArg) ? cleanMention(firstArg) : "";
+}
+async function fetchUser(client, userId) {
+  if (!userId) return null;
+  return client.users.cache.get(__zero(userId)) || await client.users.fetch(__zero(userId)).catch(() => null);
+}
+async function fetchGuild(client, guildId) {
+  if (!guildId) return null;
+  return client.guilds.cache.get(__zero(guildId)) || await client.guilds.fetch(__zero(guildId)).catch(() => null);
+}
+async function fetchMember(guild, memberId) {
+  if (!memberId) return null;
+  return guild.members.cache.get(__zero(memberId)) || await guild.members.fetch(__zero(memberId)).catch(() => null);
+}
+async function fetchChannel(guild, channelId, type) {
+  if (!channelId) return null;
+  const channel = guild.channels.cache.get(__zero(channelId)) || await guild.channels.fetch(__zero(channelId)).catch(() => null);
+  if (type && channel?.type !== type) return null;
+  return channel;
+}
+async function fetchRole(guild, roleId) {
+  if (!roleId) return null;
+  return guild.roles.cache.get(__zero(roleId)) || await guild.roles.fetch(__zero(roleId)).catch(() => null) || null;
+}
+async function fetchMessage(channel, messageId) {
+  if (!messageId) return null;
+  return channel.messages.cache.get(__zero(messageId)) || await channel.messages.fetch(__zero(messageId)).catch(() => null) || null;
+}
+
+// src/types/status.ts
+var import_discord4 = require("discord.js");
+var import_lodash11 = __toESM(require("lodash"));
+var StatusType = /* @__PURE__ */ ((StatusType2) => {
+  StatusType2["DND"] = "dnd";
+  StatusType2["Idle"] = "idle";
+  StatusType2["Online"] = "online";
+  StatusType2["Invisible"] = "invisible";
+  return StatusType2;
+})(StatusType || {});
+var defaultPresence = {
+  production: {
+    interval: 6e4,
+    randomize: false,
+    activity: [
+      { status: "online" /* Online */, type: import_discord4.ActivityType.Custom, name: "Need help? Use /help or !help" },
+      { status: "online" /* Online */, type: import_discord4.ActivityType.Custom, name: "Join our community!" },
+      { status: "online" /* Online */, type: import_discord4.ActivityType.Watching, name: "\u2728 $GUILD_COUNT servers" }
+    ]
+  },
+  development: {
+    activity: { status: "dnd" /* DND */, type: import_discord4.ActivityType.Custom, name: "In development!" }
+  }
+};
+function createVimcordStatusConfig(options = {}) {
+  return import_lodash11.default.merge(defaultPresence, options);
+}
+
+// src/utils/number.ts
+function formatThousands(num, sep = ",") {
+  return `${num}`.replace(/\B(?<!\.\d*)(?=(\d{3})+(?!\d))/g, sep);
+}
+
+// src/utils/random.ts
+function pickRandom(arr, options) {
+  const _rnd = () => {
+    return arr[Math.floor(Math.random() * arr.length)];
+  };
+  let att = 0;
+  let candidate = _rnd();
+  if (options?.notEqualTo !== void 0 && arr.length > 1) {
+    while (candidate === options.notEqualTo) {
+      if (att < (options?.maxRerollAttempts ?? 100)) {
+        throw new Error(`pickRandom reached max reroll attempts (${options?.maxRerollAttempts ?? 100})`);
+      }
+      candidate = _rnd();
+      att++;
+    }
+  }
+  return options?.clone ? structuredClone(candidate) : candidate;
+}
+
+// src/modules/status.manager.ts
+var import_node_cron = __toESM(require("node-cron"));
+var import_node_events = __toESM(require("events"));
+var VimcordStatusManager = class {
+  client;
+  logger;
+  emitter = new import_node_events.default();
+  lastActivity = null;
+  lastActivityIndex = 0;
+  task = null;
+  constructor(client) {
+    this.client = client;
+    this.logger = new Logger({ prefixEmoji: "\u{1F4AC}", prefix: `StatusManager (i${this.client.index})` });
+    this.emitter.on("changed", (activity) => {
+      if (this.client.config.app.verbose) {
+        this.logger.debug(`Status changed to '${activity.name}'`);
+      }
+    });
+    this.emitter.on("cleared", () => {
+      if (this.client.config.app.verbose) {
+        this.logger.debug("Status cleared");
+      }
+    });
+    this.emitter.on("rotation", () => {
+      if (this.client.config.app.verbose) {
+        this.logger.debug("Status rotated");
+      }
+    });
+    this.emitter.on("rotationStarted", () => {
+      if (this.client.config.app.verbose) {
+        this.logger.debug("Status rotation resumed \u25B6\uFE0F");
+      }
+    });
+    this.emitter.on("rotationPaused", () => {
+      if (this.client.config.app.verbose) {
+        this.logger.debug("Status rotation paused \u23F8\uFE0F");
+      }
+    });
+  }
+  clearData() {
+    this.task?.destroy();
+    this.task = null;
+    this.lastActivity = null;
+    this.lastActivityIndex = 0;
+    return this;
+  }
+  async getReadyClient() {
+    const client = await this.client.whenReady();
+    if (!client.user) throw new Error("Cannot manage the client's activity when its user is not hydrated");
+    return client;
+  }
+  async formatActivityName(name) {
+    name = name.replace("$USER_COUNT", formatThousands(this.client.users.cache.size)).replace("$GUILD_COUNT", formatThousands(this.client.guilds.cache.size)).replace(
+      "$INVITE",
+      this.client.config.staff.guild.inviteUrl ? this.client.config.staff.guild.inviteUrl : "<STAFF_INVITE_URL_NOT_SET>"
+    );
+    if (name.includes("$STAFF_GUILD_MEMBER_COUNT")) {
+      await fetchGuild(this.client, this.client.config.staff.guild.id).then((guild) => {
+        if (!guild) return name = name.replace("$STAFF_GUILD_MEMBER_COUNT", "<STAFF_GUILD_NOT_FOUND>");
+        name = name.replace("$STAFF_GUILD_MEMBER_COUNT", formatThousands(guild.members.cache.size));
+      }).catch((err) => this.logger.error("Failed to fetch the staff guild", err));
+    }
+    return name;
+  }
+  async setActivity(activity) {
+    const client = await this.getReadyClient();
+    activity.name = await this.formatActivityName(activity.name);
+    client.user.setStatus(activity.status);
+    client.user.setActivity({ name: activity.name, type: activity.type, url: activity.streamUrl });
+    this.emitter.emit("changed", activity);
+  }
+  async statusRotationTask(clientStatus) {
+    let activity;
+    if (clientStatus.randomize) {
+      activity = pickRandom(clientStatus.activity, {
+        notEqualTo: this.lastActivity,
+        clone: true
+      });
+      this.lastActivity = activity;
+    } else {
+      const activityIndex = (this.lastActivityIndex + 1) % clientStatus.activity.length;
+      this.lastActivityIndex = activityIndex;
+      activity = clientStatus.activity[activityIndex];
+    }
+    await this.setActivity(activity);
+    this.emitter.emit("rotation", activity);
+  }
+  async scheduleStatusRotation(clientStatus) {
+    if (!clientStatus.interval) throw new Error("Cannot create client activity interval without interval time");
+    this.task?.destroy();
+    this.task = null;
+    await this.statusRotationTask(clientStatus);
+    this.task = import_node_cron.default.createTask(
+      `*/${clientStatus.interval} * * * * *`,
+      async () => await this.statusRotationTask(clientStatus),
+      { noOverlap: true }
+    );
+    this.start();
+    this.emitter.emit("rotationStarted", this.task);
+  }
+  start() {
+    if (this.task) {
+      this.task.start();
+      this.emitter.emit("rotationStarted", this.task);
+      if (this.client.config.app.verbose) {
+        this.logger.debug("Status rotation started");
+      }
+    }
+    return this;
+  }
+  pause() {
+    if (this.task) {
+      this.task.stop();
+      this.emitter.emit("rotationPaused", this.task);
+      if (this.client.config.app.verbose) {
+        this.logger.debug("Status rotation paused");
+      }
+    }
+    return this;
+  }
+  async set(status) {
+    const statusConfig = createVimcordStatusConfig(status);
+    let clientStatus;
+    if (this.client.config.app.devMode) {
+      clientStatus = statusConfig.development;
+    } else {
+      clientStatus = statusConfig.production;
+    }
+    if (!clientStatus.interval) {
+      await this.setActivity(Array.isArray(clientStatus.activity) ? clientStatus.activity[0] : clientStatus.activity);
+      return this;
+    }
+    if (clientStatus.interval) {
+      await this.scheduleStatusRotation(clientStatus);
+    }
+    return this;
+  }
+  async destroy() {
+    if (this.task) {
+      this.task.destroy();
+      this.task = null;
+      this.emitter.emit("rotationDestroyed");
+      if (this.client.config.app.verbose) {
+        this.logger.debug("Status rotation destroyed");
+      }
+      await this.clear();
+    }
+    return this;
+  }
+  async clear() {
+    const client = await this.getReadyClient();
+    this.clearData();
+    client.user.setActivity({ name: "" });
+    this.emitter.emit("cleared");
+    if (this.client.config.app.verbose) {
+      this.logger.debug("Status cleared");
+    }
+    return this;
+  }
+};
+
+// src/modules/command.manager.ts
+var import_discord5 = require("discord.js");
+var VimcordCommandManager = class {
+  slash;
+  prefix;
+  context;
+  constructor(client) {
+    this.slash = new VimcordSlashCommandManager(client);
+    this.prefix = new VimcordPrefixCommandManager(client);
+    this.context = new VimcordContextCommandManager(client);
+  }
+};
+var VimcordSlashCommandManager = class {
+  constructor(client) {
+    this.client = client;
+    client.whenReady().then((c) => this.rest = new import_discord5.REST().setToken(c.token));
+  }
+  commands = /* @__PURE__ */ new Map();
+  rest;
+  get(name) {
+    return this.commands.get(name);
+  }
+  getAll(options) {
+    const matchedCommands = /* @__PURE__ */ new Map();
+    for (const cmd of this.commands.values()) {
+      let matched = null;
+      if (options?.names || options?.fuzzyNames || options?.guilds) {
+        const nameMatched = (
+          // Exact name match
+          options.names?.includes(cmd.builder.name) || // Fuzzy match
+          options.fuzzyNames?.some((fuzzyCommand) => cmd.builder.name.includes(fuzzyCommand))
+        );
+        if ((options.names || options.fuzzyNames) && !nameMatched) continue;
+        const guildMatched = cmd.deployment?.guilds?.some((guildId) => options.guilds?.includes(guildId));
+        if (options.guilds && !guildMatched) continue;
+        matched = cmd;
+      } else {
+        matched = cmd;
+      }
+      if (!matched) continue;
+      if (options?.ignoreDeploymentOptions) {
+        if (matchedCommands.has(matched.builder.name)) continue;
+        matchedCommands.set(matched.builder.name, matched);
+        continue;
+      }
+      const isProperEnvironment = matched?.deployment?.environments?.includes(
+        this.client.config.app.devMode ? "development" : "production"
+      );
+      if ((isProperEnvironment ?? true) && ((options?.globalOnly && (matched?.deployment?.global ?? true)) ?? true)) {
+        matchedCommands.set(matched.builder.name, matched);
+      }
+    }
+    return matchedCommands;
+  }
+  /** Import command modules that end with `.slash` */
+  async importFrom(dir, replaceAll) {
+    if (replaceAll) {
+      this.commands.clear();
+    }
+    dir = Array.isArray(dir) ? dir : [dir];
+    const commandModules = await Promise.all(
+      dir.map((dir2) => importModulesFromDir(dir2, "slash"))
+    );
+    let importedCommands = 0;
+    for (const command of commandModules.flat()) {
+      const isProperEnvironment = command.module.default.deployment?.environments?.includes(
+        this.client.config.app.devMode ? "development" : "production"
+      );
+      if (isProperEnvironment ?? true) {
+        this.commands.set(command.module.default.builder.name, command.module.default);
+        importedCommands++;
+      }
+    }
+    this.client.logger.moduleLoaded("Slash Commands", importedCommands);
+    return this.commands;
+  }
+  async registerGuild(options) {
+    const client = await this.client.whenReady();
+    const commandsToRegister = Array.from(
+      this.getAll({
+        names: options?.commands,
+        fuzzyNames: options?.fuzzyCommands
+      }).values()
+    ).map((cmd) => cmd.builder.toJSON());
+    if (!commandsToRegister.length) {
+      console.log("[SlashCommandManager] No commands to register");
+      return;
+    }
+    const guildIds = options?.guilds || client.guilds.cache.map((guild) => guild.id);
+    console.log(
+      `[SlashCommandManager] Registering ${commandsToRegister.length} app (/) ${commandsToRegister.length === 1 ? "command" : "commands"} for ${guildIds.length} ${guildIds.length === 1 ? "guild" : "guilds"}...`
+    );
+    await Promise.all(
+      guildIds.map(
+        (guildId) => this.rest.put(import_discord5.Routes.applicationGuildCommands(client.user.id, guildId), {
+          body: commandsToRegister
+        }).then(
+          () => console.log(
+            `[SlashCommandManager] \u2714 Set app (/) commands in guild: ${guildId} (${client.guilds.cache.find((g) => g.id === guildId)?.name || "n/a"})`
+          )
+        ).catch(
+          (err) => console.log(
+            `[SlashCommandManager] \u2716 Failed to set app (/) commands in guild: ${guildId} (${client.guilds.cache.find((g) => g.id === guildId)?.name || "n/a"})`,
+            err
+          )
+        )
+      )
+    );
+    console.log(
+      `[SlashCommandManager] \u2714 Finished registering app (/) commands for ${guildIds.length} ${guildIds.length === 1 ? "guild" : "guilds"}`
+    );
+  }
+  async unregisterGuild(options) {
+    const client = await this.client.whenReady();
+    const guildIds = options?.guilds || client.guilds.cache.map((guild) => guild.id);
+    console.log(
+      `[SlashCommandManager] Unregistering app (/) commands from ${guildIds.length} ${guildIds.length === 1 ? "guild" : "guilds"}...`
+    );
+    await Promise.all(
+      guildIds.map(
+        (guildId) => this.rest.put(import_discord5.Routes.applicationGuildCommands(client.user.id, guildId), {
+          body: []
+        }).then(
+          () => console.log(
+            `[SlashCommandManager] \u2714 Removed app (/) commands in guild: ${guildId} (${client.guilds.cache.find((g) => g.id === guildId)?.name || "n/a"})`
+          )
+        ).catch(
+          (err) => console.log(
+            `[SlashCommandManager] \u2716 Failed to remove app (/) commands in guild: ${guildId} (${client.guilds.cache.find((g) => g.id === guildId)?.name || "n/a"})`,
+            err
+          )
+        )
+      )
+    );
+    console.log(
+      `[SlashCommandManager] \u2714 Finished unregistering app (/) commands for ${guildIds.length} ${guildIds.length === 1 ? "guild" : "guilds"}`
+    );
+  }
+  async registerGlobal(options) {
+    const client = await this.client.whenReady();
+    const commandsToRegister = Array.from(
+      this.getAll({
+        names: options?.commands,
+        fuzzyNames: options?.fuzzyCommands,
+        globalOnly: true
+      }).values()
+    ).map((cmd) => cmd.builder.toJSON());
+    if (!commandsToRegister.length) {
+      console.log("[SlashCommandManager] No commands to register");
+      return;
+    }
+    console.log(
+      `[SlashCommandManager] Registering ${commandsToRegister.length} app (/) ${commandsToRegister.length === 1 ? "command" : "commands"} globally...`
+    );
+    try {
+      await this.rest.put(import_discord5.Routes.applicationCommands(client.user.id), { body: commandsToRegister });
+      console.log("[SlashCommandManager] \u2714 Registered app (/) commands globally");
+    } catch (err) {
+      console.log("[SlashCommandManager] \u2716 Failed to register app (/) commands globally", err);
+    }
+  }
+  async unregisterGlobal() {
+    const client = await this.client.whenReady();
+    console.log("[SlashCommandManager] Unregistering app (/) commands globally...");
+    try {
+      await this.rest.put(import_discord5.Routes.applicationCommands(client.user.id), { body: [] });
+      console.log("[SlashCommandManager] \u2714 Removed app (/) commands globally");
+    } catch (err) {
+      console.log("[SlashCommandManager] \u2716 Failed to remove app (/) commands globally", err);
+    }
+  }
+};
+var VimcordPrefixCommandManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  commands = /* @__PURE__ */ new Map();
+  get(name) {
+    if (this.client.config.prefixCommands.allowCaseInsensitiveCommandNames) {
+      name = name.toLowerCase();
+      return Array.from(this.commands.values()).find((cmd) => cmd.name.toLowerCase() === name);
+    }
+    return this.commands.get(name);
+  }
+  getByAlias(alias) {
+    if (this.client.config.prefixCommands.allowCaseInsensitiveCommandNames) {
+      alias = alias.toLowerCase();
+      return Array.from(this.commands.values()).find((cmd) => cmd.aliases?.includes(alias));
+    }
+    return Array.from(this.commands.values()).find((cmd) => cmd.aliases?.includes(alias));
+  }
+  /** Import command modules that end with `.prefix` */
+  async importFrom(dir, replaceAll) {
+    if (replaceAll) {
+      this.commands.clear();
+    }
+    dir = Array.isArray(dir) ? dir : [dir];
+    const commandModules = await Promise.all(
+      dir.map((dir2) => importModulesFromDir(dir2, "prefix"))
+    );
+    let importedCommands = 0;
+    for (const command of commandModules.flat()) {
+      this.commands.set(command.module.default.name, command.module.default);
+      importedCommands++;
+    }
+    this.client.logger.moduleLoaded("Prefix Commands", importedCommands);
+    return this.commands;
+  }
+};
+var VimcordContextCommandManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  commands = /* @__PURE__ */ new Map();
+  /** Import command modules that end with `.ctx` */
+  async importFrom(dir, replaceAll) {
+    if (replaceAll) {
+      this.commands.clear();
+    }
+    dir = Array.isArray(dir) ? dir : [dir];
+    const commandModules = await Promise.all(
+      dir.map((dir2) => importModulesFromDir(dir2, "ctx"))
+    );
+    let importedCommands = 0;
+    for (const command of commandModules.flat()) {
+      this.commands.set(command.module.default.builder.name, command.module.default);
+      importedCommands++;
+    }
+    this.client.logger.moduleLoaded("Context Commands", importedCommands);
+    return this.commands;
+  }
+};
+
+// src/modules/event.manager.ts
+var import_discord6 = require("discord.js");
+var VimcordEventManager = class {
+  client;
+  events = /* @__PURE__ */ new Map();
+  logger;
+  constructor(client) {
+    this.client = client;
+    this.logger = new Logger({ prefixEmoji: "\u{1F4CB}", prefix: `EventManager (i${this.client.index})` });
+    for (const event of Object.values(import_discord6.Events)) {
+      client.on(
+        event.toString(),
+        async (...args) => this.executeEvents.apply(this, [event, ...args])
+      );
+    }
+  }
+  register(...events) {
+    for (const event of events) {
+      this.events.set(event.name, event);
+      if (this.client.config.app.verbose) {
+        this.logger.debug(`'${event.name}' registered for EventType '${event.event}'`);
+      }
+    }
+  }
+  unregister(...names) {
+    for (const name of names) {
+      const event = this.events.get(name);
+      if (!event) continue;
+      this.events.delete(name);
+      if (this.client.config.app.verbose) {
+        this.logger.debug(`'${event.name}' unregistered for EventType '${event.event}'`);
+      }
+    }
+  }
+  clear() {
+    this.events.forEach((e) => this.unregister(e.name));
+    this.events.clear();
+  }
+  get(name) {
+    return this.events.get(name);
+  }
+  getByTag(tag) {
+    return Array.from(this.events.values()).filter((event) => event.metadata?.tags?.includes(tag));
+  }
+  getByCategory(category) {
+    return Array.from(this.events.values()).filter((event) => event.metadata?.category?.includes(category));
+  }
+  getByEvent(eventType) {
+    return Array.from(this.events.values()).filter((event) => event.event === eventType);
+  }
+  async executeEvents(eventType, ...args) {
+    const events = this.getByEvent(eventType);
+    if (!events.length) return;
+    const sortedEvents = events.sort((a, b) => b.priority - a.priority);
+    await Promise.all(
+      sortedEvents.map(async (event) => {
+        try {
+          await event.execute?.(this.client, ...args);
+          if (event.once) {
+            this.unregister(event.name);
+          }
+        } catch (err) {
+          this.logger.error(`'${event.name}' failed to execute`, err);
+        }
+      })
+    );
+  }
+  /** Import event modules that end with `.event` */
+  async importFrom(dir, replaceAll) {
+    dir = Array.isArray(dir) ? dir : [dir];
+    const eventModules = await Promise.all(
+      dir.map((dir2) => importModulesFromDir(dir2, "event"))
+    );
+    if (replaceAll) {
+      this.clear();
+    }
+    let importedEvents = 0;
+    let ignoredEvents = 0;
+    for (const event of eventModules.flat()) {
+      if (!event.module.default.enabled) {
+        ignoredEvents++;
+      } else {
+        importedEvents++;
+      }
+      this.register(event.module.default);
+    }
+    this.client.logger.moduleLoaded("Event Handlers", importedEvents, ignoredEvents);
+    return this.events;
+  }
+};
+
+// src/utils/sendCommandErrorEmbed.ts
+var import_discord9 = require("discord.js");
+
+// src/tools/BetterEmbed.ts
+var import_discord8 = require("discord.js");
+
+// src/tools/dynaSend.ts
+var import_discord7 = require("discord.js");
+
+// src/tools/types.ts
+var SendMethod = /* @__PURE__ */ ((SendMethod2) => {
+  SendMethod2[SendMethod2["Reply"] = 0] = "Reply";
+  SendMethod2[SendMethod2["EditReply"] = 1] = "EditReply";
+  SendMethod2[SendMethod2["FollowUp"] = 2] = "FollowUp";
+  SendMethod2[SendMethod2["Channel"] = 3] = "Channel";
+  SendMethod2[SendMethod2["MessageReply"] = 4] = "MessageReply";
+  SendMethod2[SendMethod2["MessageEdit"] = 5] = "MessageEdit";
+  SendMethod2[SendMethod2["User"] = 6] = "User";
+  return SendMethod2;
+})(SendMethod || {});
+
+// src/tools/dynaSend.ts
+var DynaSend = class {
+  static forceArray(value) {
+    return Array.isArray(value) ? value : [value];
+  }
+  static isInteractionCallback(obj) {
+    return obj instanceof import_discord7.InteractionCallbackResponse;
+  }
+  static filterFlags(flags, excludeFlags) {
+    if (!flags) return void 0;
+    const flagArray = this.forceArray(flags);
+    return flagArray.filter((flag) => !excludeFlags.includes(flag));
+  }
+  static detectSendMethod(handler) {
+    if (handler instanceof import_discord7.BaseInteraction) {
+      return handler.replied || handler.deferred ? 1 /* EditReply */ : 0 /* Reply */;
+    }
+    if (handler instanceof import_discord7.BaseChannel) return 3 /* Channel */;
+    if (handler instanceof import_discord7.Message) return 4 /* MessageReply */;
+    if (handler instanceof import_discord7.GuildMember || handler instanceof import_discord7.User) return 6 /* User */;
+    throw new Error("[DynaSend] Unable to determine send method for handler type");
+  }
+  static validateSendMethod(handler, method) {
+    const interactionMethods = [0 /* Reply */, 1 /* EditReply */, 2 /* FollowUp */];
+    if (interactionMethods.includes(method) && !(handler instanceof import_discord7.BaseInteraction)) {
+      throw new TypeError(`[DynaSend] SendMethod '${SendMethod[method]}' requires BaseInteraction handler`);
+    }
+    if (method === 3 /* Channel */ && !(handler instanceof import_discord7.BaseChannel)) {
+      throw new TypeError(`[DynaSend] SendMethod '${SendMethod[method]}' requires BaseChannel handler`);
+    }
+    if ([4 /* MessageReply */, 5 /* MessageEdit */].includes(method) && !(handler instanceof import_discord7.Message)) {
+      throw new TypeError(`[DynaSend] SendMethod '${SendMethod[method]}' requires Message handler`);
+    }
+    if (method === 6 /* User */ && !(handler instanceof import_discord7.GuildMember || handler instanceof import_discord7.User)) {
+      throw new TypeError(`[DynaSend] SendMethod '${SendMethod[method]}' requires User or GuildMember handler`);
+    }
+  }
+  static createMessageData(options, method) {
+    const baseData = {
+      content: options.content,
+      embeds: options.embeds,
+      components: options.components,
+      files: options.files,
+      allowedMentions: options.allowedMentions,
+      tts: options.tts
+    };
+    switch (method) {
+      case 0 /* Reply */:
+        return {
+          ...baseData,
+          flags: options.flags,
+          withResponse: options.withResponse,
+          poll: options.poll
+        };
+      case 1 /* EditReply */:
+        return {
+          ...baseData,
+          flags: this.filterFlags(options.flags, ["Ephemeral", "SuppressNotifications"]),
+          withResponse: options.withResponse,
+          poll: options.poll
+        };
+      case 2 /* FollowUp */:
+        return {
+          ...baseData,
+          flags: options.flags,
+          withResponse: options.withResponse,
+          poll: options.poll
+        };
+      case 3 /* Channel */:
+        return {
+          ...baseData,
+          flags: this.filterFlags(options.flags, ["Ephemeral"]),
+          poll: options.poll,
+          stickers: options.stickers,
+          reply: options.reply
+        };
+      case 4 /* MessageReply */:
+        return {
+          ...baseData,
+          flags: this.filterFlags(options.flags, ["Ephemeral"]),
+          poll: options.poll,
+          stickers: options.stickers
+        };
+      case 5 /* MessageEdit */:
+        return {
+          ...baseData,
+          flags: this.filterFlags(options.flags, ["Ephemeral", "SuppressNotifications"])
+        };
+      case 6 /* User */:
+        return {
+          ...baseData,
+          flags: this.filterFlags(options.flags, ["Ephemeral"]),
+          poll: options.poll,
+          forward: options.forward,
+          stickers: options.stickers
+        };
+      default:
+        return baseData;
+    }
+  }
+  static async executeSend(handler, method, data) {
+    try {
+      switch (method) {
+        case 0 /* Reply */: {
+          const response = await handler.reply(data);
+          return this.isInteractionCallback(response) ? response.resource?.message ?? null : null;
+        }
+        case 1 /* EditReply */:
+          return await handler.editReply(data);
+        case 2 /* FollowUp */:
+          return await handler.followUp(data);
+        case 3 /* Channel */:
+          return await handler.send(data);
+        case 4 /* MessageReply */:
+          return await handler.reply(data);
+        case 5 /* MessageEdit */: {
+          const message = handler;
+          if (!message.editable) {
+            console.warn("[DynaSend] Message is not editable");
+            return null;
+          }
+          return await message.edit(data);
+        }
+        case 6 /* User */:
+          return await handler.send(data);
+        default:
+          throw new Error(`[DynaSend] Unknown send method '${method}'`);
+      }
+    } catch (error) {
+      console.error(`[DynaSend] Error with method '${SendMethod[method]}':`, error);
+      return null;
+    }
+  }
+  static scheduleDelete(message, delay) {
+    if (delay < 1e3) {
+      console.warn(`[DynaSend] Delete delay is less than 1 second (${delay}ms). Is this intentional?`);
+    }
+    setTimeout(async () => {
+      try {
+        if (message.deletable) {
+          await message.delete();
+        }
+      } catch (error) {
+        console.error("[DynaSend] Error deleting message:", error);
+      }
+    }, delay);
+  }
+  static async send(handler, options) {
+    const sendMethod = options.sendMethod ?? this.detectSendMethod(handler);
+    this.validateSendMethod(handler, sendMethod);
+    const messageData = this.createMessageData(options, sendMethod);
+    const message = await this.executeSend(handler, sendMethod, messageData);
+    if (options.deleteAfter && message) {
+      this.scheduleDelete(message, options.deleteAfter);
+    }
+    return message;
+  }
+};
+async function dynaSend(handler, options) {
+  return DynaSend.send(handler, options);
+}
+
+// src/tools/BetterEmbed.ts
+var BetterEmbed = class _BetterEmbed {
+  embed = new import_discord8.EmbedBuilder();
+  data;
+  config;
+  /** A powerful wrapper for `EmbedBuilder` that introduces useful features
+   *
+   * Auto-shorthand context formatting (_ACF_) is enabled by default
+   *
+   * All functions utilize _ACF_ unless `BetterEmbed.acf` is set to `false`
+   *
+   * ___Use a blackslash___ `\` ___to escape any context___
+   *
+   * \- - - Author Context - - -
+   * - __`$USER`__: _author's mention (@xsqu1znt)_
+   * - __`$USER_NAME`__: _author's username_
+   * - __`$DISPLAY_NAME`__: _author's display name (requires `GuildMember` context)_
+   * - __`$USER_AVATAR`__: _author's avatar_
+   *
+   * \- - - Client Context - - -
+   *
+   * - __`$BOT_AVATAR`__: _bot's avatar_
+   *
+   * \- - - Shorthand Context - - -
+   * - __`$YEAR`__: _YYYY_
+   * - __`$MONTH`__: _MM_
+   * - __`$DAY`__: _DD_
+   * - __`$year`__: _YY_
+   * - __`$month`__: _M or MM_
+   * - __`$day`__: _D or DD_ */
+  constructor(data = {}) {
+    this.config = data.config || globalVimcordToolsConfig;
+    this.data = {
+      context: data.context || null,
+      author: data.author || null,
+      title: data.title || null,
+      thumbnailUrl: data.thumbnailUrl || null,
+      description: data.description || null,
+      imageUrl: data.imageUrl || null,
+      footer: data.footer || null,
+      fields: data.fields || [],
+      color: data.color ?? (this.config.devMode ? this.config.embedColorDev : this.config.embedColor),
+      timestamp: data.timestamp || null,
+      acf: data.acf ?? true
+    };
+    this.build();
+  }
+  build() {
+    this.normalizeData();
+    this.applyContextFormatting();
+    this.configureEmbed();
+  }
+  normalizeData() {
+    if (typeof this.data.author === "string") {
+      this.data.author = { text: this.data.author };
+    }
+    if (typeof this.data.title === "string") {
+      this.data.title = { text: this.data.title };
+    }
+    if (typeof this.data.footer === "string") {
+      this.data.footer = { text: this.data.footer };
+    }
+    if (this.data.timestamp === true) {
+      this.data.timestamp = Date.now();
+    }
+  }
+  getContextUser() {
+    const context = this.data.context;
+    if (!context) return null;
+    return context.user || context.interaction?.member || context.interaction?.user || context.message?.member || context.message?.author || null;
+  }
+  getContextClient() {
+    const context = this.data.context;
+    if (!context) return null;
+    return context.client || context.interaction?.client || context.message?.client || null;
+  }
+  applyContextFormatting(str) {
+    if (!this.data.acf) return;
+    const user = this.getContextUser();
+    const guildMember = user instanceof import_discord8.GuildMember ? user : null;
+    const actualUser = guildMember?.user || (user instanceof import_discord8.User ? user : null);
+    const client = this.getContextClient();
+    const formatString = (str2) => {
+      if (!str2 || !str2.includes("$")) return str2;
+      return str2.replace(/(?<!\\)\$USER\b/g, actualUser?.toString() || "$USER").replace(/(?<!\\)\$USER_NAME\b/g, actualUser?.username || "$USER_NAME").replace(/(?<!\\)\$USER_AVATAR\b/g, actualUser?.avatarURL() || "$USER_AVATAR").replace(/(?<!\\)\$DISPLAY_NAME\b/g, guildMember?.displayName || "$DISPLAY_NAME").replace(/(?<!\\)\$BOT_AVATAR\b/g, client?.user?.avatarURL() || "$BOT_AVATAR").replace(/(?<!\\)\$INVIS\b/g, "\u200B").replace(/(?<!\\)\$YEAR/g, (/* @__PURE__ */ new Date()).getFullYear().toString()).replace(/(?<!\\)\$MONTH/g, String((/* @__PURE__ */ new Date()).getMonth() + 1).padStart(2, "0")).replace(/(?<!\\)\$DAY/g, String((/* @__PURE__ */ new Date()).getDate()).padStart(2, "0")).replace(/(?<!\\)\$year/g, String((/* @__PURE__ */ new Date()).getFullYear()).slice(-2)).replace(/(?<!\\)\$month/g, String((/* @__PURE__ */ new Date()).getMonth() + 1).padStart(2, "0")).replace(/(?<!\\)\$day/g, String((/* @__PURE__ */ new Date()).getDate()).padStart(2, "0")).replace(/(?<!\\|<)@([0-9]+)(?!>)/g, "<@$1>").replace(/(?<!\\|<)@&([0-9]+)(?!>)/g, "<@&$1>").replace(/(?<!\\|<)#([0-9]+)(?!>)/g, "<#$1>");
+    };
+    if (str) {
+      return formatString(str);
+    }
+    if (this.data.author && typeof this.data.author === "object") {
+      this.data.author.text = formatString(this.data.author.text);
+      if (this.data.author.icon === true && actualUser) {
+        this.data.author.icon = actualUser.avatarURL();
+      } else if (typeof this.data.author.icon === "string") {
+        this.data.author.icon = formatString(this.data.author.icon);
+      }
+    }
+    if (this.data.title && typeof this.data.title === "object") {
+      this.data.title.text = formatString(this.data.title.text);
+    }
+    if (this.data.description) {
+      this.data.description = formatString(
+        Array.isArray(this.data.description) ? this.data.description.join("\n") : this.data.description
+      );
+    }
+    if (this.data.footer && typeof this.data.footer === "object") {
+      this.data.footer.text = formatString(this.data.footer.text);
+    }
+    if (this.data.thumbnailUrl) {
+      this.data.thumbnailUrl = formatString(this.data.thumbnailUrl);
+    }
+    if (this.data.imageUrl) {
+      this.data.imageUrl = formatString(this.data.imageUrl);
+    }
+    this.data.fields = this.data.fields.map((field) => ({
+      ...field,
+      name: formatString(field.name),
+      value: formatString(field.value)
+    }));
+  }
+  configureEmbed() {
+    if (this.data.author && typeof this.data.author === "object" && this.data.author.text) {
+      try {
+        this.embed.setAuthor({
+          name: this.data.author.text,
+          iconURL: typeof this.data.author.icon === "string" ? this.data.author.icon : void 0,
+          url: this.data.author.hyperlink || void 0
+        });
+      } catch (error) {
+        console.error("[BetterEmbed] Invalid author configuration:", error);
+      }
+    }
+    if (this.data.title && typeof this.data.title === "object" && this.data.title.text) {
+      try {
+        this.embed.setTitle(this.data.title.text);
+        if (this.data.title.hyperlink) {
+          this.embed.setURL(this.data.title.hyperlink);
+        }
+      } catch (error) {
+        console.error("[BetterEmbed] Invalid title configuration:", error);
+      }
+    }
+    if (this.data.description) {
+      this.embed.setDescription(
+        Array.isArray(this.data.description) ? this.data.description.join("\n") : this.data.description
+      );
+    }
+    if (this.data.thumbnailUrl) {
+      try {
+        this.embed.setThumbnail(this.data.thumbnailUrl);
+      } catch (error) {
+        console.error("[BetterEmbed] Invalid thumbnail URL:", error);
+      }
+    }
+    if (this.data.imageUrl) {
+      try {
+        this.embed.setImage(this.data.imageUrl);
+      } catch (error) {
+        console.error("[BetterEmbed] Invalid image URL:", error);
+      }
+    }
+    if (this.data.footer && typeof this.data.footer === "object" && this.data.footer.text) {
+      try {
+        this.embed.setFooter({
+          text: this.data.footer.text,
+          iconURL: typeof this.data.footer.icon === "string" ? this.data.footer.icon : void 0
+        });
+      } catch (error) {
+        console.error("[BetterEmbed] Invalid footer configuration:", error);
+      }
+    }
+    if (this.data.color) {
+      try {
+        const color = Array.isArray(this.data.color) ? this.data.color[Math.floor(Math.random() * this.data.color.length)] ?? null : this.data.color;
+        this.embed.setColor(color);
+      } catch (error) {
+        console.error("[BetterEmbed] Invalid color:", error);
+      }
+    }
+    if (this.data.timestamp && this.data.timestamp !== true) {
+      try {
+        this.embed.setTimestamp(this.data.timestamp);
+      } catch (error) {
+        console.error("[BetterEmbed] Invalid timestamp:", error);
+      }
+    }
+    if (this.data.fields.length > 0) {
+      const validFields = this.data.fields.slice(0, 25);
+      if (this.data.fields.length > 25) {
+        console.warn("[BetterEmbed] Only first 25 fields will be used (Discord limit)");
+      }
+      this.embed.setFields(validFields);
+    }
+  }
+  setAuthor(author) {
+    this.data.author = author;
+    this.build();
+    return this;
+  }
+  setTitle(title) {
+    this.data.title = title;
+    this.build();
+    return this;
+  }
+  setDescription(description) {
+    this.data.description = description;
+    this.build();
+    return this;
+  }
+  setThumbnail(url) {
+    this.data.thumbnailUrl = url;
+    this.build();
+    return this;
+  }
+  setImage(url) {
+    this.data.imageUrl = url;
+    this.build();
+    return this;
+  }
+  setFooter(footer) {
+    this.data.footer = footer;
+    this.build();
+    return this;
+  }
+  setColor(color) {
+    this.data.color = color;
+    this.build();
+    return this;
+  }
+  setTimestamp(timestamp) {
+    this.data.timestamp = timestamp;
+    this.build();
+    return this;
+  }
+  addFields(fields) {
+    this.data.fields = [...this.data.fields, ...fields];
+    this.build();
+    return this;
+  }
+  setFields(fields) {
+    this.data.fields = fields;
+    this.build();
+    return this;
+  }
+  spliceFields(index, deleteCount, ...fields) {
+    this.data.fields.splice(index, deleteCount, ...fields);
+    this.build();
+    return this;
+  }
+  clone(overrides = {}) {
+    return new _BetterEmbed({ ...this.data, ...overrides });
+  }
+  toJSON() {
+    return this.embed.toJSON();
+  }
+  async send(handler, options = {}, overrides) {
+    this.build();
+    if (options.content && this.data.acf) {
+      options.content = this.applyContextFormatting(options.content);
+    }
+    return await dynaSend(handler, {
+      ...options,
+      embeds: [
+        overrides ? this.clone(overrides) : this,
+        ...Array.isArray(options?.embeds) ? options?.embeds : options?.embeds ? [options?.embeds] : []
+      ]
+    });
+  }
+};
+
+// src/utils/sendCommandErrorEmbed.ts
+async function sendCommandErrorEmbed(client, error, guild, messageOrInteraction) {
+  if (!client.features.enableCommandErrorMessage) return null;
+  const config = typeof client.features.enableCommandErrorMessage !== "boolean" ? client.features.enableCommandErrorMessage : void 0;
+  const buttons = {
+    supportServer: new import_discord9.ButtonBuilder({
+      url: config?.inviteUrl || client.config.staff.guild.inviteUrl || "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+      // may or may not be a rickroll
+      label: config?.inviteButtonLabel || "Support Support",
+      style: import_discord9.ButtonStyle.Link
+    }),
+    details: new import_discord9.ButtonBuilder({
+      customId: "btn_details",
+      label: config?.detailButtonLabel || "Details",
+      style: import_discord9.ButtonStyle.Secondary
+    })
+  };
+  const actionRow = new import_discord9.ActionRowBuilder({
+    components: config?.inviteUrl && guild?.id !== (config.inviteUrl || client.config.staff.guild.id) ? [buttons.supportServer, buttons.details] : [buttons.details]
+  });
+  const embed_error = config?.embed?.(new BetterEmbed(), error, guild) || new BetterEmbed({
+    color: "Red",
+    title: "Something went wrong",
+    description: "If you keep encountering this error, please report it"
+  });
+  const msg = await embed_error.send(messageOrInteraction, {
+    components: [actionRow],
+    flags: config?.ephemeral ? "Ephemeral" : void 0,
+    deleteAfter: config?.deleteAfter
+  });
+  if (!msg) return null;
+  const collector = msg.createMessageComponentCollector({
+    componentType: import_discord9.ComponentType.Button,
+    idle: config?.detailButtonIdleTimeout ?? 3e4,
+    filter: (i) => i.customId === "btn_details"
+  });
+  collector.on("collect", (i) => {
+    const attachment = new import_discord9.AttachmentBuilder(Buffer.from(`${error.message}
+
+${error.stack}`), {
+      name: "error.txt"
+    });
+    i.reply({ files: [attachment], flags: "Ephemeral" });
+  });
+  collector.on("end", () => {
+    buttons.details.setDisabled(true);
+    embed_error.send(messageOrInteraction, {
+      sendMethod: messageOrInteraction instanceof import_discord9.Message ? 5 /* MessageEdit */ : void 0,
+      components: [actionRow]
+    });
+  });
+  return msg;
+}
+
+// src/utils/async.ts
+async function retryExponentialBackoff(fn, maxRetries = 3, retryDelay = 1e3) {
+  let attempts = 0;
+  while (true) {
+    try {
+      return await fn(attempts);
+    } catch (error) {
+      if (attempts >= maxRetries) throw error;
+      await new Promise((resolve) => setTimeout(resolve, Math.pow(1.75, attempts) * retryDelay + Math.random() * 500));
+      attempts++;
+    }
+  }
+}
+
+// package.json
+var version = "1.0.0";
+
+// src/client.ts
+var import_node_crypto3 = require("crypto");
+var import_chalk2 = __toESM(require("chalk"));
+var clientInstances = [];
+var Vimcord = class _Vimcord extends import_discord10.Client {
+  uuid = (0, import_node_crypto3.randomUUID)();
+  index = clientInstances.length;
+  clientOptions;
+  features;
+  config;
+  status;
+  events;
+  commands;
+  database;
+  // Configure custom logger
+  logger = new Logger({ prefixEmoji: "\u26A1", prefix: `vimcord (i${this.index})` }).extend({
+    clientBanner(client) {
+      if (client.config.app.disableBanner) return;
+      const border = "\u2550".repeat(50);
+      console.log(import_chalk2.default.hex(this.colors.primary)(`
+\u2554${border}\u2557`));
+      console.log(
+        import_chalk2.default.hex(this.colors.primary)("\u2551") + import_chalk2.default.bold.hex(this.colors.text)(
+          `  \u{1F680} ${client.config.app.name} v${client.config.app.appVersion}`.padEnd(
+            50 - (client.config.app.devMode ? 12 : 0)
+          )
+        ) + import_chalk2.default.hex(this.colors.primary)(
+          `${client.config.app.devMode ? import_chalk2.default.hex(this.colors.warn)("devMode \u26A0\uFE0F   ") : ""}\u2551`
+        )
+      );
+      console.log(import_chalk2.default.hex(this.colors.primary)(`\u2551${"".padEnd(50)}\u2551`));
+      console.log(
+        import_chalk2.default.hex(this.colors.primary)("\u2551") + import_chalk2.default.hex(this.colors.muted)(
+          `  # Powered by Vimcord v${version}`.padEnd(50 - 3 - `${client.index}`.length)
+        ) + import_chalk2.default.hex(this.colors.primary)(`${import_chalk2.default.hex(this.colors.muted)(`i${client.index}`)}  \u2551`)
+      );
+      console.log(import_chalk2.default.hex(this.colors.primary)(`\u255A${border}\u255D
+`));
+    },
+    clientReady(clientTag, guildCount) {
+      console.log(
+        this.formatTimestamp(),
+        this.formatPrefix(),
+        import_chalk2.default.hex(this.colors.success)("\u{1F916} READY"),
+        import_chalk2.default.white(`Connected as ${import_chalk2.default.bold.hex(this.colors.primary)(clientTag)}`),
+        import_chalk2.default.hex(this.colors.muted)(`\u2022 ${guildCount} guilds`)
+      );
+    },
+    moduleLoaded(moduleName, count, ignoredCount) {
+      const countText = count ? import_chalk2.default.hex(this.colors.muted)(`(${count} items)`) : "";
+      console.log(
+        this.formatTimestamp(),
+        this.formatPrefix(),
+        import_chalk2.default.hex("#9B59B6")("\u{1F4E6} MODULE"),
+        import_chalk2.default.hex(this.colors.warn)(`${moduleName} loaded`),
+        ignoredCount ? import_chalk2.default.hex(this.colors.muted)(`(${ignoredCount} ignored)`) : "",
+        countText
+      );
+    },
+    commandExecuted(commandName, username, guildName) {
+      const location = guildName ? `in ${import_chalk2.default.hex(this.colors.muted)(guildName)}` : "in DMs";
+      console.log(
+        this.formatTimestamp(),
+        this.formatPrefix(),
+        import_chalk2.default.hex("#87CEEB")("\u{1F4DD} COMMAND"),
+        import_chalk2.default.hex(this.colors.warn)(`/${commandName}`),
+        import_chalk2.default.white(`used by ${import_chalk2.default.bold(username)}`),
+        import_chalk2.default.hex(this.colors.muted)(location)
+      );
+    },
+    database(action, details) {
+      console.log(
+        this.formatTimestamp(),
+        this.formatPrefix(),
+        import_chalk2.default.hex("#FF6B9D")("\u{1F5C4}\uFE0F  DATABASE"),
+        import_chalk2.default.white(action),
+        details ? import_chalk2.default.hex(this.colors.muted)(details) : ""
+      );
+    }
+  });
+  clientStartingPromise = null;
+  constructor(options, features = {}, config = {}) {
+    super(options);
+    this.clientOptions = options;
+    this.features = features;
+    this.config = {
+      app: createVimcordAppConfig(config.app),
+      staff: createVimcordStaffConfig(config.staff),
+      slashCommands: createVimcordSlashCommandConfig(config.slashCommands),
+      prefixCommands: createVimcordPrefixCommandConfig(config.prefixCommands),
+      contextCommands: createVimcordContextCommandConfig(config.contextCommands)
+    };
+    this.status = new VimcordStatusManager(this);
+    this.events = new VimcordEventManager(this);
+    this.commands = new VimcordCommandManager(this);
+    if (this.features.useEnv) {
+      if (typeof this.features.useEnv === "object") {
+        import_dotenv.default.config({ quiet: true, ...this.features.useEnv });
+      } else {
+        import_dotenv.default.config({ quiet: true });
+      }
+    }
+    if (this.features.useGlobalErrorHandlers) {
+      process.on("uncaughtException", (err) => this.logger.error("Uncaught Exception", err));
+      process.on("unhandledRejection", (err) => this.logger.error("Unhandled Rejection", err));
+      process.on("exit", (code) => this.logger.debug(`Process exited with code ${code}`));
+      this.on("error", (err) => this.logger.error("Client Error", err));
+      this.on("shardError", (err) => this.logger.error("Client Shard Error", err));
+    }
+    this.logger.clientBanner(this);
+    this.once("clientReady", (client) => {
+      this.logger.clientReady(client.user.tag, client.guilds.cache.size);
+    });
+    clientInstances.push(this);
+  }
+  /** Returns the options, features, and config of this client */
+  toJSON() {
+    return {
+      options: this.clientOptions,
+      features: this.features,
+      config: this.config
+    };
+  }
+  /** Make a clone of this client */
+  clone() {
+    const { options, features, config } = this.toJSON();
+    return new _Vimcord(options, features, config);
+  }
+  configureApp(options = {}) {
+    this.config.app = createVimcordAppConfig(options);
+    if (this.features.hookToolsDevMode) {
+      globalVimcordToolsConfig.devMode = this.config.app.devMode;
+    }
+    return this;
+  }
+  configureStaff(options = {}) {
+    this.config.staff = createVimcordStaffConfig(options);
+    return this;
+  }
+  configureSlashCommands(options) {
+    this.config.slashCommands = createVimcordSlashCommandConfig(options);
+    return this;
+  }
+  configurePrefixCommands(options) {
+    this.config.prefixCommands = createVimcordPrefixCommandConfig(options);
+    return this;
+  }
+  configureContextCommands(options) {
+    this.config.contextCommands = createVimcordContextCommandConfig(options);
+    return this;
+  }
+  async addEventModules(dir, replaceAll) {
+    await this.events.importFrom(dir, replaceAll);
+    return this;
+  }
+  async addSlashCommandModules(dir, replaceAll) {
+    await this.commands.slash.importFrom(dir, replaceAll);
+    return this;
+  }
+  async addPrefixCommandModules(dir, replaceAll) {
+    await this.commands.prefix.importFrom(dir, replaceAll);
+    return this;
+  }
+  async addContextCommandModules(dir, replaceAll) {
+    await this.commands.context.importFrom(dir, replaceAll);
+    return this;
+  }
+  async useDatabase(database) {
+    this.database = database;
+    this.logger.database("Using", database.name);
+    return this.database.connect();
+  }
+  async whenReady() {
+    if (this.isReady()) return this;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error("Client is not ready")), 45e3);
+      this.once("clientReady", () => {
+        clearTimeout(timeout);
+        resolve(this);
+      });
+    });
+  }
+  async build() {
+    this.configureApp(this.config.app);
+    this.configureStaff(this.config.staff);
+    this.configureSlashCommands(this.config.slashCommands);
+    this.configurePrefixCommands(this.config.prefixCommands);
+    this.configureContextCommands(this.config.contextCommands);
+    if (this.features.importModules) {
+      const importModules = this.features.importModules;
+      await Promise.all([
+        importModules.events && this.addEventModules(importModules.events),
+        importModules.slashCommands && this.addSlashCommandModules(importModules.slashCommands),
+        importModules.prefixCommands && this.addPrefixCommandModules(importModules.prefixCommands),
+        importModules.contextCommands && this.addContextCommandModules(importModules.contextCommands)
+      ]);
+    }
+    if (this.features.useDefaultSlashCommandHandler) {
+      this.events.register(defaultSlashCommandHandler);
+    }
+    if (this.features.useDefaultPrefixCommandHandler) {
+      this.events.register(defaultPrefixCommandHandler);
+    }
+    if (this.features.useDefaultContextCommandHandler) {
+      this.events.register(defaultContextCommandHandler);
+    }
+    return this;
+  }
+  async start(tokenOrPreHook, preHook) {
+    if (this.clientStartingPromise) return this.clientStartingPromise;
+    const main = async () => {
+      let token = typeof tokenOrPreHook === "string" ? tokenOrPreHook : void 0;
+      token ??= this.config.app.devMode ? process.env.TOKEN_DEV : process.env.TOKEN;
+      if (!token) {
+        throw new Error(
+          `TOKEN Missing: ${this.config.app.devMode ? "devMode is enabled, but TOKEN_DEV is not set" : "TOKEN not set"}`
+        );
+      }
+      await this.build();
+      try {
+        if (typeof tokenOrPreHook === "function") {
+          await tokenOrPreHook(this);
+        } else {
+          await preHook?.(this);
+        }
+        const stopLoader = this.logger.loader("Connecting to Discord...");
+        const loginResult = await retryExponentialBackoff(
+          () => super.login(token),
+          this.features.loginAttempts ?? 3,
+          1e3
+        );
+        stopLoader("Connected to Discord    ");
+        this.config.app.verbose && this.logger.debug("\u23F3 Waiting for ready...");
+        return loginResult;
+      } catch (err) {
+        this.logger.error(
+          `Failed to log into Discord after ${this.features.loginAttempts} attempt(s))`,
+          err
+        );
+        return null;
+      } finally {
+        this.clientStartingPromise = null;
+      }
+    };
+    this.clientStartingPromise = main();
+    return this.clientStartingPromise;
+  }
+  async kill() {
+    await super.destroy();
+    const idx = clientInstances.indexOf(this);
+    if (idx >= 0) clientInstances.splice(idx, 1);
+    this.logger.debug("\u{1F6AA} Logged out of Discord");
+  }
+  /** Shortcut for {@link fetchUser tools.fetchUser} */
+  async fetchUser(id) {
+    const client = await this.whenReady();
+    return fetchUser(client, id);
+  }
+  /** Shortcut for {@link fetchGuild tools.fetchGuild} */
+  async fetchGuild(id) {
+    const client = await this.whenReady();
+    return fetchGuild(client, id);
+  }
+};
+var defaultSlashCommandHandler = new EventBuilder({
+  event: "interactionCreate",
+  name: "SlashCommandHandler",
+  async execute(client, interaction) {
+    if (!interaction.isChatInputCommand()) return;
+    const command = client.commands.slash.get(interaction.commandName);
+    if (!command) {
+      return interaction.reply({
+        content: `**/\`${interaction.commandName}\`** is not a command`,
+        flags: "Ephemeral"
+      });
+    }
+    if (command.deferReply && !interaction.replied && !interaction.deferred) {
+      await interaction.deferReply(typeof command.deferReply === "object" ? command.deferReply : void 0);
+    }
+    try {
+      return command.executeCommand(client, interaction);
+    } catch (err) {
+      sendCommandErrorEmbed(client, err, interaction.guild, interaction);
+      throw err;
+    }
+  }
+});
+var defaultPrefixCommandHandler = new EventBuilder({
+  event: "messageCreate",
+  name: "PrefixCommandHandler",
+  async execute(client, message) {
+    if (message.author.bot) return;
+    let prefixUsed;
+    if (!message.content.startsWith(client.config.prefixCommands.defaultPrefix)) {
+      if (client.config.prefixCommands.allowMentionAsPrefix) {
+        if (!message.content.startsWith(`${(0, import_discord10.userMention)(client.user.id)} `)) {
+          return;
+        } else {
+          prefixUsed = `${(0, import_discord10.userMention)(client.user.id)} `;
+        }
+      } else {
+        return;
+      }
+    } else {
+      prefixUsed = client.config.prefixCommands.defaultPrefix;
+    }
+    message.content = message.content.slice(prefixUsed.length);
+    let commandName = message.content.split(" ")[0];
+    if (!commandName) {
+      return;
+    }
+    const command = client.commands.prefix.get(commandName) || client.commands.prefix.getByAlias(commandName);
+    if (!command) {
+      return;
+    }
+    message.content = message.content.slice(commandName.length + 1);
+    try {
+      return command.executeCommand(client, message);
+    } catch (err) {
+      sendCommandErrorEmbed(client, err, message.guild, message);
+      throw err;
+    }
+  }
+});
+var defaultContextCommandHandler = new EventBuilder({
+  event: "interactionCreate",
+  name: "ContextCommandHandler",
+  execute(client, interaction) {
+    if (!interaction.isContextMenuCommand()) return;
+    interaction.reply({ content: "This handler is not yet implemented" });
+  }
+});
+
+// src/modules/db/mongo/mongo.ts
+var import_node_crypto4 = require("crypto");
+var import_node_events2 = __toESM(require("events"));
+var import_mongoose = __toESM(require("mongoose"));
+try {
+  import("mongoose");
+} catch {
+  throw new Error("MongoDatabase requires the mongoose package, install it with `npm install mongoose`");
+}
+var globalInstanceEmitter = new import_node_events2.default();
+var instances = [];
+async function useMongoDatabase(index) {
+  const instance = instances.at(index ?? 0);
+  if (!instance) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject("useMongoDatabase timed out"), 45e3);
+      globalInstanceEmitter.once("connected", (mdb) => {
+        clearTimeout(timeout);
+        resolve(mdb);
+      });
+    });
+  }
+  return instance;
+}
+var MongoDatabase = class {
+  constructor(client, options) {
+    this.client = client;
+    this.mongoose = new import_mongoose.default.Mongoose(options);
+    this.index = instances.length - 1;
+    instances.push(this);
+    globalInstanceEmitter.emit("created", this);
+  }
+  name = "MongoDatabase";
+  uuid = (0, import_node_crypto4.randomUUID)();
+  index;
+  uri;
+  mongoose;
+  eventEmitter = new import_node_events2.default();
+  isReady = false;
+  isConnecting = false;
+  async waitForReady() {
+    if (!this.isReady && this.isConnecting) {
+      return new Promise((resolve) => this.eventEmitter.once("ready", () => resolve(this.isReady)));
+    }
+    return this.isReady;
+  }
+  async connect(uri, connectionOptions, options) {
+    if (!this.isReady && this.isConnecting) {
+      return new Promise((resolve) => this.eventEmitter.once("ready", () => resolve(true)));
+    }
+    if (this.mongoose.connection?.readyState === 1) {
+      return true;
+    }
+    uri ??= this.uri || this.client.config.app.devMode ? process.env.MONGO_URI_DEV : process.env.MONGO_URI;
+    options = { ...options, maxRetries: options?.maxRetries ?? 3 };
+    if (!uri) {
+      throw new Error(
+        `MONGO_URI Missing: ${this.client.config.app.devMode ? "DEV MODE is enabled, but MONGO_URI_DEV is not set" : "MONGO_URI not set"}`
+      );
+    }
+    this.uri = uri;
+    this.isReady = false;
+    this.isConnecting = true;
+    try {
+      const stopLoader = this.client.logger.loader("Connecting to MongoDB...");
+      await retryExponentialBackoff(
+        (attempt) => {
+          return this.mongoose.connect(uri, {
+            serverSelectionTimeoutMS: 3e4,
+            socketTimeoutMS: 45e3,
+            connectTimeoutMS: 3e4,
+            maxPoolSize: 10,
+            minPoolSize: 5,
+            bufferCommands: false,
+            ...connectionOptions
+          });
+        },
+        options.maxRetries,
+        1e3
+      );
+      this.isReady = true;
+      this.eventEmitter.emit("ready");
+      globalInstanceEmitter.emit("connected", this);
+      stopLoader("Connected to MongoDB    ");
+    } catch (err) {
+      this.client.logger.error(`Failed to connect to MongoDB after ${options.maxRetries} attempt(s)`, err);
+    }
+    this.isConnecting = false;
+    return true;
+  }
+};
+
+// src/modules/db/mongo/mongoSchema.builder.ts
+var import_mongoose2 = require("mongoose");
+var import_node_crypto5 = require("crypto");
+var import_node_events3 = __toESM(require("events"));
+try {
+  import("mongoose");
+} catch {
+  throw new Error("MongoSchemaBuilder requires the mongoose package, install it with `npm install mongoose`");
+}
+function createMongoSchema(collection, definition, options) {
+  return new MongoSchemaBuilder(collection, definition, options);
+}
+var MongoSchemaBuilder = class {
+  schema;
+  model;
+  database = null;
+  connectionIndex = 0;
+  isReady = false;
+  isInitializing = false;
+  eventEmitter = new import_node_events3.default();
+  logger;
+  constructor(collection, definition, options) {
+    this.connectionIndex = options?.connectionIndex ?? this.connectionIndex;
+    this.logger = new Logger({
+      prefixEmoji: "\u{1F96D}",
+      prefix: `MongoSchema (c${this.connectionIndex}) [${collection}]`,
+      colors: { primary: "#F29B58" }
+    });
+    this.eventEmitter.once("initialized", () => {
+      if (this.database) {
+        this.schema = new import_mongoose2.Schema(definition, { versionKey: false });
+        this.model = this.database.mongoose.model(collection, this.schema);
+        this.eventEmitter.emit("ready", true);
+      } else {
+        this.eventEmitter.emit("error", new Error(`MongoDatabase (c${this.connectionIndex}) not found`));
+      }
+    });
+    this.eventEmitter.on("ready", (ready) => {
+      this.isReady = ready;
+      if (this.database?.client.config.app.verbose) {
+        this.logger.debug(`Loaded! | ${this.database?.client.config.app.name}`);
+      }
+    });
+    this.eventEmitter.on("error", (error) => this.logger.error("Error:", error));
+    this.init().catch((error) => {
+      this.eventEmitter.emit("error", error);
+    });
+  }
+  async init() {
+    if (this.isInitializing) return;
+    this.isInitializing = true;
+    try {
+      const database = await useMongoDatabase(this.connectionIndex);
+      if (!database) {
+        throw new Error("Could not use MongoDatabase");
+      }
+      this.database = database;
+      this.eventEmitter.emit("initialized");
+    } catch (err) {
+      this.eventEmitter.emit("error", err);
+    } finally {
+      this.isInitializing = false;
+    }
+  }
+  extend(extras) {
+    for (const [key, fn] of Object.entries(extras)) {
+      if (typeof fn === "function") {
+        this[key] = function(...args) {
+          return fn.call(this, ...args);
+        };
+      }
+    }
+    return this;
+  }
+  on(event, listener) {
+    this.eventEmitter.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.eventEmitter.once(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.eventEmitter.off(event, listener);
+    return this;
+  }
+  async execute(fn) {
+    try {
+      if (!this.isReady) {
+        await new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => reject("execution wait for ready timed out"), 45e3);
+          this.eventEmitter.once("ready", () => {
+            clearTimeout(timeout);
+            resolve();
+          });
+          this.eventEmitter.once("error", (error) => {
+            clearTimeout(timeout);
+            reject(error);
+          });
+        });
+      }
+      if (!this.database) {
+        throw new Error("MongoDB connection not found");
+      }
+      return await retryExponentialBackoff(async () => await fn());
+    } catch (err) {
+      this.eventEmitter.emit("error", err);
+    }
+  }
+  async createHexId(bytes, path2, maxRetries = 10) {
+    return await this.execute(async () => {
+      const createHex = () => Buffer.from((0, import_node_crypto5.randomBytes)(bytes)).toString("hex");
+      let id = createHex();
+      let tries = 0;
+      while (await this.model.exists({ [path2]: id })) {
+        if (tries >= maxRetries) throw Error(`Failed to generate a unique hex ID after ${tries} attempt(s)`);
+        id = createHex();
+        tries++;
+      }
+      return id;
+    });
+  }
+  async count(filter) {
+    return await this.execute(async () => {
+      return this.model.countDocuments(filter);
+    });
+  }
+  async exists(filter) {
+    return await this.execute(async () => {
+      return await this.model.exists(filter) ? true : false;
+    });
+  }
+  async create(query) {
+    return await this.execute(async () => {
+      return this.model.create(query);
+    });
+  }
+  async upsert(filter, query, options) {
+    return await this.execute(async () => {
+      return this.model.findOneAndUpdate(filter, query, { ...options, upsert: true, new: true });
+    });
+  }
+  async delete(filter) {
+    return await this.execute(async () => {
+      return this.model.deleteOne(filter);
+    });
+  }
+  async deleteAll(filter) {
+    return await this.execute(async () => {
+      return this.model.deleteMany(filter);
+    });
+  }
+  async distinct(key, filter) {
+    return await this.execute(async () => {
+      return this.model.distinct(key, filter);
+    });
+  }
+  async fetch(filter, projection, options) {
+    return await this.execute(async () => {
+      return this.model.findOne(filter, projection, { ...options, lean: options?.lean ?? true });
+    });
+  }
+  async fetchAll(filter, projection, options) {
+    return await this.execute(async () => {
+      return this.model.find(filter, projection, { ...options, lean: options?.lean ?? true });
+    }) || [];
+  }
+  async update(filter, update, options) {
+    return await this.execute(async () => {
+      return this.model.findOneAndUpdate(filter, update, { ...options, lean: options?.lean ?? true });
+    });
+  }
+  async updateAll(filter, update, options) {
+    return await this.execute(async () => {
+      return this.model.updateMany(filter, update, options);
+    });
+  }
+  async aggregate(pipeline, options) {
+    return await this.execute(async () => {
+      const result = await this.model.aggregate(pipeline, options);
+      return result?.length ? result : [];
+    });
+  }
+};
+
+// src/tools/BetterContainer.ts
+var import_discord11 = require("discord.js");
+var BetterContainer = class {
+  container = new import_discord11.ContainerBuilder();
+  data;
+  config;
+  constructor(data = {}) {
+    this.config = data.config || globalVimcordToolsConfig;
+    this.data = {
+      color: data.color ?? (this.config.devMode ? this.config.embedColorDev : this.config.embedColor),
+      ...data
+    };
+    this.build();
+  }
+  configure() {
+    if (this.data.color) {
+      try {
+        const color = Array.isArray(this.data.color) ? this.data.color[Math.floor(Math.random() * this.data.color.length)] ?? null : this.data.color;
+        if (color) {
+          this.container.setAccentColor(parseInt(color.replace("#", ""), 16));
+        } else {
+          this.container.clearAccentColor();
+        }
+      } catch (error) {
+        console.error("[BetterContainer] Invalid color:", error);
+      }
+    }
+  }
+  build() {
+    this.configure();
+  }
+  addSeparator(options) {
+    this.container.addSeparatorComponents((sb) => {
+      if (options?.divider !== void 0) sb.setDivider(options.divider);
+      if (options?.spacing !== void 0) sb.setSpacing(options.spacing);
+      return sb;
+    });
+    return this;
+  }
+  addText(text) {
+    this.container.addTextDisplayComponents((tdb) => tdb.setContent(Array.isArray(text) ? text.join("\n") : text));
+    return this;
+  }
+  addMedia(...media) {
+    this.container.addMediaGalleryComponents((mb) => {
+      for (const m of media) {
+        const urls = Array.isArray(m.url) ? m.url : [m.url];
+        for (const u of urls) {
+          mb.addItems((mgb) => {
+            mgb.setURL(u);
+            if (m.spoiler) mgb.setSpoiler(true);
+            if (m.description) mgb.setDescription(m.description);
+            return mgb;
+          });
+        }
+      }
+      return mb;
+    });
+    return this;
+  }
+  addSection(data) {
+    this.container.addSectionComponents((sb) => {
+      if (data.text) {
+        sb.addTextDisplayComponents(
+          (tdb) => tdb.setContent(Array.isArray(data.text) ? data.text.join("\n") : data.text)
+        );
+      }
+      if (data.thumbnail) sb.setThumbnailAccessory(new import_discord11.ThumbnailBuilder(data.thumbnail));
+      if (data.button) sb.setButtonAccessory(new import_discord11.ButtonBuilder(data.button));
+      return sb;
+    });
+    return this;
+  }
+  addActionRow(...components) {
+    this.container.addActionRowComponents(...components);
+    return this;
+  }
+  toJSON() {
+    return this.container.toJSON();
+  }
+  async send(handler, options = {}) {
+    this.build();
+    return await dynaSend(handler, {
+      ...options,
+      withResponse: true,
+      components: [this.container],
+      flags: Array.isArray(options.flags) ? [...options.flags, "IsComponentsV2"] : options.flags ? [options.flags, "IsComponentsV2"] : "IsComponentsV2"
+    });
+  }
+};
+
+// src/tools/BetterModal.ts
+var import_discord12 = require("discord.js");
+function randomCharString(length) {
+  const chars = "ABCDEFGHJKLMOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  return Array.from({ length }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join("");
+}
+var BetterModal = class {
+  id;
+  options;
+  modal;
+  components = /* @__PURE__ */ new Map();
+  config;
+  constructor(options = {}) {
+    this.id = options.id || this.createModalId();
+    this.options = options;
+    this.modal = new import_discord12.ModalBuilder().setCustomId(this.id);
+    this.config = options.config || globalVimcordToolsConfig;
+    if (options.title) {
+      this.setTitle(options.title);
+    }
+    if (options.components?.length) {
+      this.addComponents(...options.components);
+    }
+  }
+  createModalId() {
+    return `modal:${randomCharString(10)}-${Date.now()}`;
+  }
+  createComponentId() {
+    return `modal-component:${randomCharString(4)}-${Date.now().toString().slice(-4)}`;
+  }
+  validateComponentLength() {
+    if (this.components.size >= 5) throw new Error("Modal can only have 5 components");
+  }
+  toJSON() {
+    return this.modal.toJSON();
+  }
+  build() {
+    this.modal.setLabelComponents(Array.from(this.components.values()));
+    return this.modal;
+  }
+  setTitle(title) {
+    this.modal.setTitle(title);
+    return this;
+  }
+  addComponents(...components) {
+    for (const component of components) {
+      if ("textInput" in component) {
+        this.addTextInput(component.textInput);
+      } else if ("stringSelect" in component) {
+        this.addStringSelect(component.stringSelect);
+      } else if ("channelSelect" in component) {
+        this.addChannelSelect(component.channelSelect);
+      } else if ("userSelect" in component) {
+        this.addUserSelect(component.userSelect);
+      } else if ("roleSelect" in component) {
+        this.addRoleSelect(component.roleSelect);
+      } else if ("mentionableSelect" in component) {
+        this.addMentionableSelect(component.mentionableSelect);
+      } else if ("fileUpload" in component) {
+        this.addFileUpload(component.fileUpload);
+      }
+    }
+    return this;
+  }
+  setComponents(...components) {
+    this.modal.spliceLabelComponents(0, this.modal.components.length);
+    this.addComponents(...components);
+    return this;
+  }
+  addTextInput(data) {
+    this.validateComponentLength();
+    let { label, description, custom_id, ...rest } = data;
+    custom_id ||= this.createComponentId();
+    const textInputComponent = new import_discord12.TextInputBuilder(rest).setCustomId(custom_id);
+    if (!rest.style) textInputComponent.setStyle(import_discord12.TextInputStyle.Short);
+    const labelComponent = new import_discord12.LabelBuilder().setLabel(label).setTextInputComponent(textInputComponent);
+    if (description) labelComponent.setDescription(description);
+    this.components.set(custom_id, labelComponent);
+    return this;
+  }
+  addStringSelect(data) {
+    this.validateComponentLength();
+    let { label, description, custom_id, ...rest } = data;
+    custom_id ||= this.createComponentId();
+    const stringSelectComponent = new import_discord12.StringSelectMenuBuilder(rest).setCustomId(custom_id);
+    const labelComponent = new import_discord12.LabelBuilder().setLabel(label).setStringSelectMenuComponent(stringSelectComponent);
+    if (description) labelComponent.setDescription(description);
+    this.components.set(custom_id, labelComponent);
+    return this;
+  }
+  addChannelSelect(data) {
+    this.validateComponentLength();
+    let { label, description, custom_id, ...rest } = data;
+    custom_id ||= this.createComponentId();
+    const channelSelectComponent = new import_discord12.ChannelSelectMenuBuilder(rest).setCustomId(custom_id);
+    const labelComponent = new import_discord12.LabelBuilder().setLabel(label).setChannelSelectMenuComponent(channelSelectComponent);
+    if (description) labelComponent.setDescription(description);
+    this.components.set(custom_id, labelComponent);
+    return this;
+  }
+  addUserSelect(data) {
+    this.validateComponentLength();
+    let { label, description, custom_id, ...rest } = data;
+    custom_id ||= this.createComponentId();
+    const userSelectComponent = new import_discord12.UserSelectMenuBuilder(rest).setCustomId(custom_id);
+    const labelComponent = new import_discord12.LabelBuilder().setLabel(label).setUserSelectMenuComponent(userSelectComponent);
+    if (description) labelComponent.setDescription(description);
+    this.components.set(custom_id, labelComponent);
+    return this;
+  }
+  addRoleSelect(data) {
+    this.validateComponentLength();
+    let { label, description, custom_id, ...rest } = data;
+    custom_id ||= this.createComponentId();
+    const roleSelectComponent = new import_discord12.RoleSelectMenuBuilder(rest).setCustomId(custom_id);
+    const labelComponent = new import_discord12.LabelBuilder().setLabel(label).setRoleSelectMenuComponent(roleSelectComponent);
+    if (description) labelComponent.setDescription(description);
+    this.components.set(custom_id, labelComponent);
+    return this;
+  }
+  addMentionableSelect(data) {
+    this.validateComponentLength();
+    let { label, description, custom_id, ...rest } = data;
+    custom_id ||= this.createComponentId();
+    const mentionableSelectComponent = new import_discord12.MentionableSelectMenuBuilder(rest).setCustomId(custom_id);
+    const labelComponent = new import_discord12.LabelBuilder().setLabel(label).setMentionableSelectMenuComponent(mentionableSelectComponent);
+    if (description) labelComponent.setDescription(description);
+    this.components.set(custom_id, labelComponent);
+    return this;
+  }
+  addFileUpload(data) {
+    this.validateComponentLength();
+    let { label, description, custom_id, ...rest } = data;
+    custom_id ||= this.createComponentId();
+    const fileUploadComponent = new import_discord12.FileUploadBuilder(rest).setCustomId(custom_id);
+    const labelComponent = new import_discord12.LabelBuilder().setLabel(label).setFileUploadComponent(fileUploadComponent);
+    if (description) labelComponent.setDescription(description);
+    this.components.set(custom_id, labelComponent);
+    return this;
+  }
+  /** Show the modal via interaction */
+  async show(interaction) {
+    if (!("showModal" in interaction)) throw new Error("Interaction does not support showing modals");
+    if (!this.modal.data.title) throw new Error("Modal must have a title");
+    this.build();
+    await interaction.showModal(this.modal).catch((err) => {
+      console.error("Modal failed to send", err);
+    });
+  }
+  /** Waits for the modal to be submitted and returns the component data
+   * @param interaction The interaction used to show the modal
+   * @param options Options */
+  async awaitSubmit(interaction, options) {
+    if (!("showModal" in interaction)) throw new Error("Interaction does not support showing modals");
+    try {
+      const modalSubmit = await interaction.awaitModalSubmit({
+        time: this.config.timeouts.modalSubmit,
+        ...options,
+        filter: (i) => i.customId === this.id
+      });
+      const fields = {};
+      const values = [];
+      for (const [customId] of this.components) {
+        let value = null;
+        try {
+          value = modalSubmit.fields.getTextInputValue(customId);
+        } catch {
+          try {
+            const field = modalSubmit.fields.fields.get(customId);
+            if (field && "values" in field) {
+              value = field.values;
+            }
+          } catch {
+          }
+        }
+        fields[customId] = value;
+        values.push(value);
+      }
+      return { fields, values, interaction: modalSubmit };
+    } catch (error) {
+      return null;
+    }
+  }
+  async showAndAwait(interaction, options) {
+    if (!("showModal" in interaction)) throw new Error("Interaction does not support showing modals");
+    await this.show(interaction);
+    return this.awaitSubmit(interaction, options);
+  }
+};
+
+// src/tools/Paginator.ts
+var import_discord13 = require("discord.js");
+var import_node_events4 = __toESM(require("events"));
+var PaginationType = /* @__PURE__ */ ((PaginationType2) => {
+  PaginationType2[PaginationType2["Short"] = 0] = "Short";
+  PaginationType2[PaginationType2["ShortJump"] = 1] = "ShortJump";
+  PaginationType2[PaginationType2["Long"] = 2] = "Long";
+  PaginationType2[PaginationType2["LongJump"] = 3] = "LongJump";
+  return PaginationType2;
+})(PaginationType || {});
+var PaginationTimeoutType = /* @__PURE__ */ ((PaginationTimeoutType2) => {
+  PaginationTimeoutType2[PaginationTimeoutType2["DisableComponents"] = 0] = "DisableComponents";
+  PaginationTimeoutType2[PaginationTimeoutType2["ClearComponents"] = 1] = "ClearComponents";
+  PaginationTimeoutType2[PaginationTimeoutType2["DeleteMessage"] = 2] = "DeleteMessage";
+  return PaginationTimeoutType2;
+})(PaginationTimeoutType || {});
+function wrapPositive(num, max) {
+  return (num % (max + 1) + (max + 1)) % (max + 1);
+}
+function createNavButton(id, config) {
+  const data = config.paginator.buttons[id];
+  const btn = new import_discord13.ButtonBuilder({ customId: `btn_${id}`, style: import_discord13.ButtonStyle.Secondary });
+  if (data.label) {
+    btn.setLabel(data.label);
+  } else {
+    btn.setEmoji(data.emoji.name);
+  }
+  return btn;
+}
+function isEmbed(item) {
+  return item instanceof import_discord13.EmbedBuilder || item instanceof BetterEmbed;
+}
+function resolvePages(pages) {
+  if (Array.isArray(pages)) {
+    if (pages.length === 0) return [];
+    if (Array.isArray(pages[0])) return pages;
+    return pages;
+  }
+  return [pages];
+}
+var Paginator = class {
+  chapters = [];
+  options;
+  config;
+  data;
+  events;
+  eventEmitter = new import_node_events4.default();
+  constructor(options = {}) {
+    this.config = options.config || globalVimcordToolsConfig;
+    this.options = {
+      type: options.type ?? 0 /* Short */,
+      participants: options.participants ?? [],
+      pages: options.pages ?? [],
+      useReactions: options.useReactions ?? false,
+      dynamic: options.dynamic ?? false,
+      timeout: options.timeout ?? this.config.timeouts.pagination,
+      onTimeout: options.onTimeout ?? 1 /* ClearComponents */
+    };
+    this.data = {
+      message: null,
+      messageActionRows: [],
+      messageSendOptions: void 0,
+      extraButtons: [],
+      page: { current: null, index: { chapter: 0, nested: 0 } },
+      navigation: { reactions: [], isRequired: false, isLong: false, canJump: false },
+      collectors: { component: null, reaction: null },
+      components: {
+        chapterSelect: new import_discord13.StringSelectMenuBuilder({ customId: "ssm_chapterSelect" }),
+        navigation: {
+          first: createNavButton("first", this.config),
+          back: createNavButton("back", this.config),
+          jump: createNavButton("jump", this.config),
+          next: createNavButton("next", this.config),
+          last: createNavButton("last", this.config)
+        },
+        actionRows: {
+          chapterSelect: new import_discord13.ActionRowBuilder(),
+          navigation: new import_discord13.ActionRowBuilder()
+        }
+      }
+    };
+    this.data.components.actionRows.chapterSelect.setComponents(this.data.components.chapterSelect);
+    this.events = {
+      beforeChapterChange: [],
+      chapterChange: [],
+      beforePageChange: [],
+      pageChange: [],
+      first: [],
+      back: [],
+      jump: [],
+      next: [],
+      last: [],
+      collect: [],
+      react: [],
+      timeout: []
+    };
+    if (this.options.pages.length) {
+      this.addChapter(this.options.pages, { label: "Default" });
+    }
+    for (const [key, val] of Object.entries(this.config.paginator.buttons)) {
+      if (!val.emoji.id) throw new Error(`[Paginator] Button '${key}.id' is not defined`);
+      if (!val.emoji.name) throw new Error(`[Paginator] Button '${key}.name' is not defined`);
+    }
+  }
+  async build() {
+    await this.setPage();
+    this.data.components.actionRows.navigation.setComponents([]);
+    this.data.navigation.reactions = [];
+    this.data.messageActionRows = [];
+    if (this.data.navigation.isRequired) {
+      let navTypes = [];
+      if (this.options.dynamic) {
+        const isLong = this.data.navigation.isLong;
+        const isJump = this.options.type === 1 /* ShortJump */ || this.options.type === 3 /* LongJump */;
+        if (isLong) {
+          this.options.type = isJump ? 3 /* LongJump */ : 2 /* Long */;
+        } else {
+          this.options.type = isJump ? 1 /* ShortJump */ : 0 /* Short */;
+        }
+      }
+      switch (this.options.type) {
+        case 0 /* Short */:
+          navTypes = ["back", "next"];
+          break;
+        case 1 /* ShortJump */:
+          navTypes = ["back", "jump", "next"];
+          break;
+        case 2 /* Long */:
+          navTypes = ["first", "back", "next", "last"];
+          break;
+        case 3 /* LongJump */:
+          navTypes = ["first", "back", "jump", "next", "last"];
+          break;
+      }
+      if (this.options.useReactions) {
+        this.data.navigation.reactions = navTypes.map((type) => {
+          const data = this.config.paginator.buttons[type];
+          return { name: data.emoji.name, id: data.emoji.id };
+        });
+      } else {
+        this.data.components.actionRows.navigation.setComponents(
+          navTypes.map((type) => this.data.components.navigation[type])
+        );
+      }
+    }
+    if (this.chapters.length > 1) {
+      this.data.messageActionRows.push(this.data.components.actionRows.chapterSelect);
+    }
+    if (this.data.navigation.isRequired && !this.options.useReactions || this.data.extraButtons.length) {
+      for (const btn of this.data.extraButtons) {
+        this.data.components.actionRows.navigation.components.splice(btn.index, 0, btn.component);
+      }
+      this.data.messageActionRows.push(this.data.components.actionRows.navigation);
+    }
+  }
+  buildSendOptions(options = {}) {
+    const sendOptions = {
+      content: "",
+      embeds: [],
+      components: [],
+      flags: [],
+      ...options,
+      withResponse: true
+    };
+    const page = this.data.page.current;
+    if (Array.isArray(page)) {
+      sendOptions.embeds.push(...page);
+    } else if (typeof page === "string") {
+      sendOptions.content = page;
+    } else if (isEmbed(page)) {
+      sendOptions.embeds.push(page);
+    } else if (page instanceof import_discord13.ContainerBuilder || page instanceof BetterContainer) {
+      sendOptions.components.push(page);
+      if (!sendOptions.flags.includes("IsComponentsV2")) {
+        sendOptions.flags.push("IsComponentsV2");
+      }
+    }
+    sendOptions.components.push(...this.data.messageActionRows);
+    return sendOptions;
+  }
+  async handlePostTimeout() {
+    if (!this.data.message) return;
+    this.callEventStack("timeout", this.data.message);
+    this.data.collectors.component?.stop();
+    this.data.collectors.reaction?.stop();
+    switch (this.options.onTimeout) {
+      case 0 /* DisableComponents */:
+        if (!this.data.message.editable) break;
+        const disabledNavComponents = this.data.components.actionRows.navigation.components.map((component) => {
+          if ("setDisabled" in component) {
+            return component.setDisabled(true);
+          }
+          return component;
+        });
+        const disabledNavRow = import_discord13.ActionRowBuilder.from(this.data.components.actionRows.navigation).setComponents(
+          disabledNavComponents
+        );
+        const newComponents = [];
+        const currentPage = this.data.page.current;
+        if (currentPage instanceof import_discord13.ContainerBuilder || currentPage instanceof BetterContainer) {
+          newComponents.push(currentPage);
+        }
+        if (this.chapters.length > 1) {
+          const disabledSelect = import_discord13.StringSelectMenuBuilder.from(this.data.components.chapterSelect).setDisabled(
+            true
+          );
+          newComponents.push(
+            import_discord13.ActionRowBuilder.from(this.data.components.actionRows.chapterSelect).setComponents(disabledSelect)
+          );
+        }
+        if (disabledNavRow.components.length > 0) {
+          newComponents.push(disabledNavRow);
+        }
+        await this.data.message.edit({ components: newComponents }).catch(Boolean);
+        if (this.options.useReactions) {
+          await this.nav_removeFromMessage();
+        }
+        break;
+      case 1 /* ClearComponents */:
+        if (this.data.message.editable) {
+          await this.nav_removeFromMessage();
+        }
+        break;
+      case 2 /* DeleteMessage */:
+        await this.data.message.delete().catch(Boolean);
+        break;
+    }
+  }
+  async nav_removeFromMessage() {
+    if (!this.data.message?.editable) return;
+    if (this.options.useReactions) {
+      await this.data.message.reactions.removeAll().catch(Boolean);
+    } else {
+      const newComponents = this.data.message.components.filter((c) => c.type !== import_discord13.ComponentType.Container);
+      await this.data.message.edit({ components: newComponents }).catch(Boolean);
+    }
+  }
+  async nav_addReactions() {
+    if (!this.data.message || !this.options.useReactions || !this.data.navigation.reactions.length) return;
+    for (const r of this.data.navigation.reactions) {
+      await this.data.message.react(r.id).catch(Boolean);
+    }
+  }
+  async collect_components() {
+    if (!this.data.message || !this.data.messageActionRows.length) return;
+    if (this.data.collectors.component) {
+      this.data.collectors.component.resetTimer();
+      return;
+    }
+    const participantIds = this.options.participants.map((p) => typeof p === "string" ? p : p.id);
+    const collector = this.data.message.createMessageComponentCollector({
+      filter: async (i) => {
+        if (!participantIds.length) return true;
+        if (participantIds.includes(i.user.id)) {
+          return true;
+        } else {
+          await i.reply({ content: this.config.paginator.notAParticipantMessage, flags: "Ephemeral" });
+          return false;
+        }
+      },
+      ...this.options.timeout ? { idle: this.options.timeout } : {}
+    });
+    this.data.collectors.component = collector;
+    collector.on("collect", async (i) => {
+      if (!i.isStringSelectMenu() && !i.isButton()) return;
+      collector.resetTimer();
+      this.callEventStack("collect", i, this.data.page.current, this.data.page.index);
+      try {
+        if (i.customId === "btn_jump") {
+          this.callEventStack("jump", this.data.page.current, this.data.page.index);
+          await i.reply({ content: "Jump not implemented yet.", flags: "Ephemeral" });
+          return;
+        }
+        await i.deferUpdate().catch(Boolean);
+        switch (i.customId) {
+          case "ssm_chapterSelect":
+            const chapterIndex = this.chapters.findIndex(
+              (c) => c.id === i.values[0]
+            );
+            await this.setPage(chapterIndex, 0);
+            break;
+          case "btn_first":
+            this.callEventStack("first", this.data.page.current, this.data.page.index);
+            await this.setPage(this.data.page.index.chapter, 0);
+            break;
+          case "btn_back":
+            this.callEventStack("back", this.data.page.current, this.data.page.index);
+            await this.setPage(this.data.page.index.chapter, this.data.page.index.nested - 1);
+            break;
+          case "btn_next":
+            this.callEventStack("next", this.data.page.current, this.data.page.index);
+            await this.setPage(this.data.page.index.chapter, this.data.page.index.nested + 1);
+            break;
+          case "btn_last":
+            this.callEventStack("last", this.data.page.current, this.data.page.index);
+            await this.setPage(
+              this.data.page.index.chapter,
+              this.chapters[this.data.page.index.chapter].pages.length - 1
+            );
+            break;
+        }
+        await this.refresh();
+      } catch (err) {
+        console.error("[Paginator] Component navigation error", err);
+      }
+    });
+    collector.on("end", async () => {
+      this.data.collectors.component = null;
+      this.handlePostTimeout();
+    });
+  }
+  async callEventStack(event, ...args) {
+    if (!this.events[event].length) return;
+    const listeners = [...this.events[event]];
+    for (const _event of listeners) {
+      await _event.listener(...args);
+      if (_event.once) {
+        const originalIndex = this.events[event].indexOf(_event);
+        if (originalIndex > -1) this.events[event].splice(originalIndex, 1);
+      }
+    }
+  }
+  on(event, listener, once = false) {
+    this.events[event].push({ listener, once });
+    return this;
+  }
+  /** Adds a chapter to the paginator.
+   * @param pages The pages for this chapter.
+   * Note: `[Embed1, Embed2]` = 2 Pages. `[[Embed1, Embed2]]` = 1 Page (Group of 2).
+   * @param data Metadata for the chapter select menu. */
+  addChapter(pages, data) {
+    if (data.default === void 0 && !this.chapters.length) {
+      data.default = true;
+    }
+    if (data.default) {
+      this.data.components.chapterSelect.options.forEach((opt) => opt.setDefault(false));
+    }
+    if (!data.value) {
+      data.value = `ssm_c:${this.chapters.length}`;
+    }
+    const normalizedPages = resolvePages(pages);
+    this.chapters.push({ id: data.value, pages: normalizedPages });
+    this.data.components.chapterSelect.addOptions(data);
+    return this;
+  }
+  spliceChapters(index, deleteCount) {
+    this.chapters.splice(index, deleteCount);
+    this.data.components.chapterSelect.spliceOptions(index, deleteCount);
+    return this;
+  }
+  hydrateChapter(index, pages, set) {
+    if (!this.chapters[index]) {
+      throw new Error(`[Paginator] Could not find chapter at index ${index}`);
+    }
+    const normalizedPages = resolvePages(pages);
+    if (set) {
+      this.chapters[index].pages = normalizedPages;
+    } else {
+      this.chapters[index].pages.push(...normalizedPages);
+    }
+    return this;
+  }
+  setPaginationType(type) {
+    this.options.type = type;
+    return this;
+  }
+  insertButtonAt(index, component) {
+    if (this.data.components.actionRows.navigation.components.length >= 5) {
+      throw new Error("[Paginator] You cannot have more than 5 components in 1 action row. Use a separate ActionRow");
+    }
+    this.data.extraButtons.push({ index, component });
+    return this;
+  }
+  removeButtonAt(...index) {
+    index.forEach((i) => this.data.extraButtons.splice(i, 1));
+    return this;
+  }
+  async setPage(chapterIndex = this.data.page.index.chapter, nestedIndex = this.data.page.index.nested) {
+    const _oldChapterIndex = this.data.page.index.chapter;
+    this.data.page.index.chapter = wrapPositive(chapterIndex, this.chapters.length - 1);
+    const currentChapter = this.chapters[this.data.page.index.chapter];
+    if (!currentChapter) {
+      throw new Error(`[Paginator] Could not find chapter at index ${this.data.page.index.chapter}`);
+    }
+    await this.callEventStack("beforeChapterChange", this.data.page.index.chapter);
+    await this.callEventStack("beforePageChange", nestedIndex);
+    const _oldNestedIndex = this.data.page.index.nested;
+    this.data.page.index.nested = this.data.page.index.chapter !== _oldChapterIndex ? 0 : wrapPositive(nestedIndex, currentChapter.pages.length - 1);
+    const currentPage = currentChapter.pages[this.data.page.index.nested];
+    if (!currentPage) {
+      throw new Error(`[Paginator] Could not find page at index ${this.data.page.index.nested}`);
+    }
+    this.data.page.current = currentPage;
+    this.data.components.chapterSelect.options.forEach((opt) => opt.setDefault(false));
+    this.data.components.chapterSelect.options.at(this.data.page.index.chapter)?.setDefault(true);
+    const { jumpableThreshold, longThreshold } = this.config.paginator;
+    this.data.navigation.isRequired = currentChapter.pages.length >= 2;
+    this.data.navigation.canJump = currentChapter.pages.length >= jumpableThreshold;
+    this.data.navigation.isLong = currentChapter.pages.length >= longThreshold;
+    if (this.data.page.index.chapter !== _oldChapterIndex) {
+      this.callEventStack(
+        "chapterChange",
+        this.data.components.chapterSelect.options.at(this.data.page.index.chapter),
+        this.data.page.current,
+        this.data.page.index
+      );
+      this.callEventStack("pageChange", this.data.page.current, this.data.page.index);
+    } else if (this.data.page.index.nested !== _oldNestedIndex) {
+      this.callEventStack("pageChange", this.data.page.current, this.data.page.index);
+    }
+  }
+  async refresh() {
+    if (!this.data.message) {
+      throw new Error("[Paginator] Cannot refresh, message not sent");
+    }
+    if (!this.data.message.editable) {
+      throw new Error("[Paginator] Cannot refresh, message is not editable");
+    }
+    await this.build();
+    this.data.message = await dynaSend(this.data.message, {
+      sendMethod: 5 /* MessageEdit */,
+      ...this.buildSendOptions(this.data.messageSendOptions)
+    });
+    return this.data.message;
+  }
+  async send(handler, options) {
+    this.data.messageSendOptions = options;
+    await this.build();
+    this.data.message = await dynaSend(handler, this.buildSendOptions(options));
+    if (!this.data.message) return null;
+    this.collect_components();
+    return this.data.message;
+  }
+};
+
+// src/tools/Prompt.ts
+var import_discord14 = require("discord.js");
+var PromptResolveType = /* @__PURE__ */ ((PromptResolveType2) => {
+  PromptResolveType2[PromptResolveType2["DisableComponents"] = 0] = "DisableComponents";
+  PromptResolveType2[PromptResolveType2["ClearComponents"] = 1] = "ClearComponents";
+  PromptResolveType2[PromptResolveType2["DeleteOnConfirm"] = 3] = "DeleteOnConfirm";
+  PromptResolveType2[PromptResolveType2["DeleteOnReject"] = 4] = "DeleteOnReject";
+  return PromptResolveType2;
+})(PromptResolveType || {});
+var Prompt = class {
+  participants;
+  content;
+  embed;
+  container;
+  buttons;
+  customButtons;
+  onResolve;
+  timeout;
+  config;
+  message = null;
+  constructor(options = {}) {
+    this.config = options.config ?? globalVimcordToolsConfig;
+    this.participants = options.participants ?? [];
+    this.timeout = options.timeout ?? this.config.timeouts.prompt;
+    this.content = options.content;
+    this.embed = options.embed ?? this.createDefaultForm();
+    this.container = options?.container;
+    this.buttons = this.createButtons(options.buttons);
+    this.customButtons = this.createCustomButtons(options.customButtons);
+    this.onResolve = options.onResolve ?? [3 /* DeleteOnConfirm */, 4 /* DeleteOnReject */];
+  }
+  createDefaultForm() {
+    return new BetterEmbed({
+      title: this.config.prompt.defaultTitle,
+      description: this.config.prompt.defaultDescription
+    });
+  }
+  createButtons(buttonOptions) {
+    const confirm = this.buildButton(
+      buttonOptions?.confirm,
+      "btn_confirm",
+      this.config.prompt.confirmLabel,
+      import_discord14.ButtonStyle.Success
+    );
+    const reject = this.buildButton(
+      buttonOptions?.reject,
+      "btn_reject",
+      this.config.prompt.rejectLabel,
+      import_discord14.ButtonStyle.Danger
+    );
+    return { confirm, reject };
+  }
+  createCustomButtons(customOptions) {
+    const map = /* @__PURE__ */ new Map();
+    if (!customOptions) return map;
+    for (const [customId, { builder, handler, index = 2 }] of Object.entries(customOptions)) {
+      const button = this.buildButton(builder, customId, customId, import_discord14.ButtonStyle.Primary);
+      map.set(customId, { button, handler, index });
+    }
+    return map;
+  }
+  buildButton(option, customId, defaultLabel, defaultStyle) {
+    if (typeof option === "function") {
+      return option(new import_discord14.ButtonBuilder());
+    }
+    if (option instanceof import_discord14.ButtonBuilder) {
+      return option;
+    }
+    return new import_discord14.ButtonBuilder({
+      customId,
+      label: defaultLabel,
+      style: defaultStyle,
+      ...option
+    });
+  }
+  buildActionRow(disable = {}) {
+    const confirmBtn = disable.confirm ? new import_discord14.ButtonBuilder(this.buttons.confirm.data).setDisabled(true) : this.buttons.confirm;
+    const rejectBtn = disable.reject ? new import_discord14.ButtonBuilder(this.buttons.reject.data).setDisabled(true) : this.buttons.reject;
+    const buttons = [];
+    const customButtonsArray = Array.from(this.customButtons.entries()).map(([customId, data]) => ({
+      customId,
+      button: disable[customId] ? new import_discord14.ButtonBuilder(data.button.data).setDisabled(true) : data.button,
+      index: data.index
+    }));
+    customButtonsArray.sort((a, b) => a.index - b.index);
+    for (const custom of customButtonsArray) {
+      if (custom.index === 0) {
+        buttons.push(custom.button);
+      }
+    }
+    buttons.push(confirmBtn);
+    for (const custom of customButtonsArray) {
+      if (custom.index === 1) {
+        buttons.push(custom.button);
+      }
+    }
+    buttons.push(rejectBtn);
+    for (const custom of customButtonsArray) {
+      if (custom.index >= 2) {
+        buttons.push(custom.button);
+      }
+    }
+    return new import_discord14.ActionRowBuilder({ components: buttons });
+  }
+  buildSendOptions(options) {
+    const sendData = { ...options };
+    if (this.container) {
+      sendData.components = Array.isArray(sendData.components) ? [...sendData.components, this.container] : [this.container];
+      const existingFlags = sendData.flags ? Array.isArray(sendData.flags) ? sendData.flags : [sendData.flags] : [];
+      if (!existingFlags.includes("IsComponentsV2")) {
+        sendData.flags = [...existingFlags, "IsComponentsV2"];
+      } else {
+        sendData.flags = existingFlags;
+      }
+    } else {
+      sendData.embeds = Array.isArray(sendData.embeds) ? [this.embed, ...sendData.embeds] : [this.embed];
+    }
+    if (this.content) {
+      sendData.content = this.content;
+    }
+    sendData.components = Array.isArray(sendData.components) ? [...sendData.components, this.buildActionRow()] : [this.buildActionRow()];
+    return sendData;
+  }
+  isParticipant(userId) {
+    if (this.participants.length === 0) return true;
+    return this.participants.some((p) => {
+      if (typeof p === "string") return p === userId;
+      if (typeof p === "object" && "id" in p) return p.id === userId;
+      return false;
+    });
+  }
+  async handleResolve(confirmed) {
+    if (!this.message) return;
+    const shouldDelete = confirmed === true && this.onResolve.includes(3 /* DeleteOnConfirm */) || confirmed === false && this.onResolve.includes(4 /* DeleteOnReject */);
+    if (shouldDelete) {
+      await this.message.delete().catch(Boolean);
+      return;
+    }
+    if (this.onResolve.includes(1 /* ClearComponents */)) {
+      await this.message.edit({ components: [] }).catch(Boolean);
+    } else if (this.onResolve.includes(0 /* DisableComponents */)) {
+      const disableAll = { confirm: true, reject: true };
+      for (const customId of this.customButtons.keys()) {
+        disableAll[customId] = true;
+      }
+      await this.message.edit({ components: [this.buildActionRow(disableAll)] }).catch(Boolean);
+    }
+  }
+  async send(handler, options) {
+    const sendData = this.buildSendOptions(options);
+    this.message = await dynaSend(handler, sendData);
+    return this.message;
+  }
+  async awaitResponse() {
+    if (!this.message) {
+      throw new Error("Prompt must be sent before awaiting response");
+    }
+    const validCustomIds = /* @__PURE__ */ new Set(["btn_confirm", "btn_reject", ...this.customButtons.keys()]);
+    try {
+      const interaction = await this.message.awaitMessageComponent({
+        componentType: import_discord14.ComponentType.Button,
+        filter: (i) => validCustomIds.has(i.customId) && this.isParticipant(i.user.id),
+        time: this.timeout
+      });
+      await interaction.deferUpdate().catch(Boolean);
+      let confirmed = null;
+      if (interaction.customId === "btn_confirm") {
+        confirmed = true;
+      } else if (interaction.customId === "btn_reject") {
+        confirmed = false;
+      }
+      const customButton = this.customButtons.get(interaction.customId);
+      if (customButton?.handler) {
+        await customButton.handler(interaction);
+      }
+      await this.handleResolve(confirmed);
+      return {
+        message: this.message,
+        confirmed,
+        customId: interaction.customId,
+        timedOut: false
+      };
+    } catch (error) {
+      await this.handleResolve(false);
+      return {
+        message: this.message,
+        confirmed: null,
+        customId: null,
+        timedOut: true
+      };
+    }
+  }
+};
+async function prompt(handler, options, sendOptions) {
+  const p = new Prompt(options);
+  await p.send(handler, sendOptions);
+  return await p.awaitResponse();
+}
+
+// src/utils/VimcordCLI.ts
+var import_node_readline = require("readline");
+var import_jstools2 = __toESM(require("jstools"));
+var VimcordCLI = class {
+  rl;
+  options;
+  commands = /* @__PURE__ */ new Map();
+  logger = new Logger({ prefixEmoji: "\u{1F680}", prefix: "CLI", showTimestamp: false });
+  constructor(options) {
+    this.options = options;
+    this.rl = (0, import_node_readline.createInterface)({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+    this.rl.on("line", (line) => {
+      const { isCommand, commandName, content, args } = this.parseLine(line);
+      if (!isCommand) return;
+      const command = this.commands.get(commandName);
+      if (!command) {
+        const nearestMatches = Array.from(this.commands.keys()).filter(
+          (cmd) => cmd.toLowerCase().includes(commandName.toLowerCase())
+        );
+        return this.logger.error(
+          `Unknown command '${commandName}'${nearestMatches.length ? `. Did you mean ${nearestMatches.length > 1 ? `[${nearestMatches.map((m) => `'${this.options.prefix}${m}'`).join(", ")}]` : `'${this.options.prefix}${nearestMatches[0]}'`}?` : ""}`
+        );
+      }
+      command.fn(args, content);
+    });
+  }
+  parseLine(line) {
+    if (line.startsWith(this.options.prefix)) {
+      line = line.slice(this.options.prefix.length);
+    } else {
+      return { isCommand: false };
+    }
+    const args = line.split(" ").map((s) => s.trim());
+    const commandName = args.shift();
+    return { isCommand: true, commandName, content: args.join(" "), args };
+  }
+  getClientInstance(line) {
+    const clientIndex = import_jstools2.default.getFlagSubstring(line, "--client", 1) || import_jstools2.default.getFlagSubstring(line, "-c", 1);
+    if (clientIndex) {
+      const idx = Number(clientIndex);
+      if (isNaN(idx)) {
+        CLI.logger.error(`'${clientIndex}' is not a valid number`);
+        return void 0;
+      }
+      const client = clientInstances[idx];
+      if (!client) {
+        CLI.logger.error("Client instance not found");
+        return void 0;
+      }
+      return client;
+    } else {
+      const client = clientInstances[0];
+      if (!client) {
+        CLI.logger.error("Client instance not found");
+        return void 0;
+      }
+      return client;
+    }
+  }
+  addCommand(commandName, description, fn) {
+    this.commands.set(commandName, { description, fn });
+  }
+  removeCommand(commandName) {
+    if (!this.commands.has(commandName)) return false;
+    this.commands.delete(commandName);
+    return true;
+  }
+};
+var initCalled = false;
+var CLI = new VimcordCLI({ prefix: "/" });
+CLI.addCommand("help", "View information about a command, or the available CLI options", (args) => {
+  const prefix = CLI.options.prefix;
+  const helpList = {};
+  for (const cmd of CLI.commands.entries()) {
+    const commandName = cmd[0];
+    const commandDescription = cmd[1].description;
+    helpList[`${prefix}${commandName}`] = `~ ${commandDescription}`;
+  }
+  CLI.logger.table("(help)", helpList);
+});
+CLI.addCommand("register", "Register app commands globally, or per guild", async (args, content) => {
+  const client = CLI.getClientInstance(content);
+  if (!client) return;
+  const mode = args[0]?.toLowerCase() || "";
+  if (!["guild", "global"].includes(mode)) {
+    return CLI.logger.error(`'${mode}' is not a valid option. Your options are [guild|global]`);
+  }
+  let guildIds = (import_jstools2.default.getFlagSubstring(content, "--guilds", 1) || import_jstools2.default.getFlagSubstring(content, "-g", 1) || "").replaceAll(/["']/g, "").split(" ").filter(Boolean).map((s) => s.replaceAll(",", "").trim());
+  if (!guildIds.length) guildIds = client.guilds.cache.map((g) => g.id);
+  switch (mode) {
+    case "guild":
+      await client.commands.slash.registerGuild({ guilds: guildIds });
+      break;
+    case "global":
+      await client.commands.slash.registerGlobal();
+      break;
+  }
+});
+CLI.addCommand("unregister", "Unregister app commands globally, or per guild", async (args, content) => {
+  const client = CLI.getClientInstance(content);
+  if (!client) return;
+  const mode = args[0]?.toLowerCase() || "";
+  if (!["guild", "global"].includes(mode)) {
+    return CLI.logger.error(`'${mode}' is not a valid option. Your options are [guild|global]`);
+  }
+  let guildIds = (import_jstools2.default.getFlagSubstring(content, "--guilds", 1) || import_jstools2.default.getFlagSubstring(content, "-g", 1) || "").replaceAll(/["']/g, "").split(" ").filter(Boolean).map((s) => s.replaceAll(",", "").trim());
+  if (!guildIds.length) guildIds = client.guilds.cache.map((g) => g.id);
+  switch (mode) {
+    case "guild":
+      await client.commands.slash.unregisterGuild({ guilds: guildIds });
+      break;
+    case "global":
+      await client.commands.slash.unregisterGlobal();
+      break;
+  }
+});
+CLI.addCommand("stats", "View statistics about a client instance", (args, content) => {
+  const client = CLI.getClientInstance(content);
+  if (!client) return;
+  CLI.logger.table(`(stats) ~ ${client.config.app.name}`, {
+    "Guilds:": import_jstools2.default.formatThousands(client.guilds.cache.size),
+    "Ping:": `${client.ws.ping || 0}ms`,
+    "Uptime:": `${import_jstools2.default.msToSec(client.uptime || 0)}s`,
+    "Process Uptime:": `${Math.floor(process.uptime())}s`,
+    "Memory Usage:": `${(process.memoryUsage().rss / 1024 / 1024).toFixed(2)} MB`
+  });
+});
+CLI.addCommand("cmds", "List the loaded commands", (args, content) => {
+  const client = CLI.getClientInstance(content);
+  if (!client) return;
+  const mode = args[0] || "slash";
+  switch (mode) {
+    case "slash":
+      const slashCommands = Array.from(client.commands.slash.commands.values());
+      slashCommands.sort((a, b) => a.builder.name.localeCompare(b.builder.name));
+      const slashCommands_f = {};
+      for (const cmd of slashCommands) {
+        slashCommands_f[`/${cmd.builder.name}`] = `~ ${cmd.builder.description || "No description"}`;
+      }
+      return CLI.logger.table(
+        `(cmds) ~ slash (${import_jstools2.default.formatThousands(client.commands.slash.commands.size)})`,
+        slashCommands_f
+      );
+    case "prefix":
+      const prefixCommands = Array.from(client.commands.prefix.commands.values());
+      prefixCommands.sort((a, b) => a.name.localeCompare(b.name));
+      const prefixCommands_f = {};
+      for (const cmd of prefixCommands) {
+        prefixCommands_f[`${client.config.prefixCommands.defaultPrefix}${cmd.name}`] = `~ ${cmd.description || "No description"}`;
+      }
+      return CLI.logger.table(
+        `(cmds) ~ prefix (${import_jstools2.default.formatThousands(client.commands.prefix.commands.size)})`,
+        prefixCommands_f
+      );
+    case "ctx":
+      const contextCommands = Array.from(client.commands.context.commands.values());
+      contextCommands.sort((a, b) => a.builder.name.localeCompare(b.builder.name));
+      const contextCommands_f = {};
+      for (const cmd of contextCommands) {
+        contextCommands_f[`${cmd.builder.name}`] = "";
+      }
+      return CLI.logger.table(
+        `(cmds) ~ ctx (${import_jstools2.default.formatThousands(client.commands.context.commands.size)})`,
+        contextCommands_f
+      );
+    default:
+      return CLI.logger.error(`'${mode}' is not a valid option. Your options are [slash|prefix|ctx]`);
+  }
+});
+function initCLI() {
+  if (initCalled) return;
+  CLI.logger.log(`~ Type ${CLI.options.prefix}help to view available commands`);
+  initCalled = true;
+}
+
+// src/utils/clientUtils.ts
+function useClient(index = 0) {
+  return clientInstances.at(index);
+}
+async function useReadyClient(index = 0) {
+  return useClient(index)?.whenReady();
+}
+function createClient(options, features = {}, config = {}) {
+  const client = new Vimcord(options, features, config);
+  initCLI();
+  return client;
+}
+function getClientInstances() {
+  return clientInstances;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseCommandBuilder,
+  BetterContainer,
+  BetterEmbed,
+  BetterModal,
+  CLI,
+  CommandType,
+  ContextCommandBuilder,
+  DynaSend,
+  EventBuilder,
+  LogLevel,
+  Logger,
+  MissingPermissionReason,
+  MongoDatabase,
+  MongoSchemaBuilder,
+  PaginationTimeoutType,
+  PaginationType,
+  Paginator,
+  PrefixCommandBuilder,
+  Prompt,
+  PromptResolveType,
+  RateLimitScope,
+  SendMethod,
+  SlashCommandBuilder,
+  StatusType,
+  Vimcord,
+  VimcordCLI,
+  VimcordCommandManager,
+  VimcordContextCommandManager,
+  VimcordEventManager,
+  VimcordPrefixCommandManager,
+  VimcordSlashCommandManager,
+  VimcordStatusManager,
+  __zero,
+  cleanMention,
+  clientInstances,
+  createClient,
+  createMongoSchema,
+  createToolsConfig,
+  createVimcordAppConfig,
+  createVimcordContextCommandConfig,
+  createVimcordPrefixCommandConfig,
+  createVimcordSlashCommandConfig,
+  createVimcordStaffConfig,
+  createVimcordStatusConfig,
+  defineGlobalToolsConfig,
+  dynaSend,
+  fetchChannel,
+  fetchGuild,
+  fetchMember,
+  fetchMessage,
+  fetchRole,
+  fetchUser,
+  formatThousands,
+  getCallerFileName,
+  getClientInstances,
+  getFirstMentionId,
+  getMessageMention,
+  getProcessDir,
+  globalVimcordToolsConfig,
+  importModulesFromDir,
+  initCLI,
+  isMentionOrSnowflake,
+  logger,
+  pickRandom,
+  prompt,
+  retryExponentialBackoff,
+  sendCommandErrorEmbed,
+  useClient,
+  useMongoDatabase,
+  useReadyClient,
+  validateCommandPermissions
+});
+//# sourceMappingURL=index.cjs.map