@spatulox/simplediscordbot 1.0.1

package/dist/manager/hadlers_old/builder/interactions/InteractionManager.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// src/discord/InteractionManager.ts
+const readline_1 = __importDefault(require("readline"));
+const CommandManager_1 = require("./CommandManager");
+const ContextMenuManager_1 = require("./ContextMenuManager");
+const Log_1 = require("../../../../utils/Log");
+class InteractionManager {
+    static async start() {
+        console.clear();
+        Log_1.Log.info('🎛️  INTERACTION MANAGER');
+        Log_1.Log.info('=====================');
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        await this.showMainMenu(rl);
+        rl.on('line', async (input) => {
+            await this.handleMainMenu(input.trim().toLowerCase(), rl);
+        });
+    }
+    static async showMainMenu(rl) {
+        console.log('\n🎯 QUE VOULEZ-VOUS FAIRE ?');
+        console.log('  1. Slash Commands     → npm run deploy:slash');
+        console.log('  2. Context Menus      → npm run deploy:context');
+        console.log('  3. Tout déployer      → npm run deploy:all');
+        console.log('  help                  → Aide');
+        console.log('  exit                  → Quitter\n');
+        rl.prompt();
+    }
+    static async handleMainMenu(input, rl) {
+        switch (input) {
+            case '1':
+            case 'slash':
+                await new CommandManager_1.CommandManager().startInteractive();
+                break;
+            case '2':
+            case 'context':
+                await new ContextMenuManager_1.ContextMenuManager().startInteractive();
+                break;
+            case '3':
+            case 'all':
+                Log_1.Log.info('🚀 Déploiement complet...');
+                await Promise.all([
+                //new CommandManager().deployAll(),
+                //new ContextMenuManager().deployAll()
+                ]);
+                break;
+            case 'help':
+                await this.showMainMenu(rl);
+                break;
+            case 'exit':
+                Log_1.Log.info('👋 Au revoir !');
+                rl.close();
+                process.exit(0);
+            default:
+                Log_1.Log.error('❌ Choix invalide');
+                rl.prompt();
+        }
+    }
+}
+InteractionManager.start();

package/dist/manager/hadlers_old/builder/list.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*import { Routes } from 'discord-api-types/v10';
+import {Events} from "discord.js";
+import {Log} from "../../../utils/Log";
+import {client} from "../../../../src_example/client";
+
+export interface Command {
+    name: string;
+    description: string;
+    options?: any[];
+    default_member_permissions?: string | bigint | number;
+    guildID?: string[];
+    type: 1 | 2 | 3; // 1 = slash, 2 = user context, 3 = message context
+    id?: string; // Discord API Command ID
+}
+
+export interface DiscordCommand extends Command {
+    discordData?: any; // Données complètes depuis Discord API
+    deployedGuilds: string[]; // Serveurs où la commande est déployée
+}
+
+export async function analyzeRegisteredCommands(): Promise<DiscordCommand[]> {
+    if (!(await loginBot(client))) {
+        Log.error("Impossible de connecter le bot");
+        process.exit();
+    }
+
+    const allRegisteredCommands: DiscordCommand[] = [];
+
+    client.once(Events.ClientReady, async () => {
+        Log.info('Analyse des commandes enregistrées sur Discord');
+
+        // 1. Récupérer TOUTES les commandes Discord du bot
+        const globalDiscordCmds: any[] = await client.rest.get(
+            Routes.applicationCommands(client.user!.id)
+        ) as any[];
+
+        // 2. Récupérer les commandes de TOUS les serveurs où le bot est présent
+        const botGuilds = client.guilds.cache.map(guild => guild.id);
+        const guildDiscordCmds: Record<string, any[]> = {};
+
+        Log.info(`Analyse des ${botGuilds.length} serveurs où le bot est présent...`);
+
+        for (const guildId of botGuilds) {
+            try {
+                const guildCmds = await client.rest.get(
+                    Routes.applicationGuildCommands(config.clientId, guildId)
+                ) as any[];
+                guildDiscordCmds[guildId] = guildCmds;
+                Log.info((`Serveur ${guildId}: ${guildCmds.length} commandes guild`);
+            } catch (error) {
+                // Le bot n'a peut-être pas les permissions ou n'est pas dans ce serveur
+                guildDiscordCmds[guildId] = [];
+            }
+        }
+
+        // 3. Classer les commandes par nom et type
+        const commandMap = new Map<string, DiscordCommand>();
+
+        // Commandes globales
+        for (const cmd of globalDiscordCmds) {
+            const key = `${cmd.name}_${cmd.type}`;
+            if (!commandMap.has(key)) {
+                commandMap.set(key, {
+                    name: cmd.name,
+                    description: cmd.description || '',
+                    type: cmd.type,
+                    id: cmd.id,
+                    deployedGuilds: ['GLOBAL'],
+                    discordData: cmd
+                });
+            } else {
+                const existing = commandMap.get(key)!;
+                existing.deployedGuilds.push('GLOBAL');
+            }
+        }
+
+        // Commandes par serveur
+        for (const [guildId, guildCmds] of Object.entries(guildDiscordCmds)) {
+            for (const cmd of guildCmds) {
+                const key = `${cmd.name}_${cmd.type}`;
+                if (!commandMap.has(key)) {
+                    commandMap.set(key, {
+                        name: cmd.name,
+                        description: cmd.description || '',
+                        type: cmd.type,
+                        id: cmd.id,
+                        deployedGuilds: [guildId],
+                        discordData: cmd
+                    });
+                } else {
+                    const existing = commandMap.get(key)!;
+                    if (!existing.deployedGuilds.includes(guildId)) {
+                        existing.deployedGuilds.push(guildId);
+                    }
+                }
+            }
+        } // ← Fermeture de la boucle for guildId
+
+        // 4. Conversion en tableau et tri  ← ✅ DÉPLACÉ ICI (CORRIGÉ)
+        for (const [_key, cmd] of commandMap) {
+            allRegisteredCommands.push(cmd);
+        }
+
+        allRegisteredCommands.sort((a, b) => {
+            if (a.deployedGuilds.includes('GLOBAL') && !b.deployedGuilds.includes('GLOBAL')) return -1;
+            if (!a.deployedGuilds.includes('GLOBAL') && b.deployedGuilds.includes('GLOBAL')) return 1;
+            return a.name.localeCompare(b.name);
+        });
+
+        // 5. Affichage du classement
+        console.log('\n' + '='.repeat(80));
+        console.log('📋 CLASSEMENT DES COMMANDES ENREGISTRÉES SUR DISCORD');
+        console.log('='.repeat(80));
+
+        const globalCmds = allRegisteredCommands.filter(cmd => cmd.deployedGuilds.includes('GLOBAL'));
+        const guildOnlyCmds = allRegisteredCommands.filter(cmd => !cmd.deployedGuilds.includes('GLOBAL'));
+
+        console.log(`🌍 ${globalCmds.length} commandes GLOBALES`);
+        console.log(`🏛️  ${guildOnlyCmds.length} commandes SERVEUR-SEUL`);
+
+        // Tableau récapitulatif
+        console.table(
+            allRegisteredCommands.map(cmd => ({
+                Nom: cmd.name,
+                Type: cmd.type === 1 ? 'Slash' : cmd.type === 2 ? 'User Context' : 'Message Context',
+                Serveurs: cmd.deployedGuilds.length > 3
+                    ? `${cmd.deployedGuilds.slice(0, 3).join(', ')}... (+${cmd.deployedGuilds.length - 3})`
+                    : cmd.deployedGuilds.join(', '),
+                ID: cmd.id?.slice(-8) || 'N/A'
+            }))
+        );
+
+        // Détails par catégorie
+        if (globalCmds.length > 0) {
+            console.log('\n🌍 COMMANDES GLOBALES:');
+            globalCmds.forEach(cmd => {
+                console.log(`  • ${cmd.name} (ID: ${cmd.id?.slice(-8)}) - ${cmd.description}`);
+            });
+        }
+
+        if (guildOnlyCmds.length > 0) {
+            console.log('\n🏛️  COMMANDES SERVEUR-SEULEMENT:');
+            const groupedByGuild = guildOnlyCmds.reduce((acc, cmd) => {
+                for (const guildId of cmd.deployedGuilds) {
+                    if (!acc[guildId]) acc[guildId] = [];
+                    acc[guildId].push(cmd.name);
+                }
+                return acc;
+            }, {} as Record<string, string[]>);
+
+            for (const [guildId, cmds] of Object.entries(groupedByGuild)) {
+                console.log(`  📂 Serveur ${guildId.slice(-8)}: ${cmds.join(', ')}`);
+            }
+        }
+
+        console.log('\n✅ Analyse terminée!');
+        process.exit();
+    });
+
+    return allRegisteredCommands;
+}
+
+// Utilisation
+analyzeRegisteredCommands();*/ 

package/dist/manager/messages/EmbedManager.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbedManager = exports.EmbedColor = void 0;
+const discord_js_1 = require("discord.js");
+const Bot_1 = require("../../bot/Bot");
+var EmbedColor;
+(function (EmbedColor) {
+    EmbedColor[EmbedColor["error"] = 8912917] = "error";
+    EmbedColor[EmbedColor["success"] = 65280] = "success";
+    EmbedColor[EmbedColor["black"] = 0] = "black";
+    EmbedColor[EmbedColor["white"] = 16777215] = "white";
+    EmbedColor[EmbedColor["red"] = 16711680] = "red";
+    EmbedColor[EmbedColor["green"] = 65280] = "green";
+    EmbedColor[EmbedColor["blue"] = 255] = "blue";
+    EmbedColor[EmbedColor["yellow"] = 16776960] = "yellow";
+    EmbedColor[EmbedColor["cyan"] = 65535] = "cyan";
+    EmbedColor[EmbedColor["magenta"] = 16711935] = "magenta";
+    EmbedColor[EmbedColor["gray"] = 8421504] = "gray";
+    EmbedColor[EmbedColor["lightgray"] = 13882323] = "lightgray";
+    EmbedColor[EmbedColor["darkgray"] = 11119017] = "darkgray";
+    EmbedColor[EmbedColor["orange"] = 16753920] = "orange";
+    EmbedColor[EmbedColor["purple"] = 8388736] = "purple";
+    EmbedColor[EmbedColor["pink"] = 16761035] = "pink";
+    EmbedColor[EmbedColor["brown"] = 10824234] = "brown";
+    EmbedColor[EmbedColor["lime"] = 65280] = "lime";
+    EmbedColor[EmbedColor["navy"] = 128] = "navy";
+    EmbedColor[EmbedColor["teal"] = 32896] = "teal";
+    EmbedColor[EmbedColor["olive"] = 8421376] = "olive";
+    EmbedColor[EmbedColor["gold"] = 16766720] = "gold";
+    EmbedColor[EmbedColor["silver"] = 12632256] = "silver";
+    EmbedColor[EmbedColor["coral"] = 16744272] = "coral";
+    EmbedColor[EmbedColor["salmon"] = 16416882] = "salmon";
+    EmbedColor[EmbedColor["khaki"] = 15787660] = "khaki";
+    EmbedColor[EmbedColor["plum"] = 14524637] = "plum";
+    EmbedColor[EmbedColor["lavender"] = 15132410] = "lavender";
+    EmbedColor[EmbedColor["beige"] = 16119260] = "beige";
+    EmbedColor[EmbedColor["mint"] = 10026904] = "mint";
+    EmbedColor[EmbedColor["peach"] = 16767673] = "peach";
+    EmbedColor[EmbedColor["chocolate"] = 13789470] = "chocolate";
+    EmbedColor[EmbedColor["crimson"] = 14423100] = "crimson";
+    EmbedColor[EmbedColor["youtube"] = 16718362] = "youtube";
+    EmbedColor[EmbedColor["default"] = 6064856] = "default";
+    EmbedColor[EmbedColor["minecraft"] = 25600] = "minecraft";
+})(EmbedColor || (exports.EmbedColor = EmbedColor = {}));
+class EmbedManager {
+    static get BOT_ICON() {
+        return Bot_1.Bot.config.botIconUrl || "";
+    }
+    static get DEFAULT_COLOR() {
+        return Bot_1.Bot.config.defaultEmbedColor || EmbedColor.default;
+    }
+    /**
+     * Creates base embed - SAME SIMPLE API !
+     */
+    static create(color = null) {
+        return new discord_js_1.EmbedBuilder()
+            .setColor(color ?? this.DEFAULT_COLOR)
+            .setTitle('Title')
+            .setDescription('')
+            .setThumbnail('')
+            .setFooter({
+            text: Bot_1.Bot.config.botName || "",
+            iconURL: this.BOT_ICON
+        })
+            .setTimestamp(new Date());
+    }
+    /**
+     * Creates simple embed with just description
+     */
+    static simple(description, color = null) {
+        return this.create(color)
+            .setTitle('')
+            .setDescription(description)
+            .setTimestamp(null);
+    }
+    /**
+     * Creates error embed
+     */
+    static error(description) {
+        return this.create(EmbedColor.error)
+            .setTitle('Something went Wrong')
+            .setDescription(description);
+    }
+    /**
+     * Creates success embed
+     */
+    static success(description) {
+        return this.create(EmbedColor.minecraft)
+            .setTitle('Success')
+            .setDescription(description);
+    }
+    /**
+     * Creates debug embed
+     */
+    static debug(description) {
+        return this.create(EmbedColor.green)
+            .setTitle('Debug')
+            .setDescription(description);
+    }
+    /**
+     * Defer ephemeral reply
+     */
+    static deferEphemeral() {
+        return { flags: discord_js_1.MessageFlags.Ephemeral };
+    }
+    /**
+     * Quick field adder
+     */
+    static field(embed, name, value, inline = false) {
+        return embed.addFields({ name, value, inline });
+    }
+    /**
+     * Fluent API shortcuts
+     */
+    static title(embed, title) {
+        return embed.setTitle(title);
+    }
+    static desc(embed, description) {
+        return embed.setDescription(description);
+    }
+    static thumb(embed, url) {
+        return embed.setThumbnail(url);
+    }
+    static image(embed, url) {
+        return embed.setImage(url);
+    }
+    static footer(embed, text) {
+        return embed.setFooter({ text, iconURL: this.BOT_ICON });
+    }
+}
+exports.EmbedManager = EmbedManager;

package/dist/manager/messages/ReactionManager.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactionManager = void 0;
+const Log_1 = require("../../utils/Log");
+const Bot_1 = require("../../bot/Bot");
+const GuildTextChannelManager_1 = require("../guild/ChannelManager/GuildTextChannelManager");
+class ReactionManager {
+    /**
+     * Add a reaction to a message
+     */
+    static async add(channelId, messageId, emoji) {
+        try {
+            const channel = await GuildTextChannelManager_1.GuildTextChannelManager.find(channelId);
+            if (!channel) {
+                throw new Error(`Channel ${channelId} not found`);
+            }
+            if (!channel.isTextBased()) {
+                throw new Error(`Channel ${channelId} is not text based`);
+            }
+            const message = await channel.messages.fetch(messageId);
+            await message.react(emoji);
+            Log_1.Log.info(`Added reaction ${emoji} to message ${messageId}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to add reaction to ${messageId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Delete a reaction from a user
+     */
+    static async remove(channelId, messageId, emoji, userId) {
+        try {
+            const channel = await GuildTextChannelManager_1.GuildTextChannelManager.find(channelId);
+            if (!channel) {
+                throw new Error(`Channel ${channelId} not found`);
+            }
+            const message = await channel.messages.fetch(messageId);
+            const reaction = message.reactions.resolve(emoji);
+            if (!reaction) {
+                throw new Error(`Reaction ${emoji} not found on message ${messageId}`);
+            }
+            const user = await Bot_1.Bot.client.users.fetch(userId);
+            await reaction.users.remove(user);
+            Log_1.Log.info(`Removed reaction ${emoji} from user ${userId} on message ${messageId}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to remove reaction from ${messageId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Get all reaction of a message
+     */
+    static async getAll(channelId, messageId) {
+        try {
+            const channel = await GuildTextChannelManager_1.GuildTextChannelManager.find(channelId);
+            if (!channel) {
+                throw new Error(`Channel ${channelId} not found`);
+            }
+            const message = await channel.messages.fetch(messageId);
+            const reactions = message.reactions.cache;
+            const reactionList = [];
+            for (const reaction of reactions.values()) {
+                const users = await reaction.users.fetch();
+                reactionList.push({
+                    emoji: reaction.emoji,
+                    count: reaction.count,
+                    users: Array.from(users.values())
+                });
+            }
+            Log_1.Log.info(`Fetched ${reactionList.length} reactions for message ${messageId}`);
+            return reactionList;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to fetch reactions for ${messageId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Delete all reaction
+     */
+    static async clear(channelId, messageId) {
+        try {
+            const channel = await GuildTextChannelManager_1.GuildTextChannelManager.find(channelId);
+            if (!channel) {
+                throw new Error(`Channel ${channelId} not found`);
+            }
+            const message = await channel.messages.fetch(messageId);
+            await message.reactions.removeAll();
+            Log_1.Log.info(`Cleared all reactions from message ${messageId}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to clear reactions from ${messageId}: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.ReactionManager = ReactionManager;

package/dist/manager/messages/WebhookManager.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookManager = void 0;
+const discord_js_1 = require("discord.js");
+const EmbedManager_1 = require("./EmbedManager");
+const Log_1 = require("../../utils/Log");
+const Bot_1 = require("../../bot/Bot");
+class WebhookManager {
+    constructor(channel, name = Bot_1.Bot.config.botName || "", avatarURL) {
+        this.channel = channel;
+        this.name = name;
+        this.avatarURL = avatarURL;
+        this.webhook = null;
+    }
+    get textChannel() {
+        return this.channel instanceof discord_js_1.ThreadChannel
+            ? this.channel.parent
+            : this.channel;
+    }
+    /**
+     * Get or create webhook (lazy initialization)
+     */
+    async getWebhook() {
+        if (this.webhook)
+            return this.webhook;
+        try {
+            const webhooks = await this.textChannel.fetchWebhooks();
+            this.webhook = webhooks.find(h => h.name === this.name) ??
+                await this.textChannel.createWebhook({
+                    name: this.name,
+                    avatar: this.avatarURL,
+                    reason: 'Auto-created by WebhookManager'
+                });
+            Log_1.Log.info(`Webhook ${this.webhook.id} ready for ${this.textChannel.id}`);
+            return this.webhook;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to setup webhook: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Send message/text/embed - EmbedBuilder NATIVE !
+     */
+    async send(content) {
+        const webhook = await this.getWebhook();
+        const options = {};
+        if (content instanceof discord_js_1.EmbedBuilder) {
+            options.embeds = [content];
+        }
+        else if (typeof content === 'object') {
+            Object.assign(options, content);
+        }
+        else {
+            options.content = content;
+        }
+        if (this.channel instanceof discord_js_1.ThreadChannel) {
+            options.threadId = this.channel.id;
+        }
+        try {
+            const message = await webhook.send(options);
+            Log_1.Log.info(`Webhook sent to ${this.channel.id}: ${content}`);
+            return message;
+        }
+        catch (error) {
+            Log_1.Log.error(`Webhook send failed ${this.channel.id}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Quick success embed
+     */
+    async success(message) {
+        return await this.send(EmbedManager_1.EmbedManager.success(message));
+    }
+    /**
+     * Quick error embed
+     */
+    async error(message) {
+        return await this.send(EmbedManager_1.EmbedManager.error(message));
+    }
+    /**
+     * Delete webhook
+     */
+    async delete(reason) {
+        if (!this.webhook)
+            return;
+        try {
+            await this.webhook.delete(reason ?? 'Deleted by WebhookManager');
+            Log_1.Log.info(`Webhook ${this.webhook.id} deleted`);
+        }
+        catch (error) {
+            if (error.message.includes('Unknown Webhook')) {
+                Log_1.Log.warn('Webhook already deleted');
+            }
+            else {
+                Log_1.Log.error(`Failed to delete webhook: ${error}`);
+            }
+        }
+        finally {
+            this.webhook = null;
+        }
+    }
+}
+exports.WebhookManager = WebhookManager;

package/dist/type/FolderName.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FolderName = void 0;
+var FolderName;
+(function (FolderName) {
+    FolderName["SLASH_COMMANDS"] = "commands";
+    FolderName["CONTEXT_MENU"] = "context_menu";
+    FolderName["MODAL"] = "modals";
+})(FolderName || (exports.FolderName = FolderName = {}));

package/dist/utils/DiscordRegex.js

@@ -0,0 +1,116 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordRegex = void 0;
+/**
+ * Classe utilitaire pour valider tous les formats Discord avec regex
+ */
+class DiscordRegex {
+    /**
+     * Validate Discord ID Discord (18)
+     */
+    static isDiscordId(id) {
+        return this.USER_ID.test(id) || this.GUILD_ID.test(id) || this.CHANNEL_ID.test(id);
+    }
+    /**
+     * Validate a bot ID (19)
+     */
+    static isBotMention(mention) {
+        return this.BOT_REGEX.test(mention);
+    }
+    /**
+     * Validate a User ping
+     */
+    static isUserMention(mention) {
+        return this.USER_REGEX.test(mention);
+    }
+    /**
+     * Validate a Discord username
+     */
+    static isUsername(username) {
+        return this.USERNAME.test(username);
+    }
+    /**
+     * Type guard for Discord ID
+     */
+    static isDiscordIdType(id) {
+        return this.isDiscordId(id);
+    }
+    /**
+     * Any Discord URL
+     */
+    static isDiscordUrl(url) {
+        return this.URL_REGEX.test(url) || this.INVITE.test(url);
+    }
+    /**
+     * Any discord mention
+     */
+    static isAnyMention(text) {
+        return this.DISCORD_MENTION_REGEX.test(text);
+    }
+    /**
+     * List all regex
+     */
+    static listAll() {
+        return {
+            SPACE: this.SPACE,
+            URL_REGEX: this.URL_REGEX,
+            USER_REGEX: this.USER_REGEX,
+            BOT_REGEX: this.BOT_REGEX,
+            CHANNEL_REGEX: this.CHANNEL_REGEX,
+            ROLE_REGEX: this.ROLE_REGEX,
+            DISCORD_PING_REGEX: this.DISCORD_PING_REGEX,
+            DISCORD_MENTION_REGEX: this.DISCORD_MENTION_REGEX,
+            USER_ID: this.USER_ID,
+            CHANNEL_ID: this.CHANNEL_ID,
+            GUILD_ID: this.GUILD_ID,
+            USERNAME: this.USERNAME,
+            USERNAME_DISCRIM: this.USERNAME_DISCRIM,
+            CHANNEL_MENTION: this.CHANNEL_MENTION,
+            USER_MENTION: this.USER_MENTION,
+            ROLE_MENTION: this.ROLE_MENTION,
+            INVITE: this.INVITE,
+            EMOJI: this.EMOJI
+        };
+    }
+}
+exports.DiscordRegex = DiscordRegex;
+_a = DiscordRegex;
+// Caractères spéciaux
+DiscordRegex.SPACE = "\u200B";
+// URLs basiques
+DiscordRegex.URL_REGEX = /(https?:\/\/[^s]+)/;
+/* DISCORD REGEX */
+DiscordRegex.USER_REGEX = /<@\d{18}>/;
+DiscordRegex.BOT_REGEX = /<@\d{19}>/;
+DiscordRegex.CHANNEL_REGEX = /(<#\d{19}>)|(<id:(browse|customize|guide)>)/;
+DiscordRegex.ROLE_REGEX = /<@&\d{19}>/;
+/**
+ * Mention a User
+ * Mention a Role
+ */
+DiscordRegex.DISCORD_PING_REGEX = new RegExp(`(${_a.USER_REGEX.source})|(${_a.BOT_REGEX.source})|(${_a.ROLE_REGEX.source})`);
+/**
+ * Mention a User
+ * Mention a Role
+ * Mention a Channel
+ */
+DiscordRegex.DISCORD_MENTION_REGEX = new RegExp(`(${_a.DISCORD_PING_REGEX.source})|(${_a.CHANNEL_REGEX.source})`);
+// ID Discord (user, channel guild)
+DiscordRegex.USER_ID = /^[0-9]{18}$/;
+DiscordRegex.CHANNEL_ID = /^[0-9]{18}$/;
+DiscordRegex.GUILD_ID = /^[0-9]{19}$/;
+// Username Discord (2-32 caractères alphanumériques + _ .)
+DiscordRegex.USERNAME = /^[a-zA-Z0-9_]{2,32}$/;
+// Username + discrim (ancien format)
+DiscordRegex.USERNAME_DISCRIM = /^[a-zA-Z0-9_]{2,32}#\d{4}$/;
+// Channel mention <#123456789012345678>
+DiscordRegex.CHANNEL_MENTION = /^<#([0-9]{18})>$/;
+// User mention <@123456789012345678> ou <@!123456789012345678>
+DiscordRegex.USER_MENTION = /^<@!?([0-9]{18})>$/;
+// Role mention <@&123456789012345678>
+DiscordRegex.ROLE_MENTION = /^<@&([0-9]{18})>$/;
+// URL Invite Discord
+DiscordRegex.INVITE = /^discord(?:app\.com\/invite|gg)\/[a-zA-Z0-9]+$/;
+// Emoji Discord (custom or unicode)
+DiscordRegex.EMOJI = /^<a?:[a-zA-Z0-9_]{2,32}:[0-9]{18}>$|^[\u{1F300}-\u{1F5FF}\u{1F600}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}]+$/u;