+import { Constants } from 'discord-akairo';

+import { Message, MessageEmbed, MessageEmbedOptions, Util } from 'discord.js';

+import { transpile } from 'typescript';

+import { inspect, promisify } from 'util';

+import { BushCommand } from '../../lib/extensions/BushCommand';

+ if (typeof text === 'string') {

+ return (text = Util.cleanCodeBlockContent(text));

+ } else return text;

+ usage: 'eval [--depth #] <code> [--sudo] [--silent] [--delete] [--proto] [--hidden] [--ts]',

+ id: 'selDepth',

+ match: Constants.ArgumentMatches.OPTION,

+ type: Constants.ArgumentTypes.NUMBER,

+ id: 'sudo',

+ match: Constants.ArgumentMatches.FLAG,

+ flag: '--sudo'

+ },

+ {

+ id: 'deleteMSG',

+ match: Constants.ArgumentMatches.FLAG,

+ flag: '--delete'

+ },

+ {

+ match: Constants.ArgumentMatches.FLAG,

+ id: 'typescript',

+ match: Constants.ArgumentMatches.FLAG,

+ flag: '--ts'

+ },

+ {

+ id: 'hidden',

+ match: Constants.ArgumentMatches.FLAG,

+ flag: '--hidden'

+ },

+ {

+ id: 'showProto',

+ match: Constants.ArgumentMatches.FLAG,

+ flag: '--proto'

+ },

+ {

+ match: Constants.ArgumentMatches.REST,

+ type: Constants.ArgumentTypes.STRING,

+ retry: '{error} Invalid code to eval.'

+ private redactCredentials(old: string) {

+ const mapping = {

+ ['token']: 'Token',

+ ['devToken']: 'Dev Token',

+ ['MongoDB']: 'MongoDB URI',

+ ['hypixelApiKey']: 'Hypixel Api Key',

+ ['webhookID']: 'Webhook ID',

+ ['webhookToken']: 'Webhook Token'

+ };

+ return mapping[old] || old;

+ }

+

+ {

+ selDepth,

+ code: codeArg,

+ sudo,

+ silent,

+ deleteMSG,

+ typescript,

+ hidden,

+ showProto

+ }: {

+ selDepth: number;

+ code: string;

+ sudo: boolean;

+ silent: boolean;

+ deleteMSG: boolean;

+ typescript: boolean;

+ hidden: boolean;

+ showProto: boolean;

+ }

+ ): Promise<unknown> {

+ if (!this.client.config.owners.includes(message.author.id))

+ return await message.channel.send(`${this.client.util.emojis.error} Only my developers can run this command.`);

+ const code: { js?: string | null; ts?: string | null; lang?: 'js' | 'ts' } = {};

+ codeArg = codeArg.replace(/[“”]/g, '"');

+ codeArg = codeArg.replace(/```/g, '');

+ if (typescript) {

+ code.ts = codeArg;

+ code.js = transpile(codeArg);

+ code.lang = 'ts';

+ } else {

+ code.ts = null;

+ code.js = codeArg;

+ code.lang = 'js';

+ }

+

+ const bad_phrases: string[] = ['delete', 'destroy'];

+ if (bad_phrases.some((p) => code[code.lang].includes(p)) && !sudo) {

+ return await message.util.send(`${this.client.util.emojis.error} This eval was blocked by smooth brain protection™.`);

+ }

+ const embeds: (MessageEmbed | MessageEmbedOptions)[] = [new MessageEmbed()];

+ embeds.some((embed) => embed);

+ members = message.guild.members,

+ roles = message.guild.roles,

+ if (code[code.lang].replace(/ /g, '').includes('9+10' || '10+9')) {

+ output = 21;

+ } else {

+ output = eval(code.js);

+ output = await output;

+ }

+ let proto, outputProto;

+ if (showProto) {

+ proto = Object.getPrototypeOf(output);

+ outputProto = clean(inspect(proto, { depth: 1, getters: true, showHidden: true }));

+ }

+ if (typeof output !== 'string')

+ output = inspect(output, { depth: selDepth, showHidden: hidden, getters: true, showProxy: true });

+ for (const credentialName in this.client.config.credentials) {

+ const credential = this.client.config.credentials[credentialName];

+ const newCredential = this.redactCredentials(credentialName);

+ output = output.replace(

+ new RegExp(credential.toString().replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'),

+ `[${newCredential} Omitted]`

+ );

+ output = output.replace(

+ new RegExp([...credential.toString().replace(/[.*+?^${}()|[\]\\]/g, '\\$&')].reverse().join(''), 'g'),

+ `[${newCredential} Omitted]`

+ );

+ }

+

+ const inputJS = clean(code.js);

+

+ .setTitle(`${this.client.util.emojis.successFull} Evaled code successfully`)

+ .setColor(this.client.util.colors.success)

+ .setFooter(message.author.tag, message.author.displayAvatarURL({ dynamic: true }))

+ if (code.lang === 'ts') {

+ const inputTS = clean(code.ts);

+ embed

+ .addField('📥 Input (typescript)', await this.client.util.codeblock(inputTS, 1024, 'ts'))

+ .addField('📥 Input (transpiled javascript)', await this.client.util.codeblock(inputJS, 1024, 'js'));

+ } else {

+ embed.addField('📥 Input', await this.client.util.codeblock(inputJS, 1024, 'js'));

+ }

+ embed.addField('📤 Output', await this.client.util.codeblock(output, 1024, 'js'));

+ if (showProto) embed.addField('⚙️ Proto', await this.client.util.codeblock(outputProto, 1024, 'js'));

+ const inputJS = clean(code.js);

+ .setTitle(`${this.client.util.emojis.errorFull} Code was not able to be evaled.`)

+ .setColor(this.client.util.colors.error)

+ .setFooter(message.author.tag, message.author.displayAvatarURL({ dynamic: true }))

+ if (code.lang === 'ts') {

+ const inputTS = clean(code.ts);

+ embed

+ .addField('📥 Input (typescript)', await this.client.util.codeblock(inputTS, 1024, 'ts'))

+ .addField('📥 Input (transpiled javascript)', await this.client.util.codeblock(inputJS, 1024, 'js'));

+ } else {

+ embed.addField('📥 Input', await this.client.util.codeblock(inputJS, 1024, 'js'));

+ }

+ embed.addField('📤 Output', await this.client.util.codeblock(e?.stack, 1024, 'js'));

+ await message.util.reply({ embeds: [embed] });

+ await message.author.send({ embeds: [embed] });

+ if (!deleteMSG) await message.react(this.client.util.emojis.successFull);

+ if (!deleteMSG) await message.react(this.client.util.emojis.errorFull);

+

+ if (deleteMSG && message.deletable) {

+ await message.delete();

+ }

+import { ApplicationCommandOptionType } from 'discord-api-types';

+import { BushCommand } from '../../lib/extensions/BushCommand';

+import { BushInteractionMessage } from '../../lib/extensions/BushInteractionMessage';

+ public async execSlash(message: BushInteractionMessage, { fast }: { fast: SlashCommandOption<boolean> }): Promise<void> {

+ await message.interaction.reply(await this.getResponse(fast?.value));

+import { Message, User } from 'discord.js';

+import { BushInteractionMessage } from '../../lib/extensions/BushInteractionMessage';

+ await message.util.send({

+ content: await this.setLevel(user, level),

+ message: BushInteractionMessage,

+ await message.interaction.reply({

+ content: await this.setLevel(user.user, level.value),

+import { Message, MessageEmbed } from 'discord.js';

+import { BushCommand } from '../../lib/extensions/BushCommand';

+import { BushInteractionMessage } from '../../lib/extensions/BushInteractionMessage';

+ value: this.client.users.cache.size.toString(),

+ await message.util.send({ embeds: [await this.generateEmbed()] });

+ public async execSlash(message: BushInteractionMessage): Promise<void> {

+ await message.interaction.reply({ embeds: [await this.generateEmbed()] });

+import { Message, MessageEmbed } from 'discord.js';

+import { BushCommand } from '../../lib/extensions/BushCommand';

+import { BushInteractionMessage } from '../../lib/extensions/BushInteractionMessage';

+ await message.util.send({ embeds: [this.generateEmbed(command)] });

+ public async execSlash(message: BushInteractionMessage, { command }: { command: SlashCommandOption<string> }): Promise<void> {

+ await message.interaction.reply({ embeds: [this.generateEmbed(this.handler.findCommand(command.value) as BushCommand)] });

+ await message.interaction.reply({ embeds: [this.generateEmbed()] });

+import { Message, MessageEmbed } from 'discord.js';

+import { BushInteractionMessage } from '../../lib/extensions/BushInteractionMessage';

+ embeds: [embed]

+ public async execSlash(message: BushInteractionMessage): Promise<void> {

+ const timestamp1 = message.interaction.createdTimestamp;

+ await message.interaction.reply('Pong!');

+ const timestamp2 = await message.interaction.fetchReply().then((m) => (m as Message).createdTimestamp);

+ .setFooter(message.interaction.user.username, message.interaction.user.displayAvatarURL({ dynamic: true }))

+ await message.interaction.editReply({

+import { CommandInteraction, Message, MessageEmbed, User } from 'discord.js';

+import got, { HTTPError } from 'got';

+import { BushCommand } from '../../lib/extensions/BushCommand';

+import { BushInteractionMessage } from '../../lib/extensions/BushInteractionMessage';

+ slashEphemeral: true // I'll add dynamic checking to this later

+ message.reply({

+ embeds: [

+ new MessageEmbed({

+ title: `${author ? 'Your' : `${user.tag}'s`} pronouns:`,

+ description: pronounMapping[apiRes.pronouns],

+ footer: {

+ text: 'Data provided by https://pronoundb.org/'

+ }

+ })

+ ]

+ });

+ async execSlash(message: BushInteractionMessage, { user }: { user?: SlashCommandOption<void> }): Promise<void> {

+ const u = user?.user || message.author;

+ await this.sendResponse(message.interaction, u, u.id === message.author.id);

+import { ApplicationCommandOptionType } from 'discord-api-types';

+import { CommandInteraction, Message, User } from 'discord.js';

+import { BushCommand } from '../../lib/extensions/BushCommand';

+import { BushInteractionMessage } from '../../lib/extensions/BushInteractionMessage';

+import { Ban, Guild, Modlog, ModlogType } from '../../lib/models';

+ message: BushInteractionMessage,

+ for await (const response of this.genResponses(message.interaction, user.user, reason?.value, time?.value)) {

+import { ApplicationCommandOptionType } from 'discord-api-types';

+import { CommandInteraction, GuildMember, Message } from 'discord.js';

+import { BushInteractionMessage } from '../../lib/extensions/BushInteractionMessage';

+ async execSlash(message: BushInteractionMessage, { user, reason }: { user: GuildMember; reason?: string }): Promise<void> {

+ for await (const response of this.genResponses(message.interaction, user, reason)) {

+ await message.interaction.reply(response);

+import { Message, MessageEmbed } from 'discord.js';

+import moment from 'moment';

+import { BushCommand } from '../../lib/extensions/BushCommand';

+import { Modlog } from '../../lib/models';

+ await message.util.send({ embeds: [embedPages[page - 1]] });

+ await message.util.send({ embeds: [embedPages[0]] });

+ await message.util.send({

+ embeds: [

+ new MessageEmbed({

+ title: `Modlog ${entry.id}`,

+ fields: [

+ {

+ name: 'Type',

+ value: entry.type.toLowerCase(),

+ inline: true

+ },

+ {

+ name: 'Duration',

+ value: `${entry.duration ? moment.duration(entry.duration, 'milliseconds').humanize() : 'N/A'}`,

+ inline: true

+ },

+ {

+ name: 'Reason',

+ value: `${entry.reason || 'None given'}`,

+ inline: true

+ },

+ {

+ name: 'Moderator',

+ value: `<@!${entry.moderator}> (${entry.moderator})`,

+ inline: true

+ },

+ {

+ name: 'User',

+ value: `<@!${entry.user}> (${entry.user})`,

+ inline: true

+ }

+ ]

+ })

+ ]

+ });

+import { ApplicationCommandOptionType } from 'discord-api-types';

+import { GuildMember, Message, Role } from 'discord.js';

+ return message.util.reply({

+ content: `<:error:837123021016924261> <@&${role.id}> is not whitelisted, and you do not have manage roles permission.`,

+ allowedMentions: AllowedMentions.none()

+ });

+ return message.util.reply({

+ content: `<:error:837123021016924261> <@&${role.id}> is whitelisted, but you do not have any of the roles required to manage it.`,

+ allowedMentions: AllowedMentions.none()

+ });

+ return message.util.reply({

+ content: `<:error:837123021016924261> <@&${role.id}> is higher or equal to your highest role.`,

+ return message.util.reply({

+ content: `<:error:837123021016924261> <@&${role.id}> is higher or equal to my highest role.`,

+ await message.util.reply({

+ content: `<:error:837123021016924261> <@&${role.id}> is managed by an integration and cannot be managed.`,

+ allowedMentions: AllowedMentions.none()

+ });

+ return message.util.reply({

+ content: `<:error:837123021016924261> Could not remove <@&${role.id}> from <@${user.id}>.`,

+ return message.util.reply({

+ content: `<:checkmark:837109864101707807> Successfully removed <@&${role.id}> from <@${user.id}>!`,

+ return message.util.reply({

+ content: `<:error:837123021016924261> Could not add <@&${role.id}> to <@${user.id}>.`,

+ return message.util.reply({

+ content: `<:checkmark:837109864101707807> Successfully added <@&${role.id}> to <@${user.id}>!`,

+import { Message, MessageEmbed } from 'discord.js';

+import { BushInteractionMessage } from '../../lib/extensions/BushInteractionMessage';

+ private async getResponse(user: string): Promise<{ content?: string; embeds?: MessageEmbed[] }> {

+ return { content: `<:error:837123021016924261> \`${user}\` doesn't appear to be a valid username.` };

+ return { content: `<:error:837123021016924261> There was an error finding cape perms for \`${user}\`.` };

+ if (foundUser == null) return { content: `<:error:837123021016924261> \`${user}\` does not appear to have any capes.` };

+ return { embeds: [embed] };

+ return { content: `<:error:837123021016924261> There was an error finding cape perms for ${user}.` };

+ public async execSlash(message: BushInteractionMessage, { user }: { user: SlashCommandOption<string> }): Promise<void> {

+import { Message, NewsChannel, TextChannel, WebhookClient } from 'discord.js';

+ return webhookClient.send({

+ content:

+ '🎉 <@&767782793261875210> Giveaway.\n\n<:mad:783046135392239626> Spamming, line breaking, gibberish etc. disqualifies you from winning. We can and will ban you from giveaways. Winners will all be checked and rerolled if needed.',

+ username: `${message.member.nickname || message.author.username}`,

+ avatarURL: message.author.avatarURL({ dynamic: true }),

+ allowedMentions: AllowedMentions.roles()

+ });

+import { CommandInteractionOption, Message, User } from 'discord.js';

+import { BushInteractionMessage } from '../../lib/extensions/BushInteractionMessage';

+ async execSlash(message: BushInteractionMessage, { user }: { user?: CommandInteractionOption }): Promise<void> {

+ await message.reply(await this.getResponse(user?.user || message.author));

+import { CommandInteraction, Message, MessageEmbed, User } from 'discord.js';

+import { BushCommand } from '../../lib/extensions/BushCommand';

+import { BushInteractionMessage } from '../../lib/extensions/BushInteractionMessage';

+ ): { content?: string; embeds?: MessageEmbed[] } | [string, MessageEmbed] {

+ return { content: "<:no:787549684196704257> This command can only be run in Moulberry's Bush." };

+ return { embeds: [rulesEmbed] };

+ await message.util.send({

+ content: response[0],

+ embeds: [response[1]]

+ message: BushInteractionMessage,

+ const response = this.getResponse(message.interaction, rule?.value, user?.user);

+ await message.interaction.reply({

+ content: response[0],

+ await message.interaction.reply(response);

+import { Guild as DiscordGuild, Message } from 'discord.js';

+import { BushInteractionMessage } from '../../lib/extensions/BushInteractionMessage';

+ async execSlash(message: BushInteractionMessage, { prefix }: { prefix?: SlashCommandOption<string> }): Promise<void> {