ahegao 1.69.1

package/dist/utils/util.js

@@ -0,0 +1,3221 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyExt = exports.isImageSequence = exports.isModel = exports.isCode = exports.isDocument = exports.isArchive = exports.isFont = exports.isSubtitle = exports.isAudio = exports.isVideo = exports.isPicture = exports.getZeroBigInt = exports.getZero = exports.ZERO_BIG_INT = exports.geniusClient = exports.chalk = exports.musicMetadata = void 0;
+exports.toExtension = toExtension;
+exports.removeExtension = removeExtension;
+exports.rtl = rtl;
+exports.random = random;
+exports.randomBoolean = randomBoolean;
+exports.randomFromArray = randomFromArray;
+exports.randomFromArrayButNot = randomFromArrayButNot;
+exports.upsideMapDown = upsideMapDown;
+exports.forEachInfo = forEachInfo;
+exports.forEach = forEach;
+exports.forEachFileInfo = forEachFileInfo;
+exports.forEachFile = forEachFile;
+exports.forEachDirInfo = forEachDirInfo;
+exports.forEachDir = forEachDir;
+exports.forEachInfoRecursive = forEachInfoRecursive;
+exports.forEachRecursive = forEachRecursive;
+exports.forEachFileInfoRecursive = forEachFileInfoRecursive;
+exports.getEachFileInfoRecursive = getEachFileInfoRecursive;
+exports.getEachFileInfo = getEachFileInfo;
+exports.forEachFileRecursive = forEachFileRecursive;
+exports.forEachDirInfoRecursive = forEachDirInfoRecursive;
+exports.getEachDirInfoRecursive = getEachDirInfoRecursive;
+exports.forEachDirRecursive = forEachDirRecursive;
+exports.purgeEmptyDirectoriesRecursive = purgeEmptyDirectoriesRecursive;
+exports.firstUpperLowerRest = firstUpperLowerRest;
+exports.firstUpperLowerRestEachWord = firstUpperLowerRestEachWord;
+exports.countChars = countChars;
+exports.countWords = countWords;
+exports.countEmoji = countEmoji;
+exports.incrementMap = incrementMap;
+exports.incrementObjNumber = incrementObjNumber;
+exports.addObjs = addObjs;
+exports.sumValues = sumValues;
+exports.getOrDefaultObj = getOrDefaultObj;
+exports.getOrDefaultMap = getOrDefaultMap;
+exports.getOrDefault = getOrDefault;
+exports.runSoft = runSoft;
+exports.blacklistArray = blacklistArray;
+exports.getChars = getChars;
+exports.getDiff = getDiff;
+exports.formatDate = formatDate;
+exports.decide = decide;
+exports.decideAsync = decideAsync;
+exports.make = make;
+exports.makeAsync = makeAsync;
+exports.extractElementsIntoArray = extractElementsIntoArray;
+exports.extractItemsIntoArray = extractItemsIntoArray;
+exports.mapArrayOfObjsByElement = mapArrayOfObjsByElement;
+exports.mapToArray = mapToArray;
+exports.stringify = stringify;
+exports.acronymStringIfTooLong = acronymStringIfTooLong;
+exports.mkdirSoftRecursive = mkdirSoftRecursive;
+exports.mkdirSoft = mkdirSoft;
+exports.goUpDir = goUpDir;
+exports.writeFileIfNotPresent = writeFileIfNotPresent;
+exports.requireSoft = requireSoft;
+exports.clone = clone;
+exports.getBit = getBit;
+exports.isBit = isBit;
+exports.map = map;
+exports.logMap = logMap;
+exports.clamp = clamp;
+exports.clamp0 = clamp0;
+exports.datesDiff = datesDiff;
+exports.datesDiffToStamp = datesDiffToStamp;
+exports.datesGapToStamp = datesGapToStamp;
+exports.dateToStamp = dateToStamp;
+exports.toStamp = toStamp;
+exports.convertNumberBase = convertNumberBase;
+exports.moveSync = moveSync;
+exports.download = download;
+exports.isCharUpperCase = isCharUpperCase;
+exports.isCharLowerCase = isCharLowerCase;
+exports.isStandardLetter = isStandardLetter;
+exports.getOrCreateAppendedLinesFile = getOrCreateAppendedLinesFile;
+exports.rmSoft = rmSoft;
+exports.saveAppendedLinesFile = saveAppendedLinesFile;
+exports.getOrCreateFromKeys = getOrCreateFromKeys;
+exports.getOrCreate = getOrCreate;
+exports.getOrCreateObj = getOrCreateObj;
+exports.appendObjArray = appendObjArray;
+exports.organiseByKey = organiseByKey;
+exports.millisecondsToNanoseconds = millisecondsToNanoseconds;
+exports.secondsToNanoseconds = secondsToNanoseconds;
+exports.minutesToNanoseconds = minutesToNanoseconds;
+exports.hoursToNanoseconds = hoursToNanoseconds;
+exports.daysToNanoseconds = daysToNanoseconds;
+exports.weeksToNanoseconds = weeksToNanoseconds;
+exports.nanosecondsToMilliseconds = nanosecondsToMilliseconds;
+exports.secondsToMilliseconds = secondsToMilliseconds;
+exports.minutesToMilliseconds = minutesToMilliseconds;
+exports.hoursToMilliseconds = hoursToMilliseconds;
+exports.daysToMilliseconds = daysToMilliseconds;
+exports.weeksToMilliseconds = weeksToMilliseconds;
+exports.nanosecondsToSeconds = nanosecondsToSeconds;
+exports.millisecondsToSeconds = millisecondsToSeconds;
+exports.minutesToSeconds = minutesToSeconds;
+exports.hoursToSeconds = hoursToSeconds;
+exports.daysToSeconds = daysToSeconds;
+exports.weeksToSeconds = weeksToSeconds;
+exports.nanosecondsToMinutes = nanosecondsToMinutes;
+exports.millisecondsToMinutes = millisecondsToMinutes;
+exports.secondsToMinutes = secondsToMinutes;
+exports.hoursToMinutes = hoursToMinutes;
+exports.daysToMinutes = daysToMinutes;
+exports.weeksToMinutes = weeksToMinutes;
+exports.nanosecondsToHours = nanosecondsToHours;
+exports.millisecondsToHours = millisecondsToHours;
+exports.secondsToHours = secondsToHours;
+exports.minutesToHours = minutesToHours;
+exports.daysToHours = daysToHours;
+exports.weeksToHours = weeksToHours;
+exports.nanosecondsToDays = nanosecondsToDays;
+exports.millisecondsToDays = millisecondsToDays;
+exports.secondsToDays = secondsToDays;
+exports.minutesToDays = minutesToDays;
+exports.hoursToDays = hoursToDays;
+exports.weeksToDays = weeksToDays;
+exports.nanosecondsToWeeks = nanosecondsToWeeks;
+exports.millisecondsToWeeks = millisecondsToWeeks;
+exports.secondsToWeeks = secondsToWeeks;
+exports.minutesToWeeks = minutesToWeeks;
+exports.hoursToWeeks = hoursToWeeks;
+exports.daysToWeeks = daysToWeeks;
+exports.minutesToHoursMinutes = minutesToHoursMinutes;
+exports.parsedFileInfoNameToIntSort = parsedFileInfoNameToIntSort;
+exports.parsedStringToIntSort = parsedStringToIntSort;
+exports.degreesToRadians = degreesToRadians;
+exports.toRads = toRads;
+exports.radiansToDegrees = radiansToDegrees;
+exports.toDegs = toDegs;
+exports.getDayMonthYearDateString = getDayMonthYearDateString;
+exports.touchSoft = touchSoft;
+exports.increment = increment;
+exports.readFileInt = readFileInt;
+exports.hashCode = hashCode;
+exports.chalkColor = chalkColor;
+exports.chalkRainbowColor = chalkRainbowColor;
+exports.seededChalkRainbowColor = seededChalkRainbowColor;
+exports.randomChalkRainbowColor = randomChalkRainbowColor;
+exports.padLeft = padLeft;
+exports.padRight = padRight;
+exports.getCuteAscii = getCuteAscii;
+exports.isEmpty = isEmpty;
+exports.singleSpacesOnly = singleSpacesOnly;
+exports.getWeekDayString = getWeekDayString;
+exports.getFirstRegexGroupMatchElse = getFirstRegexGroupMatchElse;
+exports.getFirstRegexGroupMatchAsIntElse = getFirstRegexGroupMatchAsIntElse;
+exports.getFirstRegexGroupMatchAsFloatElse = getFirstRegexGroupMatchAsFloatElse;
+exports.getFirstRegexGroupMatchElseUndefined = getFirstRegexGroupMatchElseUndefined;
+exports.getFirstRegexGroupMatchAsIntElseUndefined = getFirstRegexGroupMatchAsIntElseUndefined;
+exports.getFirstRegexGroupMatchAsFloatElseUndefined = getFirstRegexGroupMatchAsFloatElseUndefined;
+exports.allRegexesMatched = allRegexesMatched;
+exports.countOccurrences = countOccurrences;
+exports.occursAtleastTimes = occursAtleastTimes;
+exports.removeColorCodes = removeColorCodes;
+exports.replaceAllRegexAsGlobalArray = replaceAllRegexAsGlobalArray;
+exports.replaceAllRegexAsGlobal = replaceAllRegexAsGlobal;
+exports.setToJSON = setToJSON;
+exports.mapToJSON = mapToJSON;
+exports.toJSON = toJSON;
+exports.jsonToSet = jsonToSet;
+exports.jsonToMap = jsonToMap;
+exports.fromJSON = fromJSON;
+exports.htmlAsCheerio = htmlAsCheerio;
+exports.getPageCheerio = getPageCheerio;
+exports.getPageHtml = getPageHtml;
+exports.humanReadableJsonToHumanReadableNextLineBracketsJson = humanReadableJsonToHumanReadableNextLineBracketsJson;
+exports.toJson = toJson;
+exports.charToRegexOrHomoglyphs = charToRegexOrHomoglyphs;
+exports.stringToRegexOrHomoglyphs = stringToRegexOrHomoglyphs;
+exports.toInsanelyAccurateRegex = toInsanelyAccurateRegex;
+exports.noop = noop;
+exports.noop1 = noop1;
+exports.noop2 = noop2;
+exports.noop3 = noop3;
+exports.forEachKeyValue = forEachKeyValue;
+exports.keyValueToOdt = keyValueToOdt;
+exports.orElse = orElse;
+exports.getClosestValue = getClosestValue;
+exports.getClosestNumber = getClosestNumber;
+exports.convertTime = convertTime;
+exports.getNs = getNs;
+exports.startTimer = startTimer;
+exports.getTimer = getTimer;
+exports.getTimerString = getTimerString;
+exports.printTimer = printTimer;
+exports.isString = isString;
+exports.reverseString = reverseString;
+exports.wipeAllLetters = wipeAllLetters;
+exports.keepOnlyAllLetters = keepOnlyAllLetters;
+exports.wipeNumbers = wipeNumbers;
+exports.keepOnlyNumbers = keepOnlyNumbers;
+exports.wipeAllLettersAndNumbers = wipeAllLettersAndNumbers;
+exports.keepOnlyAllLettersAndNumbers = keepOnlyAllLettersAndNumbers;
+exports.fromArrayOrNull = fromArrayOrNull;
+exports.setClipboard = setClipboard;
+exports.readClipboard = readClipboard;
+exports.toDDMMYYYY = toDDMMYYYY;
+exports.toMMDDYYYY = toMMDDYYYY;
+exports.downloadItem = downloadItem;
+exports.getChild = getChild;
+exports.getDynamicContentCheerio = getDynamicContentCheerio;
+exports.getDynamicContent = getDynamicContent;
+exports.randomTimeout = randomTimeout;
+exports.randomTimeoutVerbose = randomTimeoutVerbose;
+exports.getLast = getLast;
+exports.getLastX = getLastX;
+exports.forLastX = forLastX;
+exports.joinToXCounts = joinToXCounts;
+exports.asyncMap = asyncMap;
+exports.emptyIfEmpty = emptyIfEmpty;
+exports.getRandomWeighedItem = getRandomWeighedItem;
+exports.getWeightOfKeys = getWeightOfKeys;
+exports.getWeightOfValues = getWeightOfValues;
+exports.getSum = getSum;
+exports.getCurrentMs = getCurrentMs;
+exports.getCurrentSecond = getCurrentSecond;
+exports.getCurrentMinute = getCurrentMinute;
+exports.getCurrentHour = getCurrentHour;
+exports.getCurrentDay = getCurrentDay;
+exports.reverseMap = reverseMap;
+exports.toArray = toArray;
+exports.sortDateOldestFirst = sortDateOldestFirst;
+exports.sortDateNewestFirst = sortDateNewestFirst;
+exports.dateValuesMapToSortedKeysArray = dateValuesMapToSortedKeysArray;
+exports.getCount = getCount;
+exports.sumStringNumberObj = sumStringNumberObj;
+exports.splitWords = splitWords;
+exports.filterMap = filterMap;
+exports.filterMapCopy = filterMapCopy;
+exports.filterSet = filterSet;
+exports.filterSetCopy = filterSetCopy;
+exports.prismaDeleteIfExists = prismaDeleteIfExists;
+exports.getWeekSince1980 = getWeekSince1980;
+exports.getDaySince1980 = getDaySince1980;
+exports.runCommand = runCommand;
+exports.runCommandRejectAsResolve = runCommandRejectAsResolve;
+exports.sanitizeStringForFFMPEG = sanitizeStringForFFMPEG;
+exports.getArtistsFromFlacMetadata = getArtistsFromFlacMetadata;
+exports.getTitleFromFlacMetadata = getTitleFromFlacMetadata;
+exports.getAlbumFromFlacMetadata = getAlbumFromFlacMetadata;
+exports.getAlbumArtistFromFlacMetadata = getAlbumArtistFromFlacMetadata;
+exports.getLyricsFromFlacVorbisTags = getLyricsFromFlacVorbisTags;
+exports.generateHash = generateHash;
+exports.extensionHasAudio = extensionHasAudio;
+exports.songTitleExtractSide = songTitleExtractSide;
+exports.sanitizeStringForSeed = sanitizeStringForSeed;
+exports.addAllSetToSet = addAllSetToSet;
+exports.addAllArrayToSet = addAllArrayToSet;
+exports.addAllSetToArray = addAllSetToArray;
+exports.addAllArrayToArray = addAllArrayToArray;
+exports.addAllArrayToMap = addAllArrayToMap;
+exports.addSetArrayToMap = addSetArrayToMap;
+exports.joinSet = joinSet;
+exports.replaceAllArray = replaceAllArray;
+exports.librarySplitMultipleArtists = librarySplitMultipleArtists;
+exports.libraryFindFeaturing = libraryFindFeaturing;
+exports.libraryCleanUpStartAndEndOfString = libraryCleanUpStartAndEndOfString;
+exports.generateWeightedItemsGridString = generateWeightedItemsGridString;
+exports.promptYesOrNo = promptYesOrNo;
+exports.musicFileInfoToM3uEntry = musicFileInfoToM3uEntry;
+exports.toM3uEntry = toM3uEntry;
+exports.getStepString = getStepString;
+exports.sliceOffLastSlash = sliceOffLastSlash;
+exports.sliceOffLast = sliceOffLast;
+exports.sliceOffUntil = sliceOffUntil;
+exports.countOccurances = countOccurances;
+exports.countPathDepth = countPathDepth;
+exports.getPathEscapeString = getPathEscapeString;
+exports.getFullPathEscapeString = getFullPathEscapeString;
+exports.jsonLookupToMap = jsonLookupToMap;
+exports.extractElementFromJsonAndRemove = extractElementFromJsonAndRemove;
+exports.extractLookupFromJsonAndRemove = extractLookupFromJsonAndRemove;
+exports.forEachValueAndPathOfObj = forEachValueAndPathOfObj;
+exports.forEachLookUpValueAndPathOfObjRecursive = forEachLookUpValueAndPathOfObjRecursive;
+exports.findGeniusSongs = findGeniusSongs;
+exports.trimToCharNumbersOnly = trimToCharNumbersOnly;
+exports.trimStartToCharNumbersOnly = trimStartToCharNumbersOnly;
+exports.trimEndToCharNumbersOnly = trimEndToCharNumbersOnly;
+exports.trim = trim;
+exports.trimStart = trimStart;
+exports.trimEnd = trimEnd;
+exports.findGeniusLyrics = findGeniusLyrics;
+exports.softSliceFrom = softSliceFrom;
+exports.trimFirstLinesWhileIncludes = trimFirstLinesWhileIncludes;
+exports.getFirstLine = getFirstLine;
+exports.skyify = skyify;
+exports.dateToFilename = dateToFilename;
+exports.makeMap = makeMap;
+exports.makeWeightedMap = makeWeightedMap;
+exports.makeWeightedTextCompMap = makeWeightedTextCompMap;
+exports.generateLinesUntilCharacterLimit = generateLinesUntilCharacterLimit;
+exports.lastIndexOfSeparator = lastIndexOfSeparator;
+exports.timestamp = timestamp;
+exports.timestampWithMs = timestampWithMs;
+exports.isSilent = isSilent;
+exports.waitMs = waitMs;
+exports.waitS = waitS;
+exports.whileFalseAsyncS = whileFalseAsyncS;
+exports.whileFalseAsyncMs = whileFalseAsyncMs;
+exports.repeatForAsyncS = repeatForAsyncS;
+exports.repeatForAsyncMs = repeatForAsyncMs;
+exports.replaceLastTerminalLine = replaceLastTerminalLine;
+exports.setTerminalOutput = setTerminalOutput;
+exports.clearSetTerminalOutput = clearSetTerminalOutput;
+exports.clearTerminalLines = clearTerminalLines;
+exports.sIfNot1 = sIfNot1;
+exports.if1Else = if1Else;
+exports.makePath = makePath;
+exports.makeUnixPath = makeUnixPath;
+exports.makeWindowsPath = makeWindowsPath;
+exports.overflow = overflow;
+exports.overflow0 = overflow0;
+exports.isWithin = isWithin;
+exports.startShiftItemsMenu = startShiftItemsMenu;
+exports.getRelativeOverflow = getRelativeOverflow;
+exports.shiftMenuItemsFunction = shiftMenuItemsFunction;
+exports.startNumbersEditMenu = startNumbersEditMenu;
+exports.startMenu = startMenu;
+exports.navigationKeysToNumber = navigationKeysToNumber;
+exports.editNumberByInput = editNumberByInput;
+exports.toMenuString = toMenuString;
+exports.toPrintString = toPrintString;
+exports.print = print;
+exports.softToFixed = softToFixed;
+exports.extractEpisodeNumber = extractEpisodeNumber;
+exports.trashSoft = trashSoft;
+exports.isOfType = isOfType;
+exports.subtitlesStreamInfoToString = subtitlesStreamInfoToString;
+exports.extractsubtitlesStreamsInfo = extractsubtitlesStreamsInfo;
+exports.tryExtractSubtitles = tryExtractSubtitles;
+exports.addSubtitles = addSubtitles;
+const cheerio = __importStar(require("cheerio"));
+const fs_1 = require("fs");
+const https_1 = require("https");
+const puppeteer_1 = __importDefault(require("puppeteer"));
+const structs_1 = require("../structures/structs");
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const fs_2 = require("fs");
+const path_1 = __importStar(require("path"));
+const classes_1 = require("../types/classes");
+const fields_1 = require("../types/fields");
+const util_1 = require("./util");
+const os_1 = require("os");
+var music_metadata_1 = require("music-metadata");
+Object.defineProperty(exports, "musicMetadata", { enumerable: true, get: function () { return __importDefault(music_metadata_1).default; } });
+const ncp = require('node-clipboardy');
+exports.chalk = chalk_1.default;
+const Genius = require("genius-lyrics");
+exports.geniusClient = new Genius.Client(undefined);
+const readline = require('readline');
+//region Functions
+function toExtension(input) {
+    const indexOfPeriod = input.lastIndexOf(".");
+    return indexOfPeriod == -1 ? "" : input.substring(indexOfPeriod + 1);
+}
+function removeExtension(input) {
+    if (input[0] == ".") {
+        return input;
+    }
+    const indexOfPeriod = input.lastIndexOf(".");
+    return indexOfPeriod == -1 ? input : input.substring(0, indexOfPeriod);
+}
+function rtl(text, amount, emptyChar = '') {
+    text = text.toString();
+    let temp = "";
+    for (let i = text.length; i < amount; ++i) {
+        temp += emptyChar;
+    }
+    return temp + text;
+}
+function random(min, max) {
+    if (min > max) {
+        const temp = min;
+        min = max;
+        max = temp;
+    }
+    return (Math.floor(Math.random() * (Math.floor(max) - Math.floor(min) + 1) + Math.floor(min)));
+}
+function randomBoolean(chance = 0.5) {
+    return Math.random() < chance;
+}
+function randomFromArray(array) {
+    return array[random(0, array.length - 1)];
+}
+function randomFromArrayButNot(array, not) {
+    while (true) {
+        const item = array[random(0, array.length - 1)];
+        if (item != not) {
+            return item;
+        }
+    }
+}
+const troublesomeupsideMapdown = ["[", "]", "{", "}", "<", ">", "\\", "/", "3", "Ɛ"];
+function upsideMapDown(text, reverse) {
+    if (!text) {
+        return "You forgot the text!";
+    }
+    let returnText = "";
+    for (var i = 0; i < text.length; ++i) {
+        if (reverse) {
+            if (fields_1.UPSIDE_MAP[text[text.length - i - 1]])
+                returnText += fields_1.UPSIDE_MAP[text[text.length - i - 1]];
+            else if (fields_1.DOWNSIDE_MAP[text[text.length - i - 1]])
+                returnText += fields_1.DOWNSIDE_MAP[text[text.length - i - 1]];
+            else
+                returnText += text[text.length - i - 1];
+        }
+        else {
+            if (fields_1.UPSIDE_MAP[text[i]] && !troublesomeupsideMapdown.includes(text[i]))
+                returnText += fields_1.UPSIDE_MAP[text[i]];
+            else if (fields_1.DOWNSIDE_MAP[text[i]] && !troublesomeupsideMapdown.includes(text[i]))
+                returnText += fields_1.DOWNSIDE_MAP[text[i]];
+            else
+                returnText += text[i];
+        }
+    }
+    return returnText;
+}
+//START for each file/directory
+function forEachInfo(basePath, func) {
+    forEach(basePath, filePath => func(new structs_1.FileInfo(filePath)));
+}
+function forEach(basePath, func) {
+    //Can only iterate through a directory
+    if (!(0, fs_1.statSync)(basePath).isDirectory())
+        return;
+    for (const file of (0, fs_1.readdirSync)(basePath)) {
+        const filePath = `${basePath}/${file}`;
+        if (!(0, fs_1.existsSync)(filePath)) //Nani the fuck?
+            continue;
+        func(filePath);
+    }
+}
+//END for each file/directory
+//START for each file
+function forEachFileInfo(basePath, func) {
+    forEachFile(basePath, filePath => func(new structs_1.FileInfo(filePath)));
+}
+function forEachFile(basePath, func) {
+    forEach(basePath, filePath => {
+        if ((0, fs_1.statSync)(filePath).isDirectory())
+            return;
+        func(filePath);
+    });
+}
+//END for each file
+//START for each directory
+function forEachDirInfo(basePath, func) {
+    forEachDir(basePath, filePath => func(new structs_1.FileInfo(filePath)));
+}
+function forEachDir(basePath, func) {
+    forEach(basePath, filePath => {
+        if (!(0, fs_1.statSync)(filePath).isDirectory())
+            return;
+        func(filePath);
+    });
+}
+//END for each directory
+//START for each file/directory recursive
+function forEachInfoRecursive(basePath, func) {
+    forEachRecursive(basePath, filePath => func(new structs_1.FileInfo(filePath)));
+}
+function forEachRecursive(basePath, func) {
+    forEach(basePath, filePath => {
+        const result = func(filePath);
+        if (result != null && !result)
+            return;
+        forEachRecursive(filePath, func);
+    });
+}
+//END for each file/directory recursive
+//START for each file recursive
+function forEachFileInfoRecursive(basePath, func) {
+    forEachFileRecursive(basePath, filePath => func(new structs_1.FileInfo(filePath)));
+}
+function getEachFileInfoRecursive(basePath) {
+    const fileInfos = [];
+    forEachFileInfoRecursive(basePath, fileInfo => fileInfos.push(fileInfo));
+    return fileInfos;
+}
+function getEachFileInfo(basePath) {
+    const fileInfos = [];
+    forEachFileInfo(basePath, fileInfo => fileInfos.push(fileInfo));
+    return fileInfos;
+}
+function forEachFileRecursive(basePath, func) {
+    forEachRecursive(basePath, filePath => {
+        if (!(0, fs_1.statSync)(filePath).isDirectory())
+            func(filePath);
+    });
+}
+//END for each file recursive
+//START for each directory recursive
+function forEachDirInfoRecursive(basePath, func) {
+    forEachDirRecursive(basePath, filePath => func(new structs_1.FileInfo(filePath)));
+}
+function getEachDirInfoRecursive(basePath) {
+    const fileInfos = [];
+    forEachDirInfoRecursive(basePath, fileInfo => {
+        fileInfos.push(fileInfo);
+        return;
+    });
+    return fileInfos;
+}
+function forEachDirRecursive(basePath, func) {
+    forEachDir(basePath, filePath => {
+        const result = func(filePath);
+        if (result != null && !result)
+            return;
+        forEachDirRecursive(filePath, func);
+    });
+}
+//END for each directory recursive
+function purgeEmptyDirectoriesRecursive(basePath) {
+    let removedDirectoriesCount = 0;
+    getEachDirInfoRecursive(basePath).forEach(dirInfo => {
+        const stat = (0, fs_1.statSync)(dirInfo.path);
+        if (!stat.isDirectory()) {
+            return;
+        }
+        const items = (0, fs_1.readdirSync)(dirInfo.path);
+        if (items.length > 0) {
+            return;
+        }
+        ++removedDirectoriesCount;
+        (0, fs_1.rmdirSync)(dirInfo.path);
+    });
+    return removedDirectoriesCount;
+}
+function firstUpperLowerRest(input) {
+    return input[0].toUpperCase() + input.slice(1).toLowerCase();
+}
+function firstUpperLowerRestEachWord(input) {
+    return input.split(" ")
+        .filter(word => word.length > 0)
+        .map(word => firstUpperLowerRest(word))
+        .join(" ");
+}
+function countChars(input) {
+    const charCount = {};
+    for (const char of input)
+        incrementObjNumber(charCount, char);
+    return charCount;
+}
+function countWords(input) {
+    const wordCount = {};
+    for (const word of input.matchAll(fields_1.WORDS_REGEX))
+        incrementObjNumber(wordCount, word[0]);
+    return wordCount;
+}
+function countEmoji(input) {
+    const emojiCount = {};
+    for (const match of input.matchAll(fields_1.EMOJI_REGEX)) {
+        incrementObjNumber(emojiCount, match[0]);
+    }
+    for (const match of input.matchAll(fields_1.CUSTOM_EMOJI_REGEX)) {
+        incrementObjNumber(emojiCount, match[1]);
+    }
+    return emojiCount;
+}
+function incrementMap(map, key, incrementBy = 1) {
+    var _a;
+    const existingValue = (_a = map.get(key)) !== null && _a !== void 0 ? _a : 0;
+    if (incrementBy == 0) {
+        return existingValue;
+    }
+    const newValue = existingValue + incrementBy;
+    map.set(key, newValue);
+    return newValue;
+}
+function incrementObjNumber(obj, key, incrementBy = 1) {
+    var _a;
+    const existingValue = (_a = obj[key]) !== null && _a !== void 0 ? _a : 0;
+    if (incrementBy == 0) {
+        return existingValue;
+    }
+    const newValue = existingValue + incrementBy;
+    obj[key] = newValue;
+    return newValue;
+}
+function addObjs(obj1, obj2) {
+    for (const [key, value] of Object.entries(obj2)) {
+        incrementObjNumber(obj1, key, value);
+    }
+    return obj1;
+}
+function sumValues(obj) {
+    let sum = 0;
+    for (const key of Object.keys(obj))
+        sum += obj[key];
+    return sum;
+}
+function getOrDefaultObj(input, key, elseValue) {
+    if (input[key])
+        return input[key];
+    else
+        return elseValue;
+}
+function getOrDefaultMap(input, key, elseValue) {
+    if (input.has(key))
+        return input.get(key);
+    else
+        return elseValue;
+}
+function getOrDefault(input, ifNull) {
+    return input == undefined ? ifNull : input;
+}
+async function runSoft(func) {
+    try {
+        await func.apply(null);
+    }
+    catch (e) {
+        console.log(e);
+    }
+}
+function blacklistArray(elements, blacklist = []) {
+    const output = [];
+    for (const element of elements) {
+        if (blacklist.includes(element))
+            continue;
+        output.push(element);
+    }
+    return output;
+}
+function getChars(word) {
+    word = word.toLowerCase();
+    let chars = {};
+    for (let i = 0; i < word.length; ++i) {
+        let char = word[i];
+        incrementObjNumber(chars, char);
+    }
+    return chars;
+}
+function getDiff(mAChars, mBChars) {
+    let diff = 0;
+    const merged = {};
+    const mAKeys = Object.keys(mAChars);
+    const mBKeys = Object.keys(mBChars);
+    mAKeys.forEach(key => {
+        if (merged[key]) {
+            merged[key] -= mAChars[key];
+            if (merged[key] < 0)
+                merged[key] = -merged[key];
+        }
+        else
+            merged[key] = mAChars[key];
+    });
+    mBKeys.forEach(key => {
+        if (merged[key]) {
+            merged[key] -= mBChars[key];
+            if (merged[key] < 0)
+                merged[key] = -merged[key];
+        }
+        else
+            merged[key] = mBChars[key];
+    });
+    Object.keys(merged).forEach(key => {
+        diff += merged[key];
+    });
+    return diff;
+}
+function formatDate(date) {
+    return date.toISOString().replace(/T/, ' ').replace(/\..+/, '');
+}
+function decide(decision) {
+    return decision();
+}
+async function decideAsync(decision) {
+    return await decision();
+}
+function make(obj, init) {
+    init(obj);
+    return obj;
+}
+async function makeAsync(obj, init) {
+    await init(obj);
+    return obj;
+}
+function extractElementsIntoArray(obj, elementKey) {
+    const elements = [];
+    for (const key of Object.keys(obj)) {
+        const item = obj[key];
+        const element = item[elementKey];
+        if (item[elementKey])
+            elements.push(element);
+    }
+    return elements;
+}
+function extractItemsIntoArray(obj, predicate) {
+    const items = [];
+    for (const key of Object.keys(obj)) {
+        const item = obj[key];
+        if (predicate(item))
+            items.push(item);
+    }
+    return items;
+}
+function mapArrayOfObjsByElement(obj, elementKey) {
+    const map = new Map;
+    for (const key of Object.keys(obj)) {
+        const item = obj[key];
+        if (item[elementKey])
+            map.set(item[elementKey], item);
+    }
+    return map;
+}
+function mapToArray(items, mapFunction) {
+    return make([], (array) => {
+        for (const item of items)
+            array.push(mapFunction(item));
+    });
+}
+function stringify(obj, ignoreEmpty = false) {
+    for (const key of Object.keys(obj)) {
+        const value = obj[key];
+        const isBigInt = typeof value == "bigint";
+        if (isBigInt)
+            obj[key] = parseFloat(String(value));
+        if (ignoreEmpty) {
+            if (!value)
+                delete obj[key];
+        }
+    }
+    return JSON.stringify(obj, null, "\t").replace(/: ([{\[])\n([\t]*)\t/g, ":\n$2$1\n$2\t");
+}
+function acronymStringIfTooLong(input, limit = 10, includeFillers = true) {
+    let processedInput = input.replaceAll(/['"]/g, "").replaceAll(/[^\p{L}0-9]/giu, " ").trim();
+    if (!includeFillers) {
+        processedInput = processedInput.replaceAll(fields_1.ACRONYM_REGEXES, "");
+    }
+    if (processedInput.length <= 0) {
+        return processedInput;
+    }
+    if (processedInput.length >= limit) {
+        let output = "";
+        for (const result of processedInput.matchAll(fields_1.ACRONYM_REGEX)) {
+            const match = result[0];
+            output += match.charAt(match.length - 1);
+        }
+        return output;
+    }
+    return input;
+}
+function mkdirSoftRecursive(fullPath) {
+    let path = "";
+    const local = fullPath.length > 0 && fullPath.at(0) == ".";
+    if (local) {
+        fullPath = fullPath.slice(1);
+        path += ".";
+    }
+    for (const dir of fullPath.split(fields_1.SEP).filter(word => word.length > 0)) {
+        path += `/${dir}`;
+        mkdirSoft(path);
+    }
+}
+function mkdirSoft(path) {
+    if (!(0, fs_1.existsSync)(path)) {
+        (0, fs_1.mkdirSync)(path);
+    }
+}
+function goUpDir(dir, times = 1) {
+    for (let i = 0; i < times; ++i)
+        dir = dir.slice(0, lastIndexOfSeparator(dir));
+    return dir;
+}
+function writeFileIfNotPresent(path, data, options) {
+    if (!(0, fs_1.existsSync)(path))
+        (0, fs_1.writeFileSync)(path, data);
+}
+function requireSoft(path, data, options) {
+    writeFileIfNotPresent(path, data);
+    return require(path);
+}
+function clone(obj) {
+    return Object.assign({}, obj);
+}
+function getBit(number, bit) {
+    return (number >> bit) & 1;
+}
+function isBit(number, bit) {
+    return getBit(number, bit) == 1;
+}
+function map(input, min1, max1, min2, max2) {
+    return ((input - min1) / (max1 - min1)) * (max2 - min2) + min2;
+}
+function logMap(input, inputStart, inputEnd, outputStart, outputEnd, curveIntensity) {
+    // Validate and clamp curve intensity
+    // curveIntensity = Math.max(-1, Math.min(1, curveIntensity || 0))
+    // Handle linear case (curveIntensity = 0)
+    if (curveIntensity === 0) {
+        const linearProgress = (input - inputStart) / (inputEnd - inputStart);
+        return outputStart + linearProgress * (outputEnd - outputStart);
+    }
+    // Normalize input to 0-1 range
+    const normalizedInput = (input - inputStart) / (inputEnd - inputStart);
+    let mappedValue;
+    if (curveIntensity > 0) {
+        // Positive curve: starts fast, ends slow (logarithmic)
+        const base = 1 + curveIntensity * 9; // Base between 1-10 for positive intensity
+        mappedValue = Math.log(1 + normalizedInput * (base - 1)) / Math.log(base);
+    }
+    else {
+        // Negative curve: starts slow, ends fast (exponential)
+        const intensity = Math.abs(curveIntensity);
+        const base = 1 + intensity * 9; // Base between 1-10 for negative intensity
+        mappedValue = (Math.pow(base, normalizedInput) - 1) / (base - 1);
+    }
+    // Map to output range
+    return outputStart + mappedValue * (outputEnd - outputStart);
+}
+function clamp(input, min, max) {
+    return Math.max(min, Math.min(max, input));
+}
+function clamp0(input, max) {
+    return clamp(input, 0, max);
+}
+/**
+ * @param startDate in ms
+ * @param endDate in ms
+ */
+function datesDiff(dates) {
+    return dates.endDate.valueOf() - (dates.startDate ? dates.startDate : new Date()).valueOf();
+}
+function datesDiffToStamp(dates) {
+    return toStamp(datesDiff(dates) / 1000);
+}
+function datesGapToStamp(startDate, endDate) {
+    return toStamp((endDate.valueOf() - startDate.valueOf()) / 1000);
+}
+function dateToStamp(date) {
+    return toStamp(date.valueOf() / 1000);
+}
+function toStamp(toStamp) {
+    if (isNaN(toStamp) || toStamp == Infinity || toStamp == -Infinity) {
+        toStamp = 0;
+    }
+    let stamped = '';
+    toStamp = Math.floor(toStamp);
+    let negative = false;
+    if (toStamp < 0) {
+        toStamp = -toStamp;
+        negative = true;
+    }
+    if (Math.floor(toStamp / 3600) >= 24) {
+        if (Math.floor(toStamp / 3600) < 48)
+            stamped += `[${Math.floor(toStamp / 86400)}] day, `;
+        else
+            stamped += `[${Math.floor(toStamp / 86400)}] days, `;
+    }
+    stamped +=
+        '[' +
+            Math.floor(toStamp % 86400 / 3600) + '\:' +
+            (Math.floor(toStamp % 3600 / 60) > 9 ? Math.floor(toStamp % 3600 / 60) : ('0' + Math.floor(toStamp % 3600 / 60))) + '\:' +
+            (Math.floor(toStamp % 60) > 9 ? toStamp % 60 : '0' + toStamp % 60) +
+            ']';
+    if (negative)
+        return `-${stamped}`;
+    else
+        return stamped;
+}
+function convertNumberBase(num, fromBase, toBase) {
+    const decimalValue = parseInt(num, fromBase);
+    let convertedValue = '';
+    let quotient = decimalValue;
+    while (quotient > 0) {
+        const remainder = quotient % toBase;
+        convertedValue = remainder.toString(toBase) + convertedValue;
+        quotient = Math.floor(quotient / toBase);
+    }
+    return convertedValue;
+}
+function moveSync(oldPath, newPath) {
+    try {
+        (0, fs_1.renameSync)(oldPath, newPath);
+    }
+    catch (err) {
+        if (err.code == "EXDEV") {
+            (0, fs_1.copyFileSync)(oldPath, newPath);
+            (0, fs_1.unlinkSync)(oldPath);
+        }
+    }
+}
+async function download(url, dir) {
+    return new Promise((resolve, reject) => {
+        const file = (0, fs_1.createWriteStream)(dir);
+        const request = (0, https_1.get)(url, function (response) {
+            response.pipe(file);
+            resolve(`success\nurl:${url}\ndir:${dir}`);
+        }).on("error", reject);
+    });
+}
+function isCharUpperCase(char) {
+    return char.charCodeAt(0) >= 65 && char.charCodeAt(0) <= 90;
+}
+function isCharLowerCase(char) {
+    return char.charCodeAt(0) >= 97 && char.charCodeAt(0) <= 122;
+}
+function isStandardLetter(char) {
+    return isCharLowerCase(char) || isCharUpperCase(char);
+}
+function getOrCreateAppendedLinesFile(path) {
+    writeFileIfNotPresent(path, "");
+    return new Set((0, fs_1.readFileSync)(path, "utf8").split(/[\r\n]/));
+}
+function rmSoft(path) {
+    if ((0, fs_1.existsSync)(path)) {
+        (0, fs_1.rmSync)(path);
+    }
+}
+function saveAppendedLinesFile(path, lines, excludeEmpty = true, trim = true) {
+    rmSoft(path);
+    const slashIndex = lastIndexOfSeparator(path);
+    if (slashIndex != -1) {
+        const dirPath = path.slice(0, slashIndex);
+        mkdirSoftRecursive(dirPath);
+    }
+    for (const line of lines) {
+        if (excludeEmpty && line.length <= 0) {
+            continue;
+        }
+        (0, fs_2.appendFileSync)(path, `${trim ? line.trim() : line}\n`);
+    }
+}
+function getOrCreateFromKeys(map, keys, maker) {
+    for (const key of keys) {
+        getOrCreate(map, key, maker);
+    }
+    return map;
+}
+function getOrCreate(map, key, maker) {
+    if (!map.has(key)) {
+        map.set(key, maker());
+    }
+    return map.get(key);
+}
+function getOrCreateObj(obj, key, ifNullMaker) {
+    if (obj[key] == null) {
+        obj[key] = ifNullMaker();
+    }
+    return obj[key];
+}
+function appendObjArray(obj, key, item) {
+    let array = obj[key];
+    if (array == null) {
+        array = [];
+        obj[key] = array;
+    }
+    array.push(item);
+    return obj[key];
+}
+function organiseByKey(items, keyRetriever) {
+    const obj = {};
+    for (const item of items) {
+        appendObjArray(obj, keyRetriever(item), item);
+    }
+    return obj;
+}
+//To Nanoseconds
+function millisecondsToNanoseconds(milliseconds) {
+    return milliseconds * fields_1.NANOSECONDS_IN_MILLISECOND;
+}
+function secondsToNanoseconds(nanoseconds) {
+    return nanoseconds * fields_1.NANOSECONDS_IN_SECOND;
+}
+function minutesToNanoseconds(minutes) {
+    return minutes * fields_1.NANOSECONDS_IN_MINUTE;
+}
+function hoursToNanoseconds(hours) {
+    return hours * fields_1.NANOSECONDS_IN_HOUR;
+}
+function daysToNanoseconds(days) {
+    return days * fields_1.NANOSECONDS_IN_DAY;
+}
+function weeksToNanoseconds(weeks) {
+    return weeks * fields_1.NANOSECONDS_IN_WEEK;
+}
+//!To Nanoseconds
+//To Milliseconds
+function nanosecondsToMilliseconds(nanoseconds) {
+    return nanoseconds / fields_1.NANOSECONDS_IN_MILLISECOND;
+}
+function secondsToMilliseconds(milliseconds) {
+    return milliseconds * fields_1.MILLISECONDS_IN_SECOND;
+}
+function minutesToMilliseconds(minutes) {
+    return minutes * fields_1.MILLISECONDS_IN_MINUTE;
+}
+function hoursToMilliseconds(hours) {
+    return hours * fields_1.MILLISECONDS_IN_HOUR;
+}
+function daysToMilliseconds(days) {
+    return days * fields_1.MILLISECONDS_IN_DAY;
+}
+function weeksToMilliseconds(weeks) {
+    return weeks * fields_1.MILLISECONDS_IN_WEEK;
+}
+//!To Milliseconds
+//To Seconds
+function nanosecondsToSeconds(nanoseconds) {
+    return nanoseconds / fields_1.NANOSECONDS_IN_SECOND;
+}
+function millisecondsToSeconds(milliseconds) {
+    return milliseconds / fields_1.MILLISECONDS_IN_SECOND;
+}
+function minutesToSeconds(minutes) {
+    return minutes * fields_1.SECONDS_IN_MINUTE;
+}
+function hoursToSeconds(hours) {
+    return hours * fields_1.SECONDS_IN_HOUR;
+}
+function daysToSeconds(days) {
+    return days * fields_1.SECONDS_IN_DAY;
+}
+function weeksToSeconds(weeks) {
+    return weeks * fields_1.SECONDS_IN_WEEK;
+}
+//!To Seconds
+//To Minutes
+function nanosecondsToMinutes(nanoseconds) {
+    return nanoseconds / fields_1.NANOSECONDS_IN_MINUTE;
+}
+function millisecondsToMinutes(milliseconds) {
+    return milliseconds / fields_1.MILLISECONDS_IN_MINUTE;
+}
+function secondsToMinutes(minutes) {
+    return minutes / fields_1.SECONDS_IN_MINUTE;
+}
+function hoursToMinutes(hours) {
+    return hours * fields_1.MINUTES_IN_HOUR;
+}
+function daysToMinutes(days) {
+    return days * fields_1.MINUTES_IN_DAY;
+}
+function weeksToMinutes(weeks) {
+    return weeks * fields_1.MINUTES_IN_WEEK;
+}
+//!To Minutes
+//To Hours
+function nanosecondsToHours(nanoseconds) {
+    return nanoseconds / fields_1.NANOSECONDS_IN_HOUR;
+}
+function millisecondsToHours(milliseconds) {
+    return milliseconds / fields_1.MILLISECONDS_IN_HOUR;
+}
+function secondsToHours(seconds) {
+    return seconds / fields_1.SECONDS_IN_HOUR;
+}
+function minutesToHours(minutes) {
+    return minutes / fields_1.MINUTES_IN_HOUR;
+}
+function daysToHours(days) {
+    return days * fields_1.HOURS_IN_DAY;
+}
+function weeksToHours(weeks) {
+    return weeks * fields_1.HOURS_IN_WEEK;
+}
+//!To Hours
+//To Days
+function nanosecondsToDays(nanoseconds) {
+    return nanoseconds / fields_1.NANOSECONDS_IN_DAY;
+}
+function millisecondsToDays(milliseconds) {
+    return milliseconds / fields_1.MILLISECONDS_IN_DAY;
+}
+function secondsToDays(seconds) {
+    return seconds / fields_1.SECONDS_IN_DAY;
+}
+function minutesToDays(minutes) {
+    return minutes / fields_1.MINUTES_IN_DAY;
+}
+function hoursToDays(hours) {
+    return hours / fields_1.HOURS_IN_DAY;
+}
+function weeksToDays(weeks) {
+    return weeks * fields_1.DAYS_IN_WEEK;
+}
+//!To Days
+//To Weeks
+function nanosecondsToWeeks(nanoseconds) {
+    return nanoseconds / fields_1.NANOSECONDS_IN_WEEK;
+}
+function millisecondsToWeeks(milliseconds) {
+    return milliseconds / fields_1.MILLISECONDS_IN_WEEK;
+}
+function secondsToWeeks(seconds) {
+    return seconds / fields_1.SECONDS_IN_WEEK;
+}
+function minutesToWeeks(minutes) {
+    return minutes / fields_1.MINUTES_IN_WEEK;
+}
+function hoursToWeeks(hours) {
+    return hours / fields_1.HOURS_IN_WEEK;
+}
+function daysToWeeks(days) {
+    return days / fields_1.DAYS_IN_WEEK;
+}
+//!To Weeks
+function minutesToHoursMinutes(totalMinutes) {
+    let minutes = Math.floor(totalMinutes % 60);
+    return padLeft("" + Math.floor(totalMinutes / 60), 2, "0") + ":" + padLeft("" + minutes, 2, "0");
+}
+function parsedFileInfoNameToIntSort(a, b, ascending = true) {
+    return parsedStringToIntSort(a.name, b.name, ascending);
+}
+function parsedStringToIntSort(a, b, ascending = true) {
+    const valueA = parseInt(a.replaceAll(fields_1.NON_NUMBER_REGEX, ""));
+    const valueB = parseInt(b.replaceAll(fields_1.NON_NUMBER_REGEX, ""));
+    return ascending ? valueA - valueB : valueB - valueA;
+}
+function degreesToRadians(degrees) {
+    return degrees * fields_1.DEGREES_TO_RADIANS;
+}
+function toRads(degrees) {
+    return degrees * fields_1.DEGREES_TO_RADIANS;
+}
+function radiansToDegrees(radians) {
+    return radians * fields_1.RADIANS_TO_DEGREES;
+}
+function toDegs(radians) {
+    return radians * fields_1.RADIANS_TO_DEGREES;
+}
+function getDayMonthYearDateString() {
+    const nowDate = new Date();
+    const dateStr = `${nowDate.getDate()}-${nowDate.getMonth() + 1}-${nowDate.getFullYear()}`;
+    return dateStr;
+}
+function touchSoft(path, defaultContent = "") {
+    if (!(0, fs_1.existsSync)(path)) {
+        (0, fs_1.writeFileSync)(path, defaultContent);
+    }
+}
+function increment(path, amount = 1, float = false) {
+    if (!(0, fs_1.existsSync)(path)) {
+        (0, fs_1.writeFileSync)(path, "" + amount);
+        return amount;
+    }
+    const parsedNumber = float ? parseFloat((0, fs_1.readFileSync)(path, "utf8")) : parseInt((0, fs_1.readFileSync)(path, "utf8"));
+    const newValue = (isNaN(parsedNumber) ? 0 : parsedNumber) + amount;
+    (0, fs_1.writeFileSync)(path, "" + newValue);
+    return newValue;
+}
+function readFileInt(path) {
+    if ((0, fs_1.existsSync)(path)) {
+        return parseInt((0, fs_1.readFileSync)(path, "utf8"));
+    }
+    return -1;
+}
+function hashCode(str) {
+    let hash = 0;
+    if (str.length === 0) {
+        return hash;
+    }
+    for (let i = 0; i < str.length; ++i) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+}
+function chalkColor(input, color) {
+    return exports.chalk.keyword(color)(input);
+}
+function chalkRainbowColor(input, color) {
+    return exports.chalk.keyword(fields_1.CHALK_RAINBOW_COLORS[Math.abs(color) % fields_1.CHALK_RAINBOW_COLORS.length])(input);
+}
+function seededChalkRainbowColor(input) {
+    return exports.chalk.keyword(randomFromArray(fields_1.CHALK_RAINBOW_COLORS))(input);
+}
+function randomChalkRainbowColor(input) {
+    return chalkRainbowColor(input, hashCode(input));
+}
+function padLeft(input, leftPad, padCharacter = " ") {
+    const padAmount = leftPad - input.length;
+    for (let i = 0; i < padAmount; ++i) {
+        input = padCharacter + input;
+    }
+    return input;
+}
+function padRight(input, rightPad, padCharacter = " ") {
+    const padAmount = rightPad - input.length;
+    for (let i = 0; i < padAmount; ++i) {
+        input += padCharacter;
+    }
+    return input;
+}
+function getCuteAscii() {
+    return randomFromArray(fields_1.CUTE_ASCII);
+}
+function isEmpty(char) {
+    if (char === " ") {
+        return true;
+    }
+    return false;
+}
+function singleSpacesOnly(input, trim = true) {
+    input = input.replaceAll(/[ ]{2,}/g, " ");
+    if (trim) {
+        input = input.trim();
+    }
+    return input;
+}
+function getWeekDayString(date, lang = "en-US") {
+    return date.toLocaleDateString(lang, fields_1.VERBOSE_DATE_TIME_FORMAT_OPTIONS);
+}
+function getFirstRegexGroupMatchElse(input, regex, defaultValue) {
+    const match = input.match(regex);
+    if (match == undefined || match[1] == undefined) {
+        return defaultValue;
+    }
+    return match[1];
+}
+function getFirstRegexGroupMatchAsIntElse(input, regex, defaultValue) {
+    const match = input.match(regex);
+    if (match == undefined || match[1] == undefined) {
+        return defaultValue;
+    }
+    return parseInt(match[1]);
+}
+function getFirstRegexGroupMatchAsFloatElse(input, regex, defaultValue) {
+    const match = input.match(regex);
+    if (match == undefined || match[1] == undefined) {
+        return defaultValue;
+    }
+    return parseFloat(match[1]);
+}
+function getFirstRegexGroupMatchElseUndefined(input, regex) {
+    const match = input.match(regex);
+    if (match == undefined || match[1] == undefined) {
+        return undefined;
+    }
+    return match[1];
+}
+function getFirstRegexGroupMatchAsIntElseUndefined(input, regex) {
+    const match = input.match(regex);
+    if (match == undefined || match[1] == undefined) {
+        return undefined;
+    }
+    return parseInt(match[1]);
+}
+function getFirstRegexGroupMatchAsFloatElseUndefined(input, regex) {
+    const match = input.match(regex);
+    if (match == undefined || match[1] == undefined) {
+        return undefined;
+    }
+    return parseFloat(match[1]);
+}
+function allRegexesMatched(regexes, toMatchOn) {
+    for (const regex of regexes) {
+        if (toMatchOn.match(regex) == undefined) {
+            return false;
+        }
+    }
+    return true;
+}
+function countOccurrences(stringToCountFrom, stringToCountOccurenceOf) {
+    let count = 0;
+    let lastIndex = -1;
+    while ((lastIndex = stringToCountFrom.indexOf(stringToCountOccurenceOf, lastIndex + 1)) !== -1) {
+        ++count;
+    }
+    return count;
+}
+function occursAtleastTimes(stringToCountFrom, stringToCountOccurenceOf, requiredOccuranceCount) {
+    let count = 0;
+    let lastIndex = -1;
+    while ((lastIndex = stringToCountFrom.indexOf(stringToCountOccurenceOf, lastIndex + 1)) !== -1) {
+        ++count;
+        if (count >= requiredOccuranceCount) {
+            return true;
+        }
+    }
+    return false;
+}
+function removeColorCodes(input) {
+    return input.replace(fields_1.COLOR_CODE_REGEX, '');
+}
+function replaceAllRegexAsGlobalArray(input, regexes, replaceWith) {
+    for (const regex of regexes) {
+        input = replaceAllRegexAsGlobal(input, regex, "**$&**");
+    }
+    return input;
+}
+function replaceAllRegexAsGlobal(input, regex, replaceWith) {
+    return input.replaceAll(new RegExp(regex.source, "g"), replaceWith);
+}
+function setToJSON(set) {
+    const array = [];
+    set.forEach((value) => {
+        if (value instanceof Set) {
+            array.push(setToJSON(value));
+        }
+        else if (value instanceof Map) {
+            array.push(mapToJSON(value));
+        }
+        else {
+            array.push(value);
+        }
+    });
+    return array;
+}
+function mapToJSON(map) {
+    const obj = {};
+    map.forEach((value, key) => {
+        if (value instanceof Set) {
+            obj[key] = setToJSON(value);
+        }
+        else if (value instanceof Map) {
+            obj[key] = mapToJSON(value);
+        }
+        else {
+            obj[key] = value;
+        }
+    });
+    return obj;
+}
+function toJSON(input) {
+    if (input instanceof Set) {
+        return setToJSON(input);
+    }
+    else if (input instanceof Map) {
+        return mapToJSON(input);
+    }
+    else {
+        throw new Error('Input must be a Set or Map');
+    }
+}
+function jsonToSet(jsonArray) {
+    const set = new Set();
+    jsonArray.forEach((item) => {
+        if (Array.isArray(item)) {
+            set.add(jsonToSet(item));
+        }
+        else if (typeof item === 'object') {
+            set.add(jsonToMap(item));
+        }
+        else {
+            set.add(item);
+        }
+    });
+    return set;
+}
+function jsonToMap(jsonObject) {
+    const map = new Map();
+    Object.keys(jsonObject).forEach((key) => {
+        const value = jsonObject[key];
+        if (Array.isArray(value)) {
+            map.set(key, jsonToSet(value));
+        }
+        else if (typeof value === 'object') {
+            map.set(key, jsonToMap(value));
+        }
+        else {
+            map.set(key, value);
+        }
+    });
+    return map;
+}
+function fromJSON(json) {
+    if (Array.isArray(json)) {
+        return jsonToSet(json);
+    }
+    else if (typeof json === 'object') {
+        return jsonToMap(json);
+    }
+    else {
+        throw new Error('JSON must be an array or object');
+    }
+}
+function htmlAsCheerio(html) {
+    return cheerio.load(html);
+}
+async function getPageCheerio(url, options = fields_1.DEFAULT_HTTPS_CONNECTION_OPTIONS) {
+    return htmlAsCheerio(await getPageHtml(url, options));
+}
+async function getPageHtml(url, options = fields_1.DEFAULT_HTTPS_CONNECTION_OPTIONS) {
+    return new Promise((resolve, reject) => {
+        (0, https_1.get)(url, options, (response) => {
+            let data = '';
+            response.on('data', (chunk) => {
+                data += chunk;
+            });
+            response.on('end', () => {
+                resolve(data);
+            });
+        }).on('error', (error) => {
+            console.error(`Error making the request: ${error.message}`);
+            resolve("");
+        });
+    });
+}
+function humanReadableJsonToHumanReadableNextLineBracketsJson(json) {
+    return json.replaceAll(fields_1.JSON_NEXT_LINE_BRACKET_FROM_REGEX, fields_1.JSON_NEXT_LINE_BRACKET_TO);
+}
+/**
+ * @returns Stringified JSON version of the object in Human Readable, Next Line Bracket string.
+ */
+function toJson(obj) {
+    return humanReadableJsonToHumanReadableNextLineBracketsJson(JSON.stringify(obj, null, "\t"));
+}
+function charToRegexOrHomoglyphs(char) {
+    const homoglyphRegexpOr = fields_1.HOMOGLYPHS_AS_REGEXP_OR[char];
+    if (homoglyphRegexpOr == undefined) {
+        return char;
+    }
+    else {
+        return homoglyphRegexpOr;
+    }
+}
+function stringToRegexOrHomoglyphs(text, suffix = "+") {
+    let output = "";
+    let lastChar = "";
+    const groupChars = suffix == "+" || suffix == "*";
+    const textLength = text.length;
+    for (let i = 0; i < textLength; ++i) {
+        const char = text[i];
+        const nextChar = text[i + 1];
+        const nextCharSpecial = nextChar == "+" || nextChar == "*" || nextChar == "?";
+        if (char == "+" || char == "*" || char == "?") {
+            output += char;
+            continue;
+        }
+        if (groupChars) {
+            if (char == lastChar) {
+                continue;
+            }
+        }
+        output += charToRegexOrHomoglyphs(char);
+        if (!nextCharSpecial) {
+            output += suffix;
+        }
+        lastChar = char;
+    }
+    return output;
+}
+function toInsanelyAccurateRegex(regex, flags = "i") {
+    return new RegExp(stringToRegexOrHomoglyphs(regex, "+"));
+}
+function noop() { }
+function noop1(arg1) { }
+function noop2(arg1, arg2) { }
+function noop3(arg1, arg2, arg3) { }
+function forEachKeyValue(obj, consumer) {
+    for (const key of Object.keys(obj)) {
+        consumer(obj[key], key);
+    }
+}
+function keyValueToOdt(obj) {
+    let output = "";
+    forEachKeyValue(obj, (value, key) => {
+        output += `${key}\t${value}\n`;
+    });
+    return output;
+}
+function orElse(item, orElse) {
+    if (item == null) {
+        return orElse();
+    }
+    return item;
+}
+function getClosestValue(map, input) {
+    const closestKey = getClosestNumber(input, Array.from(map.keys()).sort());
+    return map.get(closestKey);
+}
+function getClosestNumber(input, options) {
+    if (options.length <= 0) {
+        return input;
+    }
+    let value;
+    let gap;
+    let best = -1;
+    let bestGap = Number.MAX_VALUE;
+    for (let i = 0; i < options.length; ++i) {
+        value = options[i];
+        gap = Math.abs(input - value);
+        if (gap == 0) {
+            return value;
+        }
+        if (gap < bestGap) {
+            bestGap = gap;
+            best = value;
+        }
+    }
+    return best;
+}
+const TIME_CONVERSION_TYPES = [
+    "ns_to_ms",
+    "ns_to_s",
+    "ns_to_m",
+    "ns_to_h",
+    "ns_to_d",
+    "ns_to_w",
+    "ms_to_ns",
+    "ms_to_s",
+    "ms_to_m",
+    "ms_to_h",
+    "ms_to_d",
+    "ms_to_w",
+    "s_to_ns",
+    "s_to_ms",
+    "s_to_m",
+    "s_to_h",
+    "s_to_d",
+    "s_to_w",
+    "m_to_ns",
+    "m_to_ms",
+    "m_to_s",
+    "m_to_h",
+    "m_to_d",
+    "m_to_w",
+    "h_to_ns",
+    "h_to_ms",
+    "h_to_s",
+    "h_to_m",
+    "h_to_d",
+    "h_to_w",
+    "d_to_ns",
+    "d_to_ms",
+    "d_to_s",
+    "d_to_m",
+    "d_to_h",
+    "d_to_w",
+    "w_to_ns",
+    "w_to_ms",
+    "w_to_s",
+    "w_to_m",
+    "w_to_h",
+    "w_to_d",
+];
+//~~~~~From~~~~~
+const NANOSECOND_CONVERSION_TYPES = [
+    "ns_to_ms",
+    "ns_to_s",
+    "ns_to_m",
+    "ns_to_h",
+    "ns_to_d",
+    "ns_to_w",
+];
+const MILLISECOND_CONVERSION_TYPES = [
+    "ms_to_ms",
+    "ms_to_s",
+    "ms_to_m",
+    "ms_to_h",
+    "ms_to_d",
+    "ms_to_w",
+];
+const SECOND_CONVERSION_TYPES = [
+    "s_to_ms",
+    "s_to_s",
+    "s_to_m",
+    "s_to_h",
+    "s_to_d",
+    "s_to_w",
+];
+const MINUTE_CONVERSION_TYPES = [
+    "m_to_ms",
+    "m_to_s",
+    "m_to_m",
+    "m_to_h",
+    "m_to_d",
+    "m_to_w",
+];
+const HOUR_CONVERSION_TYPES = [
+    "h_to_ms",
+    "h_to_s",
+    "h_to_m",
+    "h_to_h",
+    "h_to_d",
+    "h_to_w",
+];
+const DAY_CONVERSION_TYPES = [
+    "d_to_ms",
+    "d_to_s",
+    "d_to_m",
+    "d_to_h",
+    "d_to_d",
+    "d_to_w",
+];
+const WEEK_CONVERSION_TYPES = [
+    "w_to_ms",
+    "w_to_s",
+    "w_to_m",
+    "w_to_h",
+    "w_to_d",
+    "w_to_w",
+];
+//!~~~~~From~~~~~
+//~~~~~To~~~~~
+const TO_NANOSECOND_CONVERSION_TYPES = [
+    "ms_to_ns",
+    "s_to_ns",
+    "m_to_ns",
+    "h_to_ns",
+    "d_to_ns",
+    "w_to_ns",
+];
+const TO_MILLISECOND_CONVERSION_TYPES = [
+    "ms_to_ms",
+    "s_to_ms",
+    "m_to_ms",
+    "h_to_ms",
+    "d_to_ms",
+    "w_to_ms",
+];
+const TO_SECOND_CONVERSION_TYPES = [
+    "ms_to_s",
+    "s_to_s",
+    "m_to_s",
+    "h_to_s",
+    "d_to_s",
+    "w_to_s",
+];
+const TO_MINUTE_CONVERSION_TYPES = [
+    "ms_to_m",
+    "s_to_m",
+    "m_to_m",
+    "h_to_m",
+    "d_to_m",
+    "w_to_m",
+];
+const TO_HOUR_CONVERSION_TYPES = [
+    "ms_to_h",
+    "s_to_h",
+    "m_to_h",
+    "h_to_h",
+    "d_to_h",
+    "w_to_h",
+];
+const TO_DAY_CONVERSION_TYPES = [
+    "ms_to_d",
+    "s_to_d",
+    "m_to_d",
+    "h_to_d",
+    "d_to_d",
+    "w_to_d",
+];
+const TO_WEEK_CONVERSION_TYPES = [
+    "ms_to_w",
+    "s_to_w",
+    "m_to_w",
+    "h_to_w",
+    "d_to_w",
+    "w_to_w",
+];
+//!~~~~~To~~~~~
+function convertTime(input, type) {
+    switch (type) {
+        case "ns_to_s":
+            return nanosecondsToSeconds(input);
+        case "ns_to_ms":
+            return nanosecondsToMilliseconds(input);
+        case "ns_to_m":
+            return nanosecondsToMinutes(input);
+        case "ns_to_h":
+            return nanosecondsToHours(input);
+        case "ns_to_d":
+            return nanosecondsToDays(input);
+        case "ns_to_w":
+            return nanosecondsToWeeks(input);
+        case "ms_to_ns":
+            return millisecondsToNanoseconds(input);
+        case "ms_to_s":
+            return millisecondsToSeconds(input);
+        case "ms_to_m":
+            return millisecondsToMinutes(input);
+        case "ms_to_h":
+            return millisecondsToHours(input);
+        case "ms_to_d":
+            return millisecondsToDays(input);
+        case "ms_to_w":
+            return millisecondsToWeeks(input);
+        case "s_to_ns":
+            return secondsToNanoseconds(input);
+        case "s_to_ms":
+            return secondsToMilliseconds(input);
+        case "s_to_m":
+            return secondsToMinutes(input);
+        case "s_to_h":
+            return secondsToHours(input);
+        case "s_to_d":
+            return secondsToDays(input);
+        case "s_to_w":
+            return secondsToWeeks(input);
+        case "m_to_ns":
+            return minutesToNanoseconds(input);
+        case "m_to_ms":
+            return minutesToMilliseconds(input);
+        case "m_to_s":
+            return minutesToSeconds(input);
+        case "m_to_h":
+            return minutesToHours(input);
+        case "m_to_d":
+            return minutesToDays(input);
+        case "m_to_w":
+            return minutesToWeeks(input);
+        case "h_to_ns":
+            return hoursToNanoseconds(input);
+        case "h_to_ms":
+            return hoursToMilliseconds(input);
+        case "h_to_s":
+            return hoursToSeconds(input);
+        case "h_to_m":
+            return hoursToMinutes(input);
+        case "h_to_d":
+            return hoursToDays(input);
+        case "h_to_w":
+            return hoursToWeeks(input);
+        case "d_to_ns":
+            return daysToNanoseconds(input);
+        case "d_to_ms":
+            return daysToMilliseconds(input);
+        case "d_to_s":
+            return daysToSeconds(input);
+        case "d_to_m":
+            return daysToMinutes(input);
+        case "d_to_h":
+            return daysToHours(input);
+        case "d_to_w":
+            return daysToWeeks(input);
+        case "w_to_ns":
+            return weeksToNanoseconds(input);
+        case "w_to_ms":
+            return weeksToMilliseconds(input);
+        case "w_to_s":
+            return weeksToSeconds(input);
+        case "w_to_m":
+            return weeksToMinutes(input);
+        case "w_to_h":
+            return weeksToHours(input);
+        case "w_to_d":
+            return weeksToDays(input);
+    }
+}
+exports.ZERO_BIG_INT = BigInt(0);
+const getZero = () => 0;
+exports.getZero = getZero;
+const getZeroBigInt = () => exports.ZERO_BIG_INT;
+exports.getZeroBigInt = getZeroBigInt;
+const timeTrackers = new Map();
+function getNs() {
+    return process.hrtime.bigint();
+}
+function startTimer(key) {
+    timeTrackers.set(key, getNs());
+}
+function getTimer(key) {
+    return orElse(timeTrackers.get(key), exports.getZeroBigInt);
+}
+function getTimerString(key, format = "ns_to_s") {
+    return `${key}: ${convertTime(Number(getTimer(key)), format)}`;
+}
+function printTimer(key, format = "ns_to_s") {
+    console.log(getTimerString(key, format));
+}
+function isString(input) {
+    return typeof input === 'string' || input instanceof String;
+}
+function reverseString(str) {
+    return str.split('').reverse().join('');
+}
+function wipeAllLetters(input) {
+    return input.replaceAll(fields_1.UNICODE_LETTERS_REGEX, "");
+}
+function keepOnlyAllLetters(input) {
+    return input.replaceAll(fields_1.NOT_UNICODE_LETTERS_REGEX, "");
+}
+function wipeNumbers(input) {
+    return input.replaceAll(fields_1.NUMBER_REGEX, "");
+}
+function keepOnlyNumbers(input) {
+    return input.replaceAll(fields_1.NON_NUMBER_REGEX, "");
+}
+function wipeAllLettersAndNumbers(input) {
+    return wipeAllLetters(wipeNumbers(input));
+}
+function keepOnlyAllLettersAndNumbers(input) {
+    return keepOnlyAllLetters(keepOnlyNumbers(input));
+}
+function fromArrayOrNull(array, index) {
+    if (index >= 0 && index < array.length) {
+        return array[index];
+    }
+    return null;
+}
+function setClipboard(text) {
+    ncp.writeSync(text);
+}
+function readClipboard() {
+    return ncp.readSync();
+}
+function toDDMMYYYY(date = null) {
+    if (date == null) {
+        date = new Date();
+    }
+    const month = (date.getMonth() + 1).toString().padStart(2, '0');
+    const day = date.getDate().toString().padStart(2, '0');
+    const year = date.getFullYear().toString();
+    return `${day}-${month}-${year}`;
+}
+function toMMDDYYYY(date = null) {
+    if (date == null) {
+        date = new Date();
+    }
+    const month = (date.getMonth() + 1).toString().padStart(2, '0');
+    const day = date.getDate().toString().padStart(2, '0');
+    const year = date.getFullYear().toString();
+    return `${month}-${day}-${year}`;
+}
+async function downloadItem(url, destination) {
+    const tempDestination = `${destination}_TEMP`;
+    if ((0, fs_1.existsSync)(tempDestination)) {
+        (0, fs_1.unlinkSync)(tempDestination);
+    }
+    return new Promise(resolve => {
+        const file = (0, fs_1.createWriteStream)(tempDestination);
+        (0, https_1.get)(url, (response) => {
+            response.pipe(file);
+            file.on('finish', () => {
+                file.close();
+                if ((0, fs_1.existsSync)(destination)) {
+                    (0, fs_1.unlinkSync)(destination);
+                }
+                if ((0, fs_1.existsSync)(tempDestination)) {
+                    (0, fs_1.renameSync)(tempDestination, destination);
+                    const stat = (0, fs_1.statSync)(destination);
+                    if (stat.size <= 0) {
+                        console.log(`low size: ${stat.size}`);
+                        resolve(false);
+                        return;
+                    }
+                    resolve(true);
+                }
+                else {
+                    resolve(false);
+                }
+            });
+        }).on('error', (err) => {
+            console.log(`Failed download ${destination}`);
+            if ((0, fs_1.existsSync)(tempDestination)) {
+                (0, fs_1.unlinkSync)(tempDestination);
+            }
+            resolve(false);
+        });
+    });
+}
+function getChild(element, childIndex = 0) {
+    if (element.children.length <= childIndex) {
+        return element.children[element.children.length - 1];
+    }
+    return element.children[childIndex];
+}
+async function getDynamicContentCheerio(url, options) {
+    const html = await getDynamicContent(url, options);
+    return cheerio.load(html);
+}
+async function getDynamicContent(url, options) {
+    const browser = await puppeteer_1.default.launch();
+    const page = await browser.newPage();
+    try {
+        await page.goto(url, options);
+        const content = await page.content();
+        return content;
+    }
+    catch (error) {
+        console.error('Error retrieving dynamic content:', error);
+        return '';
+    }
+    finally {
+        await browser.close();
+    }
+}
+async function randomTimeout(minMs = 1523, maxMs = 3251) {
+    return await new Promise(resolve => setTimeout(resolve, random(minMs, maxMs)));
+}
+async function randomTimeoutVerbose(minMs, maxMs, timeoutGapMs = 1523) {
+    const waitingForMs = random(minMs, maxMs);
+    let waitedFor = 0;
+    let waitFor = clamp(waitingForMs - waitedFor, 0, timeoutGapMs);
+    while (waitedFor < waitingForMs) {
+        console.log(`Waiting for ${exports.chalk.magentaBright(waitingForMs - waitedFor) + "ms"}...`);
+        await new Promise(resolve => setTimeout(resolve, waitFor));
+        waitedFor += timeoutGapMs;
+        waitFor = clamp(waitingForMs - waitedFor, 0, timeoutGapMs);
+    }
+    return await new Promise(resolve => setTimeout(resolve, waitFor));
+}
+function getLast(items) {
+    if (items.length <= 0) {
+        return undefined;
+    }
+    return items[items.length - 1];
+}
+function getLastX(items, lastCount) {
+    const startIndex = Math.max(0, items.length - lastCount);
+    return items.slice(startIndex);
+}
+function forLastX(items, lastCount, consumer) {
+    const itemsLength = items.length;
+    const startIndex = Math.max(0, itemsLength - lastCount);
+    for (let i = startIndex; i < itemsLength; ++i) {
+        consumer(items[i]);
+    }
+}
+function joinToXCounts(items, maxCount, joinWith = "\n") {
+    const output = [];
+    let msg = "";
+    let count = 0;
+    for (const item of items) {
+        if (++count > maxCount) {
+            count = 1;
+            output.push(msg);
+            msg = "";
+        }
+        msg += `${item}${joinWith}`;
+    }
+    if (msg.length > 0) {
+        output.push(msg);
+    }
+    return output;
+}
+async function asyncMap(items, mapper) {
+    const output = [];
+    for (const item of items) {
+        output.push(await mapper(item));
+    }
+    return output;
+}
+function emptyIfEmpty(text) {
+    return text.trim().length == 0 ? fields_1.EMPTY : text.trim();
+}
+function getRandomWeighedItem(map, total = getWeightOfValues(map)) {
+    let rand = Math.random() * total;
+    let item = null;
+    for (const [key, value] of map.entries()) {
+        item = key;
+        if (rand <= value) {
+            break;
+        }
+        rand -= value;
+    }
+    return item;
+}
+function getWeightOfKeys(map) {
+    return getSum(map.keys());
+}
+function getWeightOfValues(map) {
+    return getSum(map.values());
+}
+function getSum(numbers) {
+    let sum = 0;
+    for (const number of numbers) {
+        sum += number;
+    }
+    return sum;
+}
+function getCurrentMs() {
+    return Date.now();
+}
+function getCurrentSecond() {
+    return millisecondsToSeconds(getCurrentMs());
+}
+function getCurrentMinute() {
+    return millisecondsToMinutes(getCurrentMs());
+}
+function getCurrentHour() {
+    return millisecondsToHours(getCurrentMs());
+}
+function getCurrentDay() {
+    return millisecondsToDays(getCurrentMs());
+}
+function reverseMap(map) {
+    const reversedMap = new Map();
+    for (const [key, value] of map.entries()) {
+        reversedMap.set(value, key);
+    }
+    return reversedMap;
+}
+function toArray(iterator) {
+    const array = [];
+    let result = iterator.next();
+    while (!result.done) {
+        array.push(result.value);
+        result = iterator.next();
+    }
+    return array;
+}
+function sortDateOldestFirst(a, b) {
+    return a.getTime() - b.getTime();
+}
+function sortDateNewestFirst(a, b) {
+    return b.getTime() - a.getTime();
+}
+function dateValuesMapToSortedKeysArray(map, newestFirst) {
+    const sortedKeys = [];
+    const reversedMap = reverseMap(map);
+    const sortedDates = toArray(map.values());
+    sortedDates.sort(newestFirst ? sortDateNewestFirst : sortDateOldestFirst);
+    for (const date of sortedDates) {
+        sortedKeys.push(reversedMap.get(date));
+    }
+    return sortedKeys;
+}
+function getCount(iterable) {
+    let count = 0;
+    for (const item of iterable) {
+        ++count;
+    }
+    return count;
+}
+function sumStringNumberObj(obj) {
+    let sum = 0;
+    for (const [key, value] of Object.entries(obj)) {
+        sum += value;
+    }
+    return sum;
+}
+function splitWords(input) {
+    return input.split(/[ \r\n]/).filter(word => word.length > 0);
+}
+function filterMap(map, filter) {
+    for (const [key, value] of map.entries()) {
+        if (!filter(key, value)) {
+            map.delete(key);
+        }
+    }
+}
+function filterMapCopy(map, filter) {
+    const newMap = new Map();
+    for (const [key, value] of map.entries()) {
+        if (filter(key, value)) {
+            newMap.set(key, value);
+        }
+    }
+    return newMap;
+}
+function filterSet(set, filter) {
+    for (const item of set) {
+        if (!filter(item)) {
+            set.delete(item);
+        }
+    }
+}
+function filterSetCopy(set, filter) {
+    const newSet = new Set();
+    for (const item of set) {
+        if (!filter(item)) {
+            newSet.add(item);
+        }
+    }
+    return newSet;
+}
+async function prismaDeleteIfExists(db, where) {
+    const item = await db.findFirst({ where });
+    if (item == null) {
+        return false;
+    }
+    await db.delete({ where });
+    return true;
+}
+function getWeekSince1980() {
+    return Math.floor(millisecondsToWeeks(Date.now()));
+}
+function getDaySince1980() {
+    return Math.floor(millisecondsToDays(Date.now()));
+}
+async function runCommand(command, as_user) {
+    return new Promise((resolve, reject) => {
+        if (as_user != null) {
+            command = `sudo -u ${as_user} sh -c '${command}'`;
+        }
+        (0, child_process_1.exec)(command, (error, stdout, stderr) => {
+            if (error) {
+                reject(stderr || error.message || error);
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}
+async function runCommandRejectAsResolve(command, as_user) {
+    try {
+        return await runCommand(command, as_user);
+    }
+    catch (error) {
+        return String(error);
+    }
+}
+function sanitizeStringForFFMPEG(input) {
+    return input.replaceAll(/([$!"`])/g, "\\$1");
+}
+function getArtistsFromFlacMetadata(tags, aliases = classes_1.MUSIC_ALIASES) {
+    const artists = new Set;
+    if (tags.common != null) {
+        if (tags.common.artists != null) {
+            for (let allegedArtist of tags.common.artists) {
+                allegedArtist = aliases.get(singleSpacesOnly(allegedArtist).trim());
+                for (const artist of librarySplitMultipleArtists(allegedArtist, aliases)) {
+                    artists.add(artist);
+                }
+            }
+        }
+        if (tags.common.artist != null) {
+            const allegedArtist = aliases.get(singleSpacesOnly(tags.common.artist).trim());
+            for (const artist of librarySplitMultipleArtists(allegedArtist, aliases)) {
+                artists.add(artist);
+            }
+        }
+        if (artists.size == 0) {
+            if (tags.common.albumartist != null) {
+                const allegedArtist = aliases.get(singleSpacesOnly(tags.common.albumartist).trim());
+                for (const artist of librarySplitMultipleArtists(allegedArtist, aliases)) {
+                    artists.add(artist);
+                }
+            }
+        }
+    }
+    return artists;
+}
+function getTitleFromFlacMetadata(tags) {
+    var _a;
+    return (_a = tags.common.title) !== null && _a !== void 0 ? _a : "";
+}
+function getAlbumFromFlacMetadata(tags) {
+    var _a;
+    return (_a = tags.common.album) !== null && _a !== void 0 ? _a : "";
+}
+function getAlbumArtistFromFlacMetadata(tags) {
+    var _a;
+    return (_a = tags.common.albumartist) !== null && _a !== void 0 ? _a : "";
+}
+function getLyricsFromFlacVorbisTags(vorbisTags) {
+    let lyrics = vorbisTags[fields_1.UNSYNCEDLYRICS_FLAC_ID];
+    if (lyrics == null) {
+        return "";
+    }
+    return lyrics.trim();
+}
+function generateHash(seed) {
+    const hash = (0, crypto_1.createHash)('sha256');
+    hash.update(seed);
+    return hash.digest('hex');
+}
+function extensionHasAudio(extension) {
+    return fields_1.AUDIO_CONTAINING_EXTENSION_TYPES.has(extension);
+}
+function songTitleExtractSide(input, doSides, side) {
+    let output = input;
+    if (doSides) {
+        const indexOfDash = output.lastIndexOf(" - ");
+        if (indexOfDash != -1) {
+            if (side) {
+                output = output.slice(indexOfDash + 3);
+            }
+            else {
+                output = output.slice(0, indexOfDash);
+            }
+        }
+    }
+    while (output.includes("  ")) {
+        output = output.replaceAll("  ", " ");
+    }
+    output = output.trim();
+    return output;
+}
+function sanitizeStringForSeed(input) {
+    let output = input.toLowerCase();
+    for (const [name, regex] of fields_1.BEFORE_SIDES_SANITIZE_REGEXES) {
+        output = output.replaceAll(regex, "");
+    }
+    for (const [name, regex] of fields_1.AFTER_SIDES_SANITIZE_REGEXES) {
+        output = output.replaceAll(regex, "");
+    }
+    while (output.includes("  ")) {
+        output = output.replaceAll("  ", " ");
+    }
+    output = output.trim();
+    return output;
+}
+function addAllSetToSet(input, outputSet) {
+    for (const item of input) {
+        outputSet.add(item);
+    }
+    return outputSet;
+}
+function addAllArrayToSet(input, outputSet) {
+    for (const item of input) {
+        outputSet.add(item);
+    }
+    return outputSet;
+}
+function addAllSetToArray(input, outputArray) {
+    for (const item of input) {
+        outputArray.push(item);
+    }
+    return outputArray;
+}
+function addAllArrayToArray(input, outputArray) {
+    for (const item of input) {
+        outputArray.push(item);
+    }
+    return outputArray;
+}
+function addAllArrayToMap(items, map, keyGetter) {
+    for (const item of items) {
+        map.set(keyGetter(item), item);
+    }
+}
+function addSetArrayToMap(items, map, keyGetter) {
+    for (const item of items) {
+        map.set(keyGetter(item), item);
+    }
+}
+function joinSet(input, joinWith) {
+    let output = "";
+    if (input.size <= 0) {
+        return output;
+    }
+    let first = true;
+    for (const item of input) {
+        output += item;
+        if (first) {
+            first = false;
+        }
+        else {
+            output += joinWith;
+        }
+    }
+    return output;
+}
+function replaceAllArray(input, replaceInputs, replaceWith) {
+    let output = input;
+    for (const replaceInput of replaceInputs) {
+        output = output.replaceAll(replaceInput, replaceWith);
+    }
+    return output;
+}
+function librarySplitMultipleArtists(input, aliases = classes_1.MUSIC_ALIASES) {
+    const inputs = input.split(/(?:[,+;]|\W(?:[&x]|and|with|fixes|befriends|vs\.?)\W|\/)/gi);
+    return inputs.map(artist => {
+        artist = aliases.get(singleSpacesOnly(artist.replaceAll("​", " ").replaceAll(" - Topic", ""))).trim();
+        const parenthesisFeatMatch = artist.match(fields_1.FEAT_WITH_PARENTHESIS_REGEX);
+        if (parenthesisFeatMatch != null) {
+            artist = artist.slice(0, parenthesisFeatMatch.index).trim();
+        }
+        const indexOfParenthesis = artist.indexOf("(");
+        if (indexOfParenthesis != -1) {
+            artist = artist.slice(0, indexOfParenthesis).trim();
+        }
+        artist = libraryCleanUpStartAndEndOfString(artist);
+        artist = artist.replaceAll("", "").replaceAll("[", "(").replaceAll("]", ")").trim();
+        return singleSpacesOnly(artist);
+    }).filter(artist => artist.length > 0);
+}
+function libraryFindFeaturing(originalInput, aliases = classes_1.MUSIC_ALIASES) {
+    let input = originalInput;
+    const featMatch = input.match(fields_1.FEAT_WITH_PARENTHESIS_REGEX);
+    if (featMatch == null) {
+        return { newName: input, artists: [] };
+    }
+    let newName = input;
+    const featString = featMatch[0].trim();
+    newName = singleSpacesOnly(originalInput.replace(featString, "")).trim();
+    input = featMatch[1];
+    const indexOfDash = input.indexOf(" - ");
+    if (indexOfDash != -1) {
+        input = input.slice(0, indexOfDash).trim();
+    }
+    const featuring = [];
+    const regex = /([^\(\)\[\]]+)/gi;
+    for (const match of input.matchAll(regex)) {
+        for (const artist of librarySplitMultipleArtists(match[1], aliases)) {
+            featuring.push(artist.trim());
+        }
+    }
+    return {
+        newName: aliases.get(newName),
+        artists: featuring
+    };
+}
+function libraryCleanUpStartAndEndOfString(input) {
+    input = input.trim();
+    if (input.length == 0) {
+        return input;
+    }
+    let firstChar = input.at(0);
+    while (firstChar == "-") {
+        input = input.slice(1, input.length).trim();
+        if (input.length == 0) {
+            break;
+        }
+        firstChar = input.at(0);
+    }
+    let lastChar = input.at(input.length - 1);
+    while (lastChar == "-" || lastChar == "(" || lastChar == "[") {
+        input = input.slice(0, input.length - 1).trim();
+        if (input.length == 0) {
+            break;
+        }
+        lastChar = input.at(input.length - 1);
+    }
+    return singleSpacesOnly(input).trim();
+}
+function generateWeightedItemsGridString(width, height, symbols, totalWeight) {
+    let grid = '';
+    let lastItem = '';
+    for (let y = 0; y < height; ++y) {
+        let line = '';
+        for (let x = 0; x < width; ++x) {
+            do {
+                const item = getRandomWeighedItem(symbols, totalWeight);
+                if (item == lastItem) {
+                    if (randomBoolean(0.8)) {
+                        continue;
+                    }
+                }
+                line += item;
+                lastItem = item;
+                break;
+            } while (true);
+        }
+        grid += `${line}\n`;
+    }
+    return grid;
+}
+async function promptYesOrNo(actionName = "Proceed?") {
+    return new Promise(resolve => {
+        process.stdout.write(`${actionName} [y/n]: `);
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        const onKeyPress = (buffer) => {
+            const key = buffer.toString().toLowerCase();
+            if (key === 'y') {
+                cleanup();
+                resolve(true);
+            }
+            else if (key === 'n') {
+                cleanup();
+                resolve(false);
+            }
+        };
+        const cleanup = () => {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            process.stdin.off('data', onKeyPress);
+        };
+        process.stdin.on('data', onKeyPress);
+    });
+}
+async function musicFileInfoToM3uEntry(fileInfo) {
+    var _a;
+    const titleAndArtists = await classes_1.TitleAndArtists.fromFileInfo(fileInfo);
+    const tags = await util_1.musicMetadata.parseFile(fileInfo.path, { skipCovers: true });
+    const formatTags = tags.format;
+    const durationS = (_a = formatTags.duration) !== null && _a !== void 0 ? _a : -1;
+    return toM3uEntry(fileInfo.path, titleAndArtists.artistsDashTitle, durationS);
+}
+function toM3uEntry(path, title = "", durationS = -1) {
+    const safeTitle = title.trim().length == 0 ? (0, path_1.basename)(path) : title;
+    return `#EXTINF:${Math.floor(durationS)},${safeTitle}\n${path}`;
+}
+function getStepString(step, totalSteps = -1) {
+    if (totalSteps > 0) {
+        return `Step ${step}/${totalSteps}:`;
+    }
+    return `Step ${step}:`;
+}
+function sliceOffLastSlash(path, times = 1) {
+    return sliceOffLast(path, fields_1.SEP, times);
+}
+function sliceOffLast(path, lastMatch, times = 1) {
+    do {
+        const lastSlashIndex = path.lastIndexOf(lastMatch);
+        if (lastSlashIndex == -1) {
+            break;
+        }
+        path = path.slice(0, lastSlashIndex);
+    } while (--times > 0);
+    return path;
+}
+function sliceOffUntil(text, lastMatch) {
+    const lastSlashIndex = text.lastIndexOf(lastMatch);
+    if (lastSlashIndex == -1) {
+        return text;
+    }
+    text = text.slice(lastSlashIndex);
+    return text;
+}
+function sliceOffNonProject(path) {
+    const srcIndex = path.replaceAll("\\", "/").indexOf("/src/");
+    if (srcIndex === -1) {
+        return path;
+    }
+    const pathUntilSrc = path.substring(0, srcIndex);
+    const lastSlashIndex = lastIndexOfSeparator(pathUntilSrc);
+    if (lastSlashIndex === -1) {
+        return path;
+    }
+    return path.substring(lastSlashIndex + 1);
+}
+function countOccurances(path, match) {
+    let count = 0;
+    let index = path.indexOf(match);
+    while (index != -1) {
+        ++count;
+        index = path.indexOf(match, index + match.length);
+    }
+    return count;
+}
+function countPathDepth(path) {
+    return countOccurances(path, "/");
+}
+function getPathEscapeString(depth) {
+    let pathEscapeString = "";
+    for (let i = 0; i < depth; ++i) {
+        pathEscapeString += "../";
+    }
+    return pathEscapeString;
+}
+function getFullPathEscapeString(path) {
+    const depth = countPathDepth(path);
+    return getPathEscapeString(depth);
+}
+function jsonLookupToMap(json) {
+    const map = new Map();
+    for (const [key, value] of Object.entries(json)) {
+        const numberKey = parseInt(key);
+        if (isNaN(numberKey)) {
+            console.error(`Invalid lookup: ${key}`);
+            continue;
+        }
+        map.set(numberKey, value);
+    }
+    return map;
+}
+function extractElementFromJsonAndRemove(obj, key) {
+    const element = obj[key];
+    delete obj[key];
+    return element;
+}
+function extractLookupFromJsonAndRemove(obj) {
+    const keys = jsonLookupToMap(extractElementFromJsonAndRemove(obj, "lookup"));
+    return keys;
+}
+function forEachValueAndPathOfObj(obj, callback, lookup = new Map) {
+    return forEachLookUpValueAndPathOfObjRecursive(lookup, obj, callback);
+}
+function forEachLookUpValueAndPathOfObjRecursive(lookup, obj, callback, inputPath = "") {
+    for (const [key, value] of Object.entries(obj)) {
+        const path = inputPath.length == 0 ? key : `${inputPath}/${key}`;
+        if (Array.isArray(value)) {
+            for (const arrayValue of value) {
+                callback(path, lookup.get(arrayValue));
+            }
+        }
+        else if (typeof value === "object") {
+            forEachLookUpValueAndPathOfObjRecursive(lookup, value, callback, path);
+        }
+        else {
+            callback(path, lookup.get(value));
+        }
+    }
+}
+async function findGeniusSongs(search) {
+    const songs = await exports.geniusClient.songs.search(search);
+    return songs;
+}
+function trimToCharNumbersOnly(input) {
+    return trim(input, fields_1.NON_NUMBER_OR_CHAR_REGEX);
+}
+function trimStartToCharNumbersOnly(input) {
+    return trimStart(input, fields_1.NON_NUMBER_OR_CHAR_REGEX);
+}
+function trimEndToCharNumbersOnly(input) {
+    return trimEnd(input, fields_1.NON_NUMBER_OR_CHAR_REGEX);
+}
+function trim(input, regex = fields_1.TRIM_REGEX) {
+    return trimStart(trimEnd(input, regex), regex);
+}
+function trimStart(input, regex) {
+    let startIndex = 0;
+    while (startIndex < input.length && regex.test(input[startIndex])) {
+        ++startIndex;
+    }
+    return input.slice(startIndex, input.length);
+}
+function trimEnd(input, regex) {
+    let endIndex = input.length - 1;
+    while (endIndex >= 0 && regex.test(input[endIndex])) {
+        --endIndex;
+    }
+    return input.slice(0, endIndex + 1);
+}
+async function findGeniusLyrics(query, artistsToMatch = []) {
+    const geniusSongs = await findGeniusSongs(query);
+    for (const geniusSong of geniusSongs) {
+        const geniusArtistsDashTitle = `${geniusSong.artist.name} - ${geniusSong.title}`;
+        const geniusSongArtist = classes_1.MUSIC_ALIASES.get(geniusSong.artist.name);
+        let correctArtist = false;
+        if (artistsToMatch.length == 0) {
+            correctArtist = true;
+        }
+        else {
+            for (const artist of artistsToMatch) {
+                if (geniusSongArtist === classes_1.MUSIC_ALIASES.get(artist)) {
+                    correctArtist = true;
+                    break;
+                }
+            }
+        }
+        if (correctArtist) {
+            try {
+                const geniusLyrics = (await geniusSong.lyrics()).replaceAll(fields_1.CONTRIBUTORS_REGEX, "");
+                return geniusLyrics;
+            }
+            catch (err) {
+                console.log(exports.chalk.redBright(`Error getting Genius lyrics for ${geniusArtistsDashTitle}:\n${err}`));
+            }
+        }
+    }
+}
+function softSliceFrom(input, sliceFrom, anyCase = true, fromElseTo = true) {
+    const regex = new RegExp(`(${sliceFrom})`, `${anyCase ? "i" : ""}`);
+    const match = input.match(regex);
+    if (match != null) {
+        const lyricsIndex = match.index;
+        if (lyricsIndex != null) {
+            const lyricsStart = fromElseTo ?
+                input.slice(0, lyricsIndex + match[1].length) :
+                input.slice(lyricsIndex);
+            input = input.replace(lyricsStart, "");
+        }
+    }
+    return input.trim();
+}
+function trimFirstLinesWhileIncludes(input, blacklistLineTerm) {
+    input = input.trim();
+    do {
+        const nextLineMatch = input.match(fields_1.NEW_LINE_REGEX);
+        if (nextLineMatch == null) {
+            break;
+        }
+        const nextLineIndex = nextLineMatch.index;
+        const firstLine = input.slice(0, nextLineIndex);
+        if (firstLine.toLowerCase().includes(blacklistLineTerm)) {
+            input = input.slice(nextLineIndex).trim();
+        }
+        else {
+            break;
+        }
+    } while (true);
+    return input;
+}
+function getFirstLine(input) {
+    const nextLineMatch = input.match(fields_1.NEW_LINE_REGEX);
+    if (nextLineMatch == null) {
+        return undefined;
+    }
+    const nextLineIndex = nextLineMatch.index;
+    const firstLine = input.slice(0, nextLineIndex);
+    return firstLine;
+}
+function skyify(input) {
+    return input.replaceAll(/[^\n\r ]/g, (_) => getRandomWeighedItem(fields_1.NIGHT_SKY_ITEMS, fields_1.NIGHT_SKY_ITEMS_TOTAL_WEIGHT)).slice(0, fields_1.DISCORD_MESSAGE_LENGTH_LIMIT);
+}
+function dateToFilename(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}_${date.getHours()}-${date.getMinutes()}-${date.getSeconds()}`;
+}
+function makeMap(preparer) {
+    return make(new Map, preparer);
+}
+function makeWeightedMap(input) {
+    if (input instanceof Array) {
+        return makeWeightedMap(map => {
+            for (const item of input) {
+                map.add(item, 1);
+            }
+        });
+    }
+    return make(new classes_1.WeightedMap, input);
+}
+function makeWeightedTextCompMap(input) {
+    if (input instanceof Array) {
+        return makeWeightedTextCompMap(map => {
+            for (const item of input) {
+                map.add(item, 1);
+            }
+        });
+    }
+    return make(new classes_1.WeightedMap, input);
+}
+function generateLinesUntilCharacterLimit(generator, amount = 1, limit = fields_1.DISCORD_MESSAGE_LENGTH_LIMIT) {
+    let output = "";
+    for (let i = 0; i < amount; ++i) {
+        const nextLine = generator();
+        if (limit < output.length + nextLine.length + 1) {
+            break;
+        }
+        output += `${nextLine}\n`;
+    }
+    return output;
+}
+function lastIndexOfSeparator(path) {
+    return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+}
+function timestamp() {
+    const now = new Date();
+    return `[${padLeft(now.getHours().toString(), 2, "0")}:${padLeft(now.getMinutes().toString(), 2, "0")}:${padLeft(now.getSeconds().toString(), 2, "0")}]`;
+}
+function timestampWithMs() {
+    const now = new Date();
+    return `${timestamp().slice(0, -1)}.${padLeft(now.getMilliseconds().toString(), 3, "0")}]`;
+}
+function isSilent(buffer) {
+    var speechSample;
+    for (var i = 0; i < buffer.length; i = i + 2) {
+        if (buffer[i + 1] > 128) {
+            speechSample = (buffer[i + 1] - 256) * 256;
+        }
+        else {
+            speechSample = buffer[i + 1] * 256;
+        }
+        speechSample += buffer[i];
+        if (Math.abs(speechSample) > 2000) {
+            return false;
+        }
+    }
+    return true;
+}
+async function waitMs(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function waitS(s) {
+    return new Promise(resolve => setTimeout(resolve, s * 1000));
+}
+async function whileFalseAsyncS(intervalS, stopIfTrue) {
+    return whileFalseAsyncMs(intervalS * 1000, stopIfTrue);
+}
+async function whileFalseAsyncMs(intervalMs, stopIfTrue) {
+    return new Promise(async (resolve, reject) => {
+        let task = null;
+        task = setInterval(() => {
+            if (stopIfTrue()) {
+                clearInterval(task);
+                resolve(true);
+            }
+        }, intervalMs);
+    });
+}
+async function repeatForAsyncS(durationS, intervalS, stopIfTrue) {
+    return repeatForAsyncMs(durationS * 1000, intervalS * 1000, stopIfTrue);
+}
+async function repeatForAsyncMs(durationMs, intervalMs, stopIfTrue) {
+    const endTime = Date.now() + durationMs;
+    return whileFalseAsyncMs(intervalMs, () => {
+        if (Date.now() <= endTime || stopIfTrue()) {
+            return false;
+        }
+        return true;
+    });
+}
+// let lastSetTerminalLine: string = ""
+// export function replaceLastTerminalLine(text: string)
+// {
+//     process.stdout.clearLine(0)
+//     process.stdout.cursorTo(0)
+//     if (lastSetTerminalLine !== text)
+//     {
+//         process.stdout.write(text)
+//         lastSetTerminalLine = text
+//     }
+// }
+let lastSetTerminalLine = "";
+function replaceLastTerminalLine(text) {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+    if (lastSetTerminalLine !== text) {
+        process.stdout.write(text);
+        lastSetTerminalLine = text;
+    }
+}
+let lastTerminalOutputLines = 0;
+function setTerminalOutput(text, newSession = false) {
+    clearTerminalLines(lastTerminalOutputLines);
+    if (newSession) {
+        lastTerminalOutputLines = 0;
+    }
+    const lines = text.split(/[\n\r]/).length;
+    process.stdout.write(`${text}\n`);
+    lastTerminalOutputLines = lines;
+}
+function clearSetTerminalOutput() {
+    clearTerminalLines(lastTerminalOutputLines);
+    lastTerminalOutputLines = 0;
+}
+function clearTerminalLines(amount) {
+    process.stdout.write('\x1b[0G'); // Move to start of line
+    for (let i = 0; i < amount + 1; i++) {
+        process.stdout.write('\x1b[2K'); // Clear line
+        if (i < amount) {
+            process.stdout.write('\x1b[1A'); // Move up
+        }
+    }
+}
+function sIfNot1(count) {
+    return count == 1 ? "" : "s";
+}
+function if1Else(count, if1, or) {
+    return count == 1 ? if1 : or;
+}
+function makePath(...paths) {
+    return paths.join(path_1.default.sep).replaceAll(/[/\\]/g, path_1.default.sep);
+}
+function makeUnixPath(...paths) {
+    return paths.join("/").replaceAll("\\", "/");
+}
+function makeWindowsPath(...paths) {
+    return paths.join("\\").replaceAll("/", "\\");
+}
+function overflow(value, min, max) {
+    if (value < min) {
+        const gap = max - min + 1;
+        const minGap = min - value - 1;
+        return max - (minGap % gap);
+    }
+    if (max < value) {
+        const gap = max - min + 1;
+        const maxGap = value - max - 1;
+        return min + (maxGap % gap);
+    }
+    return value;
+}
+function overflow0(value, max) {
+    return overflow(value, 0, max);
+}
+function isWithin(value, min, max) {
+    return min <= value && value <= max;
+}
+//region Menu
+async function startShiftItemsMenu(items, itemValueMap, values, selectedIndex = 0, rainbow = true, itemToString = objectToString, valueToString = objectToString) {
+    if (values.length === 0) {
+        throw new Error("startShiftItemsMenu: No values to select from!");
+    }
+    const valueMemory = [];
+    for (const item of items) {
+        const value = getOrCreate(itemValueMap, item, () => values[0]);
+        const valueIndex = values.indexOf(value);
+        if (valueIndex === -1) {
+            itemValueMap.set(item, value);
+        }
+        valueMemory.push(valueIndex);
+    }
+    return startMenu(items, itemValueMap, selectedIndex, (selectedIndex, info, update, setSelectedIndex) => {
+        const item = items[selectedIndex];
+        let valueIndex = valueMemory[selectedIndex];
+        const result = shiftMenuItemsFunction(valueIndex, values, values[selectedIndex], info);
+        valueIndex = result.index;
+        valueMemory[selectedIndex] = valueIndex;
+        itemValueMap.set(item, result.value);
+        update();
+    }, rainbow, itemToString, valueToString);
+}
+function getRelativeOverflow(startIndex, values, moveBy) {
+    return values[overflow0(startIndex + moveBy, values.length - 1)];
+}
+function shiftMenuItemsFunction(valueIndex, values, value, info) {
+    if (valueIndex === -1) {
+        valueIndex = clamp0(values.indexOf(value), values.length - 1);
+    }
+    const moveBy = navigationKeysToNumber(info);
+    valueIndex = overflow0(valueIndex + moveBy, values.length - 1);
+    return {
+        value: values[valueIndex],
+        index: valueIndex
+    };
+}
+async function startNumbersEditMenu(items, itemValueMap, selectedIndex = 0, rainbow = true, itemToString = objectToString, valueToString = objectToString) {
+    getOrCreateFromKeys(itemValueMap, items, () => 0);
+    return startMenu(items, itemValueMap, selectedIndex, (selectedIndex, info, update, setSelectedIndex) => {
+        switch (info.name) {
+            // case 'w':
+            // case 's':
+            // {
+            //     const itemsRange = RangedNumber.arrayLimits(items)
+            //     setSelectedIndex(editNumberByInput(selectedIndex, info.name, itemsRange, info.ctrl, info.shift, info.meta))
+            //     update()
+            // }
+            // break
+            case 'left':
+            case 'right':
+            case 'a':
+            case 'd':
+                {
+                    const item = items[selectedIndex];
+                    const value = itemValueMap.get(item);
+                    const newValue = value + navigationKeysToNumber(info);
+                    if (newValue !== value) {
+                        itemValueMap.set(item, newValue);
+                        update();
+                    }
+                }
+        }
+    }, rainbow, itemToString, valueToString);
+}
+async function startMenu(items, itemValueMap, selectedIndex = 0, onKeyPress, rainbow = true, itemToString = objectToString, valueToString = objectToString) {
+    selectedIndex = clamp0(selectedIndex, items.length - 1);
+    return new Promise((resolve, reject) => {
+        if (items.length === 0) {
+            reject('startMenu: No items to select from!');
+            return;
+        }
+        const itemsRange = structs_1.RangedNumber.range(0, items.length - 1);
+        let item;
+        const update = () => {
+            item = items[selectedIndex];
+            setTerminalOutput(toMenuString(items, itemValueMap, selectedIndex, rainbow, itemToString, valueToString));
+        };
+        update();
+        readline.emitKeypressEvents(process.stdin);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.on('keypress', (ignore, info) => {
+            switch (info.name) {
+                case 'up':
+                case 'down':
+                case 'w':
+                case 's':
+                    {
+                        selectedIndex = editNumberByInput(selectedIndex, info.name, itemsRange, info.ctrl, info.shift, info.meta);
+                        update();
+                    }
+                    break;
+                case 'return':
+                case 'enter':
+                case 'escape':
+                    {
+                        process.stdin.removeAllListeners('keypress');
+                        if (process.stdin.isTTY) {
+                            process.stdin.setRawMode(false);
+                        }
+                        resolve(true);
+                        return;
+                    }
+                    break;
+                default:
+                    {
+                        onKeyPress(selectedIndex, info, update, (newIndex) => selectedIndex = newIndex);
+                    }
+                    break;
+            }
+        });
+    });
+}
+function navigationKeysToNumber(info) {
+    const key = info.name.toLowerCase();
+    switch (key) {
+        case 'up':
+        case 'down':
+        case 'w':
+        case 's':
+            {
+                const up = key === 'up' || key === 'w';
+                let moveBy = info.ctrl ? 25 : info.shift ? 5 : 1;
+                return up ? -moveBy : moveBy;
+            }
+        case 'left':
+        case 'right':
+        case 'a':
+        case 'd':
+            {
+                const left = key === 'left' || key === 'a';
+                let changeBy = (info.ctrl && info.shift) ? 1000 : info.ctrl ? 100 : info.shift ? 10 : 1;
+                return left ? -changeBy : changeBy;
+            }
+    }
+    return 0;
+}
+function editNumberByInput(value, key, overflowLimits, control = false, shift = false, meta = false) {
+    switch (key.toLowerCase()) {
+        case 'up':
+        case 'down':
+        case 'w':
+        case 's':
+            {
+                const up = key === 'up' || key === 'w';
+                let moveBy = control ? 25 : shift ? 5 : 1;
+                if (up) {
+                    moveBy = -moveBy;
+                }
+                value += moveBy;
+                if (overflowLimits) {
+                    value = overflow(value, overflowLimits.minValue, overflowLimits.maxValue);
+                }
+            }
+            break;
+        case 'left':
+        case 'right':
+        case 'a':
+        case 'd':
+            {
+                const left = key === 'left' || key === 'a';
+                let changeBy = (control && shift) ? 1000 : control ? 100 : shift ? 10 : 1;
+                if (left) {
+                    changeBy = -changeBy;
+                }
+                value += changeBy;
+            }
+            break;
+    }
+    return value;
+}
+const objectToString = (obj) => obj.toString();
+function toMenuString(items, itemValueMap, selectedIndex = 0, rainbow = true, itemToString = objectToString, valueToString = objectToString) {
+    let output = '';
+    let longest = 0;
+    for (const [item, value] of itemValueMap) {
+        const valueText = valueToString(value);
+        if (longest < valueText.length) {
+            longest = valueText.length;
+        }
+    }
+    let itemIndex = 0;
+    for (const [item, value] of itemValueMap) {
+        const selected = itemIndex === selectedIndex;
+        const prefix = selected ? '>' : fields_1.EMPTY;
+        const valueText = valueToString(value);
+        let itemText = `${prefix}${`[${padRight(valueText, longest, fields_1.EMPTY)}]`} | ${itemToString(item)}`;
+        if (selected) {
+            itemText = exports.chalk.bold(itemText);
+        }
+        if (rainbow) {
+            itemText = chalkRainbowColor(itemText, itemIndex);
+        }
+        output += `${itemText}\n`;
+        ++itemIndex;
+    }
+    return output.trim();
+}
+//endregion Menu
+function toPrintString(fileName, functionName, lineNumber) {
+    return `${timestamp()} ${exports.chalk.cyanBright(sliceOffNonProject(fileName).replaceAll("\\", "/"))}${functionName ? ` | ${exports.chalk.magentaBright(functionName)}` : ""}#${exports.chalk.greenBright(lineNumber)}`;
+}
+function print(message) {
+    message = message ? `: ${message}` : "";
+    const stack = new Error().stack;
+    if (stack) {
+        const lines = stack.split('\n');
+        if (lines.length > 2) {
+            const callerLine = lines[2].trim();
+            const match = callerLine.match(/at\s+(.*)\s+\((.*):(\d+):\d+\)/);
+            if (match) {
+                const [, functionName, fileName, lineNumber] = match;
+                console.log(`${toPrintString(fileName, functionName, lineNumber)}${message}`);
+            }
+            else {
+                const match2 = callerLine.match(/at\s+(.*):(\d+):\d+/);
+                if (match2) {
+                    const [, fileName, lineNumber] = match2;
+                    console.log(`${toPrintString(fileName, undefined, lineNumber)}${message}`);
+                }
+            }
+        }
+    }
+}
+function softToFixed(num, maxDecimals = 2) {
+    if (!isFinite(num)) {
+        return String(num);
+    }
+    const factor = Math.pow(10, maxDecimals);
+    const rounded = Math.round(num * factor) / factor;
+    return rounded.toString();
+}
+function extractEpisodeNumber(filename) {
+    const match = filename.match(/(?:e\s*)?(\d{1,3})(?!\d)/i);
+    return match ? parseInt(match[1], 10) : -1;
+}
+function trashSoft(filePath) {
+    if (!(0, fs_1.existsSync)(filePath)) {
+        return false;
+    }
+    const plat = (0, os_1.platform)();
+    try {
+        switch (plat) {
+            case "win32":
+                {
+                    (0, child_process_1.execSync)(`powershell -Command "Add-Type -AssemblyName Microsoft.VisualBasic; [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteFile('${filePath.replace(/'/g, "''")}', 'OnlyErrorDialogs', 'SendToRecycleBin')"`);
+                }
+                break;
+            case "darwin":
+                {
+                    (0, child_process_1.execSync)(`osascript -e 'tell app "Finder" to delete POSIX file "${filePath.replace(/"/g, '\\"')}"'`);
+                }
+                break;
+            default:
+                {
+                    try {
+                        (0, child_process_1.execSync)(`gio trash "${filePath.replace(/"/g, '\\"')}"`);
+                    }
+                    catch (_a) {
+                        (0, child_process_1.execSync)(`trash "${filePath.replace(/"/g, '\\"')}"`);
+                    }
+                }
+                break;
+        }
+    }
+    catch (e) {
+        (0, fs_1.rmSync)(filePath);
+    }
+    return true;
+}
+//region extensions
+const pictureExtensions = new Set([
+    'jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'tiff', 'tif',
+    'heif', 'heic', 'avif', 'svg', 'ico', 'raw', 'cr2', 'nef', 'orf', 'raf'
+]);
+const videoExtensions = new Set([
+    'mp4', 'mkv', 'mov', 'avi', 'wmv', 'flv', 'webm', 'm4v',
+    'mpeg', 'mpg', '3gp', 'ogv', 'ts', 'm2ts'
+]);
+const audioExtensions = new Set([
+    'mp3', 'wav', 'ogg', 'flac', 'aac', 'm4a', 'wma', 'opus',
+    'aiff', 'alac', 'mid', 'midi'
+]);
+const subtitleExtensions = new Set([
+    'srt', 'ass', 'ssa', 'vtt', 'sub', 'idx', 'sup', 'ttml'
+]);
+const fontExtensions = new Set([
+    'ttf', 'otf', 'woff', 'woff2', 'fon'
+]);
+const archiveExtensions = new Set([
+    'zip', 'rar', '7z', 'tar', 'gz', 'bz2', 'xz'
+]);
+const documentExtensions = new Set([
+    'txt', 'rtf', 'pdf', 'doc', 'docx', 'odt', 'md', 'html', 'htm',
+    'epub', 'djvu'
+]);
+const codeExtensions = new Set([
+    'ts', 'js', 'jsx', 'tsx', 'py', 'java', 'c', 'cpp', 'cs', 'php',
+    'rb', 'go', 'rs', 'swift', 'sh', 'bat', 'pl'
+]);
+const modelExtensions = new Set([
+    'obj', 'fbx', 'glb', 'gltf', 'stl', 'ply', '3ds', 'blend'
+]);
+const imageSequenceExtensions = new Set([
+    'dpx', 'exr', 'tga'
+]);
+function isOfType(extension, extensions) {
+    return extensions.has(extension);
+}
+// --- Exports ---
+const isPicture = (extension) => isOfType(extension, pictureExtensions);
+exports.isPicture = isPicture;
+const isVideo = (extension) => isOfType(extension, videoExtensions);
+exports.isVideo = isVideo;
+const isAudio = (extension) => isOfType(extension, audioExtensions);
+exports.isAudio = isAudio;
+const isSubtitle = (extension) => isOfType(extension, subtitleExtensions);
+exports.isSubtitle = isSubtitle;
+const isFont = (extension) => isOfType(extension, fontExtensions);
+exports.isFont = isFont;
+const isArchive = (extension) => isOfType(extension, archiveExtensions);
+exports.isArchive = isArchive;
+const isDocument = (extension) => isOfType(extension, documentExtensions);
+exports.isDocument = isDocument;
+const isCode = (extension) => isOfType(extension, codeExtensions);
+exports.isCode = isCode;
+const isModel = (extension) => isOfType(extension, modelExtensions);
+exports.isModel = isModel;
+const isImageSequence = (extension) => isOfType(extension, imageSequenceExtensions);
+exports.isImageSequence = isImageSequence;
+const classifyExt = (ext) => {
+    ext = ext.toLowerCase();
+    switch (true) {
+        case pictureExtensions.has(ext): return 'picture';
+        case videoExtensions.has(ext): return 'video';
+        case audioExtensions.has(ext): return 'audio';
+        case subtitleExtensions.has(ext): return 'subtitle';
+        case fontExtensions.has(ext): return 'font';
+        case archiveExtensions.has(ext): return 'archive';
+        case documentExtensions.has(ext): return 'document';
+        case codeExtensions.has(ext): return 'code';
+        case modelExtensions.has(ext): return '3d-model';
+        case imageSequenceExtensions.has(ext): return 'image-sequence';
+        default: return 'unknown';
+    }
+};
+exports.classifyExt = classifyExt;
+//endregion extensions
+function subtitlesStreamInfoToString(info) {
+    return `${info.language}:${info.streamIndex}`;
+}
+async function extractsubtitlesStreamsInfo(videoWithSubtitlesPath) {
+    const command = `ffmpeg -i "${sanitizeStringForFFMPEG(videoWithSubtitlesPath)}"`;
+    const result = await runCommandRejectAsResolve(command);
+    const subtitles = [];
+    for (const match of result.matchAll(fields_1.SUBTITLE_METADATA_REGEX)) {
+        let format = null;
+        const formatGroup1 = match[3].toLowerCase();
+        switch (formatGroup1) {
+            case "subrip":
+                {
+                    format = "srt";
+                }
+                break;
+            case "ass":
+                {
+                    format = "ass";
+                }
+                break;
+        }
+        if (format === null) {
+            const formatGroup2 = match[4].toLowerCase();
+            switch (formatGroup2) {
+                case "srt":
+                    {
+                        format = "srt";
+                    }
+                    break;
+                case "ssa":
+                    {
+                        format = "ass";
+                    }
+                    break;
+                default:
+                    {
+                        format = "sub";
+                    }
+            }
+        }
+        subtitles.push({
+            streamIndex: parseInt(match[1]),
+            language: match[2],
+            format: format,
+        });
+    }
+    return subtitles;
+}
+async function tryExtractSubtitles(videoWithSubtitlesPath, subtitlesOutputPath, streamId = 0) {
+    const command = `ffmpeg -y -i "${sanitizeStringForFFMPEG(videoWithSubtitlesPath)}" -map 0:${streamId} -c copy "${sanitizeStringForFFMPEG(subtitlesOutputPath)}"`;
+    try {
+        trashSoft(subtitlesOutputPath);
+        const result = await runCommand(command);
+        return true;
+    }
+    catch (e) {
+        trashSoft(subtitlesOutputPath);
+        // print(chalk.redBright(command))
+        return false;
+    }
+}
+async function addSubtitles(videoToAddSubtitlesToFile, subtitlesFile, customSubtitlesName = "", clearExistingSubtitles = false) {
+    const tempOutputFile = `${videoToAddSubtitlesToFile.directory}/temp_${videoToAddSubtitlesToFile.fullName}`;
+    trashSoft(tempOutputFile);
+    // let command = `ffmpeg -i "${sanitizeStringForFFMPEG(videoToAddSubtitlesToFile.path)}" -i "${sanitizeStringForFFMPEG(subtitlesFile.path)}" -c copy -map 0 -map 1`
+    let command = `ffmpeg -i "${sanitizeStringForFFMPEG(videoToAddSubtitlesToFile.path)}" -i "${sanitizeStringForFFMPEG(subtitlesFile.path)}" -map 0 -map 1`;
+    if (clearExistingSubtitles) {
+        command += ` -map -0:s`;
+    }
+    command += ` -c copy`;
+    if (customSubtitlesName.length > 0) {
+        command += ` -metadata:s:s:0 title="${customSubtitlesName}"`;
+    }
+    command += ` "${sanitizeStringForFFMPEG(tempOutputFile)}"`;
+    try {
+        await runCommand(command);
+    }
+    catch (e) {
+        trashSoft(tempOutputFile);
+        return false;
+    }
+    trashSoft(videoToAddSubtitlesToFile.path);
+    (0, fs_1.renameSync)(tempOutputFile, videoToAddSubtitlesToFile.path);
+    return true;
+}
+//# sourceMappingURL=util.js.map