xernerx 2.1.6 → 2.2.0

package/models/Client.js

@@ -4,6 +4,7 @@ const { color, config } = require('./data/Functions.js');
 const { CommandHandler } = require('./handlers/CommandHandler.js');
 const { EventHandler } = require('./handlers/EventHandler.js');
 const { LanguageHandler } = require('./handlers/LanguageHandler.js');
+const Loader = require('./handlers/Loader.js');
 
 /**
  * @param {string} guildId - Test guild ID. 
@@ -28,10 +29,14 @@ class Client extends Discord.Client {
             ownerId: s.array(s.string).optional,
             ignoreOwner: s.boolean.optional,
             defaultCooldown: s.number.optional,
-            logging: s.boolean.optional,
+            logging: s.array(s.string).optional,
             cacheTime: s.number.optional,
             userPermissions: s.array(s.string).optional,
-            clientPermissions: s.array(s.string).optional
+            clientPermissions: s.array(s.string).optional,
+            defer: s.object({
+                reply: s.boolean.optional,
+                ephemeral: s.boolean.optional
+            }).optional,
         }).parse(options)
 
         this.client = new Discord.Client({ intents: [options.intents || 0], partials: [options.partials] });
@@ -49,13 +54,20 @@ class Client extends Discord.Client {
 
             defaultCooldown: options.defaultCooldown || 0,
 
-            logging: options.logging || false,
+            logging: options.logging || undefined,
 
             cacheTime: options.cacheTime || 300000,
 
             userPermissions: options.userPermissions || [],
 
-            clientPermissions: options.clientPermissions || []
+            clientPermissions: options.clientPermissions || [],
+
+            defer: {
+                reply: options?.defer?.reply === undefined ? null : options?.defer?.reply,
+                ephemeral: options?.defer?.ephemeral === undefined ? null : options?.defer?.ephemeral
+            },
+
+            language: options.language
         }
 
         this.client.color = color({ client: this.client, options: options });
@@ -69,7 +81,9 @@ class Client extends Discord.Client {
 
             eventHandler: new EventHandler({ client: this.client }),
 
-            // languageHandler: new LanguageHandler({ client: this.client })
+            languageHandler: new LanguageHandler(this.client),
+
+            loader: new Loader(this.client)
         }
 
         return this.client;

package/models/commands/ContextMenuCommand.js

@@ -19,7 +19,8 @@ class ContextMenuCommand {
             channels: s.array(s.string).optional,
             guilds: s.array(s.string).optional,
             userPermissions: s.array(s.string).optional,
-            clientPermissions: s.array(s.string).optional
+            clientPermissions: s.array(s.string).optional,
+            description: s.string.optional
         }).parse(options)
 
         this.data = new Discord.ContextMenuCommandBuilder()
@@ -45,6 +46,8 @@ class ContextMenuCommand {
         this.clientPermissions = options.clientPermissions || [];
 
         this.config = options.config;
+
+        this.description = options.description || undefined;
     }
 
     exec(interaction) {

package/models/commands/InteractionCommand.js

@@ -27,7 +27,11 @@ class InteractionCommand {
             channels: s.array(s.string).optional,
             guilds: s.array(s.string).optional,
             userPermissions: s.array(s.string).optional,
-            clientPermissions: s.array(s.string).optional
+            clientPermissions: s.array(s.string).optional,
+            defer: s.object({
+                reply: s.boolean.optional,
+                ephemeral: s.boolean.optional
+            }).optional
         }).parse(options);
 
         this.data = new SlashCommandBuilder()
@@ -75,6 +79,11 @@ class InteractionCommand {
         this.userPermissions = options.userPermissions || [];
 
         this.clientPermissions = options.clientPermissions || [];
+
+        this.defer = {
+            reply: options?.defer?.reply === undefined ? null : options?.defer?.reply,
+            ephemeral: options?.defer?.ephemeral === undefined ? null : options?.defer?.ephemeral
+        }
     }
 
     exec(interaction) {

package/models/data/Util.js

@@ -63,12 +63,72 @@ function selectMenuPaginator(interaction, embeds, options = {}) {
     })();
 }
 
+function commandName(interaction, cmd) {
+    if (cmd) {
+        cmds = [];
+
+        for (const commands of Object.values(interaction.client.commands)) {
+            let commandInfo = {};
+
+            if (commands.has(cmd)) {
+                const command = commands.get(cmd);
+
+                if (command?.data?.options?.length > 0) {
+                    command?.data?.options?.map(option => {
+                        if (!option?.type) {
+                            if (option?.options?.length > 0) {
+                                option?.options?.map(opt => {
+                                    if (!opt.type) {
+                                        commandInfo.name = command?.data?.name + " " + option?.name + " " + opt?.name;
+
+                                        commandInfo.description = opt.description;
+                                    }
+
+                                    else {
+                                        commandInfo.name = command?.data?.name + " " + option?.name;
+
+                                        commandInfo.description = option?.description;
+                                    }
+                                })
+                            }
+
+                            else {
+                                commandInfo.name = command?.data?.name + " " + option?.name;
+
+                                commandInfo.description = option?.description;
+                            }
+                        }
+
+                        else {
+                            commandInfo.name = command?.data?.name || command?.id;
+
+                            commandInfo.description = command?.data?.description || command?.description;
+                        }
+                    })
+                }
+
+                else {
+                    commandInfo.name = command?.data?.name || command?.id;
+
+                    commandInfo.description = command?.data?.description || command?.description;
+                }
+
+                cmds.push(commandInfo);
+            }
+
+        }
+        return cmds;
+    }
+
+    if (!cmd) return [interaction?.commandName || interaction.content?.replace(interaction.client.settings.prefix.find(p => interaction.content.startsWith(p)), "").split(/ +/)[0], interaction?.options?._group, interaction?.options?._subcommand].join(' ').replace(/  +/g, " ").trim();
+}
+
 function buttonPaginator(interaction, embeds, options = {}) {
     if (!options.buttons) options.buttons = ["⏪", "◀️", "⏹️", "▶️", "⏩"];
 
-    if (options.buttons.length <= 4 || options.buttons.length > 5) throw new Error('Must specify 5 emotes.')
+    if (options.buttons.length <= 4 || options.buttons.length > 5) throw new Error('Must specify 5 emotes.');
 
-    options.row = new ActionRowBuilder()
+    options.row = new ActionRowBuilder();
 
     for (const button of options.buttons) {
         options.row
@@ -78,7 +138,7 @@ function buttonPaginator(interaction, embeds, options = {}) {
                     .setStyle(ButtonStyle[options.style || 'Primary'])
                     .setEmoji(button)
             )
-    }
+    };
 
     (async () => {
         let embed = embeds[options.index || 0];
@@ -135,6 +195,8 @@ class Util {
 
         message.util.buttonPaginator = (embeds, options) => buttonPaginator(message, embeds, options);
 
+        message.util.commandName = (command) => commandName(message, command);
+
         if (type == "create") {
             message.client.messages[message.id] = null;
 
@@ -182,11 +244,21 @@ class Util {
                 const msg = await message.channel.messages.fetch(message.client.messages[message.id]);
 
                 message.util.send = async (e) => {
-                    return await msg.edit(e);
+                    try {
+                        return await msg.edit(e);
+                    }
+                    catch {
+                        message.channel.send(e);
+                    }
                 }
 
                 message.util.reply = async (e) => {
-                    return await msg.edit(e);
+                    try {
+                        return await msg.edit(e);
+                    }
+                    catch {
+                        message.reply(e);
+                    }
                 }
 
                 return;
@@ -202,6 +274,8 @@ class Util {
         interaction.util.selectMenuPaginator = (embeds, options) => selectMenuPaginator(interaction, embeds, options);
 
         interaction.util.buttonPaginator = (embeds, options) => buttonPaginator(interaction, embeds, options);
+
+        interaction.util.commandName = (command) => commandName(interaction, command);
     }
 }
 

package/models/events/interactionCreate.js

@@ -19,8 +19,10 @@ class BuildInInteractionEvent extends Event {
         await interactionUtil(interaction)
 
         if (interaction.type == InteractionType.ApplicationCommand) {
-            if (interaction.client.interactionCommands.has(interaction.commandName)) {
-                let command = interaction.client.interactionCommands.get(interaction.commandName);
+            if (interaction.client.commands.interaction.has(interaction.commandName)) {
+                let command = interaction.client.commands.interaction.get(interaction.commandName);
+
+                await this.defer(interaction, command);
 
                 command.client = interaction.client;
 
@@ -42,8 +44,10 @@ class BuildInInteractionEvent extends Event {
                 }
             }
 
-            if (interaction.client.contextMenuCommands.has(interaction.commandName)) {
-                let command = interaction.client.contextMenuCommands.get(interaction.commandName);
+            if (interaction.client.commands.contextMenu.has(interaction.commandName)) {
+                let command = interaction.client.commands.contextMenu.get(interaction.commandName);
+
+                await this.defer(interaction, command);
 
                 command.client = interaction.client;
 
@@ -58,6 +62,14 @@ class BuildInInteractionEvent extends Event {
             }
         }
     }
+
+    async defer(interaction, command) {
+        if (command?.defer?.reply) return await interaction.deferReply({ ephemeral: command?.defer?.ephemeral });
+
+        else if (command?.defer?.reply === false && interaction.client?.settings?.defer?.reply) return;
+
+        else if (interaction.client?.settings?.defer?.reply) return await interaction.deferReply({ ephemeral: interaction.client?.settings?.defer?.ephemeral || command?.defer?.ephemeral });
+    }
 }
 
 module.exports = BuildInInteractionEvent;

package/models/events/messageCreate.js

@@ -26,9 +26,9 @@ class BuildInMessageEvent extends Event {
 
                 let command = message.content.replace(prefix, "").split(/ +/).shift().toLowerCase();
 
-                if (!message.client.messageCommands.has(command) || command == '') return;
+                if (!message.client.commands.message.has(command) || command == '') return;
 
-                command = message.client.messageCommands.get(command);
+                command = message.client.commands.message.get(command);
 
                 command.client = message.client;
 

package/models/events/messageUpdate.js

@@ -29,9 +29,9 @@ class BuildInMessageUpdateEvent extends Event {
 
                 let command = newMessage.content.replace(prefix, "").split(/ +/).shift().toLowerCase();
 
-                if (!newMessage.client.messageCommands.has(command) || command === '') return;
+                if (!newMessage.client.commands.message.has(command) || command === '') return;
 
-                command = newMessage.client.messageCommands.get(command);
+                command = newMessage.client.commands.message.get(command);
 
                 command.client = newMessage.client;
 

package/models/events/readyOnce.js

@@ -14,6 +14,29 @@ class BuildInReadyOnceEvent extends Event {
 
     async run(client) {
         if (client.logging) console.log(logStyle(`${client.user.tag} is online in ${(await client.guilds.fetch()).size} server(s).`, "text", "green"))
+
+        if (client.settings.logging) {
+            let loaded = [];
+
+            for (const [type, commands] of Object.entries(client.commands)) {
+                for (let [id, command] of commands) {
+                    command.name = command?.data?.name || command?.aliases[0] || command.id;
+
+                    command.description = command?.data?.description || command.description;
+
+                    command.runType = type;
+
+                    if (!loaded.includes(command)) loaded.push(command);
+                }
+            }
+            for (const [id, event] of [...client.events]) {
+                event.runType = 'event'
+
+                loaded.push(event)
+            }
+
+            console.table(loaded, client.settings.logging);
+        }
     }
 };
 

package/models/handlers/CommandHandler.js

@@ -3,7 +3,8 @@ const Discord = require('discord.js');
 const { REST } = require('@discordjs/rest');
 const { Routes, GatewayVersion } = require('discord-api-types/v10');
 const { delay, logStyle } = require('dumfunctions')
-const paths = require("path")
+const paths = require("path");
+const Loader = require('./Loader.js');
 
 /**
  * @param {object} client - The client.
@@ -16,117 +17,27 @@ class CommandHandler {
 
         this.commands = [];
 
-        client.messageCommands = new Discord.Collection();
+        client.commands = {
+            message: new Discord.Collection(),
 
-        client.interactionCommands = new Discord.Collection();
+            interaction: new Discord.Collection(),
 
-        client.contextMenuCommands = new Discord.Collection();
-    }
-
-    loadAllInteractionCommands(path, logging = false) {
-        let commands = [];
-
-        const commandFiles = fs.readdirSync(path).filter(file => file.endsWith('.js'))
-
-        for (const file of commandFiles) {
-            let filepath = `${require("path").resolve(path)}/${file}`
-
-            let command = require(filepath);
-
-            command = new command;
-
-            command.filepath = filepath;
-
-            this.commands.push(command.data.toJSON());
-
-            commands.push(command.data.name);
-
-            this.client.interactionCommands.set(command.data.name, command);
+            contextMenu: new Discord.Collection()
         }
 
-        this.#deployCommands("interaction commands", logging);
+        this.load = new Loader(client);
+    }
 
-        if (logging || this.client.settings.logging) console.info(logStyle(`Loading interaction commands: ${commands.join(', ')}`, "text", "yellow"));
+    loadAllInteractionCommands(path, logging = false) {
+        this.load.loadAllInteractionCommands(path, logging);
     }
 
     loadAllContextMenuCommands(path, logging = false) {
-        let commands = [];
-
-        const commandFiles = fs.readdirSync(path).filter(file => file.endsWith('.js'));
-
-        for (const file of commandFiles) {
-            let filepath = `${require("path").resolve(path)}/${file}`
-
-            let command = require(filepath);
-
-            command = new command;
-
-            command.filepath = filepath;
-
-            this.commands.push(command.data.toJSON());
-
-            commands.push(command.data.name);
-
-            this.client.contextMenuCommands.set(command.data.name, command);
-        }
-
-        this.#deployCommands("context menu commands", logging);
-
-        if (logging || this.client.settings.logging) console.info(logStyle(`Loading context menu commands: ${commands.join(', ')}`, 'text', 'yellow'));
+        this.load.loadAllContextMenuCommands(path, logging);
     }
 
     loadAllMessageCommands(path, logging = false) {
-        let commands = [];
-
-        const commandFiles = fs.readdirSync(path).filter(file => file.endsWith('.js'));
-
-        for (const file of commandFiles) {
-            let filepath = `${require("path").resolve(path)}/${file}`
-
-            let command = require(filepath);
-
-            command = new command;
-
-            command.filepath = filepath;
-
-            command.aliases.forEach((alias) => {
-                if (this.client.messageCommands.has(alias)) throw new Error('Cannot have duplicated aliases.');
-
-                this.client.messageCommands.set(alias, command);
-            });
-
-            commands.push(command.name || command.id);
-        }
-
-        if (logging || this.client.settings.logging) console.info(logStyle(`Loaded message commands: ${commands.join(', ')}`, 'text', 'purple'));
-    }
-
-    #deployCommands(type, logging = false) {
-        this.client.once('ready', client => {
-            const rest = new REST({ version: GatewayVersion }).setToken(client.token);
-
-            (async () => {
-                if (type === "interaction commands" && client.settings.logging) console.log(logStyle(`${client.user.tag} is online in ${(await client.guilds.fetch()).size} servers.`, "text", "cyan"));
-
-                try {
-                    if (client.settings.global == true) {
-                        if (logging || this.client.settings.logging) console.info(logStyle(`Loaded ${type} in ${(await client.guilds.fetch()).size} server(s) globally.`, 'text', 'purple'));
-                        rest.put(Routes.applicationCommands(client.user.id), {
-                            body: this.commands
-                        })
-                    }
-                    else {
-                        if (logging || this.client.settings.logging) console.info(logStyle(`Loaded ${type} locally.`, 'text', 'purple'));
-                        rest.put(Routes.applicationGuildCommands(client.user.id, client.settings.guildId), {
-                            body: this.commands
-                        })
-                    }
-                }
-                catch (e) {
-                    throw new Error(e)
-                }
-            })();
-        })
+        this.load.loadAllMessageCommands(path, logging);
     }
 }
 

package/models/handlers/EventHandler.js

@@ -1,5 +1,5 @@
-const { logStyle } = require('dumfunctions');
 const fs = require('fs');
+const Discord = require('discord.js');
 
 /**
  * @param {object} client - Client object.
@@ -7,13 +7,13 @@ const fs = require('fs');
 class EventHandler {
     constructor({ client: client }) {
         this.client = client;
+
+        client.events = new Discord.Collection()
     }
 
-    loadEvents(path, logging) {
+    loadAllEvents(path, logging) {
         const eventFiles = fs.readdirSync(path).filter(file => file.endsWith('.js'))
 
-        let events = [];
-
         for (const file of eventFiles) {
             let event = require(`${require("path").resolve(path)}/${file}`);
 
@@ -21,7 +21,7 @@ class EventHandler {
 
             event.client = this.client;
 
-            events.push(event.name);
+            this.client.events.set(event.name, event);
 
             if (event.once) {
                 this.emitter(event.type).once(event.name, (...args) => {
@@ -35,8 +35,6 @@ class EventHandler {
             }
         }
 
-        if (logging || this.client.settings.logging) console.info(logStyle(`Loaded events: ${events.join(', ')}`, 'text', 'purple'));
-
         const builderFiles = fs.readdirSync(`${__dirname}/../events`).filter(file => file.endsWith('.js'))
 
         for (const file of builderFiles) {

package/models/handlers/LanguageHandler.js

@@ -3,25 +3,15 @@ const fs = require('fs');
 const i = require('i18next');
 
 class LanguageHandler {
-    constructor({ client, lang, fallbackLang, ns }) {
+    constructor(client) {
         this.client = client;
 
-        this.lang = lang;
-
-        this.fallbackLang = fallbackLang;
-
-        this.ns = ns;
-
-        i.init({
-            lng: lang,
-            fallbackLng: fallbackLang,
-            ns: ns
-        })
+        i.init(this.client.settings.language)
 
         this.client.languages = []
     }
 
-    loadLanguages({ path, resources = true, deep = true, logging = false }) {
+    loadAllLanguages(path, deep = true, overwrite = true) {
         let langs = [];
 
         const languages = fs.readdirSync(path).filter(file => file.endsWith('.json'));
@@ -29,20 +19,14 @@ class LanguageHandler {
         for (const file of languages) {
             const language = require(`${require("path").resolve(path)}/${file}`);
 
-            i.addResourceBundle(
-                file.replace('.json', ""),
-                this.ns,
-                language,
-                resources,
-                deep
-            )
+            i.addResourceBundle(file.replace('.json', ""), this.ns, language, deep, overwrite)
 
             this.client.languages.push(file.replace('.json', ""));
 
             langs.push(file.replace('.json', ""));
         }
 
-        if (logging || this.client.logging) console.info(logStyle(`Loaded languages: ${langs.join(', ')}`, 'text', 'purple'))
+        if (this.client.settings.logging) console.info(logStyle(`Loaded languages: ${langs.join(', ')}`, 'text', 'purple'))
     }
 }
 

package/models/handlers/Loader.js

@@ -0,0 +1,205 @@
+const fs = require('fs');
+const Discord = require('discord.js');
+const { REST } = require('@discordjs/rest');
+const { Routes, GatewayVersion } = require('discord-api-types/v10');
+const { logStyle } = require('dumfunctions');
+
+class Loader {
+    constructor(client) {
+        this.client = client;
+
+        this.commands = [];
+
+        client.commands = {
+            message: new Discord.Collection(),
+
+            interaction: new Discord.Collection(),
+
+            contextMenu: new Discord.Collection()
+        }
+    }
+
+    loadAllInteractionCommands(path, logging = false) {
+        const commandFiles = fs.readdirSync(path).filter(file => file.endsWith('.js'))
+
+        for (const file of commandFiles) {
+            let filepath = `${require("path").resolve(path)}/${file}`
+
+            let command = require(filepath);
+
+            command = new command;
+
+            command.filepath = filepath;
+
+            this.commands.push(command.data.toJSON());
+
+            this.client.commands.interaction.set(command.data.name, command);
+        }
+
+        this.#deployCommands("interaction commands", logging);
+    }
+
+    reloadAllInteractionCommands() {
+        let commands = this.client.commands.interaction.map(command => command.filepath);
+
+        this.commands = [];
+
+        this.client.commands.interaction.sweep(() => true);
+
+        commands.map(path => {
+            delete require.cache[require.resolve(path)];
+
+            let command = require(path);
+
+            command = new command;
+
+            command.filepath = path;
+
+            this.commands.push(command.data.toJSON());
+
+            this.client.commands.interaction.set(command.data.name, command);
+        })
+
+        return this.#redeployCommands()
+    }
+
+    loadAllContextMenuCommands(path, logging = false) {
+        const commandFiles = fs.readdirSync(path).filter(file => file.endsWith('.js'));
+
+        for (const file of commandFiles) {
+            let filepath = `${require("path").resolve(path)}/${file}`
+
+            let command = require(filepath);
+
+            command = new command;
+
+            command.filepath = filepath;
+
+            this.commands.push(command.data.toJSON());
+
+            this.client.commands.contextMenu.set(command.data.name, command);
+        }
+
+        this.#deployCommands("context menu commands", logging);
+    }
+
+    reloadAllContextMenuCommands() {
+        let commands = this.client.commands.contextMenu.map(command => command.filepath);
+
+        this.commands = [];
+
+        this.client.commands.contextMenu.sweep(() => true);
+
+        commands.map(path => {
+            delete require.cache[require.resolve(path)];
+
+            let command = require(path);
+
+            command = new command;
+
+            command.filepath = path;
+
+            this.commands.push(command.data.toJSON());
+
+            this.client.commands.contextMenu.set(command.data.name, command);
+        })
+
+        return this.#redeployCommands()
+    }
+
+    loadAllMessageCommands(path, logging = false) {
+        const commandFiles = fs.readdirSync(path).filter(file => file.endsWith('.js'));
+
+        for (const file of commandFiles) {
+            let filepath = `${require("path").resolve(path)}/${file}`
+
+            let command = require(filepath);
+
+            command = new command;
+
+            command.filepath = filepath;
+
+            command.aliases.forEach((alias) => {
+                if (this.client.commands.message.has(alias)) throw new Error('Cannot have duplicated aliases.');
+
+                this.client.commands.message.set(alias, command);
+            });
+        }
+    }
+
+    reloadAllMessageCommands() {
+        let commands = this.client.commands.message.map(command => command.filepath);
+
+        this.commands = [];
+
+        this.client.commands.message.sweep(() => true);
+
+        commands.map(path => {
+            delete require.cache[require.resolve(path)];
+
+            let command = require(path);
+
+            command = new command;
+
+            command.filepath = path;
+
+            this.client.commands.message.set(command.id, command);
+        })
+
+        return this.#redeployCommands()
+    }
+
+    #deployCommands(type, logging = false) {
+        this.client.once('ready', client => {
+            const rest = new REST({ version: GatewayVersion }).setToken(client.token);
+
+            (async () => {
+                if (type === "interaction commands" && client.settings.logging) console.log(logStyle(`${client.user.tag} is online in ${(await client.guilds.fetch()).size} servers.`, "text", "cyan"));
+
+                try {
+                    if (client.settings.global == true) {
+                        if (logging || this.client.settings.logging) console.info(logStyle(`Loaded ${type} in ${(await client.guilds.fetch()).size} server(s) globally.`, 'text', 'purple'));
+                        rest.put(Routes.applicationCommands(client.user.id), {
+                            body: this.commands
+                        })
+                    }
+                    else {
+                        if (logging || this.client.settings.logging) console.info(logStyle(`Loaded ${type} locally.`, 'text', 'purple'));
+                        rest.put(Routes.applicationGuildCommands(client.user.id, client.settings.guildId), {
+                            body: this.commands
+                        })
+                    }
+                }
+                catch (e) {
+                    throw new Error(e)
+                }
+            })();
+        })
+    }
+
+    #redeployCommands() {
+        const rest = new REST({ version: GatewayVersion }).setToken(this.client.token);
+
+        (async () => {
+            try {
+                if (this.client.settings.global == true) {
+                    rest.put(Routes.applicationCommands(this.client.user.id), {
+                        body: this.commands
+                    })
+                }
+                else {
+                    rest.put(Routes.applicationGuildCommands(this.client.user.id, this.client.settings.guildId), {
+                        body: this.commands
+                    })
+                }
+            }
+            catch (e) {
+                throw new Error(e)
+            }
+        })();
+
+        return this.commands;
+    }
+}
+
+module.exports = Loader;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xernerx",
-  "version": "2.1.6",
+  "version": "2.2.0",
   "description": "A bot framework for discord.js. [BETA]",
   "main": "main.js",
   "scripts": {
@@ -19,10 +19,10 @@
   "dependencies": {
     "@discordjs/rest": "1.0.1",
     "@sapphire/shapeshift": "3.5.1",
-    "discord-api-types": "^0.37.0",
-    "discord.js": "^14.1.2",
+    "discord-api-types": "^0.37.3",
+    "discord.js": "^14.2.0",
     "dumfunctions": "^1.0.7",
-    "i18next": "^21.8.16"
+    "i18next": "^21.9.1"
   },
   "packageManager": "npm@8.5.5"
 }