vimcord 1.0.58 → 2.0.0

package/dist/index.cjs

@@ -1,14 +1,8 @@
 "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))
@@ -17,4559 +11,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
-__export(index_exports, {
-  BaseCommandBuilder: () => BaseCommandBuilder,
-  BaseCommandManager: () => BaseCommandManager,
-  BetterCollector: () => BetterCollector,
-  BetterContainer: () => BetterContainer,
-  BetterEmbed: () => BetterEmbed,
-  BetterModal: () => BetterModal,
-  CLI: () => CLI,
-  CollectorTimeoutType: () => CollectorTimeoutType,
-  CommandManager: () => CommandManager,
-  CommandType: () => CommandType,
-  ContextCommandBuilder: () => ContextCommandBuilder,
-  ContextCommandManager: () => ContextCommandManager,
-  DEFAULT_MODULE_SUFFIXES: () => DEFAULT_MODULE_SUFFIXES,
-  DynaSend: () => DynaSend,
-  ErrorHandler: () => ErrorHandler,
-  EventBuilder: () => EventBuilder,
-  EventManager: () => EventManager,
-  LOGGER_COLORS: () => LOGGER_COLORS,
-  LogLevel: () => LogLevel,
-  Logger: () => Logger,
-  MissingPermissionReason: () => MissingPermissionReason,
-  ModuleImporter: () => ModuleImporter,
-  MongoDatabase: () => MongoDatabase,
-  MongoSchemaBuilder: () => MongoSchemaBuilder,
-  PaginationTimeoutType: () => PaginationTimeoutType,
-  PaginationType: () => PaginationType,
-  Paginator: () => Paginator,
-  PrefixCommandBuilder: () => PrefixCommandBuilder,
-  PrefixCommandManager: () => PrefixCommandManager,
-  Prompt: () => Prompt,
-  PromptResolveType: () => PromptResolveType,
-  RateLimitScope: () => RateLimitScope,
-  SendMethod: () => SendMethod,
-  SlashCommandBuilder: () => SlashCommandBuilder,
-  SlashCommandManager: () => SlashCommandManager,
-  StatusManager: () => StatusManager,
-  StatusType: () => StatusType,
-  Vimcord: () => Vimcord,
-  VimcordCLI: () => VimcordCLI,
-  VimcordErrorHandler: () => VimcordErrorHandler,
-  __zero: () => __zero,
-  cleanMention: () => cleanMention,
-  clientLoggerFactory: () => clientLoggerFactory,
-  configSetters: () => configSetters,
-  contextCommandHandler: () => contextCommandHandler,
-  createAppConfig: () => createAppConfig,
-  createClient: () => createClient,
-  createConfigFactory: () => createConfigFactory,
-  createContextCommandConfig: () => createContextCommandConfig,
-  createMongoPlugin: () => createMongoPlugin,
-  createMongoSchema: () => createMongoSchema,
-  createPrefixCommandConfig: () => createPrefixCommandConfig,
-  createSlashCommandConfig: () => createSlashCommandConfig,
-  createStaffConfig: () => createStaffConfig,
-  createToolsConfig: () => createToolsConfig,
-  createVimcordStatusConfig: () => createVimcordStatusConfig,
-  deepMerge: () => deepMerge,
-  defineClientOptions: () => defineClientOptions,
-  defineGlobalToolsConfig: () => defineGlobalToolsConfig,
-  defineVimcordConfig: () => defineVimcordConfig,
-  defineVimcordFeatures: () => defineVimcordFeatures,
-  dynaSend: () => dynaSend,
-  fetchChannel: () => fetchChannel,
-  fetchGuild: () => fetchGuild,
-  fetchMember: () => fetchMember,
-  fetchMessage: () => fetchMessage,
-  fetchRole: () => fetchRole,
-  fetchUser: () => fetchUser,
-  getDevMode: () => getDevMode,
-  getFirstMentionId: () => getFirstMentionId,
-  getMessageMention: () => getMessageMention,
-  getPackageJson: () => getPackageJson,
-  globalToolsConfig: () => globalToolsConfig,
-  importModulesFromDir: () => importModulesFromDir,
-  isMentionOrSnowflake: () => isMentionOrSnowflake,
-  logger: () => logger,
-  moduleImporters: () => moduleImporters,
-  prefixCommandHandler: () => prefixCommandHandler,
-  prompt: () => prompt,
-  sendCommandErrorEmbed: () => sendCommandErrorEmbed,
-  slashCommandHandler: () => slashCommandHandler,
-  useClient: () => useClient,
-  useReadyClient: () => useReadyClient,
-  validateCommandPermissions: () => validateCommandPermissions
-});
 module.exports = __toCommonJS(index_exports);
-
-// src/modules/validators/permissions.validator.ts
-var import_discord = require("discord.js");
-
-// src/types/command.base.ts
-var CommandType = /* @__PURE__ */ ((CommandType2) => {
-  CommandType2[CommandType2["Slash"] = 0] = "Slash";
-  CommandType2[CommandType2["Prefix"] = 1] = "Prefix";
-  CommandType2[CommandType2["Context"] = 2] = "Context";
-  return CommandType2;
-})(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/modules/validators/permissions.validator.ts
-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.ownerId === user.id || client.config.staff.superUsers.includes(user.id)) {
-      return { validated: true };
-    }
-    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: true };
-      }
-    }
-    if (typeof command === "string" && client.config.staff.bypassers.some(
-      (bypass) => bypass.commandName.toLowerCase() === command.toLowerCase() && bypass.userIds.includes(user.id)
-    )) {
-      return { validated: true };
-    }
-    if (inGuild) {
-      for (const role of user.roles.cache.values()) {
-        if (!user.roles.cache.has(role.id)) {
-          missingRoles.push(role.id);
-        }
-      }
-      if (missingRoles.length) {
-        return { validated: false, failReason: 8 /* NotBotStaff */, missingRoles };
-      } else {
-        return { validated: true };
-      }
-    }
-    return { validated: false, failReason: 8 /* NotBotStaff */ };
-  }
-  return { validated: true };
-}
-
-// src/utils/mergeUtils.ts
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null) return false;
-  if (Array.isArray(value)) return false;
-  return Object.prototype.toString.call(value) === "[object Object]";
-}
-function deepMerge(target, ...sources) {
-  for (const source of sources) {
-    if (!source) continue;
-    for (const key in source) {
-      if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
-      const sourceValue = source[key];
-      const targetValue = target[key];
-      if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
-        deepMerge(targetValue, sourceValue);
-      } else if (sourceValue !== void 0) {
-        target[key] = sourceValue;
-      }
-    }
-  }
-  return target;
-}
-
-// src/builders/baseCommand.builder.ts
-var import_node_crypto = require("crypto");
-var BaseCommandBuilder = class {
-  uuid = (0, import_node_crypto.randomUUID)();
-  commandType;
-  name = "";
-  /** Local command configuration and hooks */
-  options;
-  /** Internal state for rate limiting across different scopes */
-  rlStores = {
-    [3 /* Global */]: { executions: 0, timestamp: 0 },
-    [0 /* User */]: /* @__PURE__ */ new Map(),
-    [1 /* Guild */]: /* @__PURE__ */ new Map(),
-    [2 /* Channel */]: /* @__PURE__ */ new Map()
-  };
-  /** Mapping of CommandTypes to their respective config keys in the Vimcord client */
-  typeConfigMapping = {
-    [0 /* Slash */]: "slashCommands",
-    [1 /* Prefix */]: "prefixCommands",
-    [2 /* Context */]: "contextCommands"
-  };
-  constructor(type, options = {}) {
-    this.commandType = type;
-    this.options = { enabled: true, ...options };
-  }
-  setCommandName(name) {
-    this.name = name;
-  }
-  validateBaseConfig() {
-    if (this.options.rateLimit) {
-      const { max, interval } = this.options.rateLimit;
-      if (max <= 0 || interval <= 0) {
-        throw new Error(`[Vimcord:${this.constructor.name}] Rate limit values must be positive.`);
-      }
-    }
-  }
-  /**
-   * Resolves the final configuration by merging layers:
-   * Client Defaults < Client Type-Specific < Local Command Options
-   */
-  resolveConfig(client) {
-    const typeKey = this.typeConfigMapping[this.commandType];
-    const typeSpecificGlobals = client.config?.[typeKey] || {};
-    return deepMerge({}, typeSpecificGlobals, this.options);
-  }
-  /**
-   * Executes the command lifecycle.
-   * Merges global client config with local command options at runtime.
-   */
-  async run(client, ...args) {
-    const config = this.resolveConfig(client);
-    const ctx = this.extractContext(args);
-    let canceled = false;
-    const cancel = () => canceled = true;
-    try {
-      if (!config.enabled) {
-        return await config.onUsedWhenDisabled?.(...args);
-      }
-      if (this.isRateLimited(config, ctx)) {
-        return await config.onRateLimit?.(...args);
-      }
-      const perms = this.checkPermissions(client, ctx.member || ctx.user, args[1]);
-      if (!perms.validated) {
-        return await config.onMissingPermissions?.(perms, ...args);
-      }
-      if (!await this.checkConditions(config, ...args)) {
-        return await config.onConditionsNotMet?.(...args);
-      }
-      if (config.beforeExecute) {
-        await config.beforeExecute?.({ cancel, name: this.name }, ...args);
-        if (canceled) return;
-      }
-      if (config.logExecution !== false) {
-        const location = ctx.guild ? `${ctx.guild.name} (${ctx.guild.id})` : "Direct Messages";
-        client.logger.commandExecuted(this.name || "Unknown", ctx.user.username, location);
-      }
-      const result = await config.execute?.(...args);
-      await config.afterExecute?.(result, ...args);
-    } catch (error) {
-      await this.handleError(error, config, ...args);
-    }
-  }
-  /**
-   * Internal logic to determine if a command execution should be throttled.
-   * @param config The merged configuration to use for limits.
-   * @param ctx Extracted Discord context (User, Guild, Channel).
-   */
-  isRateLimited(config, ctx) {
-    if (!config.rateLimit) return false;
-    const { scope, interval, max } = config.rateLimit;
-    const now = Date.now();
-    const key = this.getScopeKey(scope, ctx);
-    if (scope !== 3 /* Global */ && !key) return false;
-    let data;
-    if (scope === 3 /* Global */) {
-      data = this.rlStores[3 /* Global */];
-    } else {
-      const store = this.rlStores[scope];
-      data = store.get(key) ?? { executions: 0, timestamp: now };
-      store.set(key, data);
-    }
-    if (now - data.timestamp > interval) {
-      data.executions = 0;
-      data.timestamp = now;
-    }
-    if (data.executions >= max) return true;
-    data.executions++;
-    return false;
-  }
-  /**
-   * Validates if the user has required permissions.
-   */
-  checkPermissions(client, user, target) {
-    if (!this.options.permissions) return { validated: true };
-    return validateCommandPermissions(this.options.permissions, client, user, target);
-  }
-  /**
-   * Evaluates all custom conditions defined for the command.
-   */
-  async checkConditions(config, ...args) {
-    if (!config.conditions?.length) return true;
-    const results = await Promise.all(config.conditions.map((c) => c(...args)));
-    return results.every(Boolean);
-  }
-  /**
-   * Normalizes the trigger arguments into a standard context object.
-   */
-  extractContext(args) {
-    const event = args[1];
-    return {
-      user: event.user || event.author,
-      member: event.member,
-      guild: event.guild,
-      channel: event.channel
-    };
-  }
-  /**
-   * Resolves the storage key based on the RateLimit scope.
-   */
-  getScopeKey(scope, ctx) {
-    switch (scope) {
-      case 0 /* User */:
-        return ctx.user.id;
-      case 1 /* Guild */:
-        return ctx.guild?.id ?? null;
-      case 2 /* Channel */:
-        return ctx.channel?.id ?? null;
-      default:
-        return null;
-    }
-  }
-  /**
-   * Handles command errors by checking local handlers before falling back to global handlers.
-   */
-  async handleError(err, config, ...args) {
-    if (config.onError) return config.onError(err, ...args);
-    throw err;
-  }
-  /** Toggle command availability */
-  setEnabled(enabled) {
-    this.options.enabled = enabled;
-    return this;
-  }
-  /** Merge new permission requirements into the existing ones */
-  setPermissions(perms) {
-    this.options.permissions = deepMerge(this.options.permissions || {}, perms);
-    return this;
-  }
-  /** Set the custom conditions that must be met for this command to execute */
-  setConditions(conditions) {
-    this.options.conditions = conditions;
-    return this;
-  }
-  /** Set the primary command execution logic */
-  setExecute(fn) {
-    this.options.execute = fn;
-    return this;
-  }
-  /** Set the command metadata configuration */
-  setMetadata(metadata) {
-    this.options.metadata = deepMerge(this.options.metadata || {}, metadata);
-    return this;
-  }
-  /** Set the rate limiting options for this command */
-  setRateLimit(options) {
-    this.options.rateLimit = options;
-    this.validateBaseConfig();
-    return this;
-  }
-};
-
-// src/builders/contextCommand.builder.ts
-var import_discord2 = require("discord.js");
-var ContextCommandBuilder = class extends BaseCommandBuilder {
-  builder;
-  constructor(config) {
-    super(2 /* Context */, config);
-    this.setBuilder(config.builder);
-    const originalExecute = this.options.execute;
-    this.options.execute = async (client, interaction) => {
-      return await this.handleExecution(client, interaction, originalExecute);
-    };
-  }
-  async handleExecution(client, interaction, originalExecute) {
-    const config = this.resolveConfig(client);
-    if (config.deferReply && !interaction.replied && !interaction.deferred) {
-      await interaction.deferReply(typeof config.deferReply === "object" ? config.deferReply : void 0);
-    }
-    return await originalExecute?.(client, interaction);
-  }
-  validateBuilder() {
-    if (!this.builder.name) throw new Error(`[Vimcord] ContextCommandBuilder: Command name is required.`);
-    this.builder.toJSON();
-  }
-  // --- Specialized Fluent API ---
-  setBuilder(builder) {
-    this.builder = typeof builder === "function" ? builder(new import_discord2.ContextMenuCommandBuilder()) : builder;
-    this.validateBuilder();
-    this.setCommandName(this.builder.name);
-    return this;
-  }
-  setExecute(fn) {
-    const originalExecute = fn;
-    this.options.execute = async (client, interaction) => {
-      return await this.handleExecution(client, interaction, originalExecute);
-    };
-    return this;
-  }
-  toConfig() {
-    return { ...this.options, builder: this.builder };
-  }
-};
-
-// src/builders/event.builder.ts
-var import_node_crypto2 = require("crypto");
-
-// 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 LOGGER_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 = {
-      ...LOGGER_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 = {
-      ...LOGGER_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/builders/event.builder.ts
-var EventBuilder = class _EventBuilder {
-  uuid = (0, import_node_crypto2.randomUUID)();
-  event;
-  name = 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
-    };
-  }
-  setEnabled(enabled) {
-    this.enabled = enabled;
-    return this;
-  }
-  setExecute(execute) {
-    this.execute = execute;
-    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) {
-    let canceled = false;
-    const cancel = () => canceled = true;
-    try {
-      if (!this.enabled) {
-        return;
-      }
-      if (this.isRateLimited()) {
-        logger.warn(`Event '${this.name}' (${this.event}) is rate limited`);
-        if (this.rateLimit?.onRateLimit) {
-          return await this.rateLimit.onRateLimit(...args);
-        }
-        return;
-      }
-      if (!await this.checkConditions(...args)) {
-        return;
-      }
-      if (this.beforeExecute) {
-        await this.beforeExecute({ cancel }, ...args);
-        if (canceled) return;
-      }
-      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);
-      }
-      logger.error(`Event execution error '${this.name}' (${this.event}):`, err);
-      throw err;
-    }
-  }
-};
-
-// src/builders/prefixCommand.builder.ts
-var PrefixCommandBuilder = class extends BaseCommandBuilder {
-  constructor(options) {
-    super(1 /* Prefix */, options);
-    this.options = options;
-    this.setCommandName(options.name);
-    const originalExecute = this.options.execute;
-    this.options.execute = async (client, message) => {
-      return await this.handleExecution(client, message, originalExecute);
-    };
-    this.validatePrefixConfig();
-  }
-  /**
-   * Specialized execution logic for Prefix Commands.
-   */
-  async handleExecution(client, message, originalExecute) {
-    return await originalExecute?.(client, message);
-  }
-  validatePrefixConfig() {
-    if (!this.options.name) {
-      throw new Error(`[Vimcord] PrefixCommandBuilder: Command name is required.`);
-    }
-  }
-  // --- Overrides ---
-  /**
-   * Override setExecute to ensure handleExecution remains the entry point.
-   */
-  setExecute(fn) {
-    const originalExecute = fn;
-    this.options.execute = async (client, message) => {
-      return await this.handleExecution(client, message, originalExecute);
-    };
-    return this;
-  }
-  /**
-   * Converts the current builder state back into a config object.
-   */
-  toConfig() {
-    return {
-      ...this.options
-    };
-  }
-};
-
-// src/builders/slashCommand.builder.ts
-var import_discord3 = require("discord.js");
-var SlashCommandBuilder = class extends BaseCommandBuilder {
-  builder;
-  routes = /* @__PURE__ */ new Map();
-  constructor(config) {
-    super(0 /* Slash */, config);
-    this.setBuilder(config.builder);
-    if (config.routes) this.addRoutes(...config.routes);
-    const originalExecute = this.options.execute;
-    this.options.execute = async (client, interaction) => {
-      return await this.handleExecution(client, interaction, originalExecute);
-    };
-  }
-  async handleExecution(client, interaction, originalExecute) {
-    const config = this.resolveConfig(client);
-    if (config.deferReply && !interaction.replied && !interaction.deferred) {
-      await interaction.deferReply(typeof config.deferReply === "object" ? config.deferReply : void 0);
-    }
-    const subCommand = interaction.options.getSubcommand(false);
-    if (subCommand) {
-      const handler = this.routes.get(subCommand.toLowerCase());
-      if (handler) return await handler(client, interaction);
-      if (config.onUnknownRouteHandler) {
-        return await config.onUnknownRouteHandler(client, interaction);
-      } else {
-        return await interaction.reply({ content: `Unknown subcommand: ${subCommand}`, flags: "Ephemeral" });
-      }
-    }
-    return await originalExecute?.(client, interaction);
-  }
-  validateBuilder() {
-    if (!this.builder.name) throw new Error(`[Vimcord] SlashCommandBuilder: Command name is required.`);
-    if (!this.builder.description) throw new Error(`[Vimcord] SlashCommandBuilder: Command description is required.`);
-    this.builder.toJSON();
-  }
-  // --- Specialized Fluent API ---
-  setBuilder(builder) {
-    this.builder = typeof builder === "function" ? builder(new import_discord3.SlashCommandBuilder()) : builder;
-    this.validateBuilder();
-    this.setCommandName(this.builder.name);
-    return this;
-  }
-  addRoutes(...routes) {
-    if (!this.options.routes) this.options.routes = [];
-    for (const route of routes) {
-      const name = route.name.toLowerCase();
-      this.routes.set(name, route.handler);
-      const existingIndex = this.options.routes.findIndex((r) => r.name.toLowerCase() === name);
-      if (existingIndex > -1) this.options.routes[existingIndex] = route;
-      else this.options.routes.push(route);
-    }
-    return this;
-  }
-  setExecute(fn) {
-    const originalExecute = fn;
-    this.options.execute = async (client, interaction) => {
-      return await this.handleExecution(client, interaction, originalExecute);
-    };
-    return this;
-  }
-  toConfig() {
-    return {
-      ...this.options,
-      builder: this.builder,
-      routes: Array.from(this.routes.entries()).map(([name, handler]) => ({ name, handler }))
-    };
-  }
-};
-
-// src/modules/builtins/contextCommand.builtin.ts
-var contextCommandHandler = new EventBuilder({
-  event: "interactionCreate",
-  name: "ContextCommandHandler",
-  async execute(client, interaction) {
-    if (!interaction.isContextMenuCommand()) return;
-    const command = client.commands.context.get(interaction.commandName);
-    if (!command) {
-      const content = `**${interaction.commandName}** is not a registered context command.`;
-      if (interaction.replied || interaction.deferred) {
-        return interaction.followUp({ content, flags: "Ephemeral" });
-      }
-      return interaction.reply({ content, flags: "Ephemeral" });
-    }
-    try {
-      return await command.run(client, client, interaction);
-    } catch (err) {
-      await client.error.handleCommandError(err, interaction.guild, interaction);
-    }
-  }
-});
-
-// src/modules/builtins/prefixCommand.builtin.ts
-var import_discord4 = require("discord.js");
-var prefixCommandHandler = new EventBuilder({
-  event: "messageCreate",
-  name: "PrefixCommandHandler",
-  async execute(client, message) {
-    if (message.author.bot || !message.guild) return;
-    const config = client.config.prefixCommands;
-    let activePrefix = config.defaultPrefix;
-    if (config.guildPrefixResolver) {
-      try {
-        const customPrefix = await config.guildPrefixResolver(client, message.guild.id);
-        if (customPrefix) activePrefix = customPrefix;
-      } catch (err) {
-        client.logger.error(`Error in guildPrefixResolver for guild ${message.guild.id}:`, err);
-      }
-    }
-    let prefixUsed;
-    if (message.content.startsWith(activePrefix)) {
-      prefixUsed = activePrefix;
-    } else if (config.allowMentionAsPrefix) {
-      const mention = (0, import_discord4.userMention)(client.user.id);
-      if (message.content.startsWith(mention)) {
-        prefixUsed = message.content.startsWith(`${mention} `) ? `${mention} ` : mention;
-      }
-    }
-    if (!prefixUsed) return;
-    const contentWithoutPrefix = message.content.slice(prefixUsed.length).trim();
-    const args = contentWithoutPrefix.split(/\s+/);
-    const trigger = args.shift();
-    if (!trigger) return;
-    const command = client.commands.prefix.get(trigger);
-    if (!command) return;
-    message.content = args.join(" ");
-    try {
-      return await command.run(client, client, message);
-    } catch (err) {
-      await client.error.handleCommandError(err, message.guild, message);
-    }
-  }
-});
-
-// src/modules/builtins/slashCommand.builtin.ts
-var slashCommandHandler = new EventBuilder({
-  event: "interactionCreate",
-  name: "SlashCommandHandler",
-  async execute(client, interaction) {
-    if (!interaction.isChatInputCommand()) return;
-    const command = client.commands.slash.get(interaction.commandName);
-    if (!command) {
-      const content = `**/\`${interaction.commandName}\`** is not a registered command.`;
-      if (interaction.replied || interaction.deferred) {
-        return interaction.followUp({ content, flags: "Ephemeral" });
-      }
-      return interaction.reply({ content, flags: "Ephemeral" });
-    }
-    try {
-      return await command.run(client, client, interaction);
-    } catch (err) {
-      await client.error.handleCommandError(err, interaction.guild, interaction);
-    }
-  }
-});
-
-// src/client/vimcord.cli.ts
-var import_node_readline = require("readline");
-var import_qznt = require("qznt");
-var VimcordCLI = class _VimcordCLI {
-  static mode = "off";
-  static setMode(mode) {
-    if (_VimcordCLI.mode === mode) return;
-    _VimcordCLI.mode = mode;
-    if (mode === "on") {
-      CLI.logger.log(`~ Type ${CLI.options.prefix}help to view available commands`);
-    } else {
-      CLI.logger.log(`~ Updated mode to "${mode}"`);
-    }
-  }
-  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) => {
-      if (_VimcordCLI.mode !== "on") return;
-      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_qznt.$.str.getFlag(line, "--client", 1) || import_qznt.$.str.getFlag(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 = useClient(idx);
-      if (!client) {
-        CLI.logger.error("Client instance not found");
-        return void 0;
-      }
-      return client;
-    } else {
-      const client = useClient(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 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 (slash & context) 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_qznt.$.str.getFlag(content, "--guilds", 1) || import_qznt.$.str.getFlag(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":
-      CLI.logger.info("Registering guild commands...");
-      await client.commands.registerGuild({ guilds: guildIds });
-      break;
-    case "global":
-      CLI.logger.info("Registering global commands...");
-      await client.commands.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_qznt.$.str.getFlag(content, "--guilds", 1) || import_qznt.$.str.getFlag(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":
-      CLI.logger.info("Unregistering guild commands...");
-      await client.commands.unregisterGuild({ guilds: guildIds });
-      break;
-    case "global":
-      CLI.logger.info("Unregistering global commands...");
-      await client.commands.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_qznt.$.format.number(client.guilds.cache.size),
-    "Ping:": `${client.ws.ping || 0}ms`,
-    "Uptime:": `${import_qznt.$.math.secs(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", async (args, content) => {
-  const client = CLI.getClientInstance(content);
-  if (!client) return;
-  const mode = (args[0] || "slash").toLowerCase();
-  switch (mode) {
-    case "slash": {
-      const commands = Array.from(client.commands.slash.commands.values());
-      commands.sort((a, b) => a.builder.name.localeCompare(b.builder.name));
-      const tableData = {};
-      for (const cmd of commands) {
-        tableData[`/${cmd.builder.name}`] = `~ ${cmd.builder.description || "No description"}`;
-      }
-      return CLI.logger.table(`(cmds) ~ slash (${import_qznt.$.format.number(commands.length)})`, tableData);
-    }
-    case "prefix": {
-      const commands = Array.from(client.commands.prefix.commands.values());
-      commands.sort((a, b) => {
-        const nameA = a.toConfig().name;
-        const nameB = b.toConfig().name;
-        return nameA.localeCompare(nameB);
-      });
-      const tableData = {};
-      const defaultPrefix = client.config.prefixCommands.defaultPrefix;
-      for (const cmd of commands) {
-        const config = cmd.toConfig();
-        const aliasIndicator = config.aliases?.length ? ` [${config.aliases.join(", ")}]` : "";
-        tableData[`${defaultPrefix}${config.name}${aliasIndicator}`] = `~ ${config.description || "No description"}`;
-      }
-      return CLI.logger.table(`(cmds) ~ prefix (${import_qznt.$.format.number(commands.length)})`, tableData);
-    }
-    case "ctx": {
-      const commands = Array.from(client.commands.context.commands.values());
-      commands.sort((a, b) => a.builder.name.localeCompare(b.builder.name));
-      const tableData = {};
-      for (const cmd of commands) {
-        const type = cmd.builder.type === 2 ? "User" : "Msg";
-        tableData[`[${type}] ${cmd.builder.name}`] = "";
-      }
-      return CLI.logger.table(`(cmds) ~ ctx (${import_qznt.$.format.number(commands.length)})`, tableData);
-    }
-    default:
-      return CLI.logger.error(`'${mode}' is not a valid option. Valid options: [slash|prefix|ctx]`);
-  }
-});
-
-// src/tools/BetterEmbed.ts
-var import_discord6 = require("discord.js");
-
-// src/utils/configFactory.ts
-function createConfigFactory(defaultConfig6, validate) {
-  return (options = {}, existing) => {
-    const base = existing ? { ...existing } : { ...defaultConfig6 };
-    const result = deepMerge(base, options);
-    validate?.(result);
-    return result;
-  };
-}
-
-// src/configs/tools.config.ts
-var globalToolsConfig = {
-  devMode: false,
-  embedColor: [],
-  embedColorDev: [],
-  timeouts: {
-    collectorTimeout: 6e4,
-    collectorIdle: 6e4,
-    pagination: 6e4,
-    prompt: 3e4,
-    modalSubmit: 6e4
-  },
-  collector: {
-    notAParticipantMessage: "You are not allowed to use this.",
-    userLockMessage: "Please wait until your current action is finished.",
-    notAParticipantWarningCooldown: 5e3
-  },
-  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"
-  }
-};
-var createToolsConfig = createConfigFactory(globalToolsConfig);
-var defineGlobalToolsConfig = (options) => {
-  Object.assign(globalToolsConfig, createToolsConfig(options, globalToolsConfig));
-};
-
-// src/tools/dynaSend.ts
-var import_discord5 = 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_discord5.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_discord5.BaseInteraction) {
-      return handler.replied || handler.deferred ? 1 /* EditReply */ : 0 /* Reply */;
-    }
-    if (handler instanceof import_discord5.BaseChannel) return 3 /* Channel */;
-    if (handler instanceof import_discord5.Message) return 4 /* MessageReply */;
-    if (handler instanceof import_discord5.GuildMember || handler instanceof import_discord5.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_discord5.BaseInteraction)) {
-      throw new TypeError(`[DynaSend] SendMethod '${SendMethod[method]}' requires BaseInteraction handler`);
-    }
-    if (method === 3 /* Channel */ && !(handler instanceof import_discord5.BaseChannel)) {
-      throw new TypeError(`[DynaSend] SendMethod '${SendMethod[method]}' requires BaseChannel handler`);
-    }
-    if ([4 /* MessageReply */, 5 /* MessageEdit */].includes(method) && !(handler instanceof import_discord5.Message)) {
-      throw new TypeError(`[DynaSend] SendMethod '${SendMethod[method]}' requires Message handler`);
-    }
-    if (method === 6 /* User */ && !(handler instanceof import_discord5.GuildMember || handler instanceof import_discord5.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_discord6.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 ? createToolsConfig(data.config) : globalToolsConfig;
-    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_discord6.GuildMember ? user : null;
-    const actualUser = guildMember?.user || (user instanceof import_discord6.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.filter((s) => s !== null && s !== void 0).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.filter(Boolean).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/modules/builtins/commandError.builtin.ts
-var import_discord7 = require("discord.js");
-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_discord7.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_discord7.ButtonStyle.Link
-    }),
-    details: new import_discord7.ButtonBuilder({
-      customId: "btn_details",
-      label: config?.detailButtonLabel || "Details",
-      style: import_discord7.ButtonStyle.Secondary
-    })
-  };
-  const actionRow = new import_discord7.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 dynaSend(messageOrInteraction, {
-    embeds: [embed_error],
-    components: [actionRow],
-    flags: config?.ephemeral ? "Ephemeral" : void 0,
-    deleteAfter: config?.deleteAfter
-  });
-  if (!msg) return null;
-  const collector = msg.createMessageComponentCollector({
-    componentType: import_discord7.ComponentType.Button,
-    idle: config?.detailButtonIdleTimeout ?? 3e4,
-    filter: (i) => i.customId === "btn_details"
-  });
-  collector.on("collect", (i) => {
-    const attachment = new import_discord7.AttachmentBuilder(Buffer.from(`${error.message}
-
-${error.stack}`), {
-      name: "error.txt"
-    });
-    i.reply({ files: [attachment], flags: "Ephemeral" });
-  });
-  collector.on("end", () => {
-    buttons.details.setDisabled(true);
-    dynaSend(messageOrInteraction, {
-      embeds: [embed_error],
-      sendMethod: messageOrInteraction instanceof import_discord7.Message ? 5 /* MessageEdit */ : void 0,
-      components: [actionRow]
-    });
-  });
-  return msg;
-}
-
-// src/client/vimcord.errorHandler.ts
-var VimcordErrorHandler = class {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  /** Handles command errors - sends error embed to user, then rethrows. */
-  async handleCommandError(error, guild, messageOrInteraction) {
-    await sendCommandErrorEmbed(this.client, error, guild, messageOrInteraction);
-    throw error;
-  }
-  /** Handles internal Vimcord errors - logs with [Vimcord] prefix. */
-  handleVimcordError(error, context) {
-    this.client.logger.error(`[Vimcord] [${context}]`, error);
-  }
-  /** Sets up global process error handlers. */
-  setupGlobalHandlers() {
-    process.on("uncaughtException", (err) => this.handleVimcordError(err, "Uncaught Exception"));
-    process.on("unhandledRejection", (err) => this.handleVimcordError(err, "Unhandled Rejection"));
-    process.on("exit", (code) => this.client.logger.debug(`Process exited with code ${code}`));
-    this.client.on("error", (err) => this.handleVimcordError(err, "Client Error"));
-    this.client.on("shardError", (err) => this.handleVimcordError(err, "Client Shard Error"));
-  }
-};
-
-// src/client/vimcord.logger.ts
-var import_chalk2 = __toESM(require("chalk"));
-
-// package.json
-var version = "1.0.57";
-
-// src/client/vimcord.logger.ts
-var clientLoggerFactory = (client) => new Logger({ prefixEmoji: "\u26A1", prefix: `vimcord (i${client.clientId})` }).extend({
-  clientBanner(client2) {
-    if (client2.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} ${client2.$name} v${client2.$version}`.padEnd(50 - (client2.$devMode ? 12 : 0))
-      ) + import_chalk2.default.hex(this.colors.primary)(`${client2.$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 - `${client2.clientId}`.length)
-      ) + import_chalk2.default.hex(this.colors.primary)(`${import_chalk2.default.hex(this.colors.muted)(`i${client2.clientId}`)}  \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)
-    );
-  },
-  plugin(pluginName, action, details) {
-    console.log(
-      this.formatTimestamp(),
-      this.formatPrefix(),
-      import_chalk2.default.hex("#FF6B9D")(`\u{1F50C} ${pluginName}`),
-      import_chalk2.default.white(action),
-      details ? import_chalk2.default.hex(this.colors.muted)(details) : ""
-    );
-  }
-});
-
-// src/utils/processUtils.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-function getPackageJson() {
-  return JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(process.cwd(), "package.json"), "utf-8"));
-}
-function getDevMode() {
-  return process.argv.includes("--dev");
-}
-
-// src/configs/app.config.ts
-var defaultConfig = {
-  name: "Discord Bot",
-  version: getPackageJson()?.version ?? "1.0.0",
-  devMode: getDevMode(),
-  verbose: false,
-  enableCLI: false,
-  disableBanner: false
-};
-var createAppConfig = createConfigFactory(defaultConfig, (config) => {
-  if (!config.name) throw new Error("App name is required");
-  defineGlobalToolsConfig({ devMode: config.devMode });
-});
-
-// src/configs/contextCommand.config.ts
-var defaultConfig2 = {
-  enabled: true,
-  logExecution: true
-};
-var createContextCommandConfig = createConfigFactory(defaultConfig2);
-
-// src/configs/prefixCommand.config.ts
-var defaultConfig3 = {
-  enabled: true,
-  defaultPrefix: "!",
-  allowMentionAsPrefix: true,
-  allowCaseInsensitiveCommandNames: true,
-  logExecution: true
-};
-var createPrefixCommandConfig = createConfigFactory(defaultConfig3);
-
-// src/configs/slashCommand.config.ts
-var defaultConfig4 = {
-  enabled: true,
-  logExecution: true
-};
-var createSlashCommandConfig = createConfigFactory(defaultConfig4);
-
-// src/configs/staff.config.ts
-var defaultConfig5 = {
-  ownerId: null,
-  superUsers: [],
-  superUserRoles: [],
-  bypassers: [],
-  bypassesGuildAdmin: {
-    allBotStaff: false,
-    botOwner: false,
-    superUsers: false,
-    bypassers: false
-  },
-  guild: {
-    id: null,
-    inviteUrl: null,
-    channels: {}
-  }
-};
-var createStaffConfig = createConfigFactory(defaultConfig5);
-
-// src/client/vimcord.utils.ts
-var DEFAULT_MODULE_SUFFIXES = {
-  slashCommands: ".slash",
-  contextCommands: ".ctx",
-  prefixCommands: ".prefix",
-  events: ".event"
-};
-var configSetters = {
-  app: createAppConfig,
-  staff: createStaffConfig,
-  slashCommands: createSlashCommandConfig,
-  contextCommands: createContextCommandConfig,
-  prefixCommands: createPrefixCommandConfig
-};
-var moduleImporters = {
-  slashCommands: (client, options, set) => {
-    const opt = options;
-    const dir = Array.isArray(options) ? options : typeof options === "string" ? options : options?.dir ?? [];
-    const suffix = Array.isArray(options) ? DEFAULT_MODULE_SUFFIXES.slashCommands : opt?.suffix ?? DEFAULT_MODULE_SUFFIXES.slashCommands;
-    return client.commands.slash.importFrom(dir, set, suffix);
-  },
-  contextCommands: (client, options, set) => {
-    const opt = options;
-    const dir = Array.isArray(options) ? options : typeof options === "string" ? options : options?.dir ?? [];
-    const suffix = Array.isArray(options) ? DEFAULT_MODULE_SUFFIXES.contextCommands : opt?.suffix ?? DEFAULT_MODULE_SUFFIXES.contextCommands;
-    return client.commands.context.importFrom(dir, set, suffix);
-  },
-  prefixCommands: (client, options, set) => {
-    const opt = options;
-    const dir = Array.isArray(options) ? options : typeof options === "string" ? options : options?.dir ?? [];
-    const suffix = Array.isArray(options) ? DEFAULT_MODULE_SUFFIXES.prefixCommands : opt?.suffix ?? DEFAULT_MODULE_SUFFIXES.prefixCommands;
-    return client.commands.prefix.importFrom(dir, set, suffix);
-  },
-  events: (client, options, set) => {
-    const opt = options;
-    const dir = Array.isArray(options) ? options : typeof options === "string" ? options : options?.dir ?? [];
-    const suffix = Array.isArray(options) ? DEFAULT_MODULE_SUFFIXES.events : opt?.suffix ?? DEFAULT_MODULE_SUFFIXES.events;
-    return client.events.importFrom(dir, set, suffix);
-  }
-};
-function defineClientOptions(options) {
-  return options;
-}
-function defineVimcordFeatures(features) {
-  return features;
-}
-function defineVimcordConfig(config) {
-  return {
-    app: createAppConfig(config.app),
-    staff: createStaffConfig(config.staff),
-    slashCommands: createSlashCommandConfig(config.slashCommands),
-    prefixCommands: createPrefixCommandConfig(config.prefixCommands),
-    contextCommands: createContextCommandConfig(config.contextCommands)
-  };
-}
-function useClient(clientId) {
-  return Vimcord.getInstance(clientId);
-}
-function useReadyClient(clientId, timeoutMs) {
-  return Vimcord.getReadyInstance(clientId, timeoutMs);
-}
-function createClient(options, features, config) {
-  return Vimcord.create(options, features, config);
-}
-
-// src/modules/command.manager.ts
-var import_discord8 = require("discord.js");
-
-// src/utils/importUtils.ts
-var import_node_path2 = __toESM(require("path"));
-var import_qznt2 = require("qznt");
-function getProcessDir() {
-  const mainPath = process.argv[1];
-  if (!mainPath) return "";
-  return import_node_path2.default.dirname(mainPath);
-}
-function testFilenameSuffix(filename, suffix) {
-  if (!suffix) return filename.endsWith(".ts") || filename.endsWith(".js");
-  if (Array.isArray(suffix)) {
-    return suffix.some((s) => filename.endsWith(`${s}.ts`) || filename.endsWith(`${s}.js`));
-  } else {
-    return filename.endsWith(`${suffix}.ts`) || filename.endsWith(`${suffix}.js`);
-  }
-}
-async function importModulesFromDir(dir, suffix) {
-  const cwd = getProcessDir();
-  const MODULE_RELATIVE_PATH = import_node_path2.default.join(cwd, dir);
-  const MODULE_LOG_PATH = dir;
-  const files = import_qznt2.$.fs.readDir(MODULE_RELATIVE_PATH).filter((filename) => testFilenameSuffix(filename, suffix));
-  if (!files.length) return [];
-  const modules = await Promise.all(
-    files.map(async (fn) => {
-      let _path = import_node_path2.default.join(MODULE_RELATIVE_PATH, fn);
-      let _logPath = `./${import_node_path2.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;
-}
-
-// src/modules/importers/baseModule.importer.ts
-var ModuleImporter = class {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async importFrom(dir, set = false, suffix) {
-    if (set) this.items.clear();
-    const dirs = Array.isArray(dir) ? dir : [dir];
-    const modules = [];
-    for (const _dir of dirs) {
-      const results = await importModulesFromDir(_dir, suffix ?? this.itemSuffix);
-      modules.push(...results.map(({ module: module2 }) => module2.default));
-    }
-    for (const module2 of modules) {
-      const name = this.getName(module2);
-      this.items.set(name, module2);
-    }
-    this.client.logger.moduleLoaded(this.itemName, modules.length);
-    return this.items;
-  }
-};
-
-// src/modules/command.manager.ts
-var BaseCommandManager = class extends ModuleImporter {
-  type;
-  items = /* @__PURE__ */ new Map();
-  itemSuffix;
-  constructor(client, type, itemSuffix) {
-    super(client);
-    this.type = type;
-    switch (type) {
-      case 0 /* Slash */:
-        this.itemSuffix = itemSuffix ?? DEFAULT_MODULE_SUFFIXES.slashCommands;
-        break;
-      case 2 /* Context */:
-        this.itemSuffix = itemSuffix ?? DEFAULT_MODULE_SUFFIXES.contextCommands;
-        break;
-      case 1 /* Prefix */:
-        this.itemSuffix = itemSuffix ?? DEFAULT_MODULE_SUFFIXES.prefixCommands;
-        break;
-    }
-  }
-  get commands() {
-    return this.items;
-  }
-  get itemName() {
-    switch (this.type) {
-      case 0 /* Slash */:
-        return "Slash Commands";
-      case 2 /* Context */:
-        return "Context Commands";
-      case 1 /* Prefix */:
-        return "Prefix Commands";
-    }
-  }
-  getName(module2) {
-    return "builder" in module2 ? module2.builder.name : module2.options.name;
-  }
-  /**
-   * Gets a command by name.
-   */
-  get(name) {
-    if (this.type === 1 /* Prefix */) {
-      const config = this.client.config.prefixCommands;
-      const search = config.allowCaseInsensitiveCommandNames ? name.toLowerCase() : name;
-      return Array.from(this.items.values()).find((cmd) => {
-        const commandName = "builder" in cmd ? cmd.builder.name : cmd.options.name;
-        const trigger = config.allowCaseInsensitiveCommandNames ? commandName.toLowerCase() : commandName;
-        if (trigger === search) return true;
-        if ("aliases" in cmd.options) {
-          return cmd.options.aliases?.some(
-            (a) => config.allowCaseInsensitiveCommandNames ? a.toLowerCase() === search : a === search
-          );
-        }
-      });
-    } else {
-      return this.items.get(name);
-    }
-  }
-  /**
-   * Gets/filters commands and orders them alphabetically.
-   */
-  getAll(options = {}) {
-    const matchedCommands = /* @__PURE__ */ new Map();
-    const isDev = this.client.config.app.devMode;
-    for (const cmd of this.items.values()) {
-      const commandName = "builder" in cmd ? cmd.builder.name : cmd.options.name;
-      if (options.names || options.fuzzyNames) {
-        const nameMatched = options.names?.includes(commandName) || options.fuzzyNames?.some((fuzzy) => commandName.includes(fuzzy));
-        if (!nameMatched) continue;
-      }
-      if (options.ignoreDeploymentOptions) {
-        matchedCommands.set(commandName, cmd);
-        continue;
-      }
-      const deployment = "deployment" in cmd.options ? cmd.options.deployment ?? {} : {};
-      const isProperEnv = !deployment.environments || deployment.environments.includes(isDev ? "development" : "production");
-      if (!isProperEnv) continue;
-      if (options.globalOnly && deployment.global === false) continue;
-      matchedCommands.set(commandName, cmd);
-    }
-    return Array.from(matchedCommands.values()).sort((a, b) => {
-      const commandNameA = "builder" in a ? a.builder.name : a.options.name;
-      const commandNameB = "builder" in b ? b.builder.name : b.options.name;
-      return commandNameA.localeCompare(commandNameB);
-    });
-  }
-  /**
-   * Groups commands by category alphabetically.
-   */
-  sortByCategory() {
-    const categories = /* @__PURE__ */ new Map();
-    for (const cmd of this.items.values()) {
-      const metadata = cmd.options.metadata;
-      if (!metadata?.category) continue;
-      let entry = categories.get(metadata.category);
-      if (!entry) {
-        entry = {
-          name: metadata.category,
-          emoji: metadata.categoryEmoji,
-          commands: []
-        };
-        categories.set(metadata.category, entry);
-      }
-      entry.commands.push(cmd);
-    }
-    return Array.from(categories.values()).sort((a, b) => a.name.localeCompare(b.name)).map((cat) => {
-      cat.commands.sort((a, b) => {
-        const commandNameA = "builder" in a ? a.builder.name : a.options.name;
-        const commandNameB = "builder" in b ? b.builder.name : b.options.name;
-        return commandNameA.localeCompare(commandNameB);
-      });
-      return cat;
-    });
-  }
-};
-var SlashCommandManager = class extends BaseCommandManager {
-  constructor(client) {
-    super(client, 0 /* Slash */);
-  }
-};
-var ContextCommandManager = class extends BaseCommandManager {
-  constructor(client) {
-    super(client, 2 /* Context */);
-  }
-};
-var PrefixCommandManager = class extends BaseCommandManager {
-  constructor(client) {
-    super(client, 1 /* Prefix */);
-  }
-};
-var CommandManager = class {
-  client;
-  slash;
-  prefix;
-  context;
-  constructor(client) {
-    this.client = client;
-    this.slash = new SlashCommandManager(client);
-    this.prefix = new PrefixCommandManager(client);
-    this.context = new ContextCommandManager(client);
-  }
-  getAllAppCommands(options = {}) {
-    return [...this.slash.getAll(options), ...this.context.getAll(options)];
-  }
-  async registerGlobal(options = {}) {
-    const client = await Vimcord.getReadyInstance(this.client.clientId);
-    if (!client.rest) {
-      console.error(`[CommandManager] \u2716 Failed to register app commands globally: REST is not initialized`);
-      return;
-    }
-    const commands = this.getAllAppCommands(options).map((cmd) => cmd.builder.toJSON());
-    if (!commands.length) {
-      console.log("[CommandManager] No commands to register globally");
-      return;
-    }
-    console.log(
-      `[CommandManager] Registering (${commands.length}) ${commands.length === 1 ? "command" : "commands"} globally...`
-    );
-    try {
-      await client.rest.put(import_discord8.Routes.applicationCommands(client.user.id), { body: commands });
-      console.log(`[CommandManager] \u2714 Registered app ${commands.length === 1 ? "command" : "commands"} globally`);
-    } catch (err) {
-      console.error(
-        `[CommandManager] \u2716 Failed to register app ${commands.length === 1 ? "command" : "commands"} globally`,
-        err
-      );
-    }
-  }
-  async unregisterGlobal() {
-    const client = await Vimcord.getReadyInstance(this.client.clientId);
-    if (!client.rest) {
-      console.error(`[CommandManager] \u2716 Failed to remove app commands globally: REST is not initialized`);
-      return;
-    }
-    try {
-      await client.rest.put(import_discord8.Routes.applicationCommands(client.user.id), { body: [] });
-      console.log(`[CommandManager] \u2714 Removed app commands globally`);
-    } catch (err) {
-      console.error(`[CommandManager] \u2716 Failed to remove app commands globally`, err);
-    }
-  }
-  async registerGuild(options = {}) {
-    const client = await Vimcord.getReadyInstance(this.client.clientId);
-    if (!client.rest) {
-      console.error(`[CommandManager] \u2716 Failed to register app commands by guild: REST is not initialized`);
-      return;
-    }
-    const commands = this.getAllAppCommands(options).map((cmd) => cmd.builder.toJSON());
-    if (!commands.length) {
-      console.log("[CommandManager] No commands to register by guild");
-      return;
-    }
-    const guildIds = options.guilds || client.guilds.cache.map((g) => g.id);
-    console.log(
-      `[CommandManager] Registering (${commands.length}) ${commands.length === 1 ? "command" : "commands"} for ${guildIds.length} guilds...`
-    );
-    await Promise.all(
-      guildIds.map(
-        (guildId) => client.rest.put(import_discord8.Routes.applicationGuildCommands(client.user.id, guildId), { body: commands }).then(() => {
-          const gName = client.guilds.cache.get(guildId)?.name || "n/a";
-          console.log(
-            `[CommandManager] \u2714 Set app ${commands.length === 1 ? "command" : "commands"} in guild: ${guildId} (${gName})`
-          );
-        }).catch((err) => {
-          const gName = client.guilds.cache.get(guildId)?.name || "n/a";
-          console.log(
-            `[CommandManager] \u2716 Failed to set app ${commands.length === 1 ? "command" : "commands"} in guild: ${guildId} (${gName})`,
-            err
-          );
-        })
-      )
-    );
-  }
-  async unregisterGuild(options = {}) {
-    const client = await Vimcord.getReadyInstance(this.client.clientId);
-    if (!client.rest) {
-      console.error(`[CommandManager] \u2716 Failed to register app commands by guild: REST is not initialized`);
-      return;
-    }
-    const guildIds = options.guilds || client.guilds.cache.map((g) => g.id);
-    console.log(`[CommandManager] Unregistering commands from ${guildIds.length} guilds...`);
-    await Promise.all(
-      guildIds.map(
-        (guildId) => client.rest.put(import_discord8.Routes.applicationGuildCommands(client.user.id, guildId), { body: [] }).then(() => console.log(`[CommandManager] \u2714 Removed app commands in guild: ${guildId}`)).catch((err) => console.log(`[CommandManager] \u2716 Failed to remove app commands in guild: ${guildId}`, err))
-      )
-    );
-  }
-};
-
-// src/modules/event.manager.ts
-var import_discord9 = require("discord.js");
-var EventManager = class extends ModuleImporter {
-  items = /* @__PURE__ */ new Map();
-  itemSuffix = "event";
-  itemName = "Event Handlers";
-  logger;
-  constructor(client) {
-    super(client);
-    this.logger = new Logger({ prefixEmoji: "\u{1F4CB}", prefix: `EventManager (i${this.client.clientId})` });
-    for (const event of Object.values(import_discord9.Events)) {
-      client.on(
-        event.toString(),
-        async (...args) => this.executeEvents.apply(this, [event, ...args])
-      );
-    }
-  }
-  getName(module2) {
-    return module2.name;
-  }
-  register(...events) {
-    for (const event of events) {
-      this.items.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.items.get(name);
-      if (!event) continue;
-      this.items.delete(name);
-      if (this.client.config.app.verbose) {
-        this.logger.debug(`'${event.name}' unregistered for EventType '${event.event}'`);
-      }
-    }
-  }
-  clear() {
-    this.items.forEach((e) => this.unregister(e.name));
-    this.items.clear();
-  }
-  get(name) {
-    return this.items.get(name);
-  }
-  getByTag(tag) {
-    return Array.from(this.items.values()).filter((event) => event.metadata?.tags?.includes(tag));
-  }
-  getByCategory(category) {
-    return Array.from(this.items.values()).filter((event) => event.metadata?.category?.includes(category));
-  }
-  getByEvent(eventType) {
-    return Array.from(this.items.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);
-        }
-      })
-    );
-  }
-};
-
-// src/tools/utils.ts
-var MENTION_OR_SNOWFLAKE_REGEX = /<@[#&]?[\d]{6,}>|[\d]{6,}/;
-var fetchUserPromises = /* @__PURE__ */ new Map();
-var fetchGuildPromises = /* @__PURE__ */ new Map();
-var fetchMemberPromises = /* @__PURE__ */ new Map();
-var fetchChannelPromises = /* @__PURE__ */ new Map();
-var fetchMessagePromises = /* @__PURE__ */ new Map();
-var fetchRolePromises = /* @__PURE__ */ new Map();
-function createCachedFetch(cache, fetchFn, cacheKey) {
-  const cached = cache.get(cacheKey);
-  if (cached) return cached;
-  const promise = fetchFn().finally(() => cache.delete(cacheKey));
-  cache.set(cacheKey, promise);
-  return promise;
-}
-function __zero(str) {
-  return str?.length ? str : "0";
-}
-function isMentionOrSnowflake(str) {
-  return str ? MENTION_OR_SNOWFLAKE_REGEX.test(str) : 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);
-      }
-      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) {
-        if (idOnly) return arg;
-        const channel = message.guild ? await fetchChannel(message.guild, arg) : message.client.channels.cache.get(__zero(arg)) ?? message.client.channels.fetch(__zero(arg));
-        return channel;
-      }
-      return idOnly ? channelMention?.id || null : channelMention;
-    }
-    case "role": {
-      const roleMention = message.mentions.roles.at(index) || null;
-      if (!roleMention && arg) {
-        if (idOnly) return arg;
-        return message.guild ? await fetchRole(message.guild, arg) : null;
-      }
-      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 "member":
-        mentionId = options.message.mentions.members?.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;
-  const key = `${client.user.id}-${userId}`;
-  const cached = client.users.cache.get(__zero(userId));
-  if (cached) return cached;
-  return createCachedFetch(fetchUserPromises, () => client.users.fetch(__zero(userId)).catch(() => null), key);
-}
-async function fetchGuild(client, guildId) {
-  if (!guildId) return null;
-  const key = `${client.user.id}-${guildId}`;
-  const cached = client.guilds.cache.get(__zero(guildId));
-  if (cached) return cached;
-  return createCachedFetch(fetchGuildPromises, () => client.guilds.fetch(__zero(guildId)).catch(() => null), key);
-}
-async function fetchMember(guild, memberId) {
-  if (!memberId) return null;
-  const key = `${guild.id}-${memberId}`;
-  const cached = guild.members.cache.get(__zero(memberId));
-  if (cached) return cached;
-  return createCachedFetch(fetchMemberPromises, () => guild.members.fetch(__zero(memberId)).catch(() => null), key);
-}
-async function fetchChannel(guild, channelId, type) {
-  if (!channelId) return null;
-  const key = `${guild.id}-${channelId}`;
-  const cached = guild.channels.cache.get(__zero(channelId)) ?? null;
-  if (cached) {
-    if (type && cached.type !== type) return null;
-    return cached;
-  }
-  const channel = await createCachedFetch(
-    fetchChannelPromises,
-    () => guild.channels.fetch(__zero(channelId)).catch(() => null),
-    key
-  );
-  if (type && channel?.type !== type) return null;
-  return channel;
-}
-async function fetchMessage(channel, messageId) {
-  if (!messageId) return null;
-  const key = `${channel.guild.id}-${messageId}`;
-  const cached = channel.messages.cache.get(__zero(messageId));
-  if (cached) return cached;
-  return createCachedFetch(fetchMessagePromises, () => channel.messages.fetch(__zero(messageId)).catch(() => null), key);
-}
-async function fetchRole(guild, roleId) {
-  if (!roleId) return null;
-  const key = `${guild.id}-${roleId}`;
-  const cached = guild.roles.cache.get(__zero(roleId));
-  if (cached) return cached;
-  return createCachedFetch(fetchRolePromises, () => guild.roles.fetch(__zero(roleId)).catch(() => null), key);
-}
-
-// src/types/status.ts
-var import_discord10 = require("discord.js");
-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_discord10.ActivityType.Custom, name: "Need help? Use /help or !help" },
-      { status: "online" /* Online */, type: import_discord10.ActivityType.Custom, name: "Join our community!" },
-      { status: "online" /* Online */, type: import_discord10.ActivityType.Watching, name: "\u2728 $GUILD_COUNT servers" }
-    ]
-  },
-  development: {
-    activity: { status: "dnd" /* DND */, type: import_discord10.ActivityType.Custom, name: "In development!" }
-  }
-};
-function createVimcordStatusConfig(options = {}) {
-  return deepMerge({ ...defaultPresence }, options);
-}
-
-// src/modules/status.manager.ts
-var import_node_events = __toESM(require("events"));
-var import_qznt3 = require("qznt");
-var StatusManager = 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.clientId})` });
-    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");
-      }
-    });
-  }
-  clearData() {
-    this.task?.stop();
-    this.task = null;
-    this.lastActivity = null;
-    this.lastActivityIndex = 0;
-    return this;
-  }
-  async getReadyClient() {
-    const client = await Vimcord.getReadyInstance(this.client.clientId);
-    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", import_qznt3.$.format.number(this.client.users.cache.size)).replace("$GUILD_COUNT", import_qznt3.$.format.number(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", import_qznt3.$.format.number(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 && Array.isArray(clientStatus.activity)) {
-      activity = import_qznt3.$.rnd.choice(clientStatus.activity, { not: this.lastActivity });
-      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?.stop();
-    this.task = null;
-    this.task = new import_qznt3.$.Loop(() => this.statusRotationTask(clientStatus), import_qznt3.$.math.ms(clientStatus.interval), true);
-    this.start();
-  }
-  start() {
-    if (this.task) {
-      this.task.start();
-      this.emitter.emit("started", this.task);
-    }
-    return this;
-  }
-  pause() {
-    if (this.task) {
-      this.task.stop();
-      this.emitter.emit("paused", this.task);
-    }
-    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);
-    } else {
-      await this.scheduleStatusRotation(clientStatus);
-    }
-    return this;
-  }
-  async destroy() {
-    if (this.task) {
-      this.task.stop();
-      this.task = null;
-      this.emitter.emit("destroyed");
-      await this.clear();
-    }
-    return this;
-  }
-  async clear() {
-    const client = await this.getReadyClient();
-    this.clearData();
-    client.user.setActivity({ name: "" });
-    this.emitter.emit("cleared");
-    return this;
-  }
-};
-
-// src/client/Vimcord.ts
-var import_discord11 = require("discord.js");
-var import_dotenv = require("dotenv");
-var import_node_crypto3 = require("crypto");
-var import_node_events2 = __toESM(require("events"));
-var import_qznt4 = require("qznt");
-var Vimcord = class _Vimcord extends import_discord11.Client {
-  static instances = /* @__PURE__ */ new Map();
-  static emitter = new import_node_events2.default();
-  clientStartingPromise = null;
-  static create(optionsOrConfig, features, config) {
-    if ("options" in optionsOrConfig) {
-      const { options, features: features2, config: config2 } = optionsOrConfig;
-      return new _Vimcord(options, features2, config2);
-    } else {
-      return new _Vimcord(optionsOrConfig, features, config);
-    }
-  }
-  /**
-   * Returns an instance of Vimcord.
-   * @param clientId [default: 0]
-   */
-  static getInstance(clientId) {
-    if (clientId === void 0) {
-      return _Vimcord.instances.values().next().value;
-    }
-    return _Vimcord.instances.get(clientId);
-  }
-  /**
-   * Waits for a Vimcord instance to be ready.
-   * @param clientId [default: 0]
-   * @param timeoutMs [default: 60000]
-   */
-  static async getReadyInstance(clientId, timeoutMs = 6e4) {
-    const client = _Vimcord.getInstance(clientId);
-    if (client?.isReady()) {
-      _Vimcord.emitter.emit("ready", client);
-      return client;
-    }
-    if (client) {
-      return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          _Vimcord.emitter.off("ready", listener);
-          reject(new Error(`Client (i${clientId ?? 0}) timed out waiting for ready`));
-        }, timeoutMs);
-        const listener = (c) => {
-          if (c.clientId === (clientId ?? 0)) {
-            clearTimeout(timeout);
-            _Vimcord.emitter.off("ready", listener);
-            resolve(c);
-          }
-        };
-        client.once("clientReady", () => {
-          clearTimeout(timeout);
-          _Vimcord.emitter.emit("ready", client);
-          resolve(client);
-        });
-      });
-    }
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        _Vimcord.emitter.off("ready", listener);
-        reject(new Error(`Vimcord instance (i${clientId ?? 0}) failed to initialize within ${timeoutMs / 1e3}s.`));
-      }, timeoutMs);
-      const listener = (c) => {
-        if (c.clientId === (clientId ?? 0)) {
-          clearTimeout(timeout);
-          _Vimcord.emitter.off("ready", listener);
-          resolve(c);
-        }
-      };
-      _Vimcord.emitter.on("ready", listener);
-    });
-  }
-  uuid = (0, import_node_crypto3.randomUUID)();
-  clientId = _Vimcord.instances.size;
-  clientOptions;
-  features;
-  config;
-  status;
-  events;
-  commands;
-  db;
-  logger = clientLoggerFactory(this);
-  error;
-  constructor(options, features = {}, config = {}) {
-    super(options);
-    this.clientOptions = options;
-    this.features = features;
-    this.config = defineVimcordConfig(config);
-    this.error = new VimcordErrorHandler(this);
-    this.status = new StatusManager(this);
-    this.events = new EventManager(this);
-    this.commands = new CommandManager(this);
-    this.once("clientReady", (client) => this.logger.clientReady(client.user.tag, client.guilds.cache.size));
-    _Vimcord.instances.set(this.clientId, this);
-  }
-  /** Builds the client by importing modules and registering builtin handlers. */
-  async build() {
-    this.configure("app", this.config.app);
-    this.configure("staff", this.config.staff);
-    this.configure("slashCommands", this.config.slashCommands);
-    this.configure("prefixCommands", this.config.prefixCommands);
-    this.configure("contextCommands", this.config.contextCommands);
-    if (this.features.useGlobalErrorHandlers) {
-      this.error.setupGlobalHandlers();
-    }
-    if (this.features.useDefaultSlashCommandHandler) {
-      this.events.register(slashCommandHandler);
-    }
-    if (this.features.useDefaultContextCommandHandler) {
-      this.events.register(contextCommandHandler);
-    }
-    if (this.features.useDefaultPrefixCommandHandler) {
-      this.events.register(prefixCommandHandler);
-    }
-    if (this.features.importModules) {
-      const importModules = this.features.importModules;
-      await Promise.all([
-        importModules.events && this.importModules("events", importModules.events),
-        importModules.slashCommands && this.importModules("slashCommands", importModules.slashCommands),
-        importModules.prefixCommands && this.importModules("prefixCommands", importModules.prefixCommands),
-        importModules.contextCommands && this.importModules("contextCommands", importModules.contextCommands)
-      ]);
-    }
-    this.logger.clientBanner(this);
-    if (this.config.app.enableCLI) {
-      VimcordCLI.setMode("on");
-    }
-    return this;
-  }
-  /** Current app name */
-  // prettier-ignore
-  get $name() {
-    return this.config.app.name;
-  }
-  // prettier-ignore
-  set $name(name) {
-    this.config.app.name = name;
-  }
-  /** Current app version */
-  // prettier-ignore
-  get $version() {
-    return this.config.app.version;
-  }
-  // prettier-ignore
-  set $version(version2) {
-    this.config.app.version = version2;
-  }
-  /** Current dev mode state */
-  // prettier-ignore
-  get $devMode() {
-    return this.config.app.devMode;
-  }
-  // prettier-ignore
-  set $devMode(mode) {
-    this.config.app.devMode = mode;
-  }
-  /** Current verbose mode state */
-  // prettier-ignore
-  get $verboseMode() {
-    return this.config.app.verbose;
-  }
-  // prettier-ignore
-  set $verboseMode(mode) {
-    this.config.app.verbose = mode;
-  }
-  /** Returns the options, features, and config of this client. */
-  toJSON() {
-    return { options: this.clientOptions, features: this.features, config: this.config };
-  }
-  /** Makes a clone of this client. */
-  clone() {
-    const { options, features, config } = this.toJSON();
-    return new _Vimcord(options, features, config);
-  }
-  /**
-   * Modifies a client config.
-   * @param type The type of config to modify.
-   * @param options The options to set for the config.
-   */
-  configure(type, options = {}) {
-    this.config[type] = configSetters[type](options, this.config[type]);
-    return this;
-  }
-  /**
-   * Allows Vimcord to handle environment variables using [dotenv](https://www.npmjs.com/package/dotenv).
-   * @param options Options for dotenv
-   * @see https://www.npmjs.com/package/dotenv
-   */
-  useEnv(options) {
-    this.logger.plugin("ENV", "Using", "dotenv");
-    (0, import_dotenv.configDotenv)({ quiet: true, ...options });
-    return this;
-  }
-  /**
-   * Connects to a database.
-   * @param db The database manager to use.
-   */
-  async useDatabase(db) {
-    this.db = db;
-    this.logger.plugin("DATABASE", "Using", db.moduleName);
-    return this.db.connect();
-  }
-  /**
-   * Imports modules into the client.
-   * @param type The type of modules to import.
-   * @param options The options to import the module with.
-   * @param set Replaces already imported modules with the ones found.
-   */
-  async importModules(type, options, set) {
-    await moduleImporters[type](this, options, set);
-    return this;
-  }
-  /**
-   * Fetches a user from the client, checking the cache first.
-   * @param userId The ID of the user to fetch.
-   */
-  async fetchUser(userId) {
-    const client = await _Vimcord.getReadyInstance(this.clientId);
-    return fetchUser(client, userId);
-  }
-  /**
-   * Fetches a guild from the client, checking the cache first.
-   * @param guildId The ID of the guild to fetch.
-   */
-  async fetchGuild(guildId) {
-    const client = await _Vimcord.getReadyInstance(this.clientId);
-    return fetchGuild(client, guildId);
-  }
-  async start(tokenOrPreHook, callback) {
-    if (this.clientStartingPromise) return this.clientStartingPromise;
-    const execute = async () => {
-      let token = typeof tokenOrPreHook === "string" ? tokenOrPreHook : void 0;
-      token ??= this.$devMode ? process.env.TOKEN_DEV : process.env.TOKEN;
-      if (!token) {
-        throw new Error(
-          `TOKEN Missing: ${this.$devMode ? "devMode is enabled, but TOKEN_DEV is not set" : "TOKEN not set"}`
-        );
-      }
-      await this.build();
-      try {
-        const stopLoader = this.logger.loader("Connecting to Discord...");
-        const loginResult = await import_qznt4.$.async.retry(() => super.login(token), {
-          retries: this.features.maxLoginAttempts ?? 3,
-          delay: 1e3
-        });
-        stopLoader("Connected to Discord    ");
-        this.logger.debug("Waiting for the client to be ready...");
-        if (typeof tokenOrPreHook === "function") {
-          await tokenOrPreHook(this);
-        } else {
-          await callback?.(this);
-        }
-        return loginResult;
-      } catch (err) {
-        this.logger.error(
-          `Failed to log into Discord after ${this.features.maxLoginAttempts} attempt(s)`,
-          err
-        );
-        return null;
-      } finally {
-        this.clientStartingPromise = null;
-      }
-    };
-    this.clientStartingPromise = execute();
-    return this.clientStartingPromise;
-  }
-  /** Destroys the client and disconnects from Discord. */
-  async kill() {
-    await super.destroy();
-    _Vimcord.instances.delete(this.clientId);
-    this.logger.debug("Logged out of Discord");
-  }
-};
-
-// src/client/error.handler.ts
-var ErrorHandler = class {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  /** Handles command errors - sends error embed to user, then rethrows. */
-  async handleCommandError(error, guild, messageOrInteraction) {
-    await sendCommandErrorEmbed(this.client, error, guild, messageOrInteraction);
-    throw error;
-  }
-  /** Handles internal Vimcord errors - logs with [Vimcord] prefix. */
-  handleVimcordError(error, context) {
-    this.client.logger.error(`[Vimcord] [${context}]`, error);
-  }
-  /** Sets up global process error handlers. */
-  setupGlobalHandlers() {
-    process.on("uncaughtException", (err) => this.handleVimcordError(err, "Uncaught Exception"));
-    process.on("unhandledRejection", (err) => this.handleVimcordError(err, "Unhandled Rejection"));
-    process.on("exit", (code) => this.client.logger.debug(`Process exited with code ${code}`));
-    this.client.on("error", (err) => this.handleVimcordError(err, "Client Error"));
-    this.client.on("shardError", (err) => this.handleVimcordError(err, "Client Shard Error"));
-  }
-};
-
-// src/db/mongo/mongo.database.ts
-var import_mongoose = __toESM(require("mongoose"));
-var import_node_events3 = __toESM(require("events"));
-var import_qznt5 = require("qznt");
-try {
-  import("mongoose");
-} catch {
-  throw new Error("MongoDatabase requires the mongoose package, install it with `npm install mongoose`");
-}
-var MongoDatabase = class _MongoDatabase {
-  static instances = /* @__PURE__ */ new Map();
-  static emitter = new import_node_events3.default();
-  moduleName = "MongoDatabase";
-  clientId;
-  client;
-  mongoose;
-  isConnecting = false;
-  /**
-   * Returns an instance of MongoDatabase.
-   * @param clientId [default: 0]
-   */
-  static getInstance(clientId) {
-    const id = (typeof clientId === "number" ? clientId : clientId?.clientId) ?? 0;
-    return _MongoDatabase.instances.get(id);
-  }
-  /**
-   * Waits for a MongoDatabase instance to be ready. First waiting for the instance to initialize if it doesn't exist.
-   * @param clientId [default: 0]
-   * @param timeoutMs [default: 60000]
-   */
-  static async getReadyInstance(clientId, timeoutMs = 6e4) {
-    const existing = _MongoDatabase.getInstance(clientId);
-    if (existing) return await existing.waitForReady();
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        _MongoDatabase.emitter.off("ready", listener);
-        reject(
-          new Error(
-            `MongoDatabase instance (${clientId}) failed to initialize within ${timeoutMs / 1e3}s. Check your connection logic.`
-          )
-        );
-      }, timeoutMs);
-      const listener = (db) => {
-        if (db.clientId === clientId) {
-          clearTimeout(timeout);
-          _MongoDatabase.emitter.off("ready", listener);
-          resolve(db);
-        }
-      };
-      _MongoDatabase.emitter.on("ready", listener);
-    });
-  }
-  /**
-   * Starts a new Mongo client session.
-   * @param options Options for the new session
-   * @param clientId [default: 0]
-   */
-  static async startSession(options, clientId) {
-    return (await _MongoDatabase.getReadyInstance(clientId))?.startSession(options);
-  }
-  constructor(client, options) {
-    this.client = client;
-    this.mongoose = new import_mongoose.default.Mongoose(options);
-    this.clientId = this.client.clientId;
-    _MongoDatabase.instances.set(this.clientId, this);
-  }
-  get connection() {
-    return this.mongoose.connection;
-  }
-  get isReady() {
-    return this.connection.readyState === import_mongoose.ConnectionStates.connected;
-  }
-  async waitForReady() {
-    if (!this.isReady && this.isConnecting) {
-      return new Promise((resolve) => _MongoDatabase.emitter.once("ready", (db) => resolve(db)));
-    }
-    return this;
-  }
-  async connect(uri, connectionOptions, options = {}) {
-    const { maxRetries = 3 } = options;
-    if (this.isReady) {
-      return true;
-    }
-    if (!this.isReady && this.isConnecting) {
-      return new Promise((resolve) => _MongoDatabase.emitter.once("ready", () => resolve(true)));
-    }
-    const connectionUri = uri ?? (this.client.config.app.devMode ? process.env.MONGO_URI_DEV : process.env.MONGO_URI);
-    options = { ...options, maxRetries: options.maxRetries ?? 3 };
-    if (!connectionUri) {
-      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.isConnecting = true;
-    try {
-      const stopLoader = this.client.logger.loader("Connecting to MongoDB...");
-      await import_qznt5.$.async.retry(() => this.mongoose.connect(connectionUri, { autoIndex: true, ...connectionOptions }), {
-        retries: maxRetries
-      });
-      _MongoDatabase.emitter.emit("ready", this);
-      stopLoader("Connected to MongoDB    ");
-    } catch (err) {
-      this.client.logger.error(`Failed to connect to MongoDB after ${maxRetries} attempt(s)`, err);
-    } finally {
-      this.isConnecting = false;
-    }
-    return true;
-  }
-  async disconnect() {
-    await this.mongoose.disconnect();
-  }
-  async startSession(options) {
-    return this.mongoose.startSession(options);
-  }
-  async useTransaction(fn) {
-    const session = await this.startSession();
-    session.startTransaction();
-    try {
-      await fn(session);
-      await session.commitTransaction();
-    } catch (err) {
-      await session.abortTransaction();
-      throw err;
-    } finally {
-      await session.endSession();
-    }
-  }
-};
-
-// src/db/mongo/mongoSchema.builder.ts
-var import_mongoose2 = require("mongoose");
-var import_qznt6 = require("qznt");
-try {
-  import("mongoose");
-} catch {
-  throw new Error("MongoSchemaBuilder requires the mongoose package, install it with `npm install mongoose`");
-}
-function createMongoSchema(collection, definition, options) {
-  return MongoSchemaBuilder.create(collection, definition, options);
-}
-function createMongoPlugin(plugin) {
-  return plugin;
-}
-var MongoSchemaBuilder = class _MongoSchemaBuilder {
-  static globalPlugins = [];
-  collection;
-  instanceId;
-  schema;
-  model = null;
-  db = null;
-  logger;
-  compilingModel = null;
-  static create(collection, definition, options) {
-    return new _MongoSchemaBuilder(collection, definition, options);
-  }
-  /**
-   * Registers a plugin globally to be used by all future schemas.
-   */
-  static use(plugin) {
-    this.globalPlugins.push(plugin);
-  }
-  constructor(collection, definition, options = {}) {
-    const { instanceId = 0, ...schemaOptions } = options;
-    this.instanceId = instanceId;
-    this.collection = collection;
-    this.schema = new import_mongoose2.Schema(definition, { versionKey: false, ...schemaOptions });
-    this.logger = new Logger({
-      prefixEmoji: "\u{1F96D}",
-      prefix: `MongoSchema (i${instanceId}) [${collection}]`,
-      colors: { primary: "#F29B58" }
-    });
-    for (const plugin of _MongoSchemaBuilder.globalPlugins) {
-      plugin(this);
-    }
-  }
-  async getModel() {
-    if (this.model) return this.model;
-    if (this.compilingModel) return this.compilingModel;
-    const fn = async () => {
-      this.db = await MongoDatabase.getReadyInstance(this.instanceId) || null;
-      if (!this.db) {
-        throw new Error(`MongoDatabase instance (${this.instanceId}) not found for schema ${this.collection}`);
-      }
-      this.model = this.db.mongoose.model(this.collection, this.schema);
-      if (this.db?.client.config.app.verbose) {
-        this.logger.debug(`Compiled! | ${this.db?.client.config.app.name}`);
-      }
-      this.compilingModel = null;
-      return this.model;
-    };
-    this.compilingModel = fn();
-    const res = await this.compilingModel;
-    return res;
-  }
-  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;
-  }
-  /**
-   * Registers a plugin to just this instance.
-   */
-  use(plugin) {
-    plugin(this);
-    return this;
-  }
-  /**
-   * Handles model resolution, connection ready, and retries.
-   * @param fn The function to execute
-   * @param maxRetries [default: 3]
-   */
-  async execute(fn, maxRetries = 3) {
-    return (0, import_qznt6.retry)(
-      async () => {
-        const model = await this.getModel();
-        return await fn(model);
-      },
-      { retries: maxRetries }
-    );
-  }
-  async startSession(options) {
-    return this.execute(async () => {
-      if (!this.db) throw new Error("No database instance found");
-      return await this.db.startSession(options);
-    });
-  }
-  async useTransaction(fn) {
-    return this.execute(async (model) => {
-      if (!this.db) throw new Error("No database instance found");
-      return await this.db.useTransaction((session) => fn(session, model));
-    });
-  }
-  async createUniqueId(collisionPath, fn, maxRetries = 10) {
-    return this.execute(async (model) => {
-      let id;
-      let tries = 0;
-      do {
-        if (tries >= maxRetries) throw new Error(`Failed to generate a unique ID after ${tries} attempt(s)`);
-        id = fn();
-        tries++;
-      } while (await model.exists({ [collisionPath]: id }));
-      return id;
-    });
-  }
-  async count(filter, options) {
-    return this.execute(async (model) => model.countDocuments(filter, options));
-  }
-  async exists(filter) {
-    return this.execute(async (model) => !!await model.exists(filter));
-  }
-  async create(query, options) {
-    return this.execute(async (model) => model.create(query, options));
-  }
-  async upsert(filter, query, options) {
-    return this.execute(
-      async (model) => model.findOneAndUpdate(filter, query, { returnDocument: "after", ...options, upsert: true })
-    );
-  }
-  async delete(filter, options) {
-    return this.execute(async (model) => model.deleteOne(filter, options));
-  }
-  async deleteAll(filter, options) {
-    return this.execute(async (model) => model.deleteMany(filter, options));
-  }
-  async distinct(key, filter, options) {
-    return this.execute(async (model) => model.distinct(key, filter, options));
-  }
-  async fetch(filter, projection, options) {
-    const result = await this.execute(
-      async (model) => model.findOne(filter, projection, { ...options, lean: options?.lean ?? true })
-    );
-    if (options?.required && !result) throw new Error("Document not found");
-    return result;
-  }
-  async fetchAll(filter = {}, projection, options) {
-    return this.execute(async (model) => model.find(filter, projection, { ...options, lean: options?.lean ?? true }));
-  }
-  async update(filter, update, options) {
-    return this.execute(
-      async (model) => model.findOneAndUpdate(filter, update, { ...options, lean: options?.lean ?? true })
-    );
-  }
-  async updateAll(filter, update, options) {
-    return this.execute(async (model) => model.updateMany(filter, update, options));
-  }
-  async aggregate(pipeline, options) {
-    return this.execute(async (model) => {
-      const result = await model.aggregate(pipeline, options);
-      return result?.length ? result : [];
-    });
-  }
-  async bulkWrite(ops, options) {
-    return this.execute(async (model) => model.bulkWrite(ops, options));
-  }
-  async bulkSave(docs, options) {
-    return this.execute(async (model) => model.bulkSave(docs, options));
-  }
-};
-
-// src/tools/BetterCollector.ts
-var CollectorTimeoutType = /* @__PURE__ */ ((CollectorTimeoutType2) => {
-  CollectorTimeoutType2[CollectorTimeoutType2["DisableComponents"] = 0] = "DisableComponents";
-  CollectorTimeoutType2[CollectorTimeoutType2["DeleteMessage"] = 1] = "DeleteMessage";
-  CollectorTimeoutType2[CollectorTimeoutType2["DoNothing"] = 2] = "DoNothing";
-  return CollectorTimeoutType2;
-})(CollectorTimeoutType || {});
-var BetterCollector = class _BetterCollector {
-  message;
-  collector;
-  options;
-  activeUsers = /* @__PURE__ */ new Set();
-  participantWarningCooldowns = /* @__PURE__ */ new Map();
-  config;
-  events = {
-    collectId: /* @__PURE__ */ new Map(),
-    collect: [],
-    end: [],
-    timeout: []
-  };
-  static create(message, options) {
-    return new _BetterCollector(message, options);
-  }
-  async validateParticipant(interaction, participants) {
-    const allowedParticipants = participants || this.options?.participants || [];
-    if (!allowedParticipants.length) return true;
-    const isAllowed = allowedParticipants.some((user) => {
-      if (typeof user === "string") return user === interaction.user.id;
-      if (typeof user === "object" && "id" in user) return user.id === interaction.user.id;
-      return false;
-    });
-    if (!isAllowed) {
-      const now = Date.now();
-      const lastWarned = this.participantWarningCooldowns.get(interaction.user.id) || 0;
-      if (now - lastWarned > this.config.collector.notAParticipantWarningCooldown) {
-        this.participantWarningCooldowns.set(interaction.user.id, now);
-        if (this.config.collector.notAParticipantMessage) {
-          await interaction.reply({
-            content: this.config.collector.notAParticipantMessage,
-            flags: "Ephemeral"
-          }).catch(() => {
-          });
-        } else {
-          await interaction.deferUpdate().catch(() => {
-          });
-        }
-      } else {
-        await interaction.deferUpdate().catch(() => {
-        });
-      }
-    }
-    return isAllowed;
-  }
-  build() {
-    if (!this.message) return;
-    if (this.collector) return;
-    this.collector = this.message.createMessageComponentCollector({
-      idle: this.options?.timeout ? void 0 : this.options?.idle ?? this.config.timeouts.collectorIdle,
-      time: this.options?.timeout ?? this.config.timeouts.collectorTimeout,
-      componentType: this.options?.type,
-      max: this.options?.max,
-      maxComponents: this.options?.maxComponents,
-      maxUsers: this.options?.maxUsers
-    });
-    this.setupListeners();
-  }
-  setupListeners() {
-    if (!this.collector) return;
-    this.collector.on("collect", async (interaction) => {
-      if (this.options?.userLock && this.activeUsers.has(interaction.user.id)) {
-        return interaction.reply({ content: this.config.collector.userLockMessage, flags: "Ephemeral" }).catch(() => {
-        });
-      }
-      if (this.options?.userLock) {
-        this.activeUsers.add(interaction.user.id);
-      }
-      const globalListeners = this.events.collect;
-      const idListeners = this.events.collectId.get(interaction.customId) || [];
-      const allListeners = [...globalListeners, ...idListeners];
-      const shouldBeDeferred = allListeners.find((l) => l.options?.defer)?.options?.defer;
-      const validListeners = [];
-      for (const listener of allListeners) {
-        const isAllowed = await this.validateParticipant(interaction, listener.options?.participants);
-        if (isAllowed) validListeners.push(listener);
-      }
-      if (validListeners.length === 0) return;
-      try {
-        if (shouldBeDeferred) {
-          if (typeof shouldBeDeferred === "object") {
-            if (shouldBeDeferred.update) {
-              await interaction.deferUpdate().catch(Boolean);
-            } else {
-              await interaction.deferReply({ flags: shouldBeDeferred.ephemeral ? "Ephemeral" : void 0 }).catch(Boolean);
-            }
-          } else {
-            await interaction.deferReply().catch(Boolean);
-          }
-        }
-        if (this.options?.sequential) {
-          for (const listener of allListeners) {
-            try {
-              const isAllowed = await this.validateParticipant(interaction, listener.options?.participants);
-              if (!isAllowed) return;
-              await listener.fn(interaction).finally(() => listener.options?.finally?.(interaction));
-            } catch (err) {
-              this.handleListenerError(err);
-            }
-          }
-        } else {
-          Promise.all(
-            allListeners.map((l) => {
-              const isAllowed = this.validateParticipant(interaction, l.options?.participants);
-              if (!isAllowed) return;
-              return l.fn(interaction).catch(this.handleListenerError).finally(() => l.options?.finally?.(interaction));
-            })
-          );
-        }
-      } finally {
-        if (this.options?.userLock) {
-          this.activeUsers.delete(interaction.user.id);
-        }
-      }
-    });
-    this.collector.on("end", async (collected, reason) => {
-      if (this.options?.sequential) {
-        for (const listener of this.events.end) {
-          try {
-            await listener.fn(collected, reason);
-          } catch (err) {
-            this.handleListenerError(err);
-          }
-        }
-      } else {
-        Promise.all(this.events.end.map((l) => l.fn(collected, reason).catch(this.handleListenerError)));
-      }
-      switch (this.options?.onTimeout) {
-        case 0 /* DisableComponents */:
-          if (!this.message?.editable) break;
-          try {
-            const disabledRows = this.message.components.map((row) => {
-              const updatedRow = row.toJSON();
-              if ("components" in updatedRow) {
-                updatedRow.components = updatedRow.components.map((component) => ({
-                  ...component,
-                  disabled: true
-                }));
-              }
-              return updatedRow;
-            });
-            await this.message.edit({ components: disabledRows });
-          } catch (err) {
-            if (!(err instanceof Error && err.message.includes("Unknown Message"))) {
-              this.handleListenerError(err);
-            }
-          }
-          break;
-        case 1 /* DeleteMessage */:
-          if (!this.message?.deletable) break;
-          await this.message.delete().catch(Boolean);
-          break;
-        case 2 /* DoNothing */:
-        default:
-          break;
-      }
-    });
-  }
-  handleListenerError(err) {
-    console.error("[BetterCollector] Listener Error:", err);
-  }
-  constructor(message, options = {}) {
-    this.config = options.config ? createToolsConfig(options.config) : globalToolsConfig;
-    this.message = message || void 0;
-    this.options = options;
-    this.build();
-  }
-  on(idOrFunc, fnOrOptions, options) {
-    let finalFn;
-    let finalOptions;
-    let customId;
-    if (typeof idOrFunc === "function") {
-      finalFn = idOrFunc;
-      finalOptions = fnOrOptions;
-    } else {
-      if (typeof fnOrOptions !== "function") {
-        throw new Error("[BetterCollector] Second argument must be a function when a customId is provided.");
-      }
-      customId = idOrFunc;
-      finalFn = fnOrOptions;
-      finalOptions = options;
-    }
-    if (customId) {
-      const listeners = this.events.collectId.get(customId) || [];
-      listeners.push({ fn: finalFn, options: finalOptions });
-      this.events.collectId.set(customId, listeners);
-    } else {
-      this.events.collect.push({ fn: finalFn, options: finalOptions });
-    }
-    return this;
-  }
-  onEnd(fn, options) {
-    this.events.end.push({ fn, options });
-    return this;
-  }
-  /** Manually stop the collector and trigger cleanup */
-  stop(reason = "manual") {
-    this.collector?.stop(reason);
-  }
-};
-
-// src/tools/BetterContainer.ts
-var import_discord12 = require("discord.js");
-var BetterContainer = class {
-  container = new import_discord12.ContainerBuilder();
-  data;
-  config;
-  constructor(data = {}) {
-    this.config = data.config ? createToolsConfig(data.config) : globalToolsConfig;
-    this.data = {
-      color: data.color ?? (this.config.devMode ? this.config.embedColorDev : this.config.embedColor),
-      ...data
-    };
-    this.build();
-  }
-  configure() {
-    if (this.data.color !== void 0) {
-      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();
-  }
-  setColor(color) {
-    this.data.color = color;
-    return this;
-  }
-  clearColor() {
-    this.data.color = null;
-    return this;
-  }
-  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.filter((t) => t !== null && t !== void 0).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.filter((t) => t !== null && t !== void 0).join("\n") : data.text
-          )
-        );
-      }
-      if (data.thumbnail) sb.setThumbnailAccessory(new import_discord12.ThumbnailBuilder(data.thumbnail));
-      if (data.button) sb.setButtonAccessory(new import_discord12.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_discord13 = require("discord.js");
-var DEFAULT_CONFIG = {
-  timeout: 6e4
-};
-function createRandomId() {
-  return `v-${Math.random().toString(36).split(".")[1]}`;
-}
-var BetterModal = class _BetterModal {
-  customId;
-  components = /* @__PURE__ */ new Map();
-  labelComponents = [];
-  modal;
-  constructor(options) {
-    this.customId = options?.customId ?? createRandomId();
-    this.modal = new import_discord13.ModalBuilder().setCustomId(this.customId);
-    if (options?.title) this.setTitle(options.title);
-    if (options?.components?.length) this.addComponents(...options.components);
-  }
-  validateComponentLength() {
-    if ((this.components.size ?? 0) >= 25) {
-      throw new Error("[BetterModal] Modal can only have 25 components");
-    }
-  }
-  createComponentId() {
-    return `${this.customId}:${createRandomId()}`;
-  }
-  createLabelComponent(data) {
-    const component = new import_discord13.LabelBuilder().setLabel(data.label);
-    if (data.description) component.setDescription(data.description);
-    return component;
-  }
-  build() {
-    if (!this.modal.data.title) throw new Error("[BetterModal] Modal must have a title");
-    this.modal.setLabelComponents(this.labelComponents);
-    return this.modal;
-  }
-  clone() {
-    return new _BetterModal({
-      customId: this.customId,
-      title: this.modal.data.title,
-      components: Array.from(this.components.values())
-    });
-  }
-  toJSON() {
-    return this.build().toJSON();
-  }
-  /**
-   * Sets the title of the modal.
-   * @param title The title of the modal.
-   */
-  setTitle(title) {
-    this.modal.setTitle(title);
-    return this;
-  }
-  /** Sets components for the modal. */
-  setComponents(...components) {
-    this.components.clear();
-    this.labelComponents = [];
-    this.addComponents(...components);
-    return this;
-  }
-  /** Adds components to the modal. */
-  addComponents(...components) {
-    for (const component of components) {
-      if ("textInput" in component) {
-        this.addTextInput(component.textInput);
-      } else if ("checkbox" in component) {
-        this.addCheckbox(component.checkbox);
-      } else if ("checkboxGroup" in component) {
-        this.addCheckboxGroup(component.checkboxGroup);
-      } else if ("radioGroup" in component) {
-        this.addRadioGroup(component.radioGroup);
-      } 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;
-  }
-  addTextInput(data) {
-    this.validateComponentLength();
-    const customId = data.customId ?? this.createComponentId();
-    const { label: _, ...textInputData } = data;
-    const textInput = new import_discord13.TextInputBuilder({ style: import_discord13.TextInputStyle.Short, required: false, ...textInputData, customId });
-    const label = this.createLabelComponent(data);
-    label.setTextInputComponent(textInput);
-    this.components.set(customId, { textInput: data });
-    this.labelComponents.push(label);
-    return this;
-  }
-  addStringSelect(data) {
-    this.validateComponentLength();
-    const customId = data.customId ?? this.createComponentId();
-    const select = new import_discord13.StringSelectMenuBuilder({ ...data, customId });
-    const label = this.createLabelComponent(data);
-    label.setStringSelectMenuComponent(select);
-    this.components.set(customId, { stringSelect: data });
-    this.labelComponents.push(label);
-    return this;
-  }
-  addCheckbox(data) {
-    this.validateComponentLength();
-    const customId = data.custom_id ?? this.createComponentId();
-    const checkbox = new import_discord13.CheckboxBuilder({ ...data, custom_id: customId });
-    const label = this.createLabelComponent(data);
-    label.setCheckboxComponent(checkbox);
-    this.components.set(customId, { checkbox: data });
-    this.labelComponents.push(label);
-    return this;
-  }
-  addCheckboxGroup(data) {
-    this.validateComponentLength();
-    const customId = data.custom_id ?? this.createComponentId();
-    const checkboxGroup = new import_discord13.CheckboxGroupBuilder({ ...data, custom_id: customId });
-    const label = this.createLabelComponent(data);
-    label.setCheckboxGroupComponent(checkboxGroup);
-    this.components.set(customId, { checkboxGroup: data });
-    this.labelComponents.push(label);
-    return this;
-  }
-  addRadioGroup(data) {
-    this.validateComponentLength();
-    const customId = data.custom_id ?? this.createComponentId();
-    const radioGroup = new import_discord13.RadioGroupBuilder({ ...data, custom_id: customId });
-    const label = this.createLabelComponent(data);
-    label.setRadioGroupComponent(radioGroup);
-    this.components.set(customId, { radioGroup: data });
-    this.labelComponents.push(label);
-    return this;
-  }
-  addChannelSelect(data) {
-    this.validateComponentLength();
-    const customId = data.customId ?? this.createComponentId();
-    const channelSelect = new import_discord13.ChannelSelectMenuBuilder({ ...data, customId });
-    const label = this.createLabelComponent(data);
-    label.setChannelSelectMenuComponent(channelSelect);
-    this.components.set(customId, { channelSelect: data });
-    this.labelComponents.push(label);
-    return this;
-  }
-  addUserSelect(data) {
-    this.validateComponentLength();
-    const customId = data.customId ?? this.createComponentId();
-    const userSelect = new import_discord13.UserSelectMenuBuilder({ ...data, customId });
-    const label = this.createLabelComponent(data);
-    label.setUserSelectMenuComponent(userSelect);
-    this.components.set(customId, { userSelect: data });
-    this.labelComponents.push(label);
-    return this;
-  }
-  addRoleSelect(data) {
-    this.validateComponentLength();
-    const customId = data.customId ?? this.createComponentId();
-    const roleSelect = new import_discord13.RoleSelectMenuBuilder({ ...data, customId });
-    const label = this.createLabelComponent(data);
-    label.setRoleSelectMenuComponent(roleSelect);
-    this.components.set(customId, { roleSelect: data });
-    this.labelComponents.push(label);
-    return this;
-  }
-  addMentionableSelect(data) {
-    this.validateComponentLength();
-    const customId = data.customId ?? this.createComponentId();
-    const mentionableSelect = new import_discord13.MentionableSelectMenuBuilder({ ...data, customId });
-    const label = this.createLabelComponent(data);
-    label.setMentionableSelectMenuComponent(mentionableSelect);
-    this.components.set(customId, { mentionableSelect: data });
-    this.labelComponents.push(label);
-    return this;
-  }
-  addFileUpload(data) {
-    this.validateComponentLength();
-    const customId = data.custom_id ?? this.createComponentId();
-    const fileUpload = new import_discord13.FileUploadBuilder({ ...data, custom_id: customId });
-    const label = this.createLabelComponent(data);
-    label.setFileUploadComponent(fileUpload);
-    this.components.set(customId, { fileUpload: data });
-    this.labelComponents.push(label);
-    return this;
-  }
-  /**
-   * Shows the modal to the user via interaction.
-   * @param interaction The command interaction to show the modal with.
-   * @param options Modal options.
-   */
-  async show(interaction, options) {
-    if (!interaction) throw new Error("[BetterModal] Interaction is null or undefined");
-    const modal = this.build();
-    await interaction.showModal(modal, options);
-  }
-  /**
-   * Shows the modal and waits for it to be submitted.
-   * @param interaction The interaction to show the modal with.
-   * @param options Modal submission options.
-   */
-  async showAndAwait(interaction, options) {
-    await this.show(interaction);
-    return this.awaitSubmit(interaction, options);
-  }
-  /**
-   * Waits for this modal to be submitted, returning a helper utility object.
-   * @param interaction The interaction to show the modal with.
-   * @param options Modal submission options.
-   */
-  async awaitSubmit(interaction, options) {
-    if (!interaction) throw new Error("[BetterModal] Interaction is null or undefined");
-    const timeout = options?.timeout ?? DEFAULT_CONFIG.timeout;
-    try {
-      const modalSubmit = await interaction.awaitModalSubmit({
-        filter: (i) => i.customId === this.customId,
-        time: timeout
-      });
-      if (options?.deferUpdate) {
-        await modalSubmit.deferUpdate();
-      }
-      const fields = /* @__PURE__ */ new Map();
-      const values = [];
-      for (const customId of this.components.keys()) {
-        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.set(customId, value);
-        values.push(value);
-      }
-      return {
-        values,
-        interaction: modalSubmit,
-        getField: (customId) => fields.get(customId),
-        reply: (options2) => dynaSend(modalSubmit, options2),
-        followUp: async (options2) => dynaSend(modalSubmit, options2),
-        deferUpdate: () => modalSubmit.deferUpdate()
-      };
-    } catch {
-      return null;
-    }
-  }
-};
-
-// src/tools/Paginator.ts
-var import_discord14 = 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";
-  PaginationTimeoutType2[PaginationTimeoutType2["DoNothing"] = 3] = "DoNothing";
-  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_discord14.ButtonBuilder({ customId: `btn_${id}`, style: import_discord14.ButtonStyle.Secondary });
-  if (data.label) {
-    btn.setLabel(data.label);
-  } else {
-    btn.setEmoji(data.emoji.name);
-  }
-  return btn;
-}
-function isEmbed(item) {
-  return item instanceof import_discord14.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 ? createToolsConfig(options.config) : globalToolsConfig;
-    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_discord14.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_discord14.ActionRowBuilder(),
-          navigation: new import_discord14.ActionRowBuilder()
-        }
-      }
-    };
-    this.data.components.actionRows.chapterSelect.setComponents(this.data.components.chapterSelect);
-    this.events = {
-      beforeChapterChange: [],
-      chapterChange: [],
-      beforePageChange: [],
-      pageChange: [],
-      first: [],
-      back: [],
-      jump: [],
-      next: [],
-      last: [],
-      collect: [],
-      react: [],
-      preTimeout: [],
-      postTimeout: []
-    };
-    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: [],
-      files: [],
-      // Explicitly empty to clear previous files on page switch
-      ...options,
-      withResponse: true
-    };
-    const page = this.data.page.current;
-    const currentChapter = this.chapters[this.data.page.index.chapter];
-    const chapterFile = currentChapter?.files?.[this.data.page.index.nested];
-    if (chapterFile) sendOptions.files.push(chapterFile);
-    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_discord14.AttachmentBuilder) {
-      sendOptions.files.push(page);
-    } else if (page instanceof import_discord14.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("preTimeout", 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_discord14.ActionRowBuilder.from(this.data.components.actionRows.navigation).setComponents(
-          disabledNavComponents
-        );
-        const newComponents = [];
-        const currentPage = this.data.page.current;
-        if (currentPage instanceof import_discord14.ContainerBuilder || currentPage instanceof BetterContainer) {
-          newComponents.push(currentPage);
-        }
-        if (this.chapters.length > 1) {
-          const disabledSelect = import_discord14.StringSelectMenuBuilder.from(this.data.components.chapterSelect).setDisabled(
-            true
-          );
-          newComponents.push(
-            import_discord14.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;
-      case 3 /* DoNothing */:
-        break;
-    }
-    this.callEventStack("postTimeout", this.data.message);
-  }
-  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_discord14.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) 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;
-        }
-        switch (i.customId) {
-          case "ssm_chapterSelect":
-            await i.deferUpdate().catch(Boolean);
-            const chapterIndex = this.chapters.findIndex(
-              (c) => c.id === i.values[0]
-            );
-            await this.setPage(chapterIndex, 0);
-            await this.refresh();
-            break;
-          case "btn_first":
-            await i.deferUpdate().catch(Boolean);
-            this.callEventStack("first", this.data.page.current, this.data.page.index);
-            await this.setPage(this.data.page.index.chapter, 0);
-            await this.refresh();
-            break;
-          case "btn_back":
-            await i.deferUpdate().catch(Boolean);
-            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);
-            await this.refresh();
-            break;
-          case "btn_next":
-            await i.deferUpdate().catch(Boolean);
-            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);
-            await this.refresh();
-            break;
-          case "btn_last":
-            await i.deferUpdate().catch(Boolean);
-            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
-            );
-            await this.refresh();
-            break;
-        }
-      } 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, files: data.files });
-    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_discord15 = 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;
-  textOnly;
-  buttons;
-  customButtons;
-  onResolve;
-  timeout;
-  config;
-  message = null;
-  constructor(options = {}) {
-    this.config = options.config ? createToolsConfig(options.config) : globalToolsConfig;
-    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.textOnly = options.textOnly;
-    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_discord15.ButtonStyle.Success
-    );
-    const reject = this.buildButton(
-      buttonOptions?.reject,
-      "btn_reject",
-      this.config.prompt.rejectLabel,
-      import_discord15.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_discord15.ButtonStyle.Primary);
-      map.set(customId, { button, handler, index });
-    }
-    return map;
-  }
-  buildButton(option, customId, defaultLabel, defaultStyle) {
-    if (typeof option === "function") {
-      return option(new import_discord15.ButtonBuilder());
-    }
-    if (option instanceof import_discord15.ButtonBuilder) {
-      return option;
-    }
-    return new import_discord15.ButtonBuilder({
-      customId,
-      label: defaultLabel,
-      style: defaultStyle,
-      ...option
-    });
-  }
-  buildActionRow(disable = {}) {
-    const confirmBtn = disable.confirm ? new import_discord15.ButtonBuilder(this.buttons.confirm.data).setDisabled(true) : this.buttons.confirm;
-    const rejectBtn = disable.reject ? new import_discord15.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_discord15.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_discord15.ActionRowBuilder({ components: buttons });
-  }
-  buildSendOptions(options) {
-    const sendData = { ...options };
-    if (!this.textOnly && 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 {
-      if (!this.textOnly) {
-        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_discord15.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();
-}
+__reExport(index_exports, require("@vimcord/core"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BaseCommandBuilder,
-  BaseCommandManager,
-  BetterCollector,
-  BetterContainer,
-  BetterEmbed,
-  BetterModal,
-  CLI,
-  CollectorTimeoutType,
-  CommandManager,
-  CommandType,
-  ContextCommandBuilder,
-  ContextCommandManager,
-  DEFAULT_MODULE_SUFFIXES,
-  DynaSend,
-  ErrorHandler,
-  EventBuilder,
-  EventManager,
-  LOGGER_COLORS,
-  LogLevel,
-  Logger,
-  MissingPermissionReason,
-  ModuleImporter,
-  MongoDatabase,
-  MongoSchemaBuilder,
-  PaginationTimeoutType,
-  PaginationType,
-  Paginator,
-  PrefixCommandBuilder,
-  PrefixCommandManager,
-  Prompt,
-  PromptResolveType,
-  RateLimitScope,
-  SendMethod,
-  SlashCommandBuilder,
-  SlashCommandManager,
-  StatusManager,
-  StatusType,
-  Vimcord,
-  VimcordCLI,
-  VimcordErrorHandler,
-  __zero,
-  cleanMention,
-  clientLoggerFactory,
-  configSetters,
-  contextCommandHandler,
-  createAppConfig,
-  createClient,
-  createConfigFactory,
-  createContextCommandConfig,
-  createMongoPlugin,
-  createMongoSchema,
-  createPrefixCommandConfig,
-  createSlashCommandConfig,
-  createStaffConfig,
-  createToolsConfig,
-  createVimcordStatusConfig,
-  deepMerge,
-  defineClientOptions,
-  defineGlobalToolsConfig,
-  defineVimcordConfig,
-  defineVimcordFeatures,
-  dynaSend,
-  fetchChannel,
-  fetchGuild,
-  fetchMember,
-  fetchMessage,
-  fetchRole,
-  fetchUser,
-  getDevMode,
-  getFirstMentionId,
-  getMessageMention,
-  getPackageJson,
-  globalToolsConfig,
-  importModulesFromDir,
-  isMentionOrSnowflake,
-  logger,
-  moduleImporters,
-  prefixCommandHandler,
-  prompt,
-  sendCommandErrorEmbed,
-  slashCommandHandler,
-  useClient,
-  useReadyClient,
-  validateCommandPermissions
+  ...require("@vimcord/core")
 });
-//# sourceMappingURL=index.cjs.map