ahegao 1.69.1

package/dist/utils/discord-util.js

@@ -0,0 +1,1370 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVALID_CHANNEL_NAME_CHARS_REGEX = exports.TRUE_KEYWORDS = exports.FALSE_KEYWORDS = exports.UWU_FACES = exports.CHECKMARK = exports.LIST_90_DEG = exports.REPLY_REFERENCE_MAX_LENGTH = exports.DISCORD_MESSAGE_LINKS_REGEX = exports.DISCORD_MESSAGE_LINK_REGEX = exports.FILLER_AND_NASTY_REGEX = exports.URL_REGEX = exports.USELESS_LINK_METADATA_REGEX = exports.DISCORD_USER_PING_REGEX = exports.DISCORD_ANY_PING_REGEX = exports.DISCORD_EMOJI_REGEX = exports.ONLY_TEXT_CHANNEL_SUPPORTED = exports.COMMAND_NOT_ALLOWED_IN_DEV_MESSAGE = exports.COMMAND_AT_START_OF_STRING_REGEX = exports.COMMAND_START_REGEX = exports.DYNAMIC_DATE_REGEX = exports.BLANK_RUNNABLE = void 0;
+exports.math = math;
+exports.calc = calc;
+exports.formatNumber = formatNumber;
+exports.scrollEmpty = scrollEmpty;
+exports.defineWord = defineWord;
+exports.makeEmbed = makeEmbed;
+exports.makeMessage = makeMessage;
+exports.makeEmbedMessage = makeEmbedMessage;
+exports.isChannelThread = isChannelThread;
+exports.makeGuildLink = makeGuildLink;
+exports.makeChannelLink = makeChannelLink;
+exports.makeMessageLinkFromMessage = makeMessageLinkFromMessage;
+exports.makeMessageLink = makeMessageLink;
+exports.makeEmbedTextAsLink = makeEmbedTextAsLink;
+exports.userIdToPing = userIdToPing;
+exports.objsToCommandChoices = objsToCommandChoices;
+exports.objToCommandChoices = objToCommandChoices;
+exports.asCommandChoices = asCommandChoices;
+exports.getOrFromKeys = getOrFromKeys;
+exports.commitSeppuku = commitSeppuku;
+exports.getStringAsNumberOrDefault = getStringAsNumberOrDefault;
+exports.getBooleanOrDefault = getBooleanOrDefault;
+exports.newSet = newSet;
+exports.getOrDefaultProperty = getOrDefaultProperty;
+exports.isDev = isDev;
+exports.isProduction = isProduction;
+exports.sanitizeDiscordMessage = sanitizeDiscordMessage;
+exports.unhideMessage = unhideMessage;
+exports.isTextBasedChannel = isTextBasedChannel;
+exports.isNotTextChannel = isNotTextChannel;
+exports.getCuteName = getCuteName;
+exports.getRandomHeartEmoji = getRandomHeartEmoji;
+exports.getRandomPetname = getRandomPetname;
+exports.getCuteIconUrl = getCuteIconUrl;
+exports.getRandomUwuFace = getRandomUwuFace;
+exports.getIsACommandString = getIsACommandString;
+exports.getDontHavePermissionString = getDontHavePermissionString;
+exports.getCuteNameForThisDay = getCuteNameForThisDay;
+exports.getCuteIconUrlForThisDay = getCuteIconUrlForThisDay;
+exports.getNameWhereOptions = getNameWhereOptions;
+exports.getIdArrayWhereOptions = getIdArrayWhereOptions;
+exports.getIdWhereOptions = getIdWhereOptions;
+exports.getUserIdWhereOptions = getUserIdWhereOptions;
+exports.getUserName = getUserName;
+exports.getMemberName = getMemberName;
+exports.getMemberNameOrElseUserName = getMemberNameOrElseUserName;
+exports.getMemberNameOrElseUserNameFromMessage = getMemberNameOrElseUserNameFromMessage;
+exports.getMemberNameOrElseUserNameFromInteraction = getMemberNameOrElseUserNameFromInteraction;
+exports.makeClickableText = makeClickableText;
+exports.updateChannelDescriptionIfDoesntMatch = updateChannelDescriptionIfDoesntMatch;
+exports.isStringFalse = isStringFalse;
+exports.isStringTrue = isStringTrue;
+exports.attachmentsToUrls = attachmentsToUrls;
+exports.attachmentsToFiles = attachmentsToFiles;
+exports.attachmentsToRawFiles = attachmentsToRawFiles;
+exports.messageToMessageCreateOptions = messageToMessageCreateOptions;
+exports.toRainbowedAcronym = toRainbowedAcronym;
+exports.itemToRainbowedAcronym = itemToRainbowedAcronym;
+exports.messageToIdentifier = messageToIdentifier;
+exports.toMessageIdentifier = toMessageIdentifier;
+exports.toNameValueChoice = toNameValueChoice;
+exports.toNameNumberValueOption = toNameNumberValueOption;
+exports.toNameStringValueOption = toNameStringValueOption;
+exports.toNameValueOption = toNameValueOption;
+exports.forEachMessage = forEachMessage;
+exports.offsetDate = offsetDate;
+exports.newDate = newDate;
+exports.dateToDynamicDate = dateToDynamicDate;
+exports.msToDynamicDate = msToDynamicDate;
+exports.sToDynamicDate = sToDynamicDate;
+exports.getCannotAccessString = getCannotAccessString;
+exports.getInvalidString = getInvalidString;
+exports.getMissingString = getMissingString;
+exports.getMissingIdString = getMissingIdString;
+exports.getMissingContentString = getMissingContentString;
+exports.getMissingCommandString = getMissingCommandString;
+exports.getMissingSubCommandString = getMissingSubCommandString;
+exports.getMissingSubCommandsCommandString = getMissingSubCommandsCommandString;
+exports.getMissingNameString = getMissingNameString;
+exports.getCheckOurDMsString = getCheckOurDMsString;
+exports.getIDontKnowThisPersonString = getIDontKnowThisPersonString;
+exports.getMessageCannotBeEmptyString = getMessageCannotBeEmptyString;
+exports.bringRoleToTop = bringRoleToTop;
+exports.renameGuildOrChannel = renameGuildOrChannel;
+exports.renameMember = renameMember;
+exports.rename = rename;
+exports.hasBot = hasBot;
+exports.hasUser = hasUser;
+exports.hasUserId = hasUserId;
+exports.hasAnyNotBot = hasAnyNotBot;
+exports.hasEmojiByUserId = hasEmojiByUserId;
+exports.setChannelPrivate = setChannelPrivate;
+exports.sanitizeChannelName = sanitizeChannelName;
+exports.channelMatches = channelMatches;
+exports.getOrCreateTextChannel = getOrCreateTextChannel;
+exports.getOrCreateThreadChannel = getOrCreateThreadChannel;
+exports.getOrCreateCategory = getOrCreateCategory;
+exports.getCategoryChannels = getCategoryChannels;
+exports.discordCrossOut = discordCrossOut;
+exports.discordUnderline = discordUnderline;
+exports.discordBold = discordBold;
+exports.dateFromDynamicDate = dateFromDynamicDate;
+exports.referenceToUrl = referenceToUrl;
+exports.react = react;
+exports.parseDiscordMessageLinks = parseDiscordMessageLinks;
+exports.parseFirstDiscordMessageLink = parseFirstDiscordMessageLink;
+exports.isChannelPublic = isChannelPublic;
+exports.messageToReference = messageToReference;
+exports.messageLinkToReference = messageLinkToReference;
+exports.getMessageById = getMessageById;
+exports.wrapTitle = wrapTitle;
+exports.isAttachmentSpoiler = isAttachmentSpoiler;
+exports.isStringSpoiler = isStringSpoiler;
+exports.messageToReplyString = messageToReplyString;
+exports.timeAndUserIdToEmbedBuilder = timeAndUserIdToEmbedBuilder;
+exports.filterUselessMetadata = filterUselessMetadata;
+exports.isTextChannel = isTextChannel;
+exports.embedToString = embedToString;
+exports.getAllChannels = getAllChannels;
+exports.arrayToDisplayUpToString = arrayToDisplayUpToString;
+exports.debugLog = debugLog;
+exports.backupToGit = backupToGit;
+exports.getOrCreateRole = getOrCreateRole;
+exports.getRoleById = getRoleById;
+exports.tooLongForDiscord = tooLongForDiscord;
+const discord_js_1 = require("discord.js");
+const mathjs_1 = require("mathjs");
+const path_1 = require("path");
+const fields_1 = require("../types/fields");
+const util_1 = require("./util");
+const define = require("word-definition");
+const BLANK_RUNNABLE = () => { };
+exports.BLANK_RUNNABLE = BLANK_RUNNABLE;
+exports.DYNAMIC_DATE_REGEX = /<t:([0-9]+)(?:\:[a-z])?>/i;
+exports.COMMAND_START_REGEX = /(?:^|\s)(\.)[^\^\.!?_]/iu;
+exports.COMMAND_AT_START_OF_STRING_REGEX = /^\.([a-z\p{L}])/iu;
+exports.COMMAND_NOT_ALLOWED_IN_DEV_MESSAGE = `The bot is currently in Dev mode; This command is not available in Dev mode!`;
+exports.ONLY_TEXT_CHANNEL_SUPPORTED = `Only TextChannel supported!`;
+exports.DISCORD_EMOJI_REGEX = /([\w\d]+):(\d+)>/gmi;
+exports.DISCORD_ANY_PING_REGEX = /<?@[^ ]+>?/ig;
+exports.DISCORD_USER_PING_REGEX = /<@!?(\d+)>/g;
+exports.USELESS_LINK_METADATA_REGEX = /(\?(ex|itmmeta)[^\n\r ]+)$/gi;
+exports.URL_REGEX = /\bhttps?:\/\/\S+\b/gi;
+exports.FILLER_AND_NASTY_REGEX = /(\bl+[oe]+l+\b|\b(h+e+){2,}\b|what the fuck|w+t+f+|rimming|cock|arse|arsing|f(?:uc)king|feck|jaysus|smegma|piss(?:ing)|jesus|l[oe]l[oel]+|seriously|stuff|victims?|honestly|my mans?|funny thing is|literally|you know it'?s serious when|gimps?|bron+(y+|i+e+s+)|bol+ock(s)?|xd+|trann(y|ies)|\bscat\b|farts?|sissy|n+[iⅰ]+[g𝗀]{2,}(a+|e+r+)|homies?|\bb+r+[u+e+]h+|lmf?ao|cring[e+y+]|dick|bussy|\bidk+|\bgtfo+|retards?|da+w+g+|ke+kw?|stinky|p+l+z+|s+h+i+t+y*|(smooth|huge|mega|big) +brain|brain +(damage)|fag|dickgirls?|futas?|ladyboys?|shemales?|pees? in (your|ur|my) \bass|🤓|🗿|dudet*e*s*|chad|god(?!ot)s?|to be honest)/gi;
+exports.DISCORD_MESSAGE_LINK_REGEX = /https:\/\/discord\.com\/channels\/([0-9]+)\/([0-9]+)\/([0-9]+)/i;
+exports.DISCORD_MESSAGE_LINKS_REGEX = new RegExp(exports.DISCORD_MESSAGE_LINK_REGEX, "gi");
+exports.REPLY_REFERENCE_MAX_LENGTH = 152;
+exports.LIST_90_DEG = "└";
+const cuteNames = [
+    "Sunflower",
+    "Duckling",
+    "Lemon",
+    "Chick",
+    "Grapefruit",
+    "Puppy",
+    "Kitten",
+    "Avocado",
+    "Panda",
+    "Plum",
+    "Fawn",
+    "Pear",
+    "Clementine",
+    "Piglet",
+    "Kiwi",
+    "Sloth",
+    "Zucchini",
+    "Swan",
+    "Apricot",
+    "Puffin",
+    "Lychee",
+    "Guava",
+    "Llama",
+    "Nectarine",
+    "Pony",
+    "Starfruit",
+    "Peacock",
+    "Cranberry",
+    "Raspberry",
+    "Raccoon",
+    "Blackberry",
+    "Fig",
+    "Koala",
+    "Hazelnut",
+    "Walrus",
+    "Passionfruit",
+    "Salamander",
+    "Quokka",
+    "Dragonfruit",
+    "Hibiscus",
+    "Frog",
+    "Hummingbird",
+    "Lyrebird",
+    "Persimmon",
+    "Beaver",
+    "Cactus",
+    "Papaya",
+    "Pangolin",
+    "Peach",
+    "Platypus",
+    "Chestnut",
+    "Cheetah",
+    "Starfish",
+    "Flamingo",
+    "Jellyfish",
+    "Duck",
+    "Chickadee",
+    "Lime",
+    "Pigeon",
+    "Cucumber",
+    "Ferret",
+    "Beet",
+    "Broccoli",
+    "Parrot",
+    "Eggplant",
+    "Grape",
+    "Gazelle",
+    "Pomegranate",
+    "Penguin",
+    "Hedgehog",
+    "Toucan",
+    "Pumpkin",
+    "Zebra",
+    "Blossom",
+    "Pudding",
+    "Fluffy",
+    "Daisy",
+    "Sprinkle",
+    "Cinnamon",
+    "Honey",
+    "Honeybee",
+    "Honeybun",
+    "Snuggle",
+    "Buttercup",
+    "Sugarcube",
+    "Bubbles",
+    "Cupcake",
+    "Petal",
+    "Marshmallow",
+    "Peachy",
+    "Cookie",
+    "Lavender",
+    "Fuzzy",
+    "Bumble",
+    "Giggles",
+    "Peaches",
+    "Twinkle",
+    "Sparkle",
+    "Cherry",
+    "Jellybean",
+    "Rainbow",
+    "Daffodil",
+    "Sunny",
+    "Bubblegum",
+    "Precious",
+    "Sugarplum",
+    "Tulip",
+    "Melody",
+    "Angel",
+    "Stardust",
+    "Lulu",
+    "Fizzy",
+    "Candy",
+    "Clover",
+    "Glimmer",
+    "Sweets",
+    "Muffin",
+    "Bluebell",
+    "Pixie",
+    "Bunny",
+    "Peony",
+    "Poppy",
+    "Cupid",
+    "Rosy",
+    "Honey",
+    "Biscuit",
+    "Breezy",
+    "Sprinkles",
+    "Lollipop",
+    "Lullaby",
+    "Dizzy",
+    "Cuddlebug",
+    "Button",
+    "Moonbeam",
+    "Mellow",
+    "Dandelion",
+    "Doodlebug",
+    "Butterfly",
+    "Sweetpea",
+    "Whisper",
+    "Teddy",
+    "Luna",
+    "Coco",
+    "Pebble",
+    "Bambi",
+    "Mochi",
+    "Willow",
+    "Snowball",
+    "Chip",
+    "Socks",
+    "Hazel",
+    "Cotton",
+    "Ginger",
+    "Nibbles",
+    "Peanut",
+    "Marbles",
+    "Popcorn",
+    "Rosie",
+    "Buttons",
+    "Waffles",
+    "Acorn",
+    "Blueberry",
+    "Whiskers",
+    "Maple",
+    "Squeaky",
+    "Thistle",
+    "Pickles",
+    "Mopsy",
+    "Squeak",
+    "Basil",
+    "Sniffles",
+    "Doodle",
+    "Tippy",
+    "Nutmeg",
+    "Dazzle",
+    "Truffle",
+    "Apple",
+    "Jingle",
+    "Tinker",
+    "Flutter",
+    "Dreamer",
+    "Crystal",
+    "Twilight",
+    "Primrose",
+    "Peppermint",
+    "Breeze",
+    "Dewdrop",
+    "Starlight",
+    "Meadow",
+    "Misty",
+    "Lilypad",
+    "Rosebud",
+    "Starshine",
+    "Lily",
+    "Diamond",
+    "Sweetie",
+    "Bubble",
+    "Cloud",
+    "Sky",
+    "Snowflake",
+    "Spark",
+    "Dew",
+    "Feather",
+    "Star",
+    "Honeydew",
+    "Berry",
+    "Rose",
+    "Butter",
+    "Dream",
+    "Sunbeam",
+    "Starry",
+    "Glitter",
+    "Jewel",
+    "Cocoa",
+    "Emerald",
+    "Coral",
+    "Pearl",
+    "Minty",
+    "Ruby",
+    "Velvet",
+    "Violet",
+    "Wisp",
+    "Frost",
+    "Aurora",
+    "Jade",
+    "Puff",
+    "Sprite",
+    "Ivy",
+    "Nymph",
+    "Moss",
+    "Ember",
+    "Zephyr",
+    "Celestia",
+    "Evergreen",
+    "Opal",
+    "Cobweb",
+    "Starling",
+    "Marigold",
+    "Topaz",
+    "Flora",
+    "Cascade",
+    "Gossamer",
+    "Brook",
+    "Sorrel",
+    "Dusk",
+    "Fauna",
+    "Mist",
+    "Iris",
+    "Cuddle",
+    "Dreamy",
+    "Shimmer",
+    "Giggles",
+    "Pearl",
+    "Sugar",
+    "Sapphire",
+    "Twirl",
+    "Glimpse",
+    "Delight",
+    "Lacey",
+    "Celeste",
+    "Flicker",
+    "Taffy",
+    "Bliss",
+    "Gem",
+];
+const genderNeutralPetnames = [
+    "Pumpkin",
+    "Sugar",
+    "Sugarcube",
+    "Honey",
+    "Sweetie",
+    "Cupcake",
+    "Buttercup",
+    "Jellybean",
+    "Marshmallow",
+    "Sweetie",
+    "Sweetheart",
+    "Darling",
+    "Love",
+    "Sugarplum",
+    "Sweetpea",
+    "Dear",
+    "Good Tomato",
+    "Silly Tomato",
+    "Sweet Tomato",
+    "Sunshine",
+    "Cutie Pie"
+];
+const HEARTS_EMOJIS = [
+    "💖",
+    "💝",
+    "<:pinku_two_hearts:1050421227711373323>",
+    "<:pinkuheart:1046374855756492871>",
+    "<:growing_heart_1:1251486909239263242>",
+    "<:growing_heart_2:1251486906785468518>",
+    "<:heart_ribbon_1:1251486509480022066>",
+    "<:heart_ribbon_2:1251486506657386517>",
+    "<:pink_heart_1:1251486508351881297>",
+    "<:pink_heart_2:1251486505046769675>",
+    "<:pink_heart_3:1251486502630719499>",
+    "<:pink_heart_4:1251486499321548894>",
+    "<:revolving_hearts_1:1251486565004214272>",
+    "<:sparkling_heart_1:1251486904281727036>",
+    "<:sparkling_heart_2:1251486566052925441>",
+    "<:two_hearts_1:1251486503725568031>",
+    "<:two_hearts_2:1251486501057990667>",
+    "<:two_hearts_3:1251486907892891709>",
+    "<:two_hearts_4:1251486905623646248>",
+    "<:two_hearts_5:1251486902960525392>",
+];
+exports.CHECKMARK = "✅";
+exports.UWU_FACES = [">w<", "owo", "OwO", "uwu"];
+const cuteIconLinks = [
+    //flower
+    "https://s3.amazonaws.com/pix.iemoji.com/andr33/0251.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/hang33/0251.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/twit33/0251.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/lg33/0251.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/sams33/0251.png",
+    //sparkles
+    "https://s3.amazonaws.com/pix.iemoji.com/andr33/0136.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/hang33/0136.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/twit33/0136.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/lg33/0136.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/sams33/0136.png",
+    //glowing star
+    "https://s3.amazonaws.com/pix.iemoji.com/andr33/0242.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/hang33/0242.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/twit33/0242.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/lg33/0242.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/sams33/0242.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/phan33/0242.png",
+    //star
+    "https://s3.amazonaws.com/pix.iemoji.com/andr33/0161.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/hang33/0161.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/twit33/0161.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/lg33/0161.png",
+    //hibiscus
+    "https://s3.amazonaws.com/pix.iemoji.com/andr33/0253.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/hang33/0253.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/twit33/0253.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/lg33/0253.png",
+    "https://s3.amazonaws.com/pix.iemoji.com/sams33/0253.png",
+];
+exports.FALSE_KEYWORDS = new Set([
+    "off",
+    "disable",
+    "disabled",
+    "false",
+    "0",
+    "no",
+]);
+exports.TRUE_KEYWORDS = new Set([
+    "on",
+    "enable",
+    "enabled",
+    "true",
+    "1",
+    "yes",
+]);
+////////////////////////////////////////////////////////////////////////////////////
+function math(args, id, givenType, minutes) {
+    let number = calc(args, minutes);
+    return formatNumber(number, id, givenType);
+}
+function calc(args, minutes) {
+    let toAdd = args.toString().toLowerCase()
+        .replace(/,/g, '.')
+        // .replace(/s/g, ``)
+        .replace(/k/g, `(1000)`)
+        .replace(/m/g, `(${minutes ? '60' : '1000000'})`)
+        .replace(/b/g, `(1000000000)`)
+        .replace(/h/g, `(3600)`)
+        .replace(/d/g, `(86400)`)
+        .replace(/w/g, `(604800)`)
+        .replace(/y/g, `(31536000)`)
+        .replace(/x10\^/g, 'e+')
+        .replace(/\*10\^/g, 'e+')
+        .replace(/x10\^-/g, 'e-')
+        .replace(/\*10\^-/g, 'e-')
+        .replace(/x/g, '*');
+    let temp = toAdd;
+    toAdd = toAdd.replace(/[a-d]/g, '').replace(/[f-z]/g, '');
+    if (toAdd != temp)
+        return NaN;
+    try {
+        return (0, mathjs_1.evaluate)(toAdd);
+    }
+    catch (e) {
+        return NaN;
+    }
+}
+function formatNumber(number, id, givenType) {
+    let type = givenType ? givenType : 'exponent';
+    try {
+        let isNegative = false;
+        if (number < 0) {
+            isNegative = true;
+            number = -number;
+        }
+        if (type == 'auto') {
+            if (number < 1000)
+                type = 'full';
+            else if (number < 1000000)
+                type = 'k';
+            else if (number < 1000000000)
+                type = 'm';
+            else if (number < 1000000000000)
+                type = 'b';
+            else if (number < 1000000000000000)
+                type = 't';
+        }
+        let final;
+        switch (type) {
+            case "exponent":
+                final = (0, mathjs_1.format)(number);
+                break;
+            case 'full':
+                final = (0, mathjs_1.format)(number, { precision: 16, lowerExp: -1000, upperExp: 1000 });
+                break;
+                // case 'med':
+                // 	final = format(number, {precision: 4, lowerExp: -9, upperExp: 9})
+                // 	break
+                // case 'low':
+                // 	final = format(number, {precision: 4, lowerExp: -2, upperExp: 3})
+                break;
+            case 'k':
+                final = (0, mathjs_1.format)(number / 1000, { precision: 3, lowerExp: -1000, upperExp: 1000 }) + 'k';
+                break;
+            case 'm':
+                final = (0, mathjs_1.format)(number / 1000000, { precision: 3, lowerExp: -1000, upperExp: 1000 }) + 'm';
+                break;
+            case 'b':
+                final = (0, mathjs_1.format)(number / 1000000000, { precision: 3, lowerExp: -1000, upperExp: 1000 }) + 'b';
+                break;
+            case 't':
+                final = (0, mathjs_1.format)(number / 1000000000000, { precision: 3, lowerExp: -1000, upperExp: 1000 }) + 't';
+                break;
+            default:
+                final = (0, mathjs_1.format)(number, { precision: 16, lowerExp: -4, upperExp: 5 });
+                break;
+        }
+        if (isNegative)
+            return `-${final}`;
+        else
+            return final;
+    }
+    catch (e) {
+        return "" + number;
+    }
+}
+// export function map(input: number, min1: number, max1: number, min2: number, max2: number): number
+// {
+// 	return parseFloat(math(((input - min1) / (max1 - min1)) * (max2 - min2) + min2, null, "raw"))
+// }
+function scrollEmpty(scrollAmount = 50) {
+    scrollAmount = (0, mathjs_1.min)(100, scrollAmount);
+    let output = `\`\`\``;
+    for (let i = 0; i < scrollAmount; ++i) {
+        output += `${fields_1.EMPTY}\n`;
+    }
+    output += `\`\`\``;
+    return output;
+}
+async function defineWord(word, lang) {
+    return new Promise((resolve, reject) => {
+        define.getDef(word, lang, null, (def) => {
+            if (def.error)
+                resolve({ definition: def.error });
+            if (def.definition == undefined)
+                resolve({ definition: `No definition found for the word: [${word}]. [${lang}]` });
+            resolve({ category: def.category, definition: def.definition });
+        });
+    });
+}
+function makeEmbed(title, description, color) {
+    if (title.length + description.length > 4096) {
+        console.log(util_1.chalk.redBright(`Longer than 4096 embed with ${title.length + description.length} length!\ntitle: ${title}\ndescription: ${description}`));
+    }
+    let embedColor = 0xff008D;
+    if (color) {
+        embedColor = color;
+    }
+    return new discord_js_1.EmbedBuilder()
+        .setTitle(title.length > 0 ? title : fields_1.EMPTY)
+        .setDescription(description.length > 0 ? description : fields_1.EMPTY)
+        .setColor(embedColor);
+}
+function makeMessage(embeds) {
+    if (Array.isArray(embeds))
+        return { embeds: embeds };
+    else
+        return { embeds: [embeds] };
+}
+function makeEmbedMessage(title, description, color) {
+    return makeMessage(makeEmbed(title, description, color));
+}
+function isChannelThread(channel) {
+    return channel.type == discord_js_1.ChannelType.PublicThread
+        || channel.type == discord_js_1.ChannelType.PrivateThread
+        || channel.type == discord_js_1.ChannelType.AnnouncementThread;
+}
+function makeGuildLink(guildId) {
+    return `https://discord.com/channels/${guildId}`;
+}
+function makeChannelLink(guildId, channelId) {
+    return `${makeGuildLink(guildId)}/${channelId}`;
+}
+function makeMessageLinkFromMessage(message) {
+    return makeMessageLink(message.guildId, message.channelId, message.id);
+}
+function makeMessageLink(guildId, channelId, messageId) {
+    if (guildId == null) {
+        return makeChannelLink(channelId, messageId);
+    }
+    return `${makeChannelLink(guildId, channelId)}/${messageId}`;
+}
+function makeEmbedTextAsLink(text, link) {
+    return `[${text}](${link})`;
+}
+function userIdToPing(userId) {
+    return `<@${userId}>`;
+}
+function objsToCommandChoices(objs, nameGetter, valueGetter) {
+    return (0, util_1.mapToArray)(objs, obj => objToCommandChoices(obj, nameGetter, valueGetter));
+}
+function objToCommandChoices(obj, nameGetter, valueGetter) {
+    return { name: nameGetter(obj), value: valueGetter(obj) };
+}
+function asCommandChoices(keys) {
+    const choices = [];
+    let i = 0;
+    for (const key of keys) {
+        if (++i == 25) {
+            console.log(`Warning: could only fit ${keys} keys as command choice`);
+            return choices;
+        }
+        choices.push({ name: key.toString(), value: key });
+    }
+    return choices;
+}
+function getOrFromKeys(stringCount, keyName) {
+    const orData = [{}];
+    delete orData[0];
+    for (const str of Object.keys(stringCount)) {
+        orData.push({
+            [keyName]: str
+        });
+    }
+    return orData;
+}
+function commitSeppuku() {
+    setTimeout(() => [1], 1523);
+}
+function getStringAsNumberOrDefault(interaction, name, defaultValue) {
+    const optionalValue = interaction.options.get(name);
+    if (optionalValue == null)
+        return defaultValue;
+    const calcResult = calc(optionalValue.value, true);
+    return isNaN(calcResult) ? defaultValue : calcResult;
+}
+function getBooleanOrDefault(interaction, name, defaultValue) {
+    const optionalValue = interaction.options.get(name);
+    if (optionalValue == null)
+        return defaultValue;
+    return optionalValue.value;
+}
+function newSet(collection) {
+    const values = new Set();
+    collection.forEach(guild => values.add(guild));
+    return values;
+}
+function getOrDefaultProperty(interaction, key, defaultValue) {
+    const valueOptional = interaction.options.get(key);
+    return valueOptional ? valueOptional.value : defaultValue;
+}
+function isDev() {
+    return process.env.ENVIRONMENT == "dev";
+}
+function isProduction() {
+    return process.env.ENVIRONMENT == "production";
+}
+function sanitizeDiscordMessage(message, hideFiller = false) {
+    message = message.replaceAll(exports.DISCORD_ANY_PING_REGEX, "[REMOVED PING]");
+    if (hideFiller) {
+        message = message.replaceAll(exports.FILLER_AND_NASTY_REGEX, "||$1||");
+    }
+    return message.trim().slice(0, fields_1.DISCORD_MESSAGE_LENGTH_LIMIT);
+}
+function unhideMessage(url) {
+    let startIndex = 0;
+    while (startIndex < url.length && (url[startIndex] === "|" || url[startIndex] === "<")) {
+        ++startIndex;
+    }
+    let endIndex = url.length;
+    while (endIndex > 0 && (url[endIndex - 1] === "|" || url[endIndex - 1] === ">")) {
+        --endIndex;
+    }
+    return url.substring(startIndex, endIndex);
+}
+function isTextBasedChannel(channel) {
+    if (channel instanceof discord_js_1.TextChannel) {
+        return true;
+    }
+    if (channel instanceof discord_js_1.ThreadChannel) {
+        return true;
+    }
+    return false;
+}
+function isNotTextChannel(channel) {
+    if (channel instanceof discord_js_1.TextChannel) {
+        return false;
+    }
+    if (channel instanceof discord_js_1.ThreadChannel) {
+        return false;
+    }
+    return true;
+}
+function getCuteName(index) {
+    return cuteNames[index % cuteNames.length];
+}
+function getRandomHeartEmoji(amount = 1) {
+    let emojis = "";
+    for (let i = 0; i < amount; ++i) {
+        emojis += (0, util_1.randomFromArray)(HEARTS_EMOJIS);
+    }
+    return emojis;
+}
+function getRandomPetname() {
+    return `${(0, util_1.randomFromArray)(genderNeutralPetnames)} ${getRandomHeartEmoji()}`;
+}
+function getCuteIconUrl(index) {
+    return cuteIconLinks[index % cuteIconLinks.length];
+}
+function getRandomUwuFace() {
+    return (0, util_1.randomFromArray)(exports.UWU_FACES);
+}
+function getIsACommandString(word) {
+    return `${wrapTitle(word)} is a command, ${getRandomPetname()}!`;
+}
+function getDontHavePermissionString() {
+    return `Excuse me ${getRandomPetname()}, but you don't have the permission to do this!`;
+}
+function getCuteNameForThisDay(user) {
+    return getCuteName((0, mathjs_1.floor)(parseInt(user.id) / (0, util_1.getDaySince1980)()));
+}
+function getCuteIconUrlForThisDay(user) {
+    return getCuteIconUrl((0, mathjs_1.floor)(parseInt(user.id) / (0, util_1.getDaySince1980)()));
+}
+function getNameWhereOptions(name) {
+    return { where: { name } };
+}
+function getIdArrayWhereOptions(ids) {
+    return { where: { id: { in: ids } } };
+}
+function getIdWhereOptions(id) {
+    return { where: { id } };
+}
+function getUserIdWhereOptions(userId) {
+    return { where: { userId } };
+}
+// export function getUser_idOptions(user_id: bigint): { where: { user_id: bigint } }
+// {
+//     return { where: { user_id } }
+// }
+function getUserName(user) {
+    if (user == null) {
+        return fields_1.EMPTY;
+    }
+    if (user instanceof discord_js_1.GuildMember) {
+        if (user.nickname != null) {
+            return user.nickname;
+        }
+        else {
+            return user.displayName;
+        }
+    }
+    return (0, util_1.orElse)(user.globalName, () => (0, util_1.orElse)(user.username, () => user.displayName));
+}
+function getMemberName(member) {
+    return (0, util_1.orElse)(member.nickname, () => member.displayName);
+}
+function getMemberNameOrElseUserName(member, user) {
+    if (member == null) {
+        return getUserName(user);
+    }
+    return getMemberName(member);
+}
+function getMemberNameOrElseUserNameFromMessage(message) {
+    return getMemberNameOrElseUserName(message.member, message.author);
+}
+function getMemberNameOrElseUserNameFromInteraction(interaction) {
+    return getMemberNameOrElseUserName(interaction.member, interaction.user);
+}
+function makeClickableText(text, url) {
+    return `[${text}](${url})`;
+}
+async function updateChannelDescriptionIfDoesntMatch(channel, description) {
+    if (channel.topic != description) {
+        await channel.setTopic(description);
+        return true;
+    }
+    return false;
+}
+function isStringFalse(text) {
+    return exports.FALSE_KEYWORDS.has(text.trim().toLowerCase());
+}
+function isStringTrue(text) {
+    return exports.TRUE_KEYWORDS.has(text.trim().toLowerCase());
+}
+function attachmentsToUrls(attachments) {
+    let files = [];
+    for (const attachment of attachments.values()) {
+        files.push(attachment.url);
+    }
+    return files;
+}
+function attachmentsToFiles(attachments) {
+    let files = [];
+    for (const attachment of attachments.values()) {
+        files.push(isAttachmentSpoiler(attachment) ? `||${attachment.url}||` : attachment.url);
+    }
+    return files;
+}
+function attachmentsToRawFiles(attachments) {
+    let files = [];
+    for (const attachment of attachments.values()) {
+        files.push({ name: attachment.name, contentType: attachment.contentType, data: attachment.url });
+        files.push(Object.assign(Object.assign({}, attachment), { data: attachment.url }));
+    }
+    return files;
+}
+function messageToMessageCreateOptions(message) {
+    const files = attachmentsToFiles(message.attachments);
+    const messageCreateOptions = {
+        content: message.content,
+        files,
+        // reply: { messageReference: message?.reference?.messageId, failIfNotExists: false },
+    };
+    return messageCreateOptions;
+}
+function toRainbowedAcronym(name, key) {
+    const acronym = (0, util_1.acronymStringIfTooLong)(name);
+    if (acronym.length == 0) {
+        return "";
+    }
+    const seed = key ? parseInt(key) : (0, util_1.hashCode)(name);
+    return (0, util_1.chalkRainbowColor)(acronym, seed);
+}
+function itemToRainbowedAcronym(item) {
+    return item ? toRainbowedAcronym(item.name, item.id) : "";
+}
+function messageToIdentifier(message) {
+    return toMessageIdentifier(message.guild, message.channel, message.author);
+}
+function toMessageIdentifier(guild, channel, author) {
+    var _a;
+    let channelText = "";
+    if (channel != null) {
+        let channelType = channel.type;
+        let channelTypeStr = discord_js_1.ChannelType[channelType];
+        const channelName = (_a = channel["name"]) !== null && _a !== void 0 ? _a : channel.id;
+        const channelNameAcronym = toRainbowedAcronym(channelName, channel.id);
+        channelText = `[${toRainbowedAcronym(channelTypeStr)}][${channelNameAcronym.length == 0 ? channelName : channelNameAcronym}]`;
+    }
+    return `${guild == null ? "" : `[${itemToRainbowedAcronym(guild)}]`}${channelText}${author ? ` ${(0, util_1.chalkRainbowColor)(getUserName(author), parseInt(author.id))}` : ""}`;
+}
+function toNameValueChoice(text) {
+    const words = text.split(/[ _]/).filter(word => word.length >= 0);
+    let name = "";
+    let i = 0;
+    for (const word of words) {
+        if (i > 0) {
+            name += " ";
+        }
+        name += (0, util_1.firstUpperLowerRest)(word);
+        ++i;
+    }
+    return { name, value: text.toLowerCase().replaceAll(" ", "_") };
+}
+function toNameNumberValueOption(text, description, required = false) {
+    return toNameValueOption(text, discord_js_1.ApplicationCommandOptionType.Number, description, required);
+}
+function toNameStringValueOption(text, description, required = false) {
+    return toNameValueOption(text, discord_js_1.ApplicationCommandOptionType.String, description, required);
+}
+function toNameValueOption(text, type, description, required = false) {
+    const words = text.split(/[ _]/).filter(word => word.length >= 0);
+    let name = "";
+    let i = 0;
+    for (const word of words) {
+        if (i > 0) {
+            name += " ";
+        }
+        name += (0, util_1.firstUpperLowerRest)(word);
+        ++i;
+    }
+    return {
+        name: name.toLowerCase().replaceAll(" ", "_"),
+        description: description == null ? `The ${name}` : description,
+        type,
+        required,
+    };
+}
+async function forEachMessage(channel, consumer, referenceMsg, after = false) {
+    let fetchPointer = referenceMsg != null ? referenceMsg : await channel.messages
+        .fetch({ limit: 1 })
+        .then(messagePage => (messagePage.size === 1 ? messagePage.at(0) : null));
+    if (fetchPointer != null && await consumer(fetchPointer)) {
+        return;
+    }
+    let earlyExit = false;
+    let page = 1;
+    let messageCount = 0;
+    while (fetchPointer && !earlyExit) {
+        const fetchParamaters = { limit: 100 };
+        if (after) {
+            fetchParamaters["after"] = fetchPointer.id;
+        }
+        else {
+            fetchParamaters["before"] = fetchPointer.id;
+        }
+        await channel.messages
+            .fetch(fetchParamaters)
+            .then(async (messagePage) => {
+            for (const messageThingy of messagePage) {
+                ++messageCount;
+                const message = messageThingy[1];
+                if (await consumer(message)) {
+                    earlyExit = true;
+                    return;
+                }
+            }
+            if (messagePage.size > 0) {
+                console.log(`${channel.name}: page: ${page++} | ${messageCount}`);
+            }
+            fetchPointer = 0 < messagePage.size ? messagePage.at(messagePage.size - 1) : null;
+        });
+    }
+}
+function offsetDate(date, hourOffset) {
+    return new Date(date.getTime() + (0, util_1.hoursToMilliseconds)(hourOffset));
+}
+function newDate(offsetMs = 0) {
+    return new Date(Date.now() + offsetMs);
+}
+// export async function forEachChannel(guild: Guild, consumer: (message: Channel) => void | boolean)
+// {
+// 	let nonThreadChannels = (await guild.channels.fetch()).values()
+// 	guild.arch
+// }
+function dateToDynamicDate(date, format = "F") {
+    return msToDynamicDate(date.getTime(), format);
+}
+function msToDynamicDate(ms, format = "F") {
+    return `<t:${Math.floor(ms / 1000)}:${format}>`;
+}
+function sToDynamicDate(seconds, format = "F") {
+    return `<t:${Math.floor(seconds)}:${format}>`;
+}
+function getCannotAccessString(itemName) {
+    return `Cannot Access ${wrapTitle(itemName)}, ${getRandomPetname()}!`;
+}
+function getInvalidString(itemName) {
+    return `Invalid ${wrapTitle(itemName)}, ${getRandomPetname()}!`;
+}
+function getMissingString(itemName) {
+    return `Missing ${wrapTitle(itemName)}, ${getRandomPetname()}!`;
+}
+function getMissingIdString() {
+    return getMissingString("Id");
+}
+function getMissingContentString() {
+    return getMissingString("Content");
+}
+function getMissingCommandString() {
+    return getMissingString("Command");
+}
+function getMissingSubCommandString() {
+    return getMissingString("Sub Command");
+}
+function getMissingSubCommandsCommandString() {
+    return getMissingString("Sub Command's Command");
+}
+function getMissingNameString(type = null) {
+    return `Missing${type == null ? "" : ` ${type}`} Name, ${getRandomPetname()}!`;
+}
+function getCheckOurDMsString() {
+    return `Please check our DMs, ${getRandomPetname()}!`;
+}
+function getIDontKnowThisPersonString() {
+    return `Sorry ${getRandomPetname()}, I don't know this person!`;
+}
+function getMessageCannotBeEmptyString() {
+    return `Sorry ${getRandomPetname()}, the message cannot be empty!`;
+}
+async function bringRoleToTop(role) {
+    const highestRole = role.guild.roles.highest;
+    if (highestRole) {
+        try {
+            await role.setPosition(highestRole.position - 1);
+        }
+        catch (error) {
+            console.error('Error moving role:', error);
+            return false;
+        }
+    }
+    return false;
+}
+async function renameGuildOrChannel(item, name) {
+    await item.setName(name);
+}
+async function renameMember(member, name) {
+    await member.setNickname(name);
+}
+async function rename(item, name) {
+    if (item instanceof discord_js_1.Guild || item instanceof discord_js_1.TextChannel) {
+        await renameGuildOrChannel(item, name);
+    }
+    if (item instanceof discord_js_1.GuildMember) {
+        await renameMember(item, name);
+    }
+}
+// export function removeExcessKeys<T1 extends object, T2 extends keyof T1>(obj: T1): Pick<T1, T2>
+// {
+// 	const result = {} as Pick<T1, T2>
+// 	Object.keys(obj).forEach(key =>
+// 		{
+// 			if (key in obj)
+// 			{
+// 				result[key as T2] = obj[key as T2]
+// 			}
+// 		})
+// 	return result
+// }
+function hasBot(users, bot) {
+    for (const user of users) {
+        if (bot.user == null) {
+            continue;
+        }
+        if (user.id === bot.user.id) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasUser(users, checkedUser) {
+    for (const user of users) {
+        if (user.id === checkedUser.id) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasUserId(users, userId) {
+    for (const user of users) {
+        if (user.id === userId) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasAnyNotBot(users) {
+    for (const user of users) {
+        if (!user.bot) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasEmojiByUserId(reaction, userId) {
+    return reaction != null && reaction.users.cache.has(userId);
+}
+async function setChannelPrivate(channel, makePrivate, to = channel.guild.roles.everyone) {
+    await channel.permissionOverwrites.create(to, {
+        ViewChannel: !makePrivate
+    });
+}
+exports.INVALID_CHANNEL_NAME_CHARS_REGEX = /[^ a-z_\-]/gi;
+function sanitizeChannelName(name) {
+    return name.replaceAll(exports.INVALID_CHANNEL_NAME_CHARS_REGEX, "").replaceAll(" ", "-").toLowerCase();
+}
+function channelMatches(channel, channelType, name) {
+    if (channel.type !== channelType) {
+        return false;
+    }
+    if (channelType !== discord_js_1.ChannelType.GuildCategory) {
+        name = sanitizeChannelName(name);
+    }
+    const channelName = channel["name"];
+    if (channelName == null) {
+        return false;
+    }
+    if (channelName !== name) {
+        return false;
+    }
+    return true;
+}
+async function getOrCreateTextChannel(guild, name, parent = null) {
+    for (const channel of parent == null ? guild.channels.cache.values() : parent.children.cache.values()) {
+        if (channelMatches(channel, discord_js_1.ChannelType.GuildText, name)) {
+            return channel;
+        }
+    }
+    return (await guild.channels.create({ name, type: discord_js_1.ChannelType.GuildText, parent }));
+}
+async function getOrCreateThreadChannel(channel, name, parent = null) {
+    for (const thread of parent == null ? channel.threads.cache.values() : parent.children.cache.values()) {
+        if (channelMatches(thread, discord_js_1.ChannelType.PublicThread, name)) {
+            return thread;
+        }
+    }
+    return (await channel.threads.create({ name, type: discord_js_1.ChannelType.PublicThread }));
+}
+async function getOrCreateCategory(guild, name) {
+    for (const channel of guild.channels.cache.values()) {
+        if (channelMatches(channel, discord_js_1.ChannelType.GuildCategory, name)) {
+            return channel;
+        }
+    }
+    return (await guild.channels.create({ name, type: discord_js_1.ChannelType.GuildCategory }));
+}
+async function getCategoryChannels(categoryChannel) {
+    const channels = {};
+    for (const channel of categoryChannel.children.cache.values()) {
+        channels[channel.name] = channel;
+    }
+    return channels;
+}
+function discordCrossOut(input) {
+    return `~~${input}~~`;
+}
+function discordUnderline(input) {
+    return `__${input}__`;
+}
+function discordBold(input, thiccness = 2) {
+    thiccness = (0, util_1.clamp)(thiccness, 1, 3);
+    let asterisks = "";
+    for (let i = 0; i < thiccness; ++i) {
+        asterisks += "*";
+    }
+    return `${asterisks}${input}${asterisks}`;
+}
+function dateFromDynamicDate(dynamicDate) {
+    const result = dynamicDate.match(exports.DYNAMIC_DATE_REGEX);
+    if (result == null) {
+        return null;
+    }
+    return new Date(parseInt(result[1]) * 1000);
+}
+function referenceToUrl(reference) {
+    if (reference == null) {
+        return "";
+    }
+    return reference.guildId != null ? makeMessageLink(reference.guildId, reference.channelId, reference.messageId) : "";
+}
+async function react(message, emoji, timeout = 0) {
+    if (message.interaction != null) {
+        return;
+    }
+    const reaction = await message.react(emoji);
+    if (timeout > 0) {
+        setTimeout(() => {
+            try {
+                reaction.remove();
+            }
+            catch (ignored) { }
+        }, timeout);
+    }
+}
+function parseDiscordMessageLinks(input) {
+    const references = [];
+    for (const match of input.matchAll(exports.DISCORD_MESSAGE_LINKS_REGEX)) {
+        references.push({
+            type: discord_js_1.MessageReferenceType.Default,
+            guildId: match[1],
+            channelId: match[2],
+            messageId: match[3],
+        });
+    }
+    return references;
+}
+function parseFirstDiscordMessageLink(input) {
+    const match = input.match(exports.DISCORD_MESSAGE_LINK_REGEX);
+    if (match == null) {
+        return null;
+    }
+    return {
+        type: discord_js_1.MessageReferenceType.Default,
+        guildId: match[1],
+        channelId: match[2],
+        messageId: match[3],
+    };
+}
+function isChannelPublic(channel) {
+    const everyoneRole = channel.guild.roles.everyone;
+    const permissions = channel.permissionsFor(everyoneRole);
+    return permissions === null || permissions === void 0 ? void 0 : permissions.has(discord_js_1.PermissionsBitField.Flags.ViewChannel);
+}
+function messageToReference(message) {
+    return { type: discord_js_1.MessageReferenceType.Default, guildId: message.guildId, channelId: message.channelId, messageId: message.id };
+}
+function messageLinkToReference(messageLink) {
+    const result = messageLink.match(exports.DISCORD_MESSAGE_LINK_REGEX);
+    if (result == null) {
+        return null;
+    }
+    return { type: discord_js_1.MessageReferenceType.Default, guildId: result[1], channelId: result[2], messageId: result[3] };
+}
+async function getMessageById(channel, messageId) {
+    let message = channel.messages.cache.get(messageId);
+    if (message != null) {
+        return message;
+    }
+    try {
+        return await channel.messages.fetch(messageId);
+    }
+    catch (err) {
+        console.log(err);
+    }
+}
+function wrapTitle(text) {
+    return `\`${text}\``;
+}
+function isAttachmentSpoiler(attachment) {
+    var _a;
+    return isStringSpoiler((0, path_1.basename)((_a = attachment.url) !== null && _a !== void 0 ? _a : attachment.name));
+}
+function isStringSpoiler(text) {
+    return text.startsWith("SPOILER_");
+}
+function messageToReplyString(message) {
+    const author = message.author;
+    const content = message.content;
+    let referenceString = `${sanitizeDiscordMessage(`${message.url}\n> By: ${getUserName(message.author)} | At ${dateToDynamicDate(message.createdAt)}`)}\n`;
+    if (content.length > 0) {
+        referenceString += `> ${content.slice(0, exports.REPLY_REFERENCE_MAX_LENGTH)}`;
+        if (content.length > exports.REPLY_REFERENCE_MAX_LENGTH) {
+            referenceString += `...`;
+        }
+        referenceString += `\n`;
+    }
+    for (const embed of message.embeds) {
+        if (embed.title && embed.title.trim().length > 0) {
+            referenceString += `> ${embed.title}\n`;
+        }
+        if (embed.description && embed.description.trim().length > 0) {
+            referenceString += `> ${embed.description}\n`;
+        }
+    }
+    for (const attachment of attachmentsToFiles(message.attachments)) {
+        referenceString += `> ${attachment}\n`;
+    }
+    return referenceString;
+}
+function timeAndUserIdToEmbedBuilder(timeMs, userId, content) {
+    return makeEmbed(`${msToDynamicDate(timeMs)}`, `<@${userId}>${content == null ? "" : `\n${content}`}`);
+}
+function filterUselessMetadata(url) {
+    return url.replaceAll(exports.USELESS_LINK_METADATA_REGEX, "");
+}
+function isTextChannel(channel) {
+    return channel["send"] != null;
+}
+function embedToString(embed) {
+    return `${embed.title == null ? "" : `Title: ${embed.title}\n`}${embed.description == null ? "" : `Description: ${embed.description}\n`}`;
+}
+async function getAllChannels(guild) {
+    const channels = new Set(guild.channels.cache.values());
+    for (const channel of (await guild.channels.fetch()).values()) {
+        if (channel == null) {
+            continue;
+        }
+        channels.add(channel);
+    }
+    return channels;
+}
+function arrayToDisplayUpToString(items, mapper, maxDisplayCount = 5) {
+    return `[${items.slice(0, maxDisplayCount).map(mapper).join(", ")}${items.length > maxDisplayCount ? ` and ${wrapTitle(items.length - maxDisplayCount)} more....` : ""}]`;
+}
+function debugLog(input) {
+    console.log(util_1.chalk.bgMagentaBright(`[DEBUG]${input}`));
+}
+async function backupToGit() {
+    console.log(`~~~Backing Up~~~`);
+    const result = await (0, util_1.runCommandRejectAsResolve)(`./git_commit && git pull && ./git_push`, `starlight`);
+    console.log(`Backup Result: ${result}`);
+    return result;
+}
+async function getOrCreateRole(roleManager, data) {
+    let role;
+    if (data.id != null) {
+        role = roleManager.cache.get(data.id);
+    }
+    if (role == null) {
+        role = roleManager.cache.find(role => role.name == data.name);
+        if (role == null) {
+            return await roleManager.create(data);
+        }
+    }
+    return role;
+}
+async function getRoleById(roleManager, roleId) {
+    return roleManager.cache.get(roleId);
+}
+function tooLongForDiscord(input) {
+    const length = (0, util_1.decide)(() => {
+        if ((0, mathjs_1.isArray)(input)) {
+            return (0, mathjs_1.sum)(input.map(item => item.length));
+        }
+        if ((0, util_1.isString)(input)) {
+            return input.length;
+        }
+        return input;
+    });
+    return length > fields_1.DISCORD_MESSAGE_LENGTH_LIMIT;
+}
+//# sourceMappingURL=discord-util.js.map