seyfert 1.5.0 → 2.1.0

package/lib/client/oninteractioncreate.js

@@ -1,198 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.onInteractionCreate = void 0;
-const v10_1 = require("discord-api-types/v10");
-const commands_1 = require("../commands");
-const structures_1 = require("../structures");
-const components_1 = require("../components");
-async function onInteractionCreate(self, body, shardId, __reply) {
-    self.debugger?.debug(`[${v10_1.InteractionType[body.type] ?? body.type}] Interaction received.`);
-    switch (body.type) {
-        case v10_1.InteractionType.ApplicationCommandAutocomplete:
-            {
-                const parentCommand = self.commands?.values.find(x => {
-                    if (body.data.guild_id) {
-                        return x.guildId?.includes(body.data.guild_id) && x.name === body.data.name;
-                    }
-                    return x.name === body.data.name;
-                });
-                const optionsResolver = new commands_1.OptionResolver(self, body.data.options ?? [], parentCommand, body.guild_id, body.data.resolved);
-                const interaction = new structures_1.AutocompleteInteraction(self, body, optionsResolver, __reply);
-                const command = optionsResolver.getAutocomplete();
-                // idc, is a YOU problem
-                if (!command?.autocomplete)
-                    return self.logger.warn(`${optionsResolver.fullCommandName} ${command?.name} command does not have 'autocomplete' callback`);
-                try {
-                    try {
-                        await command.autocomplete(interaction);
-                    }
-                    catch (error) {
-                        if (!command.onAutocompleteError)
-                            return self.logger.error(`${optionsResolver.fullCommandName} ${command.name} just threw an error, ${error ? (typeof error === 'object' && 'message' in error ? error.message : error) : 'Unknown'}`);
-                        await command.onAutocompleteError(interaction, error);
-                    }
-                }
-                catch (error) {
-                    try {
-                        await optionsResolver.getCommand()?.onInternalError?.(self, optionsResolver.getCommand(), error);
-                    }
-                    catch {
-                        // supress error
-                    }
-                }
-            }
-            break;
-        case v10_1.InteractionType.ApplicationCommand:
-            {
-                switch (body.data.type) {
-                    case v10_1.ApplicationCommandType.Message:
-                    case v10_1.ApplicationCommandType.User:
-                        {
-                            const command = self.commands?.values.find(x => {
-                                if (body.data.guild_id) {
-                                    return x.guildId?.includes(body.data.guild_id) && x.name === body.data.name;
-                                }
-                                return x.name === body.data.name;
-                            });
-                            const interaction = structures_1.BaseInteraction.from(self, body, __reply);
-                            // idc, is a YOU problem
-                            if (!command?.run)
-                                return self.logger.warn(`${command.name ?? 'Unknown'} command does not have 'run' callback`);
-                            const context = new commands_1.MenuCommandContext(self, interaction, shardId, command);
-                            const extendContext = self.options?.context?.(interaction) ?? {};
-                            Object.assign(context, extendContext);
-                            try {
-                                if (command.botPermissions && interaction.appPermissions) {
-                                    const permissions = interaction.appPermissions.missings(...interaction.appPermissions.values([command.botPermissions]));
-                                    if (!interaction.appPermissions.has('Administrator') && permissions.length) {
-                                        return command.onBotPermissionsFail(context, interaction.appPermissions.keys(permissions));
-                                    }
-                                }
-                                const resultRunGlobalMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, (self.options?.globalMiddlewares ?? []), true);
-                                if (resultRunGlobalMiddlewares.pass) {
-                                    return;
-                                }
-                                if ('error' in resultRunGlobalMiddlewares) {
-                                    return command.onMiddlewaresError(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
-                                }
-                                const resultRunMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, command.middlewares, false);
-                                if (resultRunMiddlewares.pass) {
-                                    return;
-                                }
-                                if ('error' in resultRunMiddlewares) {
-                                    return command.onMiddlewaresError(context, resultRunMiddlewares.error ?? 'Unknown error');
-                                }
-                                try {
-                                    await command.run(context);
-                                    await command.onAfterRun?.(context, undefined);
-                                }
-                                catch (error) {
-                                    await command.onRunError(context, error);
-                                    await command.onAfterRun?.(context, error);
-                                }
-                            }
-                            catch (error) {
-                                try {
-                                    await command.onInternalError(self, error);
-                                }
-                                catch {
-                                    // supress error
-                                }
-                            }
-                        }
-                        break;
-                    case v10_1.ApplicationCommandType.ChatInput:
-                        {
-                            const parentCommand = self.commands?.values.find(x => {
-                                if (body.data.guild_id) {
-                                    return x.guildId?.includes(body.data.guild_id) && x.name === body.data.name;
-                                }
-                                return x.name === body.data.name;
-                            });
-                            const optionsResolver = new commands_1.OptionResolver(self, body.data.options ?? [], parentCommand, body.guild_id, body.data.resolved);
-                            const interaction = structures_1.BaseInteraction.from(self, body, __reply);
-                            const command = optionsResolver.getCommand();
-                            if (!command?.run)
-                                return self.logger.warn(`${optionsResolver.fullCommandName} command does not have 'run' callback`);
-                            const context = new commands_1.CommandContext(self, interaction, optionsResolver, shardId, command);
-                            const extendContext = self.options?.context?.(interaction) ?? {};
-                            Object.assign(context, extendContext);
-                            try {
-                                if (command.botPermissions && interaction.appPermissions) {
-                                    const permissions = interaction.appPermissions.missings(...interaction.appPermissions.values([command.botPermissions]));
-                                    if (!interaction.appPermissions.has('Administrator') && permissions.length) {
-                                        return command.onBotPermissionsFail?.(context, interaction.appPermissions.keys(permissions));
-                                    }
-                                }
-                                const [erroredOptions, result] = await command.__runOptions(context, optionsResolver);
-                                if (erroredOptions) {
-                                    return command.onOptionsError?.(context, result);
-                                }
-                                const resultRunGlobalMiddlewares = await command.__runGlobalMiddlewares(context);
-                                if (resultRunGlobalMiddlewares.pass) {
-                                    return;
-                                }
-                                if ('error' in resultRunGlobalMiddlewares) {
-                                    return command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
-                                }
-                                const resultRunMiddlewares = await command.__runMiddlewares(context);
-                                if (resultRunMiddlewares.pass) {
-                                    return;
-                                }
-                                if ('error' in resultRunMiddlewares) {
-                                    return command.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
-                                }
-                                try {
-                                    await command.run(context);
-                                    await command.onAfterRun?.(context, undefined);
-                                }
-                                catch (error) {
-                                    await command.onRunError?.(context, error);
-                                    await command.onAfterRun?.(context, error);
-                                }
-                            }
-                            catch (error) {
-                                try {
-                                    await command.onInternalError?.(self, context.command, error);
-                                }
-                                catch {
-                                    // supress error
-                                }
-                            }
-                        }
-                        break;
-                }
-            }
-            break;
-        case v10_1.InteractionType.ModalSubmit:
-            {
-                const interaction = structures_1.BaseInteraction.from(self, body, __reply);
-                if (self.components?.hasModal(interaction)) {
-                    await self.components.onModalSubmit(interaction);
-                }
-                else {
-                    const context = new components_1.ModalContext(self, interaction);
-                    const extended = self.options?.context?.(interaction) ?? {};
-                    Object.assign(context, extended);
-                    await self.components?.executeModal(context);
-                }
-            }
-            break;
-        case v10_1.InteractionType.MessageComponent:
-            {
-                const interaction = structures_1.BaseInteraction.from(self, body, __reply);
-                if (self.components?.hasComponent(body.message.id, interaction.customId)) {
-                    await self.components.onComponent(body.message.id, interaction);
-                }
-                else {
-                    //@ts-expect-error
-                    const context = new components_1.ComponentContext(self, interaction);
-                    const extended = self.options?.context?.(interaction) ?? {};
-                    Object.assign(context, extended);
-                    await self.components?.executeComponent(context);
-                }
-            }
-            break;
-    }
-}
-exports.onInteractionCreate = onInteractionCreate;

package/lib/client/onmessagecreate.d.ts

@@ -1,13 +0,0 @@
-import { type APIApplicationCommandInteractionDataOption, type GatewayMessageCreateDispatchData } from 'discord-api-types/v10';
-import { Command, type MessageCommandOptionErrors, SubCommand, type UsingClient, type Client, type ContextOptionsResolved, type WorkerClient } from '..';
-import type { MakeRequired } from '../common';
-export declare function onMessageCreate(self: Client | WorkerClient, rawMessage: GatewayMessageCreateDispatchData, shardId: number): Promise<any>;
-export declare function defaultOptionsParser(self: UsingClient, command: Command | SubCommand, message: GatewayMessageCreateDispatchData, args: Partial<Record<string, string>>, resolved: MakeRequired<ContextOptionsResolved>): Promise<{
-    errors: {
-        name: string;
-        error: string;
-        fullError: MessageCommandOptionErrors;
-    }[];
-    options: APIApplicationCommandInteractionDataOption[];
-}>;
-export declare function defaultArgsParser(content: string): Record<string, string>;

package/lib/client/onmessagecreate.js

@@ -1,410 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultArgsParser = exports.defaultOptionsParser = exports.onMessageCreate = void 0;
-const v10_1 = require("discord-api-types/v10");
-const __1 = require("..");
-const structures_1 = require("../structures");
-function getCommandFromContent(commandRaw, self) {
-    const rawParentName = commandRaw[0];
-    const rawGroupName = commandRaw.length === 3 ? commandRaw[1] : undefined;
-    const rawSubcommandName = rawGroupName ? commandRaw[2] : commandRaw[1];
-    const parent = self.commands.values.find(x => (!('ignore' in x) || x.ignore !== __1.IgnoreCommand.Message) &&
-        (x.name === rawParentName || ('aliases' in x ? x.aliases?.includes(rawParentName) : false)));
-    const fullCommandName = `${rawParentName}${rawGroupName ? ` ${rawGroupName} ${rawSubcommandName}` : `${rawSubcommandName ? ` ${rawSubcommandName}` : ''}`}`;
-    if (!(parent instanceof __1.Command))
-        return { fullCommandName };
-    if (rawGroupName && !parent.groups?.[rawGroupName] && !parent.groupsAliases?.[rawGroupName])
-        return getCommandFromContent([rawParentName, rawGroupName], self);
-    if (rawSubcommandName &&
-        !parent.options?.some(x => x instanceof __1.SubCommand && (x.name === rawSubcommandName || x.aliases?.includes(rawSubcommandName))))
-        return getCommandFromContent([rawParentName], self);
-    const groupName = rawGroupName ? parent.groupsAliases?.[rawGroupName] || rawGroupName : undefined;
-    const command = groupName || rawSubcommandName
-        ? parent.options?.find(opt => {
-            if (opt instanceof __1.SubCommand) {
-                if (groupName) {
-                    if (opt.group !== groupName)
-                        return false;
-                }
-                if (opt.group && !groupName)
-                    return false;
-                return rawSubcommandName === opt.name || opt.aliases?.includes(rawSubcommandName);
-            }
-            return false;
-        })
-        : parent;
-    return {
-        command,
-        fullCommandName,
-        parent,
-    };
-}
-async function onMessageCreate(self, rawMessage, shardId) {
-    if (!self.options?.commands?.prefix)
-        return;
-    const message = new structures_1.Message(self, rawMessage);
-    const prefixes = (await self.options.commands.prefix(message)).sort((a, b) => b.length - a.length);
-    const prefix = prefixes.find(x => message.content.startsWith(x));
-    if (!(prefix !== undefined && message.content.startsWith(prefix)))
-        return;
-    const content = message.content.slice(prefix.length).trimStart();
-    const { fullCommandName, command, parent } = getCommandFromContent(content
-        .split(' ')
-        .filter(x => x)
-        .slice(0, 3), self);
-    if (!command)
-        return;
-    if (!command.run)
-        return self.logger.warn(`${fullCommandName} command does not have 'run' callback`);
-    if (!command.contexts.includes(v10_1.InteractionContextType.BotDM) && !message.guildId)
-        return;
-    if (!command.contexts.includes(v10_1.InteractionContextType.Guild) && message.guildId)
-        return;
-    if (command.guildId && !command.guildId?.includes(message.guildId))
-        return;
-    const resolved = {
-        channels: {},
-        roles: {},
-        users: {},
-        members: {},
-        attachments: {},
-    };
-    let newContent = content;
-    for (const i of fullCommandName.split(' ')) {
-        newContent = newContent.slice(newContent.indexOf(i) + i.length);
-    }
-    const args = self.options.commands.argsParser(newContent.slice(1), command, message);
-    const { options, errors } = await self.options.commands.optionsParser(self, command, rawMessage, args, resolved);
-    const optionsResolver = new __1.OptionResolver(self, options, parent, message.guildId, resolved);
-    const context = new __1.CommandContext(self, message, optionsResolver, shardId, command);
-    //@ts-expect-error
-    const extendContext = self.options?.context?.(message) ?? {};
-    Object.assign(context, extendContext);
-    try {
-        if (errors.length) {
-            return command.onOptionsError?.(context, Object.fromEntries(errors.map(x => {
-                return [
-                    x.name,
-                    {
-                        failed: true,
-                        value: x.error,
-                        parseError: x.fullError,
-                    },
-                ];
-            })));
-        }
-        if (command.defaultMemberPermissions && message.guildId) {
-            const memberPermissions = await self.members.permissions(message.guildId, message.author.id);
-            const permissions = memberPermissions.missings(...memberPermissions.values([command.defaultMemberPermissions]));
-            if (!memberPermissions.has('Administrator') &&
-                permissions.length &&
-                (await message.guild()).ownerId !== message.author.id) {
-                return command.onPermissionsFail?.(context, memberPermissions.keys(permissions));
-            }
-        }
-        if (command.botPermissions && message.guildId) {
-            const meMember = await self.cache.members?.get(self.botId, message.guildId);
-            if (!meMember)
-                return; //enable member cache and "Guilds" intent, lol
-            const appPermissions = await meMember.fetchPermissions();
-            const permissions = appPermissions.missings(...appPermissions.values([command.botPermissions]));
-            if (!appPermissions.has('Administrator') && permissions.length) {
-                return command.onBotPermissionsFail?.(context, appPermissions.keys(permissions));
-            }
-        }
-        const [erroredOptions, result] = await command.__runOptions(context, optionsResolver);
-        if (erroredOptions) {
-            return command.onOptionsError?.(context, result);
-        }
-        const resultRunGlobalMiddlewares = await command.__runGlobalMiddlewares(context);
-        if (resultRunGlobalMiddlewares.pass) {
-            return;
-        }
-        if ('error' in resultRunGlobalMiddlewares) {
-            return command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
-        }
-        const resultRunMiddlewares = await command.__runMiddlewares(context);
-        if (resultRunMiddlewares.pass) {
-            return;
-        }
-        if ('error' in resultRunMiddlewares) {
-            return command.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
-        }
-        try {
-            await command.run?.(context);
-            await command.onAfterRun?.(context, undefined);
-        }
-        catch (error) {
-            await command.onRunError?.(context, error);
-            await command.onAfterRun?.(context, error);
-        }
-    }
-    catch (error) {
-        try {
-            await command.onInternalError?.(self, context.command, error);
-        }
-        catch {
-            // supress error
-        }
-    }
-}
-exports.onMessageCreate = onMessageCreate;
-async function defaultOptionsParser(self, command, message, args, resolved) {
-    const options = [];
-    const errors = [];
-    for (const i of (command.options ?? [])) {
-        try {
-            let value;
-            let indexAttachment = -1;
-            switch (i.type) {
-                case v10_1.ApplicationCommandOptionType.Attachment:
-                    if (message.attachments[++indexAttachment]) {
-                        value = message.attachments[indexAttachment].id;
-                        resolved.attachments[value] = message.attachments[indexAttachment];
-                    }
-                    break;
-                case v10_1.ApplicationCommandOptionType.Boolean:
-                    if (args[i.name]) {
-                        value = ['yes', 'y', 'true', 'treu'].includes(args[i.name].toLowerCase());
-                    }
-                    break;
-                case v10_1.ApplicationCommandOptionType.Channel:
-                    {
-                        const rawId = message.content.match(/(?<=<#)[0-9]{17,19}(?=>)/g)?.find(x => args[i.name]?.includes(x)) ||
-                            args[i.name]?.match(/[0-9]{17,19}/g)?.[0];
-                        if (rawId) {
-                            const channel = (await self.cache.channels?.get(rawId)) ?? (i.required ? await self.channels.fetch(rawId) : undefined);
-                            if (channel) {
-                                if ('channel_types' in i) {
-                                    if (!i.channel_types.includes(channel.type)) {
-                                        errors.push({
-                                            name: i.name,
-                                            error: `The entered channel type is not one of ${i
-                                                .channel_types.map(t => v10_1.ChannelType[t])
-                                                .join(', ')}`,
-                                            fullError: ['CHANNEL_TYPES', i.channel_types],
-                                        });
-                                        break;
-                                    }
-                                }
-                                value = rawId;
-                                resolved.channels[rawId] = channel;
-                            }
-                        }
-                    }
-                    break;
-                case v10_1.ApplicationCommandOptionType.Mentionable:
-                    {
-                        const matches = message.content.match(/<@[0-9]{17,19}(?=>)|<@&[0-9]{17,19}(?=>)/g) ?? [];
-                        for (const match of matches) {
-                            if (match.includes('&')) {
-                                const rawId = match.slice(3);
-                                if (rawId) {
-                                    const role = (await self.cache.roles?.get(rawId)) ??
-                                        (i.required ? (await self.roles.list(message.guild_id)).find(x => x.id === rawId) : undefined);
-                                    if (role) {
-                                        value = rawId;
-                                        resolved.roles[rawId] = role;
-                                        break;
-                                    }
-                                }
-                            }
-                            else {
-                                const rawId = match.slice(2);
-                                const raw = message.mentions.find(x => rawId === x.id);
-                                if (raw) {
-                                    const { member, ...user } = raw;
-                                    value = raw.id;
-                                    resolved.users[raw.id] = user;
-                                    if (member)
-                                        resolved.members[raw.id] = member;
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                    break;
-                case v10_1.ApplicationCommandOptionType.Role:
-                    {
-                        const rawId = message.mention_roles.find(x => args[i.name]?.includes(x)) || args[i.name]?.match(/[0-9]{17,19}/g)?.[0];
-                        if (rawId) {
-                            const role = (await self.cache.roles?.get(rawId)) ??
-                                (i.required ? (await self.roles.list(message.guild_id)).find(x => x.id === rawId) : undefined);
-                            if (role) {
-                                value = rawId;
-                                resolved.roles[rawId] = role;
-                            }
-                        }
-                    }
-                    break;
-                case v10_1.ApplicationCommandOptionType.User:
-                    {
-                        const rawId = message.mentions.find(x => args[i.name]?.includes(x.id))?.id || args[i.name]?.match(/[0-9]{17,19}/g)?.[0];
-                        if (rawId) {
-                            const raw = message.mentions.find(x => args[i.name]?.includes(x.id)) ??
-                                (await self.cache.users?.get(rawId)) ??
-                                (i.required ? await self.users.fetch(rawId) : undefined);
-                            if (raw) {
-                                value = raw.id;
-                                if (raw instanceof __1.User) {
-                                    resolved.users[raw.id] = raw;
-                                    if (message.guild_id) {
-                                        const member = message.mentions.find(x => args[i.name]?.includes(x.id))?.member ??
-                                            (await self.cache.members?.get(rawId, message.guild_id)) ??
-                                            (i.required ? await self.members.fetch(rawId, message.guild_id) : undefined);
-                                        if (member)
-                                            resolved.members[raw.id] = member;
-                                    }
-                                }
-                                else {
-                                    const { member, ...user } = raw;
-                                    resolved.users[user.id] = user;
-                                    if (member)
-                                        resolved.members[user.id] = member;
-                                }
-                            }
-                        }
-                    }
-                    break;
-                case v10_1.ApplicationCommandOptionType.String:
-                    {
-                        value = args[i.name];
-                        const option = i;
-                        if (!value)
-                            break;
-                        if (option.min_length) {
-                            if (value.length < option.min_length) {
-                                value = undefined;
-                                errors.push({
-                                    name: i.name,
-                                    error: `The entered string has less than ${option.min_length} characters. The minimum required is ${option.min_length} characters.`,
-                                    fullError: ['STRING_MIN_LENGTH', option.min_length],
-                                });
-                                break;
-                            }
-                        }
-                        if (option.max_length) {
-                            if (value.length > option.max_length) {
-                                value = undefined;
-                                errors.push({
-                                    name: i.name,
-                                    error: `The entered string has more than ${option.max_length} characters. The maximum required is ${option.max_length} characters.`,
-                                    fullError: ['STRING_MAX_LENGTH', option.max_length],
-                                });
-                                break;
-                            }
-                        }
-                        if (option.choices?.length) {
-                            const choice = option.choices.find(x => x.name === value);
-                            if (!choice) {
-                                value = undefined;
-                                errors.push({
-                                    name: i.name,
-                                    error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
-                                        .map(x => x.name)
-                                        .join(', ')}.`,
-                                    fullError: ['STRING_INVALID_CHOICE', option.choices],
-                                });
-                                break;
-                            }
-                            value = choice.value;
-                        }
-                    }
-                    break;
-                case v10_1.ApplicationCommandOptionType.Number:
-                case v10_1.ApplicationCommandOptionType.Integer:
-                    {
-                        const option = i;
-                        if (!option.choices?.length) {
-                            value = Number(args[i.name]);
-                            if (args[i.name] === undefined) {
-                                value = undefined;
-                                break;
-                            }
-                            if (Number.isNaN(value)) {
-                                value = undefined;
-                                errors.push({
-                                    name: i.name,
-                                    error: 'The entered choice is an invalid number.',
-                                    fullError: ['NUMBER_NAN', args[i.name]],
-                                });
-                                break;
-                            }
-                            if (option.min_value) {
-                                if (value < option.min_value) {
-                                    value = undefined;
-                                    errors.push({
-                                        name: i.name,
-                                        error: `The entered number is less than ${option.min_value}. The minimum allowed is ${option.min_value}`,
-                                        fullError: ['NUMBER_MIN_VALUE', option.min_value],
-                                    });
-                                    break;
-                                }
-                            }
-                            if (option.max_value) {
-                                if (value > option.max_value) {
-                                    value = undefined;
-                                    errors.push({
-                                        name: i.name,
-                                        error: `The entered number is greater than ${option.max_value}. The maximum allowed is ${option.max_value}`,
-                                        fullError: ['NUMBER_MAX_VALUE', option.max_value],
-                                    });
-                                    break;
-                                }
-                            }
-                            break;
-                        }
-                        const choice = option.choices.find(x => x.name === args[i.name]);
-                        if (!choice) {
-                            value = undefined;
-                            errors.push({
-                                name: i.name,
-                                error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
-                                    .map(x => x.name)
-                                    .join(', ')}.`,
-                                fullError: ['NUMBER_INVALID_CHOICE', option.choices],
-                            });
-                            break;
-                        }
-                        value = choice.value;
-                    }
-                    break;
-                default:
-                    break;
-            }
-            if (value !== undefined) {
-                options.push({
-                    name: i.name,
-                    type: i.type,
-                    value,
-                });
-            }
-            else if (i.required)
-                if (!errors.some(x => x.name === i.name))
-                    errors.push({
-                        error: 'Option is required but returned undefined',
-                        name: i.name,
-                        fullError: ['OPTION_REQUIRED'],
-                    });
-        }
-        catch (e) {
-            errors.push({
-                error: e && typeof e === 'object' && 'message' in e ? e.message : `${e}`,
-                name: i.name,
-                fullError: ['UNKNOWN', e],
-            });
-        }
-    }
-    return { errors, options };
-}
-exports.defaultOptionsParser = defaultOptionsParser;
-function defaultArgsParser(content) {
-    const args = {};
-    for (const i of content.match(/-(.*?)(?=\s-|$)/gs) ?? []) {
-        args[i.slice(1).split(' ')[0]] = i.split(' ').slice(1).join(' ');
-    }
-    return args;
-}
-exports.defaultArgsParser = defaultArgsParser;
-//-(.*?)(?=\s-|$)/gs
-//-(?<text>[^-]*)/gm

package/lib/structures/extra/functions.d.ts

@@ -1,12 +0,0 @@
-import type { APIPartialEmoji } from 'discord-api-types/v10';
-import type { Cache } from '../../cache';
-import type { TypeArray } from '../../common';
-import type { EmojiResolvable } from '../../common/types/resolvables';
-/** * Convert a timestamp to a snowflake. * @param timestamp The timestamp to convert. * @returns The snowflake. */
-export declare function snowflakeToTimestamp(id: string): bigint;
-export declare function channelLink(channelId: string, guildId?: string): string;
-export declare function messageLink(channelId: string, messageId: string, guildId?: string): string;
-export declare function resolvePartialEmoji(emoji: EmojiResolvable): APIPartialEmoji | undefined;
-export declare function resolveEmoji(emoji: EmojiResolvable, cache: Cache): Promise<APIPartialEmoji | undefined>;
-export declare function encodeEmoji(rawEmoji: APIPartialEmoji): string;
-export declare function hasProps<T extends Record<any, any>>(target: T, props: TypeArray<keyof T>): boolean;