xernerx 4.2.0 → 4.2.1

package/dist/cjs/handlers/Handler.js

@@ -0,0 +1,308 @@
+'use strict';
+var __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              var desc = Object.getOwnPropertyDescriptor(m, k);
+              if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+                  desc = {
+                      enumerable: true,
+                      get: function () {
+                          return m[k];
+                      },
+                  };
+              }
+              Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+          });
+var __setModuleDefault =
+    (this && this.__setModuleDefault) ||
+    (Object.create
+        ? function (o, v) {
+              Object.defineProperty(o, 'default', { enumerable: true, value: v });
+          }
+        : function (o, v) {
+              o['default'] = v;
+          });
+var __importStar =
+    (this && this.__importStar) ||
+    function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k in mod) if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.Handler = void 0;
+const fs_1 = __importDefault(require('fs'));
+const path = __importStar(require('path'));
+const enums_js_1 = require('../types/enums.js');
+const shapeshift_1 = require('@sapphire/shapeshift');
+const dumfunctions_1 = require('dumfunctions');
+// TODO - Add reload<handlerFunction>
+// TODO - Add unload<handlerFunction>
+// TODO - Rename load<handlerFunction>
+// TODO - Update validator to zod
+/**
+ * @description - The Handler class.
+ * @param {XernerxClient} client - The XernerxClient.
+ */
+class Handler {
+    client;
+    commands;
+    readyTimestamp;
+    constructor(client) {
+        this.client = client;
+        this.commands = [];
+        this.readyTimestamp = Number(Date.now());
+    }
+    /**
+     * @description - The loader for the message commands.
+     * @param {MessageCommandOptions} options - The options for the message command loader.
+     */
+    loadAllMessageCommands(options) {
+        this.client.handlerOptions.message = shapeshift_1.s
+            .object({
+                directory: shapeshift_1.s.string,
+                prefix: shapeshift_1.s.union(shapeshift_1.s.string, shapeshift_1.s.array(shapeshift_1.s.string)),
+                allowMention: shapeshift_1.s.boolean.default(false),
+                cooldown: shapeshift_1.s.number.default(0),
+                userPermissions: shapeshift_1.s.array(shapeshift_1.s.bigint).default([]),
+                clientPermissions: shapeshift_1.s.array(shapeshift_1.s.bigint).default([]),
+                handleEdits: shapeshift_1.s.boolean.default(false),
+                handleDeletes: shapeshift_1.s.boolean.default(false),
+                handleTyping: shapeshift_1.s.boolean.default(false),
+                logging: shapeshift_1.s.boolean.default(false),
+            })
+            .parse(options);
+        const files = this.readdir(options.directory),
+            loaded = [];
+        for (const file of files) {
+            this.load(options.directory, file, enums_js_1.CommandType.MessageCommand);
+            loaded.push(file.replace('.js', ''));
+        }
+        if (this.client.handlerOptions.message?.logging)
+            console.info(
+                dumfunctions_1.Style.log(`Xernerx | Loaded ${loaded.length} message commands: ${loaded.join(', ')}.`, {
+                    color: dumfunctions_1.Style.TextColor.Cyan,
+                })
+            );
+    }
+    /**
+     * @description - The loader for the slash commands.
+     * @param {SlashCommandOptions} options - The options for the slash command loader.
+     */
+    loadAllSlashCommands(options) {
+        this.client.handlerOptions.slash = shapeshift_1.s
+            .object({
+                directory: shapeshift_1.s.string,
+                guildId: shapeshift_1.s.string,
+                global: shapeshift_1.s.boolean,
+                cooldown: shapeshift_1.s.number.default(0),
+                userPermissions: shapeshift_1.s.array(shapeshift_1.s.bigint).default([]),
+                clientPermissions: shapeshift_1.s.array(shapeshift_1.s.bigint).default([]),
+                logging: shapeshift_1.s.boolean.default(false),
+                defer: shapeshift_1.s.object({
+                    reply: shapeshift_1.s.boolean.optional,
+                    ephemeral: shapeshift_1.s.boolean.optional,
+                    fetchReply: shapeshift_1.s.boolean.optional,
+                }).optional,
+            })
+            .parse(options);
+        const files = this.readdir(options.directory),
+            loaded = [];
+        for (const file of files) {
+            this.load(options.directory, file, enums_js_1.CommandType.SlashCommand);
+            loaded.push(file.replace('.js', ''));
+        }
+        if (this.client.handlerOptions.slash?.logging)
+            console.info(
+                dumfunctions_1.Style.log(`Xernerx | Loaded ${loaded.length} slash commands: ${loaded.join(', ')}.`, {
+                    color: dumfunctions_1.Style.TextColor.Cyan,
+                })
+            );
+    }
+    /**
+     * @description - The loader for the context commands.
+     * @param {ContextCommandOptions} options - The options for the context command loader.
+     */
+    loadAllContextCommands(options) {
+        this.client.handlerOptions.context = shapeshift_1.s
+            .object({
+                directory: shapeshift_1.s.string,
+                guildId: shapeshift_1.s.string,
+                global: shapeshift_1.s.boolean,
+                cooldown: shapeshift_1.s.number.default(0),
+                userPermissions: shapeshift_1.s.array(shapeshift_1.s.bigint).default([]),
+                clientPermissions: shapeshift_1.s.array(shapeshift_1.s.bigint).default([]),
+                logging: shapeshift_1.s.boolean.default(false),
+                defer: shapeshift_1.s.object({
+                    reply: shapeshift_1.s.boolean.optional,
+                    ephemeral: shapeshift_1.s.boolean.optional,
+                    fetchReply: shapeshift_1.s.boolean.optional,
+                }).optional,
+            })
+            .parse(options);
+        const files = this.readdir(options.directory),
+            loaded = [];
+        for (const file of files) {
+            this.load(options.directory, file, enums_js_1.CommandType.ContextCommand);
+            loaded.push(file.replace('.js', ''));
+        }
+        if (this.client.handlerOptions.context?.logging)
+            console.info(
+                dumfunctions_1.Style.log(`Xernerx | Loaded ${loaded.length} context commands: ${loaded.join(', ')}.`, {
+                    color: dumfunctions_1.Style.TextColor.Cyan,
+                })
+            );
+    }
+    /**
+     * @description - The loader for the events.
+     * @param {EventLoadOptions} options - The options for the event loader.
+     */
+    loadAllEvents(options) {
+        this.client.handlerOptions.events = shapeshift_1.s
+            .object({
+                directory: shapeshift_1.s.string,
+                logging: shapeshift_1.s.boolean.default(false),
+            })
+            .parse(options);
+        const files = this.readdir(options.directory),
+            loaded = [];
+        (async () => {
+            for (const file of files) {
+                try {
+                    options.directory.split(/\//).shift();
+                    let event = (await import('file://' + `${path.resolve(options.directory)}/${file}`)).default;
+                    event = new event();
+                    event.client = this.client;
+                    event.commandType = enums_js_1.CommandType.Event;
+                    this.client.events.set(event.name, event);
+                    this.emitter(event);
+                } catch (error) {
+                    console.error(dumfunctions_1.Style.log(`Xernerx | Couldn't load ${file} because <${error}>`, { color: dumfunctions_1.Style.BackgroundColor.Red }));
+                }
+                loaded.push(file.replace('.js', ''));
+            }
+            if (this.client.handlerOptions.events?.logging)
+                console.info(dumfunctions_1.Style.log(`Xernerx | Loaded ${loaded.length} events: ${loaded.join(', ')}.`, { color: dumfunctions_1.Style.TextColor.Cyan }));
+        })();
+    }
+    /**
+     * @description - The loader for the inhibitors.
+     * @param {InhibitorLoadOptions} options - The options for the inhibitor loader.
+     */
+    loadAllInhibitors(options) {
+        this.client.handlerOptions.inhibitors = shapeshift_1.s
+            .object({
+                directory: shapeshift_1.s.string,
+                logging: shapeshift_1.s.boolean.default(false),
+            })
+            .parse(options);
+        const files = this.readdir(options.directory),
+            loaded = [];
+        for (const file of files) {
+            this.load(options.directory, file, enums_js_1.CommandType.Inhibitor);
+            loaded.push(file.replace('.js', ''));
+        }
+        if (this.client.handlerOptions.inhibitors?.logging)
+            console.info(
+                dumfunctions_1.Style.log(`Xernerx | Loaded ${loaded.length} inhibitors: ${loaded.join(', ')}.`, {
+                    color: dumfunctions_1.Style.TextColor.Cyan,
+                })
+            );
+    }
+    /**
+     * @description - a reader for directories
+     * @param {string} dir - the directory to look for.
+     * @returns array of files.
+     */
+    readdir(dir) {
+        try {
+            return fs_1.default.readdirSync(path.resolve(dir)).filter((file) => file.endsWith('.js'));
+        } catch (error) {
+            console.error(dumfunctions_1.Style.log(`Xernerx | Couldn't read ${dir} because <${error}>.`, { color: dumfunctions_1.Style.BackgroundColor.Red }));
+        }
+        return [];
+    }
+    /**
+     * @description file loader.
+     * @param {string} dir - the directory.
+     * @param {string} file - the file in the directory.
+     * @param {string} type - the type of file.
+     * @returns undefined
+     */
+    async load(dir, file, type) {
+        try {
+            dir.split(/\//).shift();
+            let command = (await import('file://' + `${path.resolve(dir)}/${file}`)).default;
+            command = new command();
+            command.client = this.client;
+            command.commandType = type;
+            command.filepath = `${path.resolve(dir)}\\${file}`;
+            command.file = file;
+            if (type === enums_js_1.CommandType.MessageCommand) this.client.commands.message.set(command?.name || command?.name, command);
+            if (type === enums_js_1.CommandType.SlashCommand) {
+                this.client.commands.slash.set(command?.data?.name || command?.name, command);
+            }
+            if (type === enums_js_1.CommandType.ContextCommand) {
+                this.client.commands.context.set(command?.data?.name || command?.name, command);
+            }
+            if (type === enums_js_1.CommandType.Event) {
+                this.client.events.set(command.name, command);
+            }
+            if (type === enums_js_1.CommandType.Inhibitor) {
+                this.client.inhibitors.set(command.name, command);
+            }
+        } catch (error) {
+            console.error(dumfunctions_1.Style.log(`Xernerx | Couldn't load ${file} because <${error}>`, { color: dumfunctions_1.Style.BackgroundColor.Red }));
+        }
+    }
+    /**
+     * @description the event emitter to emit all events.
+     * @param {object} event - the event to be emitted.
+     * @returns void
+     */
+    emitter(event) {
+        const client = this.client;
+        if (event.emitter === 'client') {
+            if (event.once)
+                client.once(event.name, (...args) => {
+                    event.run(...args);
+                });
+            else
+                client.on(event.name, (...args) => {
+                    event.run(...args);
+                });
+        } else if (event.emitter === 'rest') {
+            if (event.once)
+                client.once(event.name, (...args) => {
+                    event.run(...args);
+                });
+            else
+                client.on(event.name, (...args) => {
+                    event.run(...args);
+                });
+        } else if (event.emitter === 'process') {
+            if (event.once)
+                process.once(event.name, (...args) => {
+                    event.run(...args);
+                });
+            else
+                process.on(event.name, (...args) => {
+                    event.run(...args);
+                });
+        }
+    }
+}
+exports.Handler = Handler;

package/dist/cjs/handlers/InhibitorHandler.d.ts

@@ -0,0 +1,18 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { InhibitorHandlerOptions } from '../types/options.js';
+import { Handler } from './Handler.js';
+/**
+ * @description - Inhibitor loader.
+ * @param {XernerxClient} client - The XernerxClient.
+ */
+export default class InhibitorHandler {
+    client: XernerxClient;
+    handler: Handler;
+    constructor(client: XernerxClient);
+    /**
+     * @description - The loader for all inhibitors.
+     * @param {InhibitorLoadOptions} options - the inhibitor loader options.
+     * @returns undefined
+     */
+    loadAllInhibitors(options: InhibitorHandlerOptions): void;
+}

package/dist/cjs/handlers/InhibitorHandler.js

@@ -0,0 +1,24 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const Handler_js_1 = require('./Handler.js');
+/**
+ * @description - Inhibitor loader.
+ * @param {XernerxClient} client - The XernerxClient.
+ */
+class InhibitorHandler {
+    client;
+    handler;
+    constructor(client) {
+        this.client = client;
+        this.handler = new Handler_js_1.Handler(client);
+    }
+    /**
+     * @description - The loader for all inhibitors.
+     * @param {InhibitorLoadOptions} options - the inhibitor loader options.
+     * @returns undefined
+     */
+    loadAllInhibitors(options) {
+        this.handler.loadAllInhibitors(options);
+    }
+}
+exports.default = InhibitorHandler;

package/dist/cjs/main.d.ts

@@ -0,0 +1,44 @@
+export * from 'discord.js';
+export * from 'dumfunctions';
+import ExtensionBuilder from 'xernerx-extension-builder';
+import XernerxClient from './client/XernerxClient.js';
+import EventBuilder from './build/EventBuilder.js';
+import InhibitorBuilder from './build/InhibitorBuilder.js';
+import MessageCommandBuilder from './build/MessageCommandBuilder.js';
+import ContextCommandBuilder from './build/ContextCommandBuilder.js';
+import SlashCommandBuilder from './build/SlashCommandBuilder.js';
+import { CommandType, EventEmitterType, ContextCommandType, InhibitorType } from './types/enums.js';
+import XernerxError from './tools/XernerxError.js';
+declare const xernerxVersion: string;
+declare const _default: {
+    Client: typeof XernerxClient;
+    XernerxClient: typeof XernerxClient;
+    CommandType: typeof CommandType;
+    EventEmitterType: typeof EventEmitterType;
+    InhibitorType: typeof InhibitorType;
+    ContextCommandType: typeof ContextCommandType;
+    EventBuilder: typeof EventBuilder;
+    MessageCommandBuilder: typeof MessageCommandBuilder;
+    ContextCommandBuilder: typeof ContextCommandBuilder;
+    SlashCommandBuilder: typeof SlashCommandBuilder;
+    InhibitorBuilder: typeof InhibitorBuilder;
+    ExtensionBuilder: typeof ExtensionBuilder;
+    XernerxError: typeof XernerxError;
+    version: string;
+};
+export default _default;
+export {
+    XernerxClient,
+    CommandType,
+    EventEmitterType,
+    InhibitorType,
+    ContextCommandType,
+    EventBuilder,
+    MessageCommandBuilder,
+    ContextCommandBuilder,
+    SlashCommandBuilder,
+    InhibitorBuilder,
+    ExtensionBuilder,
+    XernerxError,
+    xernerxVersion,
+};

package/dist/cjs/main.js

@@ -0,0 +1,112 @@
+'use strict';
+var __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              var desc = Object.getOwnPropertyDescriptor(m, k);
+              if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+                  desc = {
+                      enumerable: true,
+                      get: function () {
+                          return m[k];
+                      },
+                  };
+              }
+              Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+          });
+var __exportStar =
+    (this && this.__exportStar) ||
+    function (m, exports) {
+        for (var p in m) if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+    };
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.xernerxVersion =
+    exports.XernerxError =
+    exports.ExtensionBuilder =
+    exports.InhibitorBuilder =
+    exports.SlashCommandBuilder =
+    exports.ContextCommandBuilder =
+    exports.MessageCommandBuilder =
+    exports.EventBuilder =
+    exports.ContextCommandType =
+    exports.InhibitorType =
+    exports.EventEmitterType =
+    exports.CommandType =
+    exports.XernerxClient =
+        void 0;
+__exportStar(require('discord.js'), exports);
+__exportStar(require('dumfunctions'), exports);
+const xernerx_extension_builder_1 = __importDefault(require('xernerx-extension-builder'));
+exports.ExtensionBuilder = xernerx_extension_builder_1.default;
+const XernerxClient_js_1 = __importDefault(require('./client/XernerxClient.js'));
+exports.XernerxClient = XernerxClient_js_1.default;
+const EventBuilder_js_1 = __importDefault(require('./build/EventBuilder.js'));
+exports.EventBuilder = EventBuilder_js_1.default;
+const InhibitorBuilder_js_1 = __importDefault(require('./build/InhibitorBuilder.js'));
+exports.InhibitorBuilder = InhibitorBuilder_js_1.default;
+const MessageCommandBuilder_js_1 = __importDefault(require('./build/MessageCommandBuilder.js'));
+exports.MessageCommandBuilder = MessageCommandBuilder_js_1.default;
+const ContextCommandBuilder_js_1 = __importDefault(require('./build/ContextCommandBuilder.js'));
+exports.ContextCommandBuilder = ContextCommandBuilder_js_1.default;
+const SlashCommandBuilder_js_1 = __importDefault(require('./build/SlashCommandBuilder.js'));
+exports.SlashCommandBuilder = SlashCommandBuilder_js_1.default;
+const enums_js_1 = require('./types/enums.js');
+Object.defineProperty(exports, 'CommandType', {
+    enumerable: true,
+    get: function () {
+        return enums_js_1.CommandType;
+    },
+});
+Object.defineProperty(exports, 'EventEmitterType', {
+    enumerable: true,
+    get: function () {
+        return enums_js_1.EventEmitterType;
+    },
+});
+Object.defineProperty(exports, 'ContextCommandType', {
+    enumerable: true,
+    get: function () {
+        return enums_js_1.ContextCommandType;
+    },
+});
+Object.defineProperty(exports, 'InhibitorType', {
+    enumerable: true,
+    get: function () {
+        return enums_js_1.InhibitorType;
+    },
+});
+const XernerxError_js_1 = __importDefault(require('./tools/XernerxError.js'));
+exports.XernerxError = XernerxError_js_1.default;
+const package_js_1 = __importDefault(require('./tools/package.js'));
+const xernerxVersion = package_js_1.default.version;
+exports.xernerxVersion = xernerxVersion;
+exports.default = {
+    // Client
+    Client: XernerxClient_js_1.default,
+    XernerxClient: XernerxClient_js_1.default,
+    // Enums
+    CommandType: enums_js_1.CommandType,
+    EventEmitterType: enums_js_1.EventEmitterType,
+    InhibitorType: enums_js_1.InhibitorType,
+    ContextCommandType: enums_js_1.ContextCommandType,
+    // Builds
+    EventBuilder: EventBuilder_js_1.default,
+    MessageCommandBuilder: MessageCommandBuilder_js_1.default,
+    ContextCommandBuilder: ContextCommandBuilder_js_1.default,
+    SlashCommandBuilder: SlashCommandBuilder_js_1.default,
+    InhibitorBuilder: InhibitorBuilder_js_1.default,
+    ExtensionBuilder: xernerx_extension_builder_1.default,
+    XernerxError: XernerxError_js_1.default,
+    // Constants
+    version: xernerxVersion,
+};

package/dist/cjs/models/CommandArguments.d.ts

@@ -0,0 +1,17 @@
+import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
+import { XernerxInteraction, XernerxMessage } from '../types/types.js';
+export declare class InteractionArguments {
+    interaction: XernerxInteraction;
+    constructor(interaction: XernerxInteraction);
+    group(): string | undefined;
+    subcommand(): string | undefined;
+    arguments(): Record<string, object>;
+}
+interface Flag {
+    flags: Record<string, string | boolean>;
+}
+interface Argument {
+    [index: string]: string | number | null;
+}
+export declare function messageArguments(message: XernerxMessage, command: MessageCommandBuilder): Promise<import('discord.js').Message<boolean> | Flag | Argument | undefined>;
+export {};

package/dist/cjs/models/CommandArguments.js

@@ -0,0 +1,106 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.messageArguments = exports.InteractionArguments = void 0;
+class InteractionArguments {
+    interaction;
+    constructor(interaction) {
+        this.interaction = interaction;
+    }
+    group() {
+        return this.interaction?.options?._group;
+    }
+    subcommand() {
+        return this.interaction?.options?._subcommand;
+    }
+    arguments() {
+        const options = {};
+        if (this.interaction?.options?._hoistedOptions) {
+            for (const option of this.interaction.options._hoistedOptions) {
+                options[option.name] = option.channel || option.user || option.role || option.value;
+            }
+        }
+        return options;
+    }
+}
+exports.InteractionArguments = InteractionArguments;
+async function messageArguments(message, command) {
+    let args = { flags: {} },
+        separator = command.separator || ' ',
+        i = 0;
+    if (!command.args) return;
+    command.args
+        .filter((c) => c.type == 'flag')
+        .map((flag) => {
+            args = args;
+            for (const flg of message.content.matchAll(flag.match)) {
+                if (flag.match == flg) {
+                    message.content = message.content.replace(flag.match, '');
+                    args.flags[flag.name] = true;
+                }
+            }
+            if (!args.flags[flag.name]) args.flags[flag.name] = false;
+        });
+    for (const argument of command.args) {
+        args = args;
+        let content = message.content
+            .split(/ +/)
+            .slice(1)
+            .join(separator)
+            .replace(new RegExp(`${separator}${separator}+`, 'g'), separator)
+            .split(separator)
+            .slice(i);
+        if (content.join(separator) != '' && argument.type !== 'flag') {
+            if (argument?.content?.includes(content[0])) {
+                args[argument.name] = content[0];
+            } else if (argument.type == 'string') {
+                args[argument.name] = content[0];
+            } else if (argument.type == 'number') {
+                args[argument.name] = parseInt(content[0]);
+            } else if (argument.type == 'boolean') {
+                if (content[0]?.toLowerCase() != 'true' && content[0]?.toLowerCase() != 'false') content[0] = null;
+                args[argument.name] = content[0];
+            } else if (argument.type == 'user') {
+                let user = message.client.users.cache.find((u) => u?.username?.toLowerCase()?.includes(content[0])) || null;
+                try {
+                    user = (await message.client.users.fetch(user?.id || content[0].replace(/<@!?|>/g, ''))) || null;
+                } catch (e) {
+                    user = null;
+                }
+                args[argument.name] = user;
+            } else if (argument.type == 'role') {
+                let role = message.guild?.roles.cache.find((r) => r?.name?.toLowerCase()?.includes(content[0])) || null;
+                try {
+                    role = (await message.guild?.roles.fetch(role?.id || content[0].replace(/<@&?|>/g, ''))) || null;
+                } catch (e) {
+                    role = null;
+                }
+                args[argument.name] = role;
+            } else if (argument.type == 'member') {
+                let member = message.guild?.members.cache.find((m) => m?.nickname?.toLowerCase()?.includes(content[0]) || m?.user?.username?.toLowerCase()?.includes(content[0])) || null;
+                try {
+                    member = (await message.guild?.members.fetch(member?.id || content[0].replace(/<@!?|>/g, ''))) || null;
+                } catch (e) {
+                    member = null;
+                }
+                args[argument.name] = member;
+            } else if (argument.type == 'channel') {
+                let channel = message.guild?.channels.cache.find((c) => c?.name?.toLowerCase()?.includes(content[0]));
+                try {
+                    channel = await message.client.channels.fetch(channel?.id || content[0].replace(/<#|>/g, ''));
+                } catch (e) {
+                    channel = null;
+                }
+                args[argument.name] = channel;
+            } else if (argument.type == 'rest') {
+                args[argument.name] = content.join(separator);
+                break;
+            } else if (argument.prompt) {
+                if (argument.prompt.reply) return message.util?.reply(argument.prompt.reply);
+                else if (argument.prompt.send) return message.channel.send(argument.prompt.send);
+            } else args[argument.name] = typeof argument.default == 'function' ? argument.default(message) : argument.default;
+            i++;
+        } else args[argument.name] = typeof argument.default == 'function' ? argument.default(message) : argument.default;
+    }
+    return args;
+}
+exports.messageArguments = messageArguments;

package/dist/cjs/models/Events.d.ts

@@ -0,0 +1,24 @@
+import XernerxClient from '../client/XernerxClient.js';
+export declare class MessageCommandEvents {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    messageCreate(): void;
+    messageUpdate(): void;
+    messageDelete(): void;
+}
+export declare class SlashCommandEvents {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    slashCreate(): void;
+}
+export declare class ContextCommandEvents {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    contextCreate(): void;
+}
+export declare class CommandsDeploy {
+    private client;
+    constructor(client: XernerxClient);
+    deploy(): void;
+    private put;
+}