ahegao 1.69.46 → 1.69.48

package/dist/types/discord_classes.d.ts

@@ -0,0 +1,93 @@
+import { Channel, Client, Collection, Guild, GuildBasedChannel, GuildMember, InteractionReplyOptions, Message, MessagePayload, MessageReference, TextBasedChannel, TextChannel, ThreadChannel, User } from "discord.js";
+import { CommandType, SendOptions, StringCommandFunction } from "./discord_types";
+import { MESSAGE_TYPE, RECIPIENT_TYPE } from "./discord_fields";
+import { ExtendedInteraction, MessageType } from "../utils/discord-util";
+import { OneOrMoreArray } from "../structures/structs";
+export declare class BaseDiscordClient extends Client {
+    readonly stringCommandsMap: Map<string, StringCommand>;
+    readonly stringCommandsSendOptions: Map<string, SendOptions>;
+    readonly stringCommandsSet: Set<StringCommand>;
+    readonly stringCommandsNamesSet: Set<string>;
+    readonly commands: Collection<string, CommandType>;
+    private noAccessGuilds;
+    private noAccessChannels;
+    private noAccessMessages;
+    private userCache;
+    private channelCache;
+    private slashCommands;
+    private readyToPostReactionQueue;
+    readonly name: string;
+    readonly nameLower: string;
+    protected styledName: string;
+    protected styledNameLower: string;
+    protected fgColor: import("chalk").Chalk;
+    readonly defaultEmbedColor: number;
+    startMessage: string;
+    private starting;
+    private started;
+    constructor(name: string);
+    get userId(): string;
+    setDefaultStartMessage(): void;
+    setFgColor(chalkColor: any): void;
+    isStartedOrStarting(): boolean;
+    onBeforeStart(): Promise<void>;
+    onAfterStart(): Promise<void>;
+    onAfterCacheInit(): Promise<void>;
+    getPreviousMessageOfChannel(channel: TextBasedChannel, indexFromLast?: number): Promise<Message<boolean>>;
+    start(token: string, resourcesPath: string): Promise<void>;
+    onStartFail(): void;
+    onError(error: Error): void;
+    importFile(filePath: string): Promise<any>;
+    private registerToDiscord;
+    protected registerBotEvents(resourcesPath: string): Promise<void>;
+    log(message?: any): void;
+    private onReady;
+    protected registerEverything(resourcesPath: string): Promise<void>;
+    protected registerSlashCommands(resourcesPath: string): Promise<void>;
+    protected registerStringCommands(resourcesPath: string): Promise<void>;
+    protected registerEvents(resourcesPath: string): Promise<void>;
+    edit(message: Message<boolean>, newContent: string): Promise<Message<boolean>>;
+    send(recipient: RECIPIENT_TYPE, message: MESSAGE_TYPE, options?: SendOptions): Promise<Message<boolean>>;
+    onEditedToReal(message: Message<boolean>): Promise<void>;
+    getUwuChance(): number;
+    getAiInterpretationChance(): number;
+    getAiRandomScenarioChance(): number;
+    sendToById(message: MESSAGE_TYPE, channelId: string, options?: SendOptions): Promise<Message<boolean>>;
+    trySendToById(messages: string[], channelId: string, options?: SendOptions): Promise<boolean>;
+    sendToByName(message: string | MessagePayload, guildId: string, channelName: string): Promise<Message<boolean>>;
+    dmUserById(userId: string, message: MESSAGE_TYPE): Promise<Message<boolean>>;
+    getOrCreateChannelByGuildName(guild: Guild, channelName: string): Promise<TextBasedChannel>;
+    findChannelByGuildName(guild: Guild, channelName: string): Promise<TextBasedChannel>;
+    findChannelByGuildIdName(guildId: string, channelName: string): Promise<TextBasedChannel>;
+    findGuildById(guildId: string): Promise<Guild>;
+    findMemberByGuildIdAndId(guildId: string, userId: string): Promise<GuildMember>;
+    findMemberByGuildAndId(guild: Guild, userId: string): Promise<GuildMember>;
+    findUserById(userId: string): Promise<User>;
+    findChannelById(channelId: string): Promise<Channel>;
+    memberHasRole(member: GuildMember, roleId: string): boolean;
+    trySetNickname(member: GuildMember, newName: string): Promise<boolean>;
+    followUp(interaction: ExtendedInteraction, options: string | MessagePayload | InteractionReplyOptions): Promise<Message<boolean>>;
+    renameGuildById(guildId: string, name: string): Promise<boolean>;
+    renameChannelById(channelId: string, name: string): Promise<boolean>;
+    renameMemberByGuildIdAndId(guildId: string, memberId: string, name: string): Promise<boolean>;
+    referenceToString(reference: MessageReference): Promise<string>;
+    delete(message: MessageType): Promise<boolean>;
+    setChannelMessagesTo(channel: TextChannel | ThreadChannel, msgs: string[]): Promise<void>;
+    stopIfDev(interaction: ExtendedInteraction): boolean;
+    stopIfNotTextChannel(interaction: ExtendedInteraction, channel: Channel): channel is Exclude<any, TextChannel>;
+    getUserNameById(userId: string): Promise<string>;
+    get loadingMessage(): string;
+    forEveryServer(doThis: (guild: Guild) => void | Promise<void>): Promise<void>;
+    forEveryMember(doThis: (member: GuildMember, guild: Guild) => void | Promise<void>): Promise<void>;
+    forEveryChannel(doThis: (channel: GuildBasedChannel, guild: Guild) => void | Promise<void>): Promise<void>;
+    getAllMembers(): Promise<Set<GuildMember>>;
+    getAllUsers(): Promise<Set<User>>;
+    getAllChannels(): Promise<Set<GuildBasedChannel>>;
+}
+export declare class StringCommand {
+    readonly name: OneOrMoreArray<string>;
+    readonly description: string;
+    readonly run: StringCommandFunction;
+    readonly options: SendOptions;
+    constructor(name: OneOrMoreArray<string>, description: string, run: StringCommandFunction, options?: SendOptions);
+}

package/dist/types/discord_classes.js

@@ -1,37 +1,68 @@
-import { chalk, dogPaths, if1Else, isString, makeUnixPath, print, skyify, stringify } from "../utils/util";
-import { Client, Collection, TextChannel } from "discord.js";
-import { AI_NOT_ALLOWED, DEFAULT_DUMMY_MESSAGE_EDIT_TO_REAL, DEFAULT_SEND_OPTIONS, STYLED_EVENT, STYLED_EVENTS, STYLED_SLASH_COMMAND, STYLED_SLASH_COMMANDS, STYLED_STRING_COMMAND, STYLED_STRING_COMMANDS, STYLED_WARNING, VERIFIED_BY_DISCORD_ADMINS_EASTER_EGG_MESSAGE } from "./discord_fields";
-import { COMMAND_NOT_ALLOWED_IN_DEV_MESSAGE, forEachMessage, forEveryChannelInGuild, forEveryMemberInGuild, getRandomUwuFace, getUserName, isDev, isNotTextChannel, messageToReplyString, ONLY_TEXT_CHANNEL_SUPPORTED, renameGuildOrChannel, renameMember, tooLongForDiscord, wrapTitle } from "../utils/discord-util";
-import { DISCORD_MESSAGE_LENGTH_LIMIT, globPromise, LINK_REGEX } from "./fields";
-import { random } from "mathjs";
-export class BaseDiscordClient extends Client {
-    stringCommandsMap = new Map;
-    stringCommandsSendOptions = new Map;
-    stringCommandsSet = new Set;
-    stringCommandsNamesSet = new Set;
-    commands = new Collection();
-    noAccessGuilds = new Set();
-    noAccessChannels = new Set();
-    noAccessMessages = new Set();
-    userCache = new Map();
-    channelCache = new Map();
-    slashCommands = [];
-    readyToPostReactionQueue = true;
-    name;
-    nameLower;
-    styledName;
-    styledNameLower;
-    fgColor = chalk.whiteBright;
-    defaultEmbedColor = 0xff0077;
-    startMessage;
-    starting = false;
-    started = false;
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringCommand = exports.BaseDiscordClient = void 0;
+const util_1 = require("../utils/util");
+const discord_js_1 = require("discord.js");
+const discord_fields_1 = require("./discord_fields");
+const discord_util_1 = require("../utils/discord-util");
+const fields_1 = require("./fields");
+const mathjs_1 = require("mathjs");
+class BaseDiscordClient extends discord_js_1.Client {
     constructor(name) {
         super({
             intents: 4194303,
             closeTimeout: 120000,
             waitGuildTimeout: 120000,
         });
+        this.stringCommandsMap = new Map;
+        this.stringCommandsSendOptions = new Map;
+        this.stringCommandsSet = new Set;
+        this.stringCommandsNamesSet = new Set;
+        this.commands = new discord_js_1.Collection();
+        this.noAccessGuilds = new Set();
+        this.noAccessChannels = new Set();
+        this.noAccessMessages = new Set();
+        this.userCache = new Map();
+        this.channelCache = new Map();
+        this.slashCommands = [];
+        this.readyToPostReactionQueue = true;
+        this.fgColor = util_1.chalk.whiteBright;
+        this.defaultEmbedColor = 0xff0077;
+        this.starting = false;
+        this.started = false;
         // super({ intents: [32767, GatewayIntentBits.MessageContent, GatewayIntentBits.GuildMessages, GatewayIntentBits.DirectMessages] })
         this.name = name;
         this.styledName = this.fgColor(this.name);
@@ -98,12 +129,14 @@ export class BaseDiscordClient extends Client {
         this.log(`Error: ${error.name}\n${error.stack ? `${error.stack}\n` : ""}${error.cause ? `${error.cause}\n` : ""}${error.message}`);
     }
     async importFile(filePath) {
-        return (await import(filePath))?.default;
+        var _a;
+        return (_a = (await Promise.resolve(`${filePath}`).then(s => __importStar(require(s))))) === null || _a === void 0 ? void 0 : _a.default;
     }
     async registerToDiscord({ commands, guildId }) {
+        var _a;
         if (guildId) {
-            await this.guilds.cache.get(guildId)?.commands.set(commands);
-            this.log(`Registering ${commands.length} ${STYLED_SLASH_COMMANDS} to ${guildId}`);
+            await ((_a = this.guilds.cache.get(guildId)) === null || _a === void 0 ? void 0 : _a.commands.set(commands));
+            this.log(`Registering ${commands.length} ${discord_fields_1.STYLED_SLASH_COMMANDS} to ${guildId}`);
         }
         else {
             await this.application.commands.set(commands);
@@ -115,7 +148,7 @@ export class BaseDiscordClient extends Client {
     }
     log(message) {
         // print(`${toStamp((Date.now() / 1000 % SECONDS_IN_DAY + SERVER_TIMEZONE_OFFSET_H * 3600) % SECONDS_IN_DAY)} ${this.styledName}: ${message}`)
-        print(message);
+        (0, util_1.print)(message);
     }
     async onReady(resourcesPath) {
         await this.registerEverything(resourcesPath);
@@ -133,7 +166,7 @@ export class BaseDiscordClient extends Client {
         await this.registerEvents(resourcesPath);
     }
     async registerSlashCommands(resourcesPath) {
-        const slashCommandsPath = makeUnixPath(resourcesPath, "slash_commands");
+        const slashCommandsPath = (0, util_1.makeUnixPath)(resourcesPath, "slash_commands");
         this.log(`Registering ${this.styledNameLower}...`);
         const registeredCommands = new Set();
         //Slash Commands
@@ -156,7 +189,7 @@ export class BaseDiscordClient extends Client {
                 }
             }
             if (registeredCommands.has(command.name)) {
-                this.log(`${STYLED_WARNING}: Duplicate ${STYLED_SLASH_COMMAND} ${command.name}. ${chalk.underline(chalk.whiteBright("Skipping!"))}`);
+                this.log(`${discord_fields_1.STYLED_WARNING}: Duplicate ${discord_fields_1.STYLED_SLASH_COMMAND} ${command.name}. ${util_1.chalk.underline(util_1.chalk.whiteBright("Skipping!"))}`);
                 return;
             }
             // this.log(`Registering ${STYLED_SLASH_COMMAND} ${command.name}`)
@@ -164,30 +197,30 @@ export class BaseDiscordClient extends Client {
             this.slashCommands.push(command);
             registeredCommands.add(command.name);
         };
-        const myCommandFilesPath = makeUnixPath(slashCommandsPath, this.nameLower, "*{.ts,.js}");
-        dogPaths(`myCommandFilesPath: "${myCommandFilesPath}"`);
-        const myCommandFiles = await globPromise(myCommandFilesPath);
+        const myCommandFilesPath = (0, util_1.makeUnixPath)(slashCommandsPath, this.nameLower, "*{.ts,.js}");
+        (0, util_1.dogPaths)(`myCommandFilesPath: "${myCommandFilesPath}"`);
+        const myCommandFiles = await (0, fields_1.globPromise)(myCommandFilesPath);
         for (const slashCommand of myCommandFiles) {
             await slashCommandRegisterer(slashCommand);
         }
-        const sharedCommandFilesPath = makeUnixPath(slashCommandsPath, "shared", "*{.ts,.js}");
-        dogPaths(`sharedCommandFilesPath: "${sharedCommandFilesPath}"`);
-        const sharedCommandFiles = await globPromise(sharedCommandFilesPath);
+        const sharedCommandFilesPath = (0, util_1.makeUnixPath)(slashCommandsPath, "shared", "*{.ts,.js}");
+        (0, util_1.dogPaths)(`sharedCommandFilesPath: "${sharedCommandFilesPath}"`);
+        const sharedCommandFiles = await (0, fields_1.globPromise)(sharedCommandFilesPath);
         for (const slashCommand of sharedCommandFiles) {
             await slashCommandRegisterer(slashCommand);
         }
         const slashCommandsCount = myCommandFiles.length + sharedCommandFiles.length;
         if (slashCommandsCount > 0) {
-            this.log(`Registered ${slashCommandsCount} ${if1Else(slashCommandsCount, STYLED_SLASH_COMMAND, STYLED_SLASH_COMMANDS)}.`);
+            this.log(`Registered ${slashCommandsCount} ${(0, util_1.if1Else)(slashCommandsCount, discord_fields_1.STYLED_SLASH_COMMAND, discord_fields_1.STYLED_SLASH_COMMANDS)}.`);
         }
     }
     async registerStringCommands(resourcesPath) {
-        const stringCommandsPath = makeUnixPath(resourcesPath, "string_commands");
+        const stringCommandsPath = (0, util_1.makeUnixPath)(resourcesPath, "string_commands");
         const stringCommandRegisterer = async (filePath) => {
             const stringCommand = await this.importFile(filePath);
             for (const name of stringCommand.name) {
                 if (this.stringCommandsMap.has(name)) {
-                    this.log(`${STYLED_WARNING}: Duplicate ${STYLED_STRING_COMMAND} name ${name}!`);
+                    this.log(`${discord_fields_1.STYLED_WARNING}: Duplicate ${discord_fields_1.STYLED_STRING_COMMAND} name ${name}!`);
                     continue;
                 }
                 this.stringCommandsMap.set(name, stringCommand);
@@ -201,25 +234,25 @@ export class BaseDiscordClient extends Client {
             }
         };
         //String Commands
-        const myStringCommandFilesPath = makeUnixPath(stringCommandsPath, this.nameLower, "*{.ts,.js}");
-        dogPaths(`myStringCommandFilesPath: "${myStringCommandFilesPath}"`);
-        const myStringCommandFiles = await globPromise(myStringCommandFilesPath);
+        const myStringCommandFilesPath = (0, util_1.makeUnixPath)(stringCommandsPath, this.nameLower, "*{.ts,.js}");
+        (0, util_1.dogPaths)(`myStringCommandFilesPath: "${myStringCommandFilesPath}"`);
+        const myStringCommandFiles = await (0, fields_1.globPromise)(myStringCommandFilesPath);
         for (const stringCommand of myStringCommandFiles) {
             await stringCommandRegisterer(stringCommand);
         }
-        const sharedStringCommandFilesPath = makeUnixPath(stringCommandsPath, "shared", "*{.ts,.js}");
-        const sharedStringCommandFiles = await globPromise(sharedStringCommandFilesPath);
-        dogPaths(`sharedStringCommandFilesPath: "${sharedStringCommandFilesPath}"`);
+        const sharedStringCommandFilesPath = (0, util_1.makeUnixPath)(stringCommandsPath, "shared", "*{.ts,.js}");
+        const sharedStringCommandFiles = await (0, fields_1.globPromise)(sharedStringCommandFilesPath);
+        (0, util_1.dogPaths)(`sharedStringCommandFilesPath: "${sharedStringCommandFilesPath}"`);
         for (const stringCommand of sharedStringCommandFiles) {
             await stringCommandRegisterer(stringCommand);
         }
         const stringCommandsCount = myStringCommandFiles.length + sharedStringCommandFiles.length;
         if (stringCommandsCount > 0) {
-            this.log(`Registered ${stringCommandsCount} ${if1Else(stringCommandsCount, STYLED_STRING_COMMAND, STYLED_STRING_COMMANDS)}.`);
+            this.log(`Registered ${stringCommandsCount} ${(0, util_1.if1Else)(stringCommandsCount, discord_fields_1.STYLED_STRING_COMMAND, discord_fields_1.STYLED_STRING_COMMANDS)}.`);
         }
     }
     async registerEvents(resourcesPath) {
-        const eventsPath = makeUnixPath(resourcesPath, "events");
+        const eventsPath = (0, util_1.makeUnixPath)(resourcesPath, "events");
         //Event
         const eventRegisterer = async (filePath) => {
             const event = await this.importFile(filePath);
@@ -229,41 +262,42 @@ export class BaseDiscordClient extends Client {
             this.on(event.event, (...args) => event.run(this, ...args));
             // this.log(`Registering ${STYLED_EVENT} ${event.event}`)
         };
-        const myEventFilesPath = makeUnixPath(eventsPath, this.nameLower, "*{.ts,.js}");
-        dogPaths(`myEventFilesPath: "${myEventFilesPath}"`);
-        const myEventFiles = await globPromise(myEventFilesPath);
+        const myEventFilesPath = (0, util_1.makeUnixPath)(eventsPath, this.nameLower, "*{.ts,.js}");
+        (0, util_1.dogPaths)(`myEventFilesPath: "${myEventFilesPath}"`);
+        const myEventFiles = await (0, fields_1.globPromise)(myEventFilesPath);
         for (const event of myEventFiles) {
             await eventRegisterer(event);
         }
-        const sharedEventFilesPath = makeUnixPath(eventsPath, "shared", "*{.ts,.js}");
-        dogPaths(`sharedEventFilesPath: "${sharedEventFilesPath}"`);
-        const sharedEventFiles = await globPromise(sharedEventFilesPath);
+        const sharedEventFilesPath = (0, util_1.makeUnixPath)(eventsPath, "shared", "*{.ts,.js}");
+        (0, util_1.dogPaths)(`sharedEventFilesPath: "${sharedEventFilesPath}"`);
+        const sharedEventFiles = await (0, fields_1.globPromise)(sharedEventFilesPath);
         for (const event of sharedEventFiles) {
             await eventRegisterer(event);
         }
         const eventsCount = myEventFiles.length + sharedEventFiles.length;
         if (eventsCount > 0) {
-            this.log(`Registered ${eventsCount} ${if1Else(eventsCount, STYLED_EVENT, STYLED_EVENTS)}.`);
+            this.log(`Registered ${eventsCount} ${(0, util_1.if1Else)(eventsCount, discord_fields_1.STYLED_EVENT, discord_fields_1.STYLED_EVENTS)}.`);
         }
     }
     async edit(message, newContent) {
-        if (newContent.length > DISCORD_MESSAGE_LENGTH_LIMIT) {
+        if (newContent.length > fields_1.DISCORD_MESSAGE_LENGTH_LIMIT) {
             newContent = newContent.slice(0, 1996) + "...";
-            this.log(`Tried to edit a message to length ${newContent.length}; Slicing to ${DISCORD_MESSAGE_LENGTH_LIMIT}...\n${newContent}`);
+            this.log(`Tried to edit a message to length ${newContent.length}; Slicing to ${fields_1.DISCORD_MESSAGE_LENGTH_LIMIT}...\n${newContent}`);
         }
         message = await message.edit(newContent);
         return message;
     }
-    async send(recipient, message, options = DEFAULT_SEND_OPTIONS) {
+    async send(recipient, message, options = discord_fields_1.DEFAULT_SEND_OPTIONS) {
+        var _a, _b;
         if (recipient["send"] == null) {
-            this.log(chalk.redBright(`Tried to send a message; no ["send"]! Recipient: ${typeof recipient} | ${recipient}`));
+            this.log(util_1.chalk.redBright(`Tried to send a message; no ["send"]! Recipient: ${typeof recipient} | ${recipient}`));
             return null;
         }
         if (recipient == null) {
             this.log(`bot.send: Null recipient:\n${message}`);
             return null;
         }
-        let content = (isString(message) ? message : message["content"] ?? null);
+        let content = ((0, util_1.isString)(message) ? message : (_a = message["content"]) !== null && _a !== void 0 ? _a : null);
         if (content == null) {
             return await (recipient["send"])(message);
         }
@@ -271,10 +305,10 @@ export class BaseDiscordClient extends Client {
             this.log(`Tried to send empty message`);
             return null;
         }
-        const dummyMessageEditToReal = options.dummyMessageEditToReal ?? DEFAULT_DUMMY_MESSAGE_EDIT_TO_REAL;
+        const dummyMessageEditToReal = (_b = options.dummyMessageEditToReal) !== null && _b !== void 0 ? _b : discord_fields_1.DEFAULT_DUMMY_MESSAGE_EDIT_TO_REAL;
         if (options.uwuAllowed) {
-            if (random() < this.getUwuChance()) {
-                const match = content.match(LINK_REGEX);
+            if ((0, mathjs_1.random)() < this.getUwuChance()) {
+                const match = content.match(fields_1.LINK_REGEX);
                 if (match == null) {
                     content = content
                         .replaceAll(/[rl]/g, "w")
@@ -289,22 +323,22 @@ export class BaseDiscordClient extends Client {
                         .replaceAll("Ni", "Nyai")
                         .replaceAll("pon", "pown")
                         .replaceAll("Pon", "Pown")
-                        .replace(/([.!?])(\s|$)/g, (_, punc, space) => `${punc} ${getRandomUwuFace()}${space}`);
+                        .replace(/([.!?])(\s|$)/g, (_, punc, space) => `${punc} ${(0, discord_util_1.getRandomUwuFace)()}${space}`);
                 }
             }
         }
-        if (tooLongForDiscord(content)) {
+        if ((0, discord_util_1.tooLongForDiscord)(content)) {
             this.log(`Tried to send a message of length ${content}; Slicing to 2000`);
             content = content.slice(0, 1996) + "...";
         }
         if (Math.random() <= 0.01523) {
-            if (tooLongForDiscord(content.length + VERIFIED_BY_DISCORD_ADMINS_EASTER_EGG_MESSAGE.length + 1)) {
-                content += `\n${VERIFIED_BY_DISCORD_ADMINS_EASTER_EGG_MESSAGE}`;
+            if ((0, discord_util_1.tooLongForDiscord)(content.length + discord_fields_1.VERIFIED_BY_DISCORD_ADMINS_EASTER_EGG_MESSAGE.length + 1)) {
+                content += `\n${discord_fields_1.VERIFIED_BY_DISCORD_ADMINS_EASTER_EGG_MESSAGE}`;
             }
         }
         let liveMsg = null;
         if (dummyMessageEditToReal) {
-            liveMsg = await (recipient["send"])(skyify(content));
+            liveMsg = await (recipient["send"])((0, util_1.skyify)(content));
             if (liveMsg != null) {
                 liveMsg = await this.edit(liveMsg, content);
                 this.onEditedToReal(liveMsg);
@@ -326,9 +360,9 @@ export class BaseDiscordClient extends Client {
     getAiRandomScenarioChance() {
         return 0;
     }
-    async sendToById(message, channelId, options = DEFAULT_SEND_OPTIONS) {
+    async sendToById(message, channelId, options = discord_fields_1.DEFAULT_SEND_OPTIONS) {
         let channel = await this.findChannelById(channelId);
-        if (channel instanceof TextChannel) {
+        if (channel instanceof discord_js_1.TextChannel) {
             return this.send(channel, message, options);
         }
         // else
@@ -337,14 +371,14 @@ export class BaseDiscordClient extends Client {
         // }
         return null;
     }
-    async trySendToById(messages, channelId, options = DEFAULT_SEND_OPTIONS) {
+    async trySendToById(messages, channelId, options = discord_fields_1.DEFAULT_SEND_OPTIONS) {
         for (let message of messages) {
             const trimmedMessage = message.trim();
             if (trimmedMessage.length <= 0) {
                 continue;
             }
-            if (trimmedMessage.length > DISCORD_MESSAGE_LENGTH_LIMIT) {
-                this.log(`${STYLED_WARNING}: Tried to send a message that's too long ${trimmedMessage.length}. Trimming!`);
+            if (trimmedMessage.length > fields_1.DISCORD_MESSAGE_LENGTH_LIMIT) {
+                this.log(`${discord_fields_1.STYLED_WARNING}: Tried to send a message that's too long ${trimmedMessage.length}. Trimming!`);
                 message = message.slice(0, 1999);
             }
             const sentMessage = await this.sendToById(message, channelId, options);
@@ -369,7 +403,7 @@ export class BaseDiscordClient extends Client {
     async dmUserById(userId, message) {
         try {
             const user = this.users.cache.get(userId);
-            return this.send(user, isString(message) ? message.slice(0, 1999) : message).catch(err => { print(err); });
+            return this.send(user, (0, util_1.isString)(message) ? message.slice(0, 1999) : message).catch(err => { (0, util_1.print)(err); });
             // this.findUserById(userId).then((user: User) =>
             // {
             //     this.send(user, message)
@@ -388,7 +422,7 @@ export class BaseDiscordClient extends Client {
                 channel = await guild.channels.create({ name: channelName });
             }
             catch (err) {
-                this.log(chalk.redBright(`Could not create channel in guild: ${guild.id} ${guild.name}, channel: ${channelName}\n${err}`));
+                this.log(util_1.chalk.redBright(`Could not create channel in guild: ${guild.id} ${guild.name}, channel: ${channelName}\n${err}`));
             }
         }
         return channel;
@@ -494,19 +528,19 @@ export class BaseDiscordClient extends Client {
             await member.setNickname(newName);
             this.log(`${oldName} changed to ${newName}`);
         }
-        catch {
+        catch (_a) {
             this.log(`Couldn't set name!`);
             return false;
         }
         return true;
     }
     async followUp(interaction, options) {
-        this.log(`Interaction: ${wrapTitle(interaction.commandName)} followUp: ${isString(options) ? options : `\n${stringify(options)}`}`);
+        this.log(`Interaction: ${(0, discord_util_1.wrapTitle)(interaction.commandName)} followUp: ${(0, util_1.isString)(options) ? options : `\n${(0, util_1.stringify)(options)}`}`);
         try {
             return await interaction.followUp(options);
         }
-        catch {
-            print(chalk.redBright(`Error following up interaction; probably timed out! Oh well! Followup message:\n${options}`));
+        catch (_a) {
+            (0, util_1.print)(util_1.chalk.redBright(`Error following up interaction; probably timed out! Oh well! Followup message:\n${options}`));
         }
         return null;
     }
@@ -515,15 +549,15 @@ export class BaseDiscordClient extends Client {
         if (guild == null) {
             return false;
         }
-        renameGuildOrChannel(guild, name);
+        (0, discord_util_1.renameGuildOrChannel)(guild, name);
         return true;
     }
     async renameChannelById(channelId, name) {
         const channel = await this.findChannelById(channelId);
-        if (!(channel instanceof TextChannel)) {
+        if (!(channel instanceof discord_js_1.TextChannel)) {
             return false;
         }
-        await renameGuildOrChannel(channel, name);
+        await (0, discord_util_1.renameGuildOrChannel)(channel, name);
         return true;
     }
     async renameMemberByGuildIdAndId(guildId, memberId, name) {
@@ -531,19 +565,20 @@ export class BaseDiscordClient extends Client {
         if (member == null) {
             return false;
         }
-        await renameMember(member, name);
+        await (0, discord_util_1.renameMember)(member, name);
         return true;
     }
     async referenceToString(reference) {
+        var _a;
         let referenceString = "";
         if (reference != null) {
             try {
                 const referenceChannel = await this.findChannelById(reference.channelId);
-                const referenceMessage = await referenceChannel.messages.fetch(reference.messageId ?? "");
-                referenceString = messageToReplyString(referenceMessage);
+                const referenceMessage = await referenceChannel.messages.fetch((_a = reference.messageId) !== null && _a !== void 0 ? _a : "");
+                referenceString = (0, discord_util_1.messageToReplyString)(referenceMessage);
             }
             catch (err) {
-                this.log(chalk.redBright(err));
+                this.log(util_1.chalk.redBright(err));
             }
         }
         return referenceString;
@@ -562,18 +597,18 @@ export class BaseDiscordClient extends Client {
         return false;
     }
     async setChannelMessagesTo(channel, msgs) {
-        await forEachMessage(channel, async (msg) => {
-            print(`Deleting old message ${msg.content}`);
+        await (0, discord_util_1.forEachMessage)(channel, async (msg) => {
+            (0, util_1.print)(`Deleting old message ${msg.content}`);
             await this.delete(msg);
         });
         for (const msg of msgs) {
-            const liveMsg = await this.send(channel, msg, AI_NOT_ALLOWED);
-            print(`Posted new message ${liveMsg.content}`);
+            const liveMsg = await this.send(channel, msg, discord_fields_1.AI_NOT_ALLOWED);
+            (0, util_1.print)(`Posted new message ${liveMsg.content}`);
         }
     }
     stopIfDev(interaction) {
-        if (isDev()) {
-            this.followUp(interaction, COMMAND_NOT_ALLOWED_IN_DEV_MESSAGE);
+        if ((0, discord_util_1.isDev)()) {
+            this.followUp(interaction, discord_util_1.COMMAND_NOT_ALLOWED_IN_DEV_MESSAGE);
             return true;
         }
         return false;
@@ -582,14 +617,14 @@ export class BaseDiscordClient extends Client {
         if (interaction.channel == null) {
             return false;
         }
-        if (isNotTextChannel(interaction.channel)) {
-            this.followUp(interaction, ONLY_TEXT_CHANNEL_SUPPORTED);
+        if ((0, discord_util_1.isNotTextChannel)(interaction.channel)) {
+            this.followUp(interaction, discord_util_1.ONLY_TEXT_CHANNEL_SUPPORTED);
             return false;
         }
         return true;
     }
     async getUserNameById(userId) {
-        return getUserName(await this.findUserById(userId));
+        return (0, discord_util_1.getUserName)(await this.findUserById(userId));
     }
     get loadingMessage() {
         return `Loading~`;
@@ -601,10 +636,10 @@ export class BaseDiscordClient extends Client {
         }
     }
     async forEveryMember(doThis) {
-        await this.forEveryServer(guild => forEveryMemberInGuild(guild, member => doThis(member, guild)));
+        await this.forEveryServer(guild => (0, discord_util_1.forEveryMemberInGuild)(guild, member => doThis(member, guild)));
     }
     async forEveryChannel(doThis) {
-        await this.forEveryServer(guild => forEveryChannelInGuild(guild, channel => doThis(channel, guild)));
+        await this.forEveryServer(guild => (0, discord_util_1.forEveryChannelInGuild)(guild, channel => doThis(channel, guild)));
     }
     async getAllMembers() {
         const members = new Set();
@@ -622,15 +657,14 @@ export class BaseDiscordClient extends Client {
         return channels;
     }
 }
-export class StringCommand {
-    name;
-    description;
-    run;
-    options;
-    constructor(name, description, run, options = DEFAULT_SEND_OPTIONS) {
+exports.BaseDiscordClient = BaseDiscordClient;
+class StringCommand {
+    constructor(name, description, run, options = discord_fields_1.DEFAULT_SEND_OPTIONS) {
         this.name = name;
         this.description = description;
         this.run = run;
         this.options = options;
     }
 }
+exports.StringCommand = StringCommand;
+//# sourceMappingURL=discord_classes.js.map