ahegao 1.69.1

package/dist/types/classes.js

@@ -0,0 +1,851 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextComp = exports.WeightedMap = exports.Config = exports.Lockable = exports.NumbersAnalysis = exports.NumberAnalysis = exports.Timer = exports.BoundedDeque = exports.Compare = exports.MUSIC_ALIASES = exports.Aliases = exports.TitleAndArtists = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const structs_1 = require("../structures/structs");
+const util_1 = require("../utils/util");
+const fields_1 = require("./fields");
+const mathjs_1 = require("mathjs");
+class TitleAndArtists {
+    constructor(artists, artist, title) {
+        this.artists = artists;
+        this.artist = artist;
+        this.title = title;
+        this.sanitized_for_seed_artist = (0, util_1.sanitizeStringForSeed)(this.artist);
+        this.sanitized_for_seed_title = (0, util_1.sanitizeStringForSeed)(title);
+        this.seed = `${this.sanitized_for_seed_artist} ${this.sanitized_for_seed_title}`.trim();
+        this.hash = (0, util_1.generateHash)(this.seed);
+    }
+    get artistsDashTitle() {
+        return `${this.artist} - ${this.title}`;
+    }
+    async findGeniusLyrics() {
+        let lyrics = await (0, util_1.findGeniusLyrics)(this.artistsDashTitle);
+        if (this.artists.length > 1) {
+            if (lyrics == undefined || lyrics.length == 0) {
+                for (const artist of this.artists) {
+                    const geniusLyrics = await (0, util_1.findGeniusLyrics)(`${artist} - ${this.title}`);
+                    if (geniusLyrics != undefined && geniusLyrics.length > 0) {
+                        lyrics = geniusLyrics;
+                        break;
+                    }
+                }
+            }
+        }
+        return lyrics;
+    }
+}
+exports.TitleAndArtists = TitleAndArtists;
+(function (TitleAndArtists) {
+    async function fromFileInfo(fileInfo, aliases = exports.MUSIC_ALIASES) {
+        let name = fileInfo.name;
+        const tags = await util_1.musicMetadata.parseFile(fileInfo.path);
+        const artists = (0, util_1.getArtistsFromFlacMetadata)(tags, aliases);
+        let artistsArray = Array.from(artists);
+        artistsArray.sort();
+        let artistsString = artistsArray.join(" & ");
+        let title = (0, util_1.getTitleFromFlacMetadata)(tags).replaceAll("[", "(").replaceAll("]", ")");
+        //region no artists / Various Artists
+        if (name.includes(" - ")) {
+            if (artistsString.length == 0 || artistsString === fields_1.VARIOUS_ARTISTS) {
+                artistsString = (0, util_1.songTitleExtractSide)(name, true, false);
+                if (artistsString.includes(" - ")) {
+                    artistsString = (0, util_1.songTitleExtractSide)(artistsString, true, true);
+                }
+                (0, util_1.addAllArrayToSet)((0, util_1.librarySplitMultipleArtists)(artistsString, aliases), artists);
+                artists.delete(fields_1.VARIOUS_ARTISTS);
+                artistsArray = Array.from(artists);
+                artistsString = artistsArray.join(" & ");
+            }
+        }
+        if (title.length == 0 || title.includes(" - ")) {
+            title = (0, util_1.songTitleExtractSide)(name, true, true);
+        }
+        const titleFeaturingResult = (0, util_1.libraryFindFeaturing)(title, aliases);
+        title = (0, util_1.libraryCleanUpStartAndEndOfString)(titleFeaturingResult.newName);
+        return new TitleAndArtists(artistsArray, artistsString, title);
+    }
+    TitleAndArtists.fromFileInfo = fromFileInfo;
+})(TitleAndArtists || (exports.TitleAndArtists = TitleAndArtists = {}));
+class Aliases {
+    constructor() {
+        this.reverseAliases = new Map;
+    }
+    add(name, ...aliases) {
+        aliases.push(name);
+        for (const alias of aliases) {
+            this.reverseAliases.set(alias.trim().toLowerCase(), name.trim());
+        }
+        return this;
+    }
+    get(name) {
+        var _a;
+        return (_a = this.reverseAliases.get(name.trim().toLowerCase())) !== null && _a !== void 0 ? _a : name;
+    }
+}
+exports.Aliases = Aliases;
+exports.MUSIC_ALIASES = new Aliases()
+    .add(fields_1.VARIOUS_ARTISTS)
+    .add("artist_lost_please_fix", "AReallyLongAndAwesomeNameThatIsBetterThanYoursInEveryPossibleWay", "Original")
+    .add("Vylet Pony", "Vylet", "VyletPony")
+    .add("General Mumble", "Mumble", "GeneralMumble", "GM")
+    .add("&I", "I", "&I (AndI)", "AndI")
+    .add("Alex S.", "AlexS", "Alex S", "Alex.", "andromulus")
+    .add("4EverfreeBrony", "4EverfreeBrony")
+    .add("Additive Subtractive", "AdditiveSubtractive")
+    .add("Age Of Vinyl", "Age Of Vinyl")
+    .add("All Levels At Once", "All Levels At Once")
+    .add("Archie", "Archie (Second Channel)", "Archie.V")
+    .add("Artémis Plume", "Artémis Plum")
+    .add("Assertive Fluttershy", "AssertiveFluttershy", "Assertive")
+    .add("Awkward Marina", "AwkwardMarina")
+    .add("Black Gryph0n", "BlackGryph0n")
+    .add("BriLizy T", "BriLizyT")
+    .add("Brilliant Venture", "Brilliant Ventures")
+    .add("Camellia", "Camelia")
+    .add("Chi-Chi", "Chi-Chi", "Chi Chi")
+    .add("Chord Catcher", "ChordCatcher")
+    .add("Cyril the Wolf", "Cyril The Wolf", "CyrilTheWolf")
+    .add("DE$iGNATED", "DE$iGNATED 2k13")
+    .add("Dauntless Dan", "Dauntless")
+    .add("Dijit", "Dijit DJT", "Dijit | DJT", "DJT")
+    .add("EnsionD", "Ension")
+    .add("Errar404", "Error 404", "Error404")
+    .add("FIREeNVY")
+    .add("FluffyKittyMusic", "FluffyKitty")
+    .add("GROskAr")
+    .add("Giggly Maria", "GigglyMaria")
+    .add("GloryOfTheRainWings", "Glory of the Rainwings")
+    .add("JackleApp", "Jackle App")
+    .add("KLBI", "KLBI VIP")
+    .add("KeepOnRockin'", "KeeponRockin'")
+    .add("MC-Arch", "MC Arch")
+    .add("Maikel631", "Maikel6311")
+    .add("MandoPony")
+    .add("Metapony", "Meta Pony")
+    .add("Mic the Microphone")
+    .add("Daniel Ingram", "My Little Pony", "My Little Pony Official")
+    .add("N. Hollow", "N.Hollow")
+    .add("Neu KatalYst")
+    .add("NeverLastStanding")
+    .add("Nikki Layne", "Nikki-Layne")
+    .add("Ponies at Dawn")
+    .add("Relative1Pitch", "Relative|Pitch")
+    .add("Rina-Chan", "Rina Chan", "Rina-Chan - Human")
+    .add("RoseDoodle")
+    .add("SP1TF1R3", "SP1TF1RE")
+    .add("Sam Quak Brony")
+    .add("Scraton", "Scraton Music Official")
+    .add("Senntenial", "Senntennial")
+    .add("Seshlehem", "Seshleshem")
+    .add("SeyN AQ")
+    .add("Sherclop Pones", "SherclopPones")
+    .add("Sim Gretina", "SimGretina")
+    .add("SoGreatAndPowerful")
+    .add("StealingShad3z")
+    .add("Synthion", "Synthion Ch")
+    .add("Thomas H.", "Thomas H")
+    .add("Tw3Lv3")
+    .add("Velvet R. Wings", "Velvet Wings")
+    .add("WoodenToaster", "Wooden Toaster")
+    .add("YOKAIII", "YOKAII", "YOKAI")
+    .add("saradisk", "saradisk - 220")
+    .add("アイスベア", "アイスベア (Ice Bear)")
+    .add("ArtAttack", "Art Attack")
+    .add("Krewella", "Krewella Fuck On Me")
+    .add("Replacer", "Replacer &I")
+    .add("Tune Up", "Tune Up!")
+    .add("µThunder")
+    .add("MC-Arch", "MC - Arch")
+    .add("Forest Rain", "ForestRain", "Forest Rain Covers")
+    .add("IgnaPon3", "IgnaPone", "IgnaPony", "Igna")
+    .add("Sam Synthis", "Synthis");
+var Compare;
+(function (Compare) {
+    let NumberCompareOperator;
+    (function (NumberCompareOperator) {
+        NumberCompareOperator["Equal"] = "equal";
+        NumberCompareOperator["NotEqual"] = "not_equal";
+        NumberCompareOperator["GreaterThan"] = "greater_than";
+        NumberCompareOperator["GreaterThanOrEqual"] = "greater_than_or_equal";
+        NumberCompareOperator["LessThan"] = "less_than";
+        NumberCompareOperator["LessThanOrEqual"] = "less_than_or_equal";
+    })(NumberCompareOperator = Compare.NumberCompareOperator || (Compare.NumberCompareOperator = {}));
+    let StringCompareOperator;
+    (function (StringCompareOperator) {
+        StringCompareOperator["Equal"] = "equal";
+        StringCompareOperator["NotEqual"] = "not_equal";
+        StringCompareOperator["Contains"] = "contains";
+        StringCompareOperator["NotContains"] = "not_contains";
+        StringCompareOperator["StartsWith"] = "starts_with";
+        StringCompareOperator["EndsWith"] = "ends_with";
+    })(StringCompareOperator = Compare.StringCompareOperator || (Compare.StringCompareOperator = {}));
+    function fromString(input) {
+        switch (input) {
+            case "equal":
+            case "eq":
+                return NumberCompareOperator.Equal;
+            case "not_equal":
+            case "neq":
+            case "!=":
+                return NumberCompareOperator.NotEqual;
+            case "greater_than":
+            case "gt":
+            case ">":
+                return NumberCompareOperator.GreaterThan;
+            case "greater_than_or_equal":
+            case "gte":
+            case ">=":
+                return NumberCompareOperator.GreaterThanOrEqual;
+            case "less_than":
+            case "lt":
+            case "<":
+                return NumberCompareOperator.LessThan;
+            case "less_than_or_equal":
+            case "lte":
+            case "<=":
+                return NumberCompareOperator.LessThanOrEqual;
+            case "contains":
+            case "in":
+                return StringCompareOperator.Contains;
+            case "starts_with":
+            case "starts":
+                return StringCompareOperator.StartsWith;
+            case "ends_with":
+            case "ends":
+                return StringCompareOperator.EndsWith;
+            case "not_contains":
+            case "not_in":
+                return StringCompareOperator.NotContains;
+            default:
+                throw new Error(`Unknown operator: ${input}`);
+        }
+    }
+    Compare.fromString = fromString;
+    function compare(value, operator) {
+        if ((0, util_1.isString)(value)) {
+            return string(value, operator);
+        }
+        else {
+            return number(value, operator);
+        }
+    }
+    Compare.compare = compare;
+    function number(value, operator) {
+        switch (operator) {
+            case NumberCompareOperator.Equal:
+                return value == value;
+            case NumberCompareOperator.NotEqual:
+                return value != value;
+            case NumberCompareOperator.GreaterThan:
+                return value > value;
+            case NumberCompareOperator.GreaterThanOrEqual:
+                return value >= value;
+            case NumberCompareOperator.LessThan:
+                return value < value;
+            case NumberCompareOperator.LessThanOrEqual:
+                return value <= value;
+        }
+    }
+    Compare.number = number;
+    function string(value, operator) {
+        switch (operator) {
+            case StringCompareOperator.Equal:
+                return value == value;
+            case StringCompareOperator.NotEqual:
+                return value != value;
+            case StringCompareOperator.Contains:
+                return value.includes(value);
+            case StringCompareOperator.StartsWith:
+                return value.startsWith(value);
+            case StringCompareOperator.EndsWith:
+                return value.endsWith(value);
+            case StringCompareOperator.NotContains:
+                return !value.includes(value);
+        }
+    }
+    Compare.string = string;
+})(Compare || (exports.Compare = Compare = {}));
+class BoundedDeque {
+    constructor(maxSize) {
+        this.maxSize = maxSize;
+        this.queue = [];
+        if (maxSize < 1)
+            throw new Error("Max size must be at least 1!");
+    }
+    pushEnd(item) {
+        this.queue.push(item);
+        this.trimFrontIfNeeded();
+    }
+    pushFront(item) {
+        this.queue.unshift(item);
+        this.trimBackIfNeeded();
+    }
+    popEnd() {
+        return this.queue.pop();
+    }
+    popFront() {
+        return this.queue.shift();
+    }
+    peekFront() {
+        return this.queue[0];
+    }
+    peekEnd() {
+        return (0, util_1.getLast)(this.queue);
+    }
+    get size() {
+        return this.queue.length;
+    }
+    isEmpty() {
+        return this.queue.length == 0;
+    }
+    isFull() {
+        return this.queue.length == this.maxSize;
+    }
+    clear() {
+        this.queue = [];
+    }
+    toArray() {
+        return [...this.queue];
+    }
+    get array() {
+        return this.queue;
+    }
+    trimFrontIfNeeded() {
+        while (this.queue.length > this.maxSize) {
+            this.queue.shift();
+        }
+    }
+    trimBackIfNeeded() {
+        while (this.queue.length > this.maxSize) {
+            this.queue.pop();
+        }
+    }
+}
+exports.BoundedDeque = BoundedDeque;
+class Timer {
+    constructor() {
+        this._startMs = 0;
+        this._lastIncrementMs = 0;
+        this._count = 0;
+        this.updateLoadingBar = util_1.noop;
+        this.reset();
+    }
+    reset() {
+        this._startMs = Date.now();
+        this._lastIncrementMs = this._startMs;
+        this._count = 0;
+    }
+    get startMs() {
+        return this._startMs;
+    }
+    get elapsedMs() {
+        return Date.now() - this._startMs;
+    }
+    get elapsedS() {
+        return this.elapsedMs / 1000;
+    }
+    increment(incrementBy = 1, updateLoadingBar = false) {
+        this._count += incrementBy;
+        this._lastIncrementMs = Date.now();
+        if (updateLoadingBar) {
+            this.updateLoadingBar();
+        }
+        return this._count;
+    }
+    get lastIncrementMs() {
+        return this._lastIncrementMs;
+    }
+    get lastIncrementGapMs() {
+        return Date.now() - this._lastIncrementMs;
+    }
+    get lastIncrementGapS() {
+        return this.lastIncrementGapMs / 1000;
+    }
+    get count() {
+        return this._count;
+    }
+    get countPerSecond() {
+        return this._count / this.elapsedS;
+    }
+    get countPerSecondString() {
+        return `${(0, util_1.softToFixed)(this.countPerSecond)}/s`;
+    }
+    isFinished(goalCount) {
+        return goalCount <= this._count;
+    }
+    getETASecondsForCount(goalCount) {
+        return (goalCount - this._count) / this.countPerSecond;
+    }
+    getETASecondsForCountString(goalCount) {
+        return (0, util_1.toStamp)(this.getETASecondsForCount(goalCount));
+    }
+    getCountAndPercentString(goalCount) {
+        if (this._count == 0) {
+            return `[0/${(0, util_1.softToFixed)(goalCount)}]~[0.00%]`;
+        }
+        const percent = (this._count / goalCount) * 100;
+        return `[${(0, util_1.softToFixed)(this.count)}/${(0, util_1.softToFixed)(goalCount)}]~[${(percent).toFixed(2)}%]`;
+    }
+    getFullStatsString(goalCount) {
+        if (this._count == 0) {
+            return this.getCountAndPercentString(goalCount);
+        }
+        return `${this.getCountAndPercentString(goalCount)} | ${this.getETASecondsForCountString(goalCount)} | ${this.countPerSecondString}`;
+    }
+    startLoadingBarForS(durationS, suffixDecider = "", onFinish = util_1.noop, intervalMs = 250, rainbowIntervalMs = 250) {
+        this.reset();
+        const loop = this.startLoadingBarUntilDone(durationS, suffixDecider, onFinish, false, intervalMs, rainbowIntervalMs);
+        let secondsPassed = 0;
+        let finished = false;
+        (0, util_1.whileFalseAsyncMs)(intervalMs, () => {
+            this.increment(secondsPassed - this._count);
+            return finished;
+        });
+        (0, util_1.whileFalseAsyncS)(1, () => {
+            ++secondsPassed;
+            if (durationS <= secondsPassed) {
+                finished = true;
+            }
+            return finished;
+        });
+        return loop;
+    }
+    startLoadingBarUntilDone(goalCountDecider, suffixDecider = "", onFinish = util_1.noop, fullStats = true, intervalMs = 250, rainbowIntervalMs = 1000) {
+        const cycleRainbowEveryMs = (0, mathjs_1.max)(rainbowIntervalMs, intervalMs);
+        const goalCountIsNumber = (0, mathjs_1.isNumber)(goalCountDecider);
+        const suffixIsString = (0, util_1.isString)(suffixDecider);
+        this.updateLoadingBar = () => {
+            const goalCount = goalCountIsNumber ? goalCountDecider : goalCountDecider();
+            const finished = goalCount <= this._count;
+            if (finished) {
+                clearInterval(loop);
+            }
+            const suffix = suffixIsString ? suffixDecider : suffixDecider();
+            let line = fullStats ? this.getFullStatsString(goalCount) : this.getCountAndPercentString(goalCount);
+            if (suffix.length > 0) {
+                line += ` | ${suffix}`;
+            }
+            const rainbowIndex = (0, mathjs_1.floor)(Date.now() / cycleRainbowEveryMs);
+            if (rainbowIntervalMs > 0) {
+                line = (0, util_1.chalkRainbowColor)(line, rainbowIndex);
+            }
+            (0, util_1.replaceLastTerminalLine)(line);
+            if (finished) {
+                console.log((0, util_1.chalkRainbowColor)(` | Finished!`, rainbowIndex));
+                this.updateLoadingBar = util_1.noop;
+                onFinish();
+            }
+        };
+        const loop = setInterval(() => {
+            this.updateLoadingBar();
+        }, intervalMs);
+        return loop;
+    }
+    startReplaceLastTerminalLineLoop(stringMaker, intervalMs = 250) {
+        return setInterval(() => {
+            (0, util_1.replaceLastTerminalLine)(stringMaker());
+        }, intervalMs);
+    }
+}
+exports.Timer = Timer;
+// export class SmartTimer extends Timer
+// {
+//     private _lookbackHistoryMs: BoundedDeque<number>
+//     public constructor(public readonly lookBackCount: number = 10)
+//     {
+//         super()
+//         this._lookbackHistoryMs = new BoundedDeque(lookBackCount)
+//     }
+//     public override increment(incrementBy?: number): number
+//     {
+//     }
+// }
+class NumberAnalysis {
+    constructor(values = fields_1.EMPTY_ARRAY) {
+        this._lowest = Number.MAX_VALUE;
+        this._highest = Number.MIN_VALUE;
+        this.updateArray(values);
+    }
+    updateArray(buffer) {
+        for (const byte of buffer) {
+            this.update(byte);
+        }
+    }
+    update(value) {
+        if (value < this._lowest) {
+            this._lowest = value;
+        }
+        else if (this._highest < value) {
+            this._highest = value;
+        }
+    }
+    get lowest() {
+        return this._lowest;
+    }
+    get highest() {
+        return this._highest;
+    }
+    forEachLowestFirst(consumer) {
+        for (let y = this._lowest; y <= this._highest; ++y) {
+            consumer(y);
+        }
+    }
+    forEachHighestFirst(consumer) {
+        for (let y = this._highest; y >= this._lowest; --y) {
+            consumer(y);
+        }
+    }
+    forEach(lowestFirst, consumer) {
+        if (lowestFirst) {
+            this.forEachLowestFirst(consumer);
+        }
+        else {
+            this.forEachHighestFirst(consumer);
+        }
+    }
+    get gap() {
+        return this._highest - this._lowest;
+    }
+    toRangedNumber() {
+        return structs_1.RangedNumber.range(this._lowest, this._highest);
+    }
+    toString() {
+        return `${this._lowest}<->${this._highest}`;
+    }
+}
+exports.NumberAnalysis = NumberAnalysis;
+class NumbersAnalysis extends NumberAnalysis {
+    constructor(values = fields_1.EMPTY_ARRAY) {
+        super(fields_1.EMPTY_ARRAY);
+        this._sum = 0;
+        this.array = [];
+        this.map = new Map();
+        this.updateArray(values);
+    }
+    update(value) {
+        super.update(value);
+        (0, util_1.incrementMap)(this.map, value);
+        this.array.push(value);
+        this._sum += value;
+    }
+    get average() {
+        return this._sum / this.count;
+    }
+    get sum() {
+        return this._sum;
+    }
+    get count() {
+        return this.array.length;
+    }
+    sortedArray(ascending = false) {
+        return this.array.slice().sort((a, b) => ascending ? a - b : b - a);
+    }
+    get median() {
+        if (this.count == 0) {
+            return 0;
+        }
+        const sorted = this.sortedArray();
+        const middle = Math.floor(this.count / 2);
+        if (this.count % 2 == 0) {
+            return (sorted[middle - 1] + sorted[middle]) / 2;
+        }
+        else {
+            return sorted[middle];
+        }
+    }
+    getSortedFrequencyKeys(ascending = false) {
+        return Array.from(this.map.keys()).sort((a, b) => ascending ? a - b : b - a);
+    }
+    toString() {
+        let text = `[${this.lowest}<->${this.highest} | count: ${this.count} | sum: ${this._sum} | average: ${(0, util_1.softToFixed)(this.average)} | median: ${this.median}]`;
+        for (const key of this.getSortedFrequencyKeys()) {
+            text += `\n- ${key}: ${this.map.get(key)}`;
+        }
+        return text;
+    }
+}
+exports.NumbersAnalysis = NumbersAnalysis;
+class Lockable {
+    constructor(item) {
+        this._locked = false;
+        this._item = item;
+    }
+    get item() {
+        return this._item;
+    }
+    set item(item) {
+        if (this._locked) {
+            throw new Error("Cannot set item, object is locked.");
+        }
+        this._item = item;
+    }
+    get locked() {
+        return this._locked;
+    }
+    set locked(locked) {
+        this._locked = locked;
+    }
+    set(item) {
+        this.item = item;
+    }
+    get() {
+        return this._item;
+    }
+    lock() {
+        this._locked = true;
+    }
+    unlock() {
+        this._locked = false;
+    }
+    toString() {
+        return `${this._item}`;
+    }
+}
+exports.Lockable = Lockable;
+class Config {
+    constructor(configPath = `${path_1.default.resolve(__dirname, "..")}/config.json`) {
+        this.configPath = configPath;
+        this._init = false;
+        this._config = {};
+        this.basePath = path_1.default.resolve(__dirname, "..");
+        this.name = path_1.default.basename(configPath);
+    }
+    get isInit() {
+        return this._init;
+    }
+    throwIfNotInit() {
+        if (!this._init) {
+            throw `Config\n"${this}"\nIs not initialized`;
+        }
+    }
+    throwIfInit(error = `${this}\nIs already initialized`) {
+        if (this._init) {
+            throw error;
+        }
+    }
+    define(key, value) {
+        this.throwIfInit(`Config\n"${this}"\nTried to define "${key}" with value "${value}" after initialization`);
+        const existingValue = this._config[key];
+        if (existingValue != null) {
+            throw `${this}\nValue "${key}" already defined: ${existingValue}`;
+        }
+        this._config[key] = value;
+        return this;
+    }
+    get(key) {
+        this.throwIfNotInit();
+        return this._config[key];
+    }
+    getString(key) {
+        return this.get(key);
+    }
+    getNumber(key) {
+        return this.get(key);
+    }
+    getBool(key) {
+        return this.is(key);
+    }
+    is(key) {
+        this.throwIfNotInit();
+        return this.get(key);
+    }
+    set(key, value) {
+        this.throwIfNotInit();
+        return this._set(key, value);
+    }
+    _set(key, value) {
+        const currentValue = this._config[key];
+        if (currentValue != null) {
+            if (typeof (value) !== typeof (currentValue)) {
+                throw `${this}\nValue type mismatch for key ${key}: expected ${typeof (this._config[key])}, got ${typeof (value)}`;
+            }
+        }
+        else {
+            throw `${this}\nKey "${key}" is not defined`;
+        }
+        this._config[key] = value;
+        return this;
+    }
+    init() {
+        this.throwIfInit();
+        if ((0, fs_1.existsSync)(this.configPath)) {
+            const localConfigJson = require(this.configPath);
+            for (const [key, value] of Object.entries(localConfigJson)) {
+                const defaultValue = this._config[key];
+                if (defaultValue == null) {
+                    console.warn(`${this}\nReading undefined config "${key}"`);
+                }
+                if (typeof (value) !== typeof (defaultValue)) {
+                    throw `${this}\nValue type mismatch for key ${key}: expected ${typeof (defaultValue)}, got ${typeof (value)}`;
+                }
+                this._set(key, value);
+            }
+        }
+        this.save();
+        this._init = true;
+        return this;
+    }
+    save() {
+        const configJson = (0, util_1.stringify)(this._config);
+        (0, fs_1.writeFileSync)(this.configPath, configJson);
+        return this;
+    }
+    toString() {
+        let result = `Config "${this.name}"\n`;
+        for (const [key, value] of Object.entries(this._config)) {
+            result += `"${key}": "${value}"\n`;
+        }
+        return result;
+    }
+}
+exports.Config = Config;
+class WeightedMap {
+    constructor() {
+        this._map = new Map();
+        this._totalWeight = 0;
+    }
+    add(item, weight = 1) {
+        if (weight <= 0) {
+            throw `${this}: Cannot add "${item}"; weight <= 0`;
+        }
+        this._map.set(item, weight);
+        this._totalWeight += weight;
+        return this;
+    }
+    get() {
+        if (this.empty) {
+            throw `${this}: Cannot get item; map is empty`;
+        }
+        const item = (0, util_1.getRandomWeighedItem)(this._map, this._totalWeight);
+        if (item == null) {
+            throw `${this}: Got ${item} item`;
+        }
+        return item;
+    }
+    get empty() {
+        return this.size == 0;
+    }
+    get hasItems() {
+        return this.size > 0;
+    }
+    get size() {
+        return this._map.size;
+    }
+}
+exports.WeightedMap = WeightedMap;
+(function (WeightedMap) {
+    function of(input) {
+        const weightedMap = new WeightedMap;
+        if ((0, mathjs_1.isArray)(input)) {
+            for (const item of input) {
+                weightedMap.add(item);
+            }
+        }
+        else {
+            weightedMap.add(input);
+        }
+        return weightedMap;
+    }
+    WeightedMap.of = of;
+})(WeightedMap || (exports.WeightedMap = WeightedMap = {}));
+class TextComp {
+    constructor(data) {
+        var _a, _b;
+        if (data == null) {
+            this._children = new WeightedMap;
+            throw `${this}: Cannot create TextComp from null`;
+        }
+        this.text = data.text == undefined ? "" : data.text.trim();
+        this.chance = (_a = data.chance) !== null && _a !== void 0 ? _a : 1;
+        this.continueToChildOnFail = (_b = data.continueToChildOnFail) !== null && _b !== void 0 ? _b : false;
+        if (data.children == undefined) {
+            this._children = new WeightedMap;
+        }
+        else {
+            if (data.children instanceof WeightedMap) {
+                this._children = data.children;
+            }
+            else {
+                this._children = new WeightedMap;
+                if ((0, mathjs_1.isArray)(data.children)) {
+                    for (const child of data.children) {
+                        this._children.add(TextComp.of(child));
+                    }
+                }
+                else {
+                    this._children.add(TextComp.of(data.children));
+                }
+            }
+        }
+    }
+    get hasChildren() {
+        return this._children.hasItems;
+    }
+    getRandomChild() {
+        return this._children.get();
+    }
+    generate(lookup = fields_1.EMPTY_MAP, separator = " ", text = "") {
+        if ((0, util_1.randomBoolean)(this.chance)) {
+            if (this.text.length > 0) {
+                text += `${text.length > 0 ? separator : ""}${this.text.replaceAll(fields_1.KEY_WORDS_REGEX, (_, match) => {
+                    const lookupItem = lookup.get(match);
+                    if (lookupItem == null) {
+                        return match;
+                    }
+                    if (lookupItem.empty) {
+                        return match;
+                    }
+                    return TextComp.of(lookupItem.get()).generate(lookup, separator);
+                })}`;
+            }
+        }
+        else {
+            if (!this.continueToChildOnFail) {
+                return text;
+            }
+        }
+        if (this._children.hasItems) {
+            const child = this.getRandomChild();
+            return child.generate(lookup, separator, text);
+        }
+        return text;
+    }
+    toString() {
+        return `TextComp: "${this.text}" | chance: ${this.chance} | children: ${this._children.size}`;
+    }
+}
+exports.TextComp = TextComp;
+(function (TextComp) {
+    function of(item) {
+        if ((0, util_1.isString)(item)) {
+            return TextComp.of({ text: item });
+        }
+        else if (item instanceof TextComp) {
+            return item;
+        }
+        else {
+            return new TextComp(item);
+        }
+    }
+    TextComp.of = of;
+})(TextComp || (exports.TextComp = TextComp = {}));
+// export abstract class ConfigEntry<T>
+// {
+//     constructor
+//     (
+//         public readonly name: string,
+//         public readonly defaultValue: T,
+//         public readonly description: string = "",
+//     )
+//     {
+//     }
+// }
+// export class Config
+// {
+// }
+//# sourceMappingURL=classes.js.map