djs-next 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1259 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import "dotenv/config";
+
+// src/client.ts
+import { Client, Collection as Collection3 } from "discord.js";
+
+// src/handlers/commandHandler.ts
+import { Collection, REST, Routes } from "discord.js";
+import fs2 from "fs";
+import path2 from "path";
+import { pathToFileURL } from "url";
+
+// src/handlers/utils.ts
+import fs from "fs";
+import path from "path";
+function getAllFiles(dirPath, arrayOfFiles = []) {
+  const files = fs.readdirSync(dirPath);
+  files.forEach((file) => {
+    const fullPath = path.join(dirPath, file);
+    if (fs.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 Collection();
+  if (!fs2.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 = path2.relative(commandsDir, file);
+    const parsed = path2.parse(relativePath);
+    const dirParts = parsed.dir ? parsed.dir.split(path2.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 module = await import(pathToFileURL(file).href);
+    const commandData = module.default || module.command || module;
+    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 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(
+        Routes.applicationGuildCommands(clientId, guildId),
+        { body: commandsData }
+      );
+    } else {
+      data = await rest.put(
+        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
+import fs3 from "fs";
+import { pathToFileURL as pathToFileURL2 } from "url";
+async function loadEvents(client2, eventsDir) {
+  if (!fs3.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(pathToFileURL2(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
+import { Collection as Collection2 } from "discord.js";
+import fs4 from "fs";
+import path3 from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+async function loadComponents(componentsDir) {
+  const components2 = new Collection2();
+  if (!fs4.existsSync(componentsDir)) return components2;
+  const files = getAllFiles(componentsDir);
+  for (const file of files) {
+    const module = await import(pathToFileURL3(file).href);
+    const componentData = module.default || module.component || module;
+    if (componentData) componentData.filepath = file;
+    if (!componentData || !componentData.execute) continue;
+    const parsed = path3.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
+import fs5 from "fs";
+import { pathToFileURL as pathToFileURL4 } from "url";
+async function loadTasks(client2, tasksDir) {
+  if (!fs5.existsSync(tasksDir)) return;
+  const files = getAllFiles(tasksDir);
+  let loaded = 0;
+  for (const file of files) {
+    const module = await import(pathToFileURL4(file).href);
+    const taskData = module.default || module.task || module;
+    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
+import path6 from "path";
+import fs8 from "fs";
+import { pathToFileURL as pathToFileURL6 } from "url";
+
+// src/utils/configLoader.ts
+import path4 from "path";
+import fs6 from "fs";
+import { pathToFileURL as pathToFileURL5 } from "url";
+async function loadConfig() {
+  const exts = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+  const cwd = process.cwd();
+  for (const ext of exts) {
+    const configPath = path4.join(cwd, `djs-next.config${ext}`);
+    if (fs6.existsSync(configPath)) {
+      try {
+        const configModule = await import(pathToFileURL5(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
+import fs7 from "fs";
+import path5 from "path";
+var localesCache = {};
+var defaultLoc = "en";
+function loadLocales(localesDir, defaultLocale) {
+  if (defaultLocale) defaultLoc = defaultLocale;
+  if (!fs7.existsSync(localesDir)) return;
+  const files = fs7.readdirSync(localesDir);
+  for (const file of files) {
+    if (file.endsWith(".json")) {
+      const lang = file.replace(".json", "");
+      const content2 = fs7.readFileSync(path5.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
+import { version as djsVersion } from "discord.js";
+import { exec } from "child_process";
+import util from "util";
+import os from "os";
+var execAsync = util.promisify(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${djsVersion}\`
+- **Node.js Runtime:** \`${process.version}\`
+- **Operating System:** \`${os.type()}\` (\`${os.cpus().length}\` thread cores, \`${(os.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 = util.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 = util.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 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 Collection3();
+    this.components = new Collection3();
+    this.cooldowns = new Collection3();
+    this._commandsDir = options.commandsDir ? path6.resolve(process.cwd(), options.commandsDir) : void 0;
+    this._eventsDir = options.eventsDir ? path6.resolve(process.cwd(), options.eventsDir) : void 0;
+    this._componentsDir = options.componentsDir ? path6.resolve(process.cwd(), options.componentsDir) : void 0;
+    this._tasksDir = options.tasksDir ? path6.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 = path6.resolve(process.cwd(), this.config.directories?.commands || "src/commands");
+    if (!this._eventsDir) this._eventsDir = path6.resolve(process.cwd(), this.config.directories?.events || "src/events");
+    if (!this._componentsDir) this._componentsDir = path6.resolve(process.cwd(), this.config.directories?.components || "src/components");
+    if (!this._tasksDir) this._tasksDir = path6.resolve(process.cwd(), this.config.directories?.tasks || "src/tasks");
+    if (!this._localesDir) this._localesDir = path6.resolve(process.cwd(), this.config.directories?.locales || "src/locales");
+    if (fs8.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 = path6.join(cwd, `middleware${ext}`);
+        if (fs8.existsSync(mwPath)) {
+          try {
+            const mwModule = await import(pathToFileURL6(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 (fs8.existsSync(this._eventsDir)) await loadEvents(this, this._eventsDir);
+    if (fs8.existsSync(this._componentsDir)) this.components = await loadComponents(this._componentsDir);
+    if (fs8.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 (fs8.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 Collection3());
+        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
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle
+} from "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 ButtonBuilder().setCustomId("djs_prev").setLabel("Previous").setStyle(ButtonStyle.Primary).setDisabled(true);
+  const nextButton = new ButtonBuilder().setCustomId("djs_next").setLabel("Next").setStyle(ButtonStyle.Primary);
+  const row = new 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 ActionRowBuilder().addComponents(prevButton, nextButton)]
+    });
+  });
+  collector.on("end", async () => {
+    prevButton.setDisabled(true);
+    nextButton.setDisabled(true);
+    if (message2.editable) {
+      await message2.edit({
+        components: [new ActionRowBuilder().addComponents(prevButton, nextButton)]
+      }).catch(() => {
+      });
+    }
+  });
+}
+
+// src/utils/prompts.ts
+import {
+  ActionRowBuilder as ActionRowBuilder2,
+  ButtonBuilder as ButtonBuilder2,
+  ButtonStyle as ButtonStyle2
+} from "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 ButtonBuilder2().setCustomId("djs_prompt_yes").setLabel("Yes").setStyle(ButtonStyle2.Success);
+  const noButton = new ButtonBuilder2().setCustomId("djs_prompt_no").setLabel("No").setStyle(ButtonStyle2.Danger);
+  const row = new ActionRowBuilder2().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
+import {
+  ActionRowBuilder as ActionRowBuilder3,
+  ButtonBuilder as ButtonBuilder3,
+  ButtonStyle as ButtonStyle3,
+  CommandInteraction as CommandInteraction3,
+  ComponentType
+} from "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 CommandInteraction3) {
+        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 ActionRowBuilder3().addComponents(
+      new ButtonBuilder3().setCustomId("prev").setLabel("\u25C0").setStyle(ButtonStyle3.Primary).setDisabled(true),
+      new ButtonBuilder3().setCustomId("page").setLabel(`1 / ${this.pages.length}`).setStyle(ButtonStyle3.Secondary).setDisabled(true),
+      new ButtonBuilder3().setCustomId("next").setLabel("\u25B6").setStyle(ButtonStyle3.Primary)
+    );
+    let replyMsg;
+    if (target instanceof CommandInteraction3) {
+      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 CommandInteraction3 ? target.user.id : target.author.id;
+    const collector = replyMsg.createMessageComponentCollector({
+      componentType: 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 ActionRowBuilder3().addComponents(
+        new ButtonBuilder3().setCustomId("prev").setLabel("\u25C0").setStyle(ButtonStyle3.Primary).setDisabled(currentPage === 0),
+        new ButtonBuilder3().setCustomId("page").setLabel(`${currentPage + 1} / ${this.pages.length}`).setStyle(ButtonStyle3.Secondary).setDisabled(true),
+        new ButtonBuilder3().setCustomId("next").setLabel("\u25B6").setStyle(ButtonStyle3.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
+export * from "discord.js";
+export {
+  DJSNextClient,
+  PaginationBuilder,
+  confirmPrompt,
+  defineConfig,
+  getLocalesCache,
+  loadConfig,
+  loadLocales,
+  paginate,
+  translate
+};
+//# sourceMappingURL=index.mjs.map