djs-next 0.0.1

package/dist/index.js

@@ -0,0 +1,1283 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DJSNextClient: () => DJSNextClient,
+  PaginationBuilder: () => PaginationBuilder,
+  confirmPrompt: () => confirmPrompt,
+  defineConfig: () => defineConfig,
+  getLocalesCache: () => getLocalesCache,
+  loadConfig: () => loadConfig,
+  loadLocales: () => loadLocales,
+  paginate: () => paginate,
+  translate: () => translate
+});
+module.exports = __toCommonJS(index_exports);
+var import_config = require("dotenv/config");
+
+// src/client.ts
+var import_discord4 = require("discord.js");
+
+// src/handlers/commandHandler.ts
+var import_discord = require("discord.js");
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_url = require("url");
+
+// src/handlers/utils.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+function getAllFiles(dirPath, arrayOfFiles = []) {
+  const files = import_fs.default.readdirSync(dirPath);
+  files.forEach((file) => {
+    const fullPath = import_path.default.join(dirPath, file);
+    if (import_fs.default.statSync(fullPath).isDirectory()) {
+      arrayOfFiles = getAllFiles(fullPath, arrayOfFiles);
+    } else {
+      if (file.endsWith(".js") || file.endsWith(".ts") || file.endsWith(".mjs") || file.endsWith(".cjs")) {
+        if (!file.endsWith(".d.ts")) {
+          arrayOfFiles.push(fullPath);
+        }
+      }
+    }
+  });
+  return arrayOfFiles;
+}
+
+// src/handlers/commandHandler.ts
+async function loadAndDeployCommands(commandsDir, token, clientId, guildId) {
+  const flatCommands = new import_discord.Collection();
+  if (!import_fs2.default.existsSync(commandsDir)) {
+    console.warn(`[djs-next] Commands directory "${commandsDir}" does not exist.`);
+    return flatCommands;
+  }
+  const commandFiles = getAllFiles(commandsDir);
+  const rootNodes = /* @__PURE__ */ new Map();
+  function getOrCreateNode(pathParts) {
+    let currentMap = rootNodes;
+    let currentNode;
+    for (const part of pathParts) {
+      if (!currentMap.has(part)) {
+        currentMap.set(part, {
+          name: part,
+          description: `${part} command`,
+          // Fallback description
+          options: [],
+          children: /* @__PURE__ */ new Map()
+        });
+      }
+      currentNode = currentMap.get(part);
+      currentMap = currentNode.children;
+    }
+    return currentNode;
+  }
+  for (const file of commandFiles) {
+    const relativePath = import_path2.default.relative(commandsDir, file);
+    const parsed = import_path2.default.parse(relativePath);
+    const dirParts = parsed.dir ? parsed.dir.split(import_path2.default.sep) : [];
+    const name = parsed.name;
+    const pathParts = [...dirParts];
+    if (name !== "index") {
+      pathParts.push(name);
+    }
+    if (pathParts.length === 0) continue;
+    if (pathParts.length > 3) {
+      console.warn(`[djs-next] Command path too deep (Discord allows max 3 levels): ${relativePath}`);
+      continue;
+    }
+    const module2 = await import((0, import_url.pathToFileURL)(file).href);
+    const commandData = module2.default || module2.command || module2;
+    if (commandData) commandData.filepath = file;
+    const node = getOrCreateNode(pathParts);
+    if (commandData.description) node.description = commandData.description;
+    if (commandData.options) node.options = commandData.options;
+    if (commandData.execute) {
+      node.execute = commandData.execute;
+      flatCommands.set(pathParts.join(" "), commandData);
+    }
+  }
+  function buildCommandJSON(node, depth) {
+    const json = {
+      name: node.name,
+      description: node.description
+    };
+    if (node.children.size > 0) {
+      json.options = [];
+      for (const [_, childNode] of node.children) {
+        const childJson = buildCommandJSON(childNode, depth + 1);
+        if (depth === 0) {
+          childJson.type = childNode.children.size > 0 ? 2 : 1;
+        } else if (depth === 1) {
+          childJson.type = 1;
+        }
+        json.options.push(childJson);
+      }
+    } else if (node.options && node.options.length > 0) {
+      json.options = node.options;
+    }
+    return json;
+  }
+  const commandsData = Array.from(rootNodes.values()).map((node) => buildCommandJSON(node, 0));
+  const rest = new import_discord.REST({ version: "10" }).setToken(token);
+  try {
+    console.log(`[djs-next] Started refreshing ${commandsData.length} File-System application (/) commands.`);
+    let data;
+    if (guildId) {
+      data = await rest.put(
+        import_discord.Routes.applicationGuildCommands(clientId, guildId),
+        { body: commandsData }
+      );
+    } else {
+      data = await rest.put(
+        import_discord.Routes.applicationCommands(clientId),
+        { body: commandsData }
+      );
+    }
+    console.log(`[djs-next] Successfully reloaded ${data.length} File-System application (/) commands.`);
+  } catch (error) {
+    console.error(`[djs-next] Failed to deploy commands:`, error);
+  }
+  return flatCommands;
+}
+
+// src/handlers/eventHandler.ts
+var import_fs3 = __toESM(require("fs"));
+var import_url2 = require("url");
+async function loadEvents(client2, eventsDir) {
+  if (!import_fs3.default.existsSync(eventsDir)) {
+    console.warn(`[djs-next] Events directory "${eventsDir}" does not exist.`);
+    return;
+  }
+  const eventFiles = getAllFiles(eventsDir);
+  let loadedEvents = 0;
+  for (const file of eventFiles) {
+    const eventModule = await import((0, import_url2.pathToFileURL)(file).href);
+    const eventData = eventModule.default?.event || eventModule.event || eventModule.default || eventModule;
+    if (eventData) eventData.filepath = file;
+    if (!eventData || !eventData.name || !eventData.execute) {
+      console.warn(`[djs-next] The event at ${file} is missing a required "name" or "execute" property.`);
+      continue;
+    }
+    if (eventData.once) {
+      client2.once(eventData.name, (...args2) => eventData.execute(client2, ...args2));
+    } else {
+      client2.on(eventData.name, (...args2) => eventData.execute(client2, ...args2));
+    }
+    loadedEvents++;
+  }
+  if (loadedEvents > 0) {
+    console.log(`[djs-next] Successfully loaded ${loadedEvents} events.`);
+  }
+}
+
+// src/handlers/componentHandler.ts
+var import_discord2 = require("discord.js");
+var import_fs4 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_url3 = require("url");
+async function loadComponents(componentsDir) {
+  const components2 = new import_discord2.Collection();
+  if (!import_fs4.default.existsSync(componentsDir)) return components2;
+  const files = getAllFiles(componentsDir);
+  for (const file of files) {
+    const module2 = await import((0, import_url3.pathToFileURL)(file).href);
+    const componentData = module2.default || module2.component || module2;
+    if (componentData) componentData.filepath = file;
+    if (!componentData || !componentData.execute) continue;
+    const parsed = import_path3.default.parse(file);
+    const customId = componentData.customId || parsed.name;
+    components2.set(customId, componentData);
+  }
+  console.log(`[djs-next] Successfully loaded ${components2.size} components.`);
+  return components2;
+}
+
+// src/handlers/taskHandler.ts
+var import_fs5 = __toESM(require("fs"));
+var import_url4 = require("url");
+async function loadTasks(client2, tasksDir) {
+  if (!import_fs5.default.existsSync(tasksDir)) return;
+  const files = getAllFiles(tasksDir);
+  let loaded = 0;
+  for (const file of files) {
+    const module2 = await import((0, import_url4.pathToFileURL)(file).href);
+    const taskData = module2.default || module2.task || module2;
+    if (taskData) taskData.filepath = file;
+    if (!taskData || !taskData.interval || !taskData.execute) continue;
+    const intervalId = setInterval(async () => {
+      try {
+        await taskData.execute(client2);
+      } catch (error) {
+        console.error(`[djs-next] Background Task error at ${file}:`, error);
+      }
+    }, taskData.interval);
+    if (!client2._activeTasks) client2._activeTasks = /* @__PURE__ */ new Map();
+    client2._activeTasks.set(file, intervalId);
+    loaded++;
+  }
+  if (loaded > 0) {
+    console.log(`[djs-next] Successfully scheduled ${loaded} background tasks.`);
+  }
+}
+
+// src/client.ts
+var import_path6 = __toESM(require("path"));
+var import_fs8 = __toESM(require("fs"));
+var import_url6 = require("url");
+
+// src/utils/configLoader.ts
+var import_path4 = __toESM(require("path"));
+var import_fs6 = __toESM(require("fs"));
+var import_url5 = require("url");
+async function loadConfig() {
+  const exts = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+  const cwd = process.cwd();
+  for (const ext of exts) {
+    const configPath = import_path4.default.join(cwd, `djs-next.config${ext}`);
+    if (import_fs6.default.existsSync(configPath)) {
+      try {
+        const configModule = await import((0, import_url5.pathToFileURL)(configPath).href);
+        return configModule.default || configModule;
+      } catch (err) {
+        console.error(`[djs-next] Error loading config file ${configPath}:`, err);
+        return {};
+      }
+    }
+  }
+  return {};
+}
+function defineConfig(config2) {
+  return config2;
+}
+
+// src/utils/i18n.ts
+var import_fs7 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+var localesCache = {};
+var defaultLoc = "en";
+function loadLocales(localesDir, defaultLocale) {
+  if (defaultLocale) defaultLoc = defaultLocale;
+  if (!import_fs7.default.existsSync(localesDir)) return;
+  const files = import_fs7.default.readdirSync(localesDir);
+  for (const file of files) {
+    if (file.endsWith(".json")) {
+      const lang = file.replace(".json", "");
+      const content2 = import_fs7.default.readFileSync(import_path5.default.join(localesDir, file), "utf8");
+      try {
+        localesCache[lang] = JSON.parse(content2);
+      } catch (e) {
+        console.error(`[djs-next] Failed to parse locale file: ${file}`, e);
+      }
+    }
+  }
+}
+function translate(key, locale = defaultLoc, variables) {
+  const dict = localesCache[locale] || localesCache[defaultLoc] || {};
+  const keys = key.split(".");
+  let value = dict;
+  for (const k of keys) {
+    if (value && typeof value === "object") {
+      value = value[k];
+    } else {
+      value = void 0;
+      break;
+    }
+  }
+  if (typeof value !== "string") {
+    return key;
+  }
+  if (variables) {
+    for (const [varKey, varValue] of Object.entries(variables)) {
+      value = value.replace(new RegExp(`{{s*${varKey}s*}}`, "g"), String(varValue));
+    }
+  }
+  return value;
+}
+function getLocalesCache() {
+  return localesCache;
+}
+
+// src/plugins/dnxt.ts
+var import_discord3 = require("discord.js");
+var import_child_process = require("child_process");
+var import_util = __toESM(require("util"));
+var import_os = __toESM(require("os"));
+var execAsync = import_util.default.promisify(import_child_process.exec);
+function buildDisplayMessage(content2, color = 5397233) {
+  const djs = require("discord.js");
+  const container = new djs.ContainerBuilder().setAccentColor(color).addTextDisplayComponents(
+    new djs.TextDisplayBuilder().setContent(content2)
+  );
+  return { components: [container], flags: 32768 };
+}
+async function handleDNXT(message, client, devPrefix) {
+  if (message.author.bot) return;
+  if (!client._developers.includes(message.author.id)) return;
+  if (client.config?.devGuildId && message.guildId !== client.config.devGuildId) return;
+  const originalReply = message.reply.bind(message);
+  message.reply = (async (content2) => {
+    if (typeof content2 === "string") {
+      return await originalReply({ ...buildDisplayMessage(content2), allowedMentions: { repliedUser: false } });
+    }
+    if (!content2.allowedMentions) content2.allowedMentions = { repliedUser: false };
+    return await originalReply(content2);
+  });
+  const content = message.content.trim();
+  const validTriggers = [devPrefix];
+  const clientPrefixes = client._prefixes || [];
+  for (const p of clientPrefixes) {
+    if (p !== "") validTriggers.push(`${p}${devPrefix}`);
+  }
+  let matchedTrigger = validTriggers.find((t) => content === t || content.startsWith(`${t} `));
+  if (!matchedTrigger) return;
+  const args = content.slice(matchedTrigger.length).trim().split(/ +/g);
+  const command = args.shift()?.toLowerCase();
+  if (command === "help") {
+    const djs = require("discord.js");
+    const container = new djs.ContainerBuilder().setAccentColor(5397233).addTextDisplayComponents(
+      new djs.TextDisplayBuilder().setContent(`# \u{1F4D6} DNXT Toolkit Reference
+> Current prefix trigger: \`${matchedTrigger}\``)
+    ).addSeparatorComponents(new djs.SeparatorBuilder()).addTextDisplayComponents(
+      new djs.TextDisplayBuilder().setContent(`### \u{1F4CA} Core Framework
+- \`${matchedTrigger}\` \u2014 Developer system dashboard
+- \`${matchedTrigger} help\` \u2014 Shows this reference menu`),
+      new djs.TextDisplayBuilder().setContent(`### \u{1F4BB} Execution & Diagnostics
+- \`${matchedTrigger} js <code>\` \u2014 Evaluates raw JS code
+- \`${matchedTrigger} sh <cmd>\` \u2014 Runs terminal shell script
+- \`${matchedTrigger} debug <code>\` \u2014 Evaluates JS with precise memory deltas`),
+      new djs.TextDisplayBuilder().setContent(`### \u{1F4C2} File System & Network
+- \`${matchedTrigger} cat <file>\` \u2014 Reads file contents
+- \`${matchedTrigger} curl <url>\` \u2014 Fetches remote URL data
+- \`${matchedTrigger} git <cmd>\` \u2014 Executes git repository commands`),
+      new djs.TextDisplayBuilder().setContent(`### \u{1F9F0} Utilities
+- \`${matchedTrigger} <load|unload|reload> <target>\` \u2014 Manages system modules
+- \`${matchedTrigger} sync\` \u2014 Forces global slash command sync
+- \`${matchedTrigger} in <channel> <cmd>\` \u2014 Executes command in target channel
+- \`${matchedTrigger} restart\` \u2014 Restarts the bot completely
+- \`${matchedTrigger} shutdown\` \u2014 Stops the bot completely`)
+    );
+    await message.reply({ components: [container], flags: 32768, allowedMentions: { repliedUser: false } });
+    return;
+  }
+  if (!command) {
+    const mem = process.memoryUsage();
+    const botPing = client.ws.ping;
+    const djs = require("discord.js");
+    const container = new djs.ContainerBuilder().setAccentColor(5397233).addTextDisplayComponents(
+      new djs.TextDisplayBuilder().setContent(`# \u{1F6E0}\uFE0F Developer System Dashboard
+> **DNXT Framework Engine**`)
+    ).addSeparatorComponents(new djs.SeparatorBuilder()).addTextDisplayComponents(
+      new djs.TextDisplayBuilder().setContent(`### \u{1F4E1} Network Status
+- **System Uptime:** <t:${Math.floor((Date.now() - client.uptime) / 1e3)}:R>
+- **WebSocket Latency:** \`${botPing}ms\``),
+      new djs.TextDisplayBuilder().setContent(`### \u{1F4E6} Host Environment
+- **Discord.js Library:** \`v${import_discord3.version}\`
+- **Node.js Runtime:** \`${process.version}\`
+- **Operating System:** \`${import_os.default.type()}\` (\`${import_os.default.cpus().length}\` thread cores, \`${(import_os.default.uptime() / 60 / 60).toFixed(2)}\` hrs uptime)`),
+      new djs.TextDisplayBuilder().setContent(`### \u{1F9E0} Resource Utilization
+- **Physical Memory:** \`${(mem.rss / 1024 / 1024).toFixed(2)} MB\`
+- **Heap Allocated:** \`${(mem.heapUsed / 1024 / 1024).toFixed(2)} MB\``)
+    );
+    await message.reply({
+      components: [container],
+      flags: 32768,
+      // MessageFlags.IsComponentsV2
+      allowedMentions: { repliedUser: false }
+    });
+    return;
+  }
+  if (command === "js" || command === "eval" || command === "py") {
+    let code = args.join(" ");
+    if (code.startsWith("```js") || code.startsWith("```py")) code = code.replace(/^```[a-z]*|```$/g, "");
+    else if (code.startsWith("```")) code = code.replace(/^```|```$/g, "");
+    if (!code) return void await message.reply("\u274C Please provide code to evaluate.");
+    try {
+      const start = process.hrtime.bigint();
+      const { commands, components, config } = client;
+      let evaled = await eval(`(async () => { ${code} })()`);
+      const end = process.hrtime.bigint();
+      const timeMs = Number(end - start) / 1e6;
+      if (typeof evaled !== "string") evaled = import_util.default.inspect(evaled, { depth: 1, colors: true });
+      await sendPaginatedText(message, `\u2705 **Evaluated in ${timeMs.toFixed(3)}ms**
+`, evaled, "ansi");
+    } catch (err) {
+      await sendPaginatedText(message, `\u274C **Evaluation Error**
+`, err.message, "ansi");
+    }
+    return;
+  }
+  if (command === "sh" || command === "shell" || command === "git") {
+    const cmd = command === "git" ? "git " + args.join(" ") : args.join(" ");
+    if (!cmd) return void await message.reply("\u274C Please provide a command to execute.");
+    try {
+      const start2 = process.hrtime.bigint();
+      let stdout = "", stderr = "", code2 = 0;
+      try {
+        const result = await execAsync(cmd);
+        stdout = result.stdout;
+        stderr = result.stderr;
+      } catch (err) {
+        stdout = err.stdout || "";
+        stderr = err.stderr || err.message || "";
+        code2 = err.code || 1;
+      }
+      const end2 = process.hrtime.bigint();
+      const timeMs2 = Number(end2 - start2) / 1e6;
+      let resultText = `$ ${cmd}
+`;
+      if (stdout) resultText += `${stdout}
+`;
+      if (stderr) resultText += `${stderr}
+`;
+      resultText += `
+[status] Return code ${code2}`;
+      await sendPaginatedText(message, `\u2705 **Executed in ${timeMs2.toFixed(3)}ms**
+`, resultText, "ansi");
+    } catch (err) {
+      await sendPaginatedText(message, `\u274C **Shell Error**
+`, err.message, "ansi");
+    }
+    return;
+  }
+  if (command === "load" || command === "unload" || command === "reload") {
+    const target = args[0]?.toLowerCase();
+    try {
+      if (target === "commands" && client["_commandsDir"]) {
+        if (command === "unload" || command === "reload") client.commands.clear();
+        if (command === "load" || command === "reload") client.commands = await loadAndDeployCommands(client["_commandsDir"], client.token, client["_clientId"], client["_guildId"]);
+        await message.reply(`\u2705 Successfully ${command}ed commands.`);
+      } else if (target === "events" && client["_eventsDir"]) {
+        if (command === "unload" || command === "reload") {
+          client.removeAllListeners();
+          client["attachCoreListeners"]();
+        }
+        if (command === "load" || command === "reload") await loadEvents(client, client["_eventsDir"]);
+        await message.reply(`\u2705 Successfully ${command}ed events.`);
+      } else if (target === "components" && client["_componentsDir"]) {
+        if (command === "unload" || command === "reload") client.components.clear();
+        if (command === "load" || command === "reload") client.components = await loadComponents(client["_componentsDir"]);
+        await message.reply(`\u2705 Successfully ${command}ed components.`);
+      } else if (target === "locales" && client["_localesDir"]) {
+        if (command === "load" || command === "reload") loadLocales(client["_localesDir"], client.config.defaultLocale);
+        await message.reply(`\u2705 Successfully ${command}ed locales.`);
+      } else if (target === "all" || !target) {
+        if (command === "unload" || command === "reload") {
+          client.removeAllListeners();
+          client["attachCoreListeners"]();
+          client.commands.clear();
+          client.components.clear();
+        }
+        if (command === "load" || command === "reload") {
+          if (client["_eventsDir"]) await loadEvents(client, client["_eventsDir"]);
+          if (client["_componentsDir"]) client.components = await loadComponents(client["_componentsDir"]);
+          if (client["_localesDir"]) loadLocales(client["_localesDir"], client.config.defaultLocale);
+          if (client["_commandsDir"]) client.commands = await loadAndDeployCommands(client["_commandsDir"], client.token, client["_clientId"], client["_guildId"]);
+        }
+        await message.reply(`\u2705 Successfully ${command}ed all framework modules.`);
+      } else {
+        await message.reply("\u274C Unknown target. Valid targets: `commands, events, components, locales, all`");
+      }
+    } catch (err) {
+      await message.reply(`\u274C **${command.toUpperCase()} Error:** ${err.message}`);
+    }
+    return;
+  }
+  if (command === "cat") {
+    const fs9 = await import("fs");
+    const path7 = await import("path");
+    const file = args.join(" ");
+    if (!file) return void await message.reply("\u274C Please provide a file to read.");
+    try {
+      const content2 = fs9.readFileSync(path7.resolve(process.cwd(), file), "utf8");
+      await sendPaginatedText(message, `\u{1F4C4} **${file}**
+`, content2, file.split(".").pop() || "");
+    } catch (e) {
+      await message.reply(`\u274C **Error reading file:** ${e.message}`);
+    }
+    return;
+  }
+  if (command === "curl") {
+    const url = args[0];
+    if (!url) return void await message.reply("\u274C Please provide a URL.");
+    try {
+      const res = await fetch(url);
+      const text = await res.text();
+      await sendPaginatedText(message, `\u{1F310} **Fetched from \`${url}\`**
+`, text, "html");
+    } catch (e) {
+      await message.reply(`\u274C **Curl Error:** ${e.message}`);
+    }
+    return;
+  }
+  if (command === "debug") {
+    let code = args.join(" ");
+    if (code.startsWith("```js") || code.startsWith("```py")) code = code.replace(/^```[a-z]*|```$/g, "");
+    else if (code.startsWith("```")) code = code.replace(/^```|```$/g, "");
+    if (!code) return void await message.reply("\u274C Please provide code to debug.");
+    try {
+      const startMem = process.memoryUsage().heapUsed;
+      const start = process.hrtime.bigint();
+      const { commands, components, config } = client;
+      let evaled = await eval(`(async () => { ${code} })()`);
+      const end = process.hrtime.bigint();
+      const endMem = process.memoryUsage().heapUsed;
+      const timeMs = Number(end - start) / 1e6;
+      const memDiff = (endMem - startMem) / 1024 / 1024;
+      if (typeof evaled !== "string") evaled = import_util.default.inspect(evaled, { depth: 1, colors: true });
+      await sendPaginatedText(message, `\u23F1\uFE0F **Debug Execution**
+Time: \`${timeMs.toFixed(3)}ms\` | Heap Delta: \`${memDiff.toFixed(3)}MB\`
+`, evaled, "ansi");
+    } catch (err) {
+      await sendPaginatedText(message, `\u274C **Debug Error**
+`, err.message, "ansi");
+    }
+    return;
+  }
+  if (command === "in") {
+    const channelId = args.shift()?.replace(/<#|>/g, "");
+    const cmd = args.join(" ");
+    if (!channelId || !cmd) return void await message.reply(`\u274C Usage: ${matchedTrigger} in <#channel|id> <command>`);
+    try {
+      const targetChannel = await client.channels.fetch(channelId);
+      if (!targetChannel || !targetChannel.isTextBased()) throw new Error("Invalid Text Channel.");
+      const mockMessage = Object.assign(Object.create(Object.getPrototypeOf(message)), message);
+      Object.defineProperty(mockMessage, "client", { value: client, configurable: true });
+      if (message.guild) {
+        Object.defineProperty(mockMessage, "guild", { value: message.guild, configurable: true });
+        Object.defineProperty(mockMessage, "guildId", { value: message.guildId, configurable: true });
+      }
+      Object.defineProperty(mockMessage, "channel", { value: targetChannel, configurable: true });
+      Object.defineProperty(mockMessage, "channelId", { value: targetChannel.id, configurable: true });
+      Object.defineProperty(mockMessage, "content", { value: cmd, configurable: true });
+      client.emit("messageCreate", mockMessage);
+    } catch (e) {
+      await message.reply(`\u274C **In Error:** ${e.message}`);
+    }
+    return;
+  }
+  if (command === "sync") {
+    try {
+      await message.reply("\u{1F504} Force syncing slash commands...");
+      await loadAndDeployCommands(client._commandsDir, client.token, client._clientId, client._guildId);
+      await message.reply("\u2705 Slash commands synchronized globally/locally.");
+    } catch (e) {
+      await message.reply(`\u274C **Sync Error:** ${e.message}`);
+    }
+    return;
+  }
+  if (command === "restart") {
+    await message.reply("\u{1F504} Restarting framework...");
+    client.destroy();
+    const { spawn } = require("child_process");
+    const child = spawn(process.argv[0], process.argv.slice(1), {
+      detached: true,
+      stdio: "ignore",
+      cwd: process.cwd()
+    });
+    child.unref();
+    process.exit(0);
+    return;
+  }
+  if (command === "shutdown" || command === "stop") {
+    await message.reply("\u{1F6D1} Shutting down framework...");
+    client.destroy();
+    process.exit(0);
+    return;
+  }
+  await message.reply(`\u2753 Unknown ${matchedTrigger} command. Available: \`js, sh, git, cat, curl, in, debug, reload, sync, restart, shutdown\``);
+}
+async function sendPaginatedText(message2, header, content2, language = "") {
+  const maxLength = 800;
+  if (content2.length <= maxLength) {
+    await message2.reply(buildDisplayMessage(`### ${header.replace(/\\*\\*/g, "")}
+\`\`\`${language}
+${content2}
+\`\`\``));
+    return;
+  }
+  const chunks = [];
+  for (let i = 0; i < content2.length; i += maxLength) {
+    chunks.push(content2.substring(i, i + maxLength));
+  }
+  let index = 0;
+  const djs = require("discord.js");
+  function buildPage(idx) {
+    const text = `### ${header.replace(/\\*\\*/g, "")}
+\`\`\`${language}
+${chunks[idx]}
+\`\`\`
+> *Page ${idx + 1} of ${chunks.length}*`;
+    const container = new djs.ContainerBuilder().setAccentColor(5397233).addTextDisplayComponents(
+      new djs.TextDisplayBuilder().setContent(text)
+    );
+    const row1 = new djs.ActionRowBuilder().addComponents(
+      new djs.ButtonBuilder().setCustomId("first").setLabel("\u226A").setStyle(2),
+      new djs.ButtonBuilder().setCustomId("prev").setLabel("\uFF1C").setStyle(2),
+      new djs.ButtonBuilder().setCustomId("goto").setLabel("\u2398").setStyle(1),
+      new djs.ButtonBuilder().setCustomId("next").setLabel("\uFF1E").setStyle(2),
+      new djs.ButtonBuilder().setCustomId("last").setLabel("\u226B").setStyle(2)
+    );
+    const row2 = new djs.ActionRowBuilder().addComponents(
+      new djs.ButtonBuilder().setCustomId("stop").setLabel("\u2716 Close").setStyle(4)
+    );
+    container.addActionRowComponents(row1, row2);
+    return { components: [container], flags: 32768 };
+  }
+  const reply = await message2.reply(buildPage(index));
+  const collector = reply.createMessageComponentCollector({
+    filter: (i) => ["first", "prev", "goto", "stop", "next", "last"].includes(i.customId) && i.user.id === message2.author.id,
+    time: 12e4
+  });
+  collector.on("collect", async (i) => {
+    if (i.customId === "first") {
+      index = 0;
+    } else if (i.customId === "prev") {
+      index = index > 0 ? index - 1 : index;
+    } else if (i.customId === "next") {
+      index = index < chunks.length - 1 ? index + 1 : index;
+    } else if (i.customId === "last") {
+      index = chunks.length - 1;
+    } else if (i.customId === "goto") {
+      const modal = new djs.ModalBuilder().setCustomId("goto_modal").setTitle("Go to Page");
+      const input = new djs.TextInputBuilder().setCustomId("page_num").setLabel(`Page Number (1-${chunks.length})`).setStyle(1).setRequired(true);
+      modal.addComponents(new djs.ActionRowBuilder().addComponents(input));
+      await i.showModal(modal);
+      try {
+        const modalSubmit = await i.awaitModalSubmit({ filter: (mi) => mi.user.id === message2.author.id && mi.customId === "goto_modal", time: 6e4 });
+        const targetPage = parseInt(modalSubmit.fields.getTextInputValue("page_num"), 10);
+        if (!isNaN(targetPage) && targetPage >= 1 && targetPage <= chunks.length) {
+          index = targetPage - 1;
+        }
+        await modalSubmit.update(buildPage(index));
+      } catch {
+      }
+      return;
+    } else if (i.customId === "stop") {
+      await reply.delete().catch(() => null);
+      collector.stop();
+      return;
+    }
+    await i.update(buildPage(index));
+  });
+  collector.on("end", () => {
+    reply.edit({ components: [] }).catch(() => null);
+  });
+}
+
+// src/client.ts
+var DJSNextClient = class extends import_discord4.Client {
+  commands;
+  components;
+  cooldowns;
+  config = {};
+  t = translate;
+  db;
+  _commandsDir;
+  _eventsDir;
+  _componentsDir;
+  _tasksDir;
+  _localesDir;
+  _clientId;
+  _guildId;
+  _developers;
+  _middleware;
+  _prefixes;
+  _enableSlashCommands;
+  _enableTextCommands;
+  _enableMentionPrefix;
+  _enableNoPrefix;
+  constructor(options) {
+    super(options);
+    this.commands = new import_discord4.Collection();
+    this.components = new import_discord4.Collection();
+    this.cooldowns = new import_discord4.Collection();
+    this._commandsDir = options.commandsDir ? import_path6.default.resolve(process.cwd(), options.commandsDir) : void 0;
+    this._eventsDir = options.eventsDir ? import_path6.default.resolve(process.cwd(), options.eventsDir) : void 0;
+    this._componentsDir = options.componentsDir ? import_path6.default.resolve(process.cwd(), options.componentsDir) : void 0;
+    this._tasksDir = options.tasksDir ? import_path6.default.resolve(process.cwd(), options.tasksDir) : void 0;
+    this._clientId = options.clientId;
+    this._guildId = options.guildId;
+    this._developers = options.developers || [];
+    this._middleware = options.middleware;
+    const prefs = options.prefixes || [];
+    this._prefixes = Array.isArray(prefs) ? prefs : [prefs];
+    this._prefixes = this._prefixes.filter((p) => p !== "");
+    this._enableSlashCommands = options.enableSlashCommands ?? true;
+    this._enableTextCommands = options.enableTextCommands ?? true;
+    this._enableMentionPrefix = options.enableMentionPrefix ?? true;
+    this._enableNoPrefix = options.enableNoPrefix ?? false;
+    if (options.db) this.db = options.db;
+    this.attachCoreListeners();
+  }
+  attachCoreListeners() {
+    this.on("interactionCreate", async (interaction) => {
+      if (this._middleware) {
+        try {
+          const shouldContinue = await this._middleware(interaction, this);
+          if (!shouldContinue) return;
+        } catch (error) {
+          console.error(`[djs-next] Middleware error:`, error);
+          return;
+        }
+      }
+      if (interaction.isChatInputCommand()) {
+        if (!this._enableSlashCommands) return;
+        let commandKey = interaction.commandName;
+        const group = interaction.options.getSubcommandGroup(false);
+        const sub = interaction.options.getSubcommand(false);
+        if (group) commandKey += ` ${group}`;
+        if (sub) commandKey += ` ${sub}`;
+        const command2 = this.commands.get(commandKey);
+        if (!command2 || !command2.execute) return;
+        if (!await this.handlePreconditions(command2, interaction, commandKey)) return;
+        try {
+          await command2.execute(interaction, this);
+        } catch (error) {
+          await this.handleCommandError(error, commandKey, interaction);
+        }
+      }
+      if (interaction.isAutocomplete()) {
+        let commandKey = interaction.commandName;
+        const group = interaction.options.getSubcommandGroup(false);
+        const sub = interaction.options.getSubcommand(false);
+        if (group) commandKey += ` ${group}`;
+        if (sub) commandKey += ` ${sub}`;
+        const command2 = this.commands.get(commandKey);
+        if (command2 && command2.autocomplete) {
+          try {
+            await command2.autocomplete(interaction, this);
+          } catch (error) {
+            console.error(`[djs-next] Error executing autocomplete for: "${commandKey}"`, error);
+          }
+        }
+      }
+      if (interaction.isMessageComponent() || interaction.isModalSubmit()) {
+        if (interaction.customId === "djs_prev" || interaction.customId === "djs_next") return;
+        let component = this.components.get(interaction.customId);
+        let params = {};
+        if (!component) {
+          for (const [key, comp] of this.components) {
+            if (!key.includes("[")) continue;
+            const escapedKey = key.replace(/[.*+?^${}()|\\-]/g, "\\$&");
+            const regexStr = "^" + escapedKey.replace(/\\\[([^\]]+)\\\]/g, "(?<$1>.+)") + "$";
+            const match = interaction.customId.match(new RegExp(regexStr));
+            if (match) {
+              component = comp;
+              if (match.groups) params = match.groups;
+              break;
+            }
+          }
+        }
+        if (component) {
+          if (!await this.handlePreconditions(component, interaction, interaction.customId)) return;
+          try {
+            await component.execute(interaction, this, params);
+          } catch (error) {
+            await this.handleCommandError(error, interaction.customId, interaction);
+          }
+        }
+      }
+    });
+    this.on("messageCreate", async (message2) => {
+      if (message2.author.bot) return;
+      if (!this._enableTextCommands) return;
+      if (this._middleware) {
+        try {
+          const shouldContinue = await this._middleware(message2, this);
+          if (!shouldContinue) return;
+        } catch (error) {
+          console.error(`[djs-next] Middleware error (Message):`, error);
+          return;
+        }
+      }
+      let content2 = message2.content.trim();
+      let matchedPrefix = "";
+      let isCommand = false;
+      const mentionRegex = new RegExp(`^<@!?${this.user?.id}>\\s*`);
+      const canUseMention = this._enableMentionPrefix === true || Array.isArray(this._enableMentionPrefix) && this._enableMentionPrefix.includes(message2.author.id);
+      if (canUseMention && mentionRegex.test(content2)) {
+        matchedPrefix = content2.match(mentionRegex)[0];
+        isCommand = true;
+      } else {
+        const sortedPrefs = [...this._prefixes].sort((a, b) => b.length - a.length);
+        for (const p of sortedPrefs) {
+          if (content2.startsWith(p)) {
+            matchedPrefix = p;
+            isCommand = true;
+            break;
+          }
+        }
+        const canUseNoPrefix = this._enableNoPrefix === true || Array.isArray(this._enableNoPrefix) && this._enableNoPrefix.includes(message2.author.id);
+        if (!isCommand && canUseNoPrefix) {
+          isCommand = true;
+          matchedPrefix = "";
+        }
+      }
+      if (!isCommand) return;
+      const args2 = content2.slice(matchedPrefix.length).trim().split(/ +/g);
+      const commandName = args2.shift()?.toLowerCase();
+      if (!commandName) return;
+      let command2 = this.commands.get(commandName);
+      if (!command2) {
+        command2 = this.commands.find((c) => c.aliases?.includes(commandName) || false);
+      }
+      if (!command2 || !command2.executeText) return;
+      if (!await this.handlePreconditions(command2, message2, commandName)) return;
+      try {
+        await command2.executeText(message2, args2, this);
+      } catch (error) {
+        await this.handleCommandError(error, commandName, message2);
+      }
+    });
+  }
+  async start(token) {
+    if (!token) throw new Error("[djs-next] A token must be provided to start the bot.");
+    this.config = await loadConfig();
+    this._guildId = this._guildId || this.config.devGuildId;
+    if (!this._commandsDir) this._commandsDir = import_path6.default.resolve(process.cwd(), this.config.directories?.commands || "src/commands");
+    if (!this._eventsDir) this._eventsDir = import_path6.default.resolve(process.cwd(), this.config.directories?.events || "src/events");
+    if (!this._componentsDir) this._componentsDir = import_path6.default.resolve(process.cwd(), this.config.directories?.components || "src/components");
+    if (!this._tasksDir) this._tasksDir = import_path6.default.resolve(process.cwd(), this.config.directories?.tasks || "src/tasks");
+    if (!this._localesDir) this._localesDir = import_path6.default.resolve(process.cwd(), this.config.directories?.locales || "src/locales");
+    if (import_fs8.default.existsSync(this._localesDir)) loadLocales(this._localesDir, this.config.defaultLocale);
+    if (!this._middleware) {
+      const exts = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+      const cwd = process.cwd();
+      for (const ext of exts) {
+        const mwPath = import_path6.default.join(cwd, `middleware${ext}`);
+        if (import_fs8.default.existsSync(mwPath)) {
+          try {
+            const mwModule = await import((0, import_url6.pathToFileURL)(mwPath).href);
+            this._middleware = mwModule.default?.middleware || mwModule.middleware || mwModule.default || mwModule;
+            if (this._middleware) {
+              console.log(`[djs-next] Loaded global middleware.`);
+              break;
+            }
+          } catch (err) {
+            console.error(`[djs-next] Error loading middleware file ${mwPath}:`, err);
+          }
+        }
+      }
+    }
+    if (import_fs8.default.existsSync(this._eventsDir)) await loadEvents(this, this._eventsDir);
+    if (import_fs8.default.existsSync(this._componentsDir)) this.components = await loadComponents(this._componentsDir);
+    if (import_fs8.default.existsSync(this._tasksDir)) await loadTasks(this, this._tasksDir);
+    await this.login(token);
+    console.log(`[djs-next] Bot is ready and logged in as ${this.user?.tag}!`);
+    if (import_fs8.default.existsSync(this._commandsDir)) {
+      this._clientId = this._clientId || this.user.id;
+      this.commands = await loadAndDeployCommands(this._commandsDir, token, this._clientId, this._guildId);
+    }
+  }
+  enableDevTools(prefix = "dnxt") {
+    if (prefix !== "dnxt" && prefix !== "nxt") {
+      throw new Error(`[djs-next] Developer Tools prefix must be either 'dnxt' or 'nxt'. Received: ${prefix}`);
+    }
+    this.on("messageCreate", async (message2) => {
+      await handleDNXT(message2, this, prefix);
+    });
+    console.log(`[djs-next] \u{1F6E0}\uFE0F Developer Tools enabled. Use "${prefix}" in chat. Ensure MessageContent intent is enabled!`);
+  }
+  async enableHMR() {
+    try {
+      const chokidar = await import("chokidar");
+      console.log(`[djs-next] \u{1F504} HMR Enabled. Watching for file changes...`);
+      const watcher = chokidar.watch([
+        this._commandsDir,
+        this._eventsDir,
+        this._componentsDir,
+        this._localesDir
+      ].filter(Boolean), { ignoreInitial: true });
+      watcher.on("change", async (filePath) => {
+        console.log(`[djs-next] \u267B\uFE0F File changed: ${filePath}. Reloading...`);
+        this.removeAllListeners();
+        this.commands.clear();
+        this.components.clear();
+        this.attachCoreListeners();
+        if (this._eventsDir) await loadEvents(this, this._eventsDir);
+        if (this._componentsDir) this.components = await loadComponents(this._componentsDir);
+        if (this._commandsDir && this._clientId) {
+          this.commands = await loadAndDeployCommands(this._commandsDir, this.token, this._clientId, this._guildId);
+        }
+        if (this._localesDir) loadLocales(this._localesDir, this.config.defaultLocale);
+        console.log(`[djs-next] \u2705 Hot Reload complete.`);
+      });
+    } catch (e) {
+      console.warn(`[djs-next] chokidar not installed. HMR is disabled. Please run "npm install chokidar" to use this feature.`);
+    }
+  }
+  async handleCommandError(error, commandKey, context) {
+    console.error(`[djs-next] Error executing command/component: "${commandKey}"`, error);
+    const djs = require("discord.js");
+    if (this.config.responses?.errorBoundary === null) {
+    } else {
+      try {
+        const errorContent = this.config.responses?.errorBoundary || `### \u26A0\uFE0F Execution Error
+> The framework encountered a fatal error while executing \`${commandKey}\`.`;
+        const codeBlock = `\`\`\`js
+${String(error.stack || error.message).substring(0, 1500)}
+\`\`\``;
+        if ("commandName" in context || "customId" in context) {
+          const container = new djs.ContainerBuilder().setAccentColor(15548997).addTextDisplayComponents(new djs.TextDisplayBuilder().setContent(errorContent)).addSeparatorComponents(new djs.SeparatorBuilder()).addTextDisplayComponents(new djs.TextDisplayBuilder().setContent(codeBlock));
+          const payload = { components: [container], flags: 32768, ephemeral: true };
+          const i = context;
+          if (i.isRepliable()) {
+            if (i.replied || i.deferred) await i.followUp(payload);
+            else await i.reply(payload);
+          }
+        } else {
+          const embed = new djs.EmbedBuilder().setColor(15548997).setDescription(`${errorContent}
+
+${codeBlock}`);
+          const m = context;
+          await m.reply({ embeds: [embed] });
+        }
+      } catch (e) {
+      }
+    }
+    if (this.config.errorLogChannelId) {
+      try {
+        const channel = await this.channels.fetch(this.config.errorLogChannelId);
+        if (channel && channel.isTextBased()) {
+          const userId = "user" in context ? context.user.id : context.author.id;
+          await channel.send(`\u{1F6A8} **Global Error Boundary Caught Exception**
+**Context:** \`${commandKey}\`
+**User:** <@${userId}>
+\`\`\`js
+${String(error.stack || error.message).substring(0, 1900)}
+\`\`\``);
+        }
+      } catch (e) {
+        console.error(`[djs-next] Failed to send error to log channel:`, e);
+      }
+    }
+  }
+  async handlePreconditions(command2, context, commandKey) {
+    const userId = "user" in context ? context.user.id : context.author.id;
+    const isGuild = "guild" in context && context.guild !== null;
+    const member = context.member;
+    const sendErr = async (msg) => {
+      if (msg === null) return;
+      if ("reply" in context && typeof context.reply === "function") {
+        try {
+          if ("replied" in context && context.isRepliable() && (context.replied || context.deferred)) {
+            await context.followUp({ content: msg, ephemeral: true });
+          } else {
+            await context.reply({ content: msg, ephemeral: true, allowedMentions: { repliedUser: false } });
+          }
+        } catch (e) {
+        }
+      }
+    };
+    if ("developerOnly" in command2 && command2.developerOnly && !this._developers.includes(userId)) {
+      await sendErr(this.config.responses?.developerOnly !== void 0 ? this.config.responses.developerOnly : "Only developers can use this command.");
+      return false;
+    }
+    if ("guildOnly" in command2 && command2.guildOnly && !isGuild) {
+      await sendErr(this.config.responses?.guildOnly !== void 0 ? this.config.responses.guildOnly : "This command can only be used in a server.");
+      return false;
+    }
+    if ("userPermissions" in command2 && command2.userPermissions && member?.permissions) {
+      const missing = member.permissions.missing(command2.userPermissions);
+      if (missing.length > 0) {
+        await sendErr(this.config.responses?.missingPerms !== void 0 ? this.config.responses.missingPerms === null ? null : this.config.responses.missingPerms.replace("{perms}", missing.join(", ")) : `You are missing permissions: \`${missing.join(", ")}\``);
+        return false;
+      }
+    }
+    if ("botPermissions" in command2 && command2.botPermissions && context.guild?.members.me?.permissions) {
+      const missing = context.guild.members.me.permissions.missing(command2.botPermissions);
+      if (missing.length > 0) {
+        await sendErr(this.config.responses?.missingPerms !== void 0 ? this.config.responses.missingPerms === null ? null : this.config.responses.missingPerms.replace("{perms}", missing.join(", ")) : `I am missing permissions to run this: \`${missing.join(", ")}\``);
+        return false;
+      }
+    }
+    let totalCooldown = "cooldown" in command2 && command2.cooldown ? command2.cooldown * 1e3 : 0;
+    if (command2.preconditions) {
+      for (const pre of command2.preconditions) {
+        const parts = pre.split(":");
+        const type = parts[0].toLowerCase();
+        const val = parts.slice(1).join(":");
+        if (type === "owneronly" || type === "developeronly") {
+          if (!this._developers.includes(userId)) {
+            await sendErr(this.config.responses?.developerOnly !== void 0 ? this.config.responses.developerOnly : "Only developers can use this command.");
+            return false;
+          }
+        } else if (type === "guildonly") {
+          if (!isGuild) {
+            await sendErr(this.config.responses?.guildOnly !== void 0 ? this.config.responses.guildOnly : "This command can only be used in a server.");
+            return false;
+          }
+        } else if (type === "requireperms") {
+          const perms = val.split(",").map((p) => p.trim());
+          if (member?.permissions) {
+            const missing = member.permissions.missing(perms);
+            if (missing.length > 0) {
+              await sendErr(this.config.responses?.missingPerms !== void 0 ? this.config.responses.missingPerms === null ? null : this.config.responses.missingPerms.replace("{perms}", missing.join(", ")) : `You are missing permissions: \`${missing.join(", ")}\``);
+              return false;
+            }
+          }
+        } else if (type === "cooldown") {
+          const match = val.match(/(\d+)(s|m|h)/);
+          if (match) {
+            let amount = parseInt(match[1]) * 1e3;
+            if (match[2] === "m") amount *= 60;
+            if (match[2] === "h") amount *= 3600;
+            totalCooldown = Math.max(totalCooldown, amount);
+          }
+        }
+      }
+    }
+    if (totalCooldown > 0) {
+      const now = Date.now();
+      if (this.config.cooldownAdapter) {
+        const lastUsed = await this.config.cooldownAdapter.get(commandKey, userId);
+        if (lastUsed) {
+          const expirationTime = lastUsed + totalCooldown;
+          if (now < expirationTime) {
+            const timeStr = `<t:${Math.round(expirationTime / 1e3)}:R>`;
+            await sendErr(this.config.responses?.cooldown !== void 0 ? this.config.responses.cooldown === null ? null : this.config.responses.cooldown.replace("{time}", timeStr) : `Please wait, you are on a cooldown. You can use it again ${timeStr}.`);
+            return false;
+          }
+        }
+        await this.config.cooldownAdapter.set(commandKey, userId, now);
+      } else {
+        if (!this.cooldowns.has(commandKey)) this.cooldowns.set(commandKey, new import_discord4.Collection());
+        const timestamps = this.cooldowns.get(commandKey);
+        if (timestamps.has(userId)) {
+          const expirationTime = timestamps.get(userId) + totalCooldown;
+          if (now < expirationTime) {
+            const timeStr = `<t:${Math.round(expirationTime / 1e3)}:R>`;
+            await sendErr(this.config.responses?.cooldown !== void 0 ? this.config.responses.cooldown === null ? null : this.config.responses.cooldown.replace("{time}", timeStr) : `Please wait, you are on a cooldown. You can use it again ${timeStr}.`);
+            return false;
+          }
+        }
+        timestamps.set(userId, now);
+        setTimeout(() => timestamps.delete(userId), totalCooldown);
+      }
+    }
+    return true;
+  }
+};
+
+// src/utils/paginate.ts
+var import_discord5 = require("discord.js");
+async function paginate(context, pages, time = 6e4) {
+  const isMessage = "author" in context;
+  if (!isMessage) {
+    if (!context.deferred && !context.replied) {
+      await context.deferReply();
+    }
+  }
+  if (pages.length === 1) {
+    if (isMessage) {
+      return context.reply({ embeds: [pages[0]], components: [] });
+    } else {
+      return context.editReply({ embeds: [pages[0]], components: [] });
+    }
+  }
+  let index = 0;
+  const prevButton = new import_discord5.ButtonBuilder().setCustomId("djs_prev").setLabel("Previous").setStyle(import_discord5.ButtonStyle.Primary).setDisabled(true);
+  const nextButton = new import_discord5.ButtonBuilder().setCustomId("djs_next").setLabel("Next").setStyle(import_discord5.ButtonStyle.Primary);
+  const row = new import_discord5.ActionRowBuilder().addComponents(prevButton, nextButton);
+  let message2;
+  if (isMessage) {
+    message2 = await context.reply({
+      embeds: [pages[index]],
+      components: [row]
+    });
+  } else {
+    message2 = await context.editReply({
+      embeds: [pages[index]],
+      components: [row]
+    });
+  }
+  const collector = message2.createMessageComponentCollector({
+    filter: (i) => i.user.id === (isMessage ? context.author.id : context.user.id),
+    time
+  });
+  collector.on("collect", async (i) => {
+    if (i.customId === "djs_prev") {
+      index = index > 0 ? index - 1 : index;
+    } else if (i.customId === "djs_next") {
+      index = index < pages.length - 1 ? index + 1 : index;
+    }
+    prevButton.setDisabled(index === 0);
+    nextButton.setDisabled(index === pages.length - 1);
+    await i.update({
+      embeds: [pages[index]],
+      components: [new import_discord5.ActionRowBuilder().addComponents(prevButton, nextButton)]
+    });
+  });
+  collector.on("end", async () => {
+    prevButton.setDisabled(true);
+    nextButton.setDisabled(true);
+    if (message2.editable) {
+      await message2.edit({
+        components: [new import_discord5.ActionRowBuilder().addComponents(prevButton, nextButton)]
+      }).catch(() => {
+      });
+    }
+  });
+}
+
+// src/utils/prompts.ts
+var import_discord6 = require("discord.js");
+async function confirmPrompt(context, content2, time = 3e4) {
+  const isMessage = "author" in context;
+  if (!isMessage) {
+    if (!context.deferred && !context.replied) {
+      await context.deferReply();
+    }
+  }
+  const yesButton = new import_discord6.ButtonBuilder().setCustomId("djs_prompt_yes").setLabel("Yes").setStyle(import_discord6.ButtonStyle.Success);
+  const noButton = new import_discord6.ButtonBuilder().setCustomId("djs_prompt_no").setLabel("No").setStyle(import_discord6.ButtonStyle.Danger);
+  const row = new import_discord6.ActionRowBuilder().addComponents(yesButton, noButton);
+  const payload = { components: [row] };
+  if (typeof content2 === "string") {
+    payload.content = content2;
+  } else {
+    payload.embeds = [content2];
+  }
+  let message2;
+  if (isMessage) {
+    message2 = await context.reply(payload);
+  } else {
+    message2 = await context.editReply(payload);
+  }
+  try {
+    const interaction = await message2.awaitMessageComponent({
+      filter: (i) => i.user.id === (isMessage ? context.author.id : context.user.id),
+      time
+    });
+    if (interaction.customId === "djs_prompt_yes") {
+      await interaction.update({ components: [] });
+      return true;
+    } else {
+      await interaction.update({ components: [] });
+      return false;
+    }
+  } catch (error) {
+    if (message2.editable) {
+      await message2.edit({ components: [] }).catch(() => {
+      });
+    }
+    return null;
+  }
+}
+
+// src/utils/PaginationBuilder.ts
+var import_discord7 = require("discord.js");
+var PaginationBuilder = class {
+  pages = [];
+  timeout = 6e4;
+  constructor(pages) {
+    if (pages) this.pages = pages;
+  }
+  addPage(embed) {
+    this.pages.push(embed);
+    return this;
+  }
+  setPages(pages) {
+    this.pages = pages;
+    return this;
+  }
+  setTimeout(ms) {
+    this.timeout = ms;
+    return this;
+  }
+  async build(target) {
+    if (this.pages.length === 0) throw new Error("[djs-next] PaginationBuilder requires at least one page.");
+    if (this.pages.length === 1) {
+      if (target instanceof import_discord7.CommandInteraction) {
+        if (target.deferred || target.replied) {
+          return await target.editReply({ embeds: [this.pages[0]] });
+        }
+        return await target.reply({ embeds: [this.pages[0]], fetchReply: true });
+      } else {
+        return await target.reply({ embeds: [this.pages[0]] });
+      }
+    }
+    let currentPage = 0;
+    const row = new import_discord7.ActionRowBuilder().addComponents(
+      new import_discord7.ButtonBuilder().setCustomId("prev").setLabel("\u25C0").setStyle(import_discord7.ButtonStyle.Primary).setDisabled(true),
+      new import_discord7.ButtonBuilder().setCustomId("page").setLabel(`1 / ${this.pages.length}`).setStyle(import_discord7.ButtonStyle.Secondary).setDisabled(true),
+      new import_discord7.ButtonBuilder().setCustomId("next").setLabel("\u25B6").setStyle(import_discord7.ButtonStyle.Primary)
+    );
+    let replyMsg;
+    if (target instanceof import_discord7.CommandInteraction) {
+      if (target.deferred || target.replied) {
+        replyMsg = await target.editReply({ embeds: [this.pages[0]], components: [row] });
+      } else {
+        replyMsg = await target.reply({ embeds: [this.pages[0]], components: [row], fetchReply: true });
+      }
+    } else {
+      replyMsg = await target.reply({ embeds: [this.pages[0]], components: [row] });
+    }
+    const userId = target instanceof import_discord7.CommandInteraction ? target.user.id : target.author.id;
+    const collector = replyMsg.createMessageComponentCollector({
+      componentType: import_discord7.ComponentType.Button,
+      time: this.timeout,
+      filter: (i) => i.user.id === userId
+    });
+    collector.on("collect", async (i) => {
+      if (i.customId === "prev") currentPage--;
+      else if (i.customId === "next") currentPage++;
+      const newRow = new import_discord7.ActionRowBuilder().addComponents(
+        new import_discord7.ButtonBuilder().setCustomId("prev").setLabel("\u25C0").setStyle(import_discord7.ButtonStyle.Primary).setDisabled(currentPage === 0),
+        new import_discord7.ButtonBuilder().setCustomId("page").setLabel(`${currentPage + 1} / ${this.pages.length}`).setStyle(import_discord7.ButtonStyle.Secondary).setDisabled(true),
+        new import_discord7.ButtonBuilder().setCustomId("next").setLabel("\u25B6").setStyle(import_discord7.ButtonStyle.Primary).setDisabled(currentPage === this.pages.length - 1)
+      );
+      await i.update({ embeds: [this.pages[currentPage]], components: [newRow] });
+    });
+    collector.on("end", () => {
+      replyMsg.edit({ components: [] }).catch(() => null);
+    });
+    return replyMsg;
+  }
+};
+
+// src/index.ts
+__reExport(index_exports, require("discord.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DJSNextClient,
+  PaginationBuilder,
+  confirmPrompt,
+  defineConfig,
+  getLocalesCache,
+  loadConfig,
+  loadLocales,
+  paginate,
+  translate,
+  ...require("discord.js")
+});
+//# sourceMappingURL=index.js.map