maidraw 0.8.8 → 0.9.0

package/dist/mai/lib/kamaiTachi/index.js

@@ -3,15 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KamaiTachi = void 0;
+exports.KamaiTachiBuilder = exports.KamaiTachi = void 0;
 const type_1 = require("../../type");
 const __1 = __importDefault(require(".."));
 const best50_1 = require("../../best50");
+const chart_1 = require("../../chart");
 class KamaiTachi extends __1.default {
-    CURRENT_VERSION;
-    constructor({ baseURL = "https://kamai.tachi.ac/", currentVersion = KamaiTachi.EGameVersions.PRISM, } = {}) {
+    currentVersion;
+    currentRegion;
+    constructor({ baseURL = "https://kamai.tachi.ac/", version = KamaiTachi.GameVersions.PRISM, region = "DX", } = {}) {
         super({ baseURL });
-        this.CURRENT_VERSION = currentVersion;
+        this.currentVersion = version;
+        this.currentRegion = region;
+    }
+    versions() {
+        return new KamaiTachiBuilder();
     }
     async getPlayerPB(userId) {
         return this.get(`/api/v1/users/${userId}/games/maimaidx/Single/pbs/all`, undefined, 60 * 1000);
@@ -110,26 +116,64 @@ class KamaiTachi extends __1.default {
             })(),
         };
     }
-    async getPlayerBest50(userId, { currentVersion = this.CURRENT_VERSION, omnimix = true, use = "ALL", } = {}) {
-        function APFilter(score) {
+    async getPlayerBest50(userId, { omnimix = true, use = "ALL", } = {}) {
+        function filterAP(score) {
             return (score.pb.scoreData.lamp == "ALL PERFECT" ||
                 score.pb.scoreData.lamp == "ALL PERFECT+");
         }
-        function FCFilter(score) {
+        function filterFC(score) {
             return (score.pb.scoreData.lamp == "FULL COMBO" ||
                 score.pb.scoreData.lamp == "FULL COMBO+");
         }
-        function useFilter(score) {
+        function filterUseAchievementFilter(score) {
             switch (use) {
                 case "AP":
-                    return APFilter(score);
+                    return filterFC(score);
                 case "FC":
-                    return APFilter(score) || FCFilter(score);
+                    return filterAP(score) || filterFC(score);
                 case "ALL":
                 default:
                     return true;
             }
         }
+        const filterIsLocalChartNewVersion = (score) => {
+            return (chart_1.Chart.Database.getLocalChart(score.chart.data.inGameID, (() => {
+                switch (true) {
+                    case score.chart.difficulty.includes("RE:MASTER"):
+                        return type_1.EDifficulty.REMASTER;
+                    case score.chart.difficulty.includes("MASTER"):
+                        return type_1.EDifficulty.MASTER;
+                    case score.chart.difficulty.includes("EXPERT"):
+                        return type_1.EDifficulty.EXPERT;
+                    case score.chart.difficulty.includes("ADVANCED"):
+                        return type_1.EDifficulty.ADVANCED;
+                    case score.chart.difficulty.includes("BASIC"):
+                    default:
+                        return type_1.EDifficulty.BASIC;
+                }
+            })())?.addVersion[this.currentRegion]?.name ==
+                this.currentVersion[this.currentRegion]);
+        };
+        const filterIsLocalChartOldVersion = (score) => {
+            const addVersion = chart_1.Chart.Database.getLocalChart(score.chart.data.inGameID, (() => {
+                switch (true) {
+                    case score.chart.difficulty.includes("RE:MASTER"):
+                        return type_1.EDifficulty.REMASTER;
+                    case score.chart.difficulty.includes("MASTER"):
+                        return type_1.EDifficulty.MASTER;
+                    case score.chart.difficulty.includes("EXPERT"):
+                        return type_1.EDifficulty.EXPERT;
+                    case score.chart.difficulty.includes("ADVANCED"):
+                        return type_1.EDifficulty.ADVANCED;
+                    case score.chart.difficulty.includes("BASIC"):
+                    default:
+                        return type_1.EDifficulty.BASIC;
+                }
+            })())?.addVersion[this.currentRegion]?.name;
+            if (!addVersion)
+                return false;
+            return (KamaiTachi.compareGameVersions(this.currentVersion, KamaiTachi.getGameVersion(addVersion)) > 0);
+        };
         const rawPBs = await this.getPlayerPB(userId);
         if (!rawPBs?.body)
             return null;
@@ -141,22 +185,27 @@ class KamaiTachi extends __1.default {
                 pbs.push({ pb, chart, song });
             }
         }
-        const newScores = pbs
-            .filter((v) => v.chart.data.displayVersion == currentVersion // Assume new scores does not have omnimix charts.
-        )
-            .filter(useFilter);
-        const oldScores = pbs
-            .filter((v) => 
-        // Chart exists
-        v.chart &&
-            // Chart version is older than current Version
-            KamaiTachi.compareGameVersions(currentVersion, v.chart.data.displayVersion) > 0 &&
-            (omnimix || // Omnimix is enabled, all charts are included.
-                !((v.chart.versions[0].includes("-omni") && // Alternatively, if omnimix is disabled, check if the chart is included in omnimix folder of the latest version, (which should always happen).
-                    v.chart.versions[1].includes("-omni")) // Then check if the second last version is a omnimix folder. If two omnimix folders occur in a row, it is a omnimix chart.
-                )) // Reject that case.
-        )
-            .filter(useFilter);
+        let newScores = [], oldScores = [];
+        if (chart_1.Chart.Database.hasLocalDatabase()) {
+            newScores = pbs.filter(filterIsLocalChartNewVersion);
+            oldScores = pbs.filter(filterIsLocalChartOldVersion);
+        }
+        else {
+            newScores = pbs.filter((v) => v.chart.data.displayVersion == this.currentVersion.kamai // Assume new scores does not have omnimix charts.
+            );
+            oldScores = pbs.filter((v) => 
+            // Chart exists
+            v.chart &&
+                // Chart version is older than current Version
+                KamaiTachi.compareGameVersions(this.currentVersion, KamaiTachi.getGameVersion(v.chart.data.displayVersion)) > 0 &&
+                (omnimix || // Omnimix is enabled, all charts are included.
+                    !((v.chart.versions[0].includes("-omni") && // Alternatively, if omnimix is disabled, check if the chart is included in omnimix folder of the latest version, (which should always happen).
+                        v.chart.versions[1].includes("-omni")) // Then check if the second last version is a omnimix folder. If two omnimix folders occur in a row, it is a omnimix chart.
+                    )) // Reject that case.
+            );
+        }
+        newScores = newScores.filter(filterUseAchievementFilter);
+        oldScores = oldScores.filter(filterUseAchievementFilter);
         return {
             new: newScores
                 .sort((a, b) => b.pb.calculatedData.rate - a.pb.calculatedData.rate
@@ -173,7 +222,6 @@ class KamaiTachi extends __1.default {
         };
     }
     async getPlayerInfo(userId, options = {
-        currentVersion: this.CURRENT_VERSION,
         omnimix: true,
         use: "ALL",
     }) {
@@ -250,224 +298,428 @@ class KamaiTachi extends __1.default {
                 : null,
         };
     }
-    maimai() {
+    async getPlayerLevel50(username, level, page, options = { percise: false }) {
+        if (page < 1)
+            page = 1;
+        const rawPBs = await this.getPlayerPB(username);
+        if (!rawPBs?.body)
+            return null;
+        const pbs = [];
+        for (const pb of rawPBs.body.pbs) {
+            let chart = rawPBs.body.charts.find((v) => v.chartID == pb.chartID);
+            let song = rawPBs.body.songs.find((v) => v.id == pb.songID);
+            if (chart && song) {
+                pbs.push({ pb, chart, song });
+            }
+        }
+        return pbs
+            .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song))
+            .sort((a, b) => b.achievement - a.achievement ||
+            b.chart.level - a.chart.level)
+            .filter((v) => options.percise
+            ? v.chart.level == level
+            : this.levelBoundChecker(v.chart.level, level, 6))
+            .slice((page - 1) * 50, (page - 1) * 50 + 50);
+    }
+    levelBoundChecker(payload, target, border) {
+        let lb = 0, hb = 0;
+        if ((target * 10) % 10 < border) {
+            lb = Math.trunc(target);
+            hb = Math.trunc(target) + (border - 1) * 0.1;
+        }
+        else {
+            lb = Math.trunc(target) + border * 0.1;
+            hb = Math.ceil(target) - 0.1;
+        }
+        return lb <= payload && payload <= hb;
+    }
+}
+exports.KamaiTachi = KamaiTachi;
+class KamaiTachiBuilder {
+    maimai(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.MAIMAI,
+            version: KamaiTachi.GameVersions.MAIMAI,
+            region,
         });
     }
-    maimaiPlus() {
+    maimaiPlus(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.MAIMAI_PLUS,
+            version: KamaiTachi.GameVersions.MAIMAI_PLUS,
+            region,
         });
     }
-    green() {
+    green(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.GREEN,
+            version: KamaiTachi.GameVersions.GREEN,
+            region,
         });
     }
-    greenPlus() {
+    greenPlus(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.GREEN_PLUS,
+            version: KamaiTachi.GameVersions.GREEN_PLUS,
+            region,
         });
     }
-    orange() {
+    orange(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.ORANGE,
+            version: KamaiTachi.GameVersions.ORANGE,
+            region,
         });
     }
-    orangePlus() {
+    orangePlus(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.ORANGE_PLUS,
+            version: KamaiTachi.GameVersions.ORANGE_PLUS,
+            region,
         });
     }
-    pink() {
+    pink(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.PINK,
+            version: KamaiTachi.GameVersions.PINK,
+            region,
         });
     }
-    pinkPlus() {
+    pinkPlus(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.PINK_PLUS,
+            version: KamaiTachi.GameVersions.PINK_PLUS,
+            region,
         });
     }
-    murasaki() {
+    murasaki(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.MURASAKI,
+            version: KamaiTachi.GameVersions.MURASAKI,
+            region,
         });
     }
-    murasakiPlus() {
+    murasakiPlus(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.MURASAKI_PLUS,
+            version: KamaiTachi.GameVersions.MURASAKI_PLUS,
+            region,
         });
     }
-    milk() {
+    milk(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.MILK,
+            version: KamaiTachi.GameVersions.MILK,
+            region,
         });
     }
-    milkPlus() {
+    milkPlus(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.MILK_PLUS,
+            version: KamaiTachi.GameVersions.MILK_PLUS,
+            region,
         });
     }
-    finale() {
+    finale(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.FINALE,
+            version: KamaiTachi.GameVersions.FINALE,
+            region,
         });
     }
-    dx() {
+    dx(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.DX,
+            version: KamaiTachi.GameVersions.DX,
+            region,
         });
     }
-    dxPlus() {
+    dxPlus(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.DX_PLUS,
+            version: KamaiTachi.GameVersions.DX_PLUS,
+            region,
         });
     }
-    splash() {
+    splash(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.SPLASH,
+            version: KamaiTachi.GameVersions.SPLASH,
+            region,
         });
     }
-    splashPlus() {
+    splashPlus(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.SPLASH_PLUS,
+            version: KamaiTachi.GameVersions.SPLASH_PLUS,
+            region,
         });
     }
-    universe() {
+    universe(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.UNIVERSE,
+            version: KamaiTachi.GameVersions.UNIVERSE,
+            region,
         });
     }
-    universePlus() {
+    universePlus(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.UNIVERSE_PLUS,
+            version: KamaiTachi.GameVersions.UNIVERSE_PLUS,
+            region,
         });
     }
-    festival() {
+    festival(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.FESTIVAL,
+            version: KamaiTachi.GameVersions.FESTIVAL,
+            region,
         });
     }
-    festivalPlus() {
+    festivalPlus(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.FESTIVAL_PLUS,
+            version: KamaiTachi.GameVersions.FESTIVAL_PLUS,
+            region,
         });
     }
-    buddies() {
+    buddies(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.BUDDIES,
+            version: KamaiTachi.GameVersions.BUDDIES,
+            region,
         });
     }
-    buddiesPlus() {
+    buddiesPlus(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.BUDDIES_PLUS,
+            version: KamaiTachi.GameVersions.BUDDIES_PLUS,
+            region,
         });
     }
-    prism() {
+    prism(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.PRISM,
+            version: KamaiTachi.GameVersions.PRISM,
+            region,
         });
     }
-    prismPlus() {
+    prismPlus(region) {
         return new KamaiTachi({
-            currentVersion: KamaiTachi.EGameVersions.PRISM_PLUS,
+            version: KamaiTachi.GameVersions.PRISM_PLUS,
+            region,
         });
     }
-    async getPlayerLevel50(username, level, page, options = { percise: false }) {
-        if (page < 1)
-            page = 1;
-        const rawPBs = await this.getPlayerPB(username);
-        if (!rawPBs?.body)
-            return null;
-        const pbs = [];
-        for (const pb of rawPBs.body.pbs) {
-            let chart = rawPBs.body.charts.find((v) => v.chartID == pb.chartID);
-            let song = rawPBs.body.songs.find((v) => v.id == pb.songID);
-            if (chart && song) {
-                pbs.push({ pb, chart, song });
-            }
-        }
-        return pbs
-            .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song))
-            .sort((a, b) => b.achievement - a.achievement ||
-            b.chart.level - a.chart.level)
-            .filter((v) => options.percise
-            ? v.chart.level == level
-            : this.levelBoundChecker(v.chart.level, level, 6))
-            .slice((page - 1) * 50, (page - 1) * 50 + 50);
-    }
-    levelBoundChecker(payload, target, border) {
-        let lb = 0, hb = 0;
-        if ((target * 10) % 10 < border) {
-            lb = Math.floor(target);
-            hb = Math.floor(target) + (border - 1) * 0.1;
-        }
-        else {
-            lb = Math.floor(target) + border * 0.1;
-            hb = Math.ceil(target) - 0.1;
-        }
-        return lb <= payload && payload <= hb;
+    CN() {
+        return {
+            DX() {
+                return new KamaiTachi({
+                    version: KamaiTachi.GameVersions.DX,
+                    region: "CN",
+                });
+            },
+            DX2021() {
+                return new KamaiTachi({
+                    version: KamaiTachi.GameVersions.SPLASH,
+                    region: "CN",
+                });
+            },
+            DX2022() {
+                return new KamaiTachi({
+                    version: KamaiTachi.GameVersions.UNIVERSE,
+                    region: "CN",
+                });
+            },
+            DX2023() {
+                return new KamaiTachi({
+                    version: KamaiTachi.GameVersions.FESTIVAL,
+                    region: "CN",
+                });
+            },
+            DX2024() {
+                return new KamaiTachi({
+                    version: KamaiTachi.GameVersions.BUDDIES,
+                    region: "CN",
+                });
+            },
+            DX2025() {
+                return new KamaiTachi({
+                    version: KamaiTachi.GameVersions.PRISM,
+                    region: "CN",
+                });
+            },
+        };
     }
 }
-exports.KamaiTachi = KamaiTachi;
+exports.KamaiTachiBuilder = KamaiTachiBuilder;
 (function (KamaiTachi) {
-    let EGameVersions;
-    (function (EGameVersions) {
-        EGameVersions["PRISM_PLUS"] = "maimai\u3067\u3089\u3063\u304F\u3059 PRiSM PLUS";
-        EGameVersions["PRISM"] = "maimai\u3067\u3089\u3063\u304F\u3059 PRiSM";
-        EGameVersions["BUDDIES_PLUS"] = "maimai\u3067\u3089\u3063\u304F\u3059 BUDDiES PLUS";
-        EGameVersions["BUDDIES"] = "maimai\u3067\u3089\u3063\u304F\u3059 BUDDiES";
-        EGameVersions["FESTIVAL_PLUS"] = "maimai\u3067\u3089\u3063\u304F\u3059 FESTiVAL PLUS";
-        EGameVersions["FESTIVAL"] = "maimai\u3067\u3089\u3063\u304F\u3059 FESTiVAL";
-        EGameVersions["UNIVERSE_PLUS"] = "maimai\u3067\u3089\u3063\u304F\u3059 UNiVERSE PLUS";
-        EGameVersions["UNIVERSE"] = "maimai\u3067\u3089\u3063\u304F\u3059 UNiVERSE";
-        EGameVersions["SPLASH_PLUS"] = "maimai\u3067\u3089\u3063\u304F\u3059 Splash PLUS";
-        EGameVersions["SPLASH"] = "maimai\u3067\u3089\u3063\u304F\u3059 Splash";
-        EGameVersions["DX_PLUS"] = "maimai\u3067\u3089\u3063\u304F\u3059 PLUS";
-        EGameVersions["DX"] = "maimai\u3067\u3089\u3063\u304F\u3059";
-        EGameVersions["FINALE"] = "maimai FiNALE";
-        EGameVersions["MILK_PLUS"] = "maimai MiLK PLUS";
-        EGameVersions["MILK"] = "maimai MiLK";
-        EGameVersions["MURASAKI_PLUS"] = "maimai MURASAKi PLUS";
-        EGameVersions["MURASAKI"] = "maimai MURASAKi";
-        EGameVersions["PINK_PLUS"] = "maimai PiNK PLUS";
-        EGameVersions["PINK"] = "maimai PiNK";
-        EGameVersions["ORANGE_PLUS"] = "maimai ORANGE PLUS";
-        EGameVersions["ORANGE"] = "maimai ORANGE";
-        EGameVersions["GREEN_PLUS"] = "maimai GreeN PLUS";
-        EGameVersions["GREEN"] = "maimai GreeN";
-        EGameVersions["MAIMAI_PLUS"] = "maimai PLUS";
-        EGameVersions["MAIMAI"] = "maimai";
-    })(EGameVersions = KamaiTachi.EGameVersions || (KamaiTachi.EGameVersions = {}));
-    const GameVersions = [
-        EGameVersions.MAIMAI,
-        EGameVersions.MAIMAI_PLUS,
-        EGameVersions.GREEN,
-        EGameVersions.GREEN_PLUS,
-        EGameVersions.ORANGE,
-        EGameVersions.ORANGE_PLUS,
-        EGameVersions.PINK,
-        EGameVersions.PINK_PLUS,
-        EGameVersions.MURASAKI,
-        EGameVersions.MURASAKI_PLUS,
-        EGameVersions.MILK,
-        EGameVersions.MILK_PLUS,
-        EGameVersions.FINALE,
-        EGameVersions.DX,
-        EGameVersions.DX_PLUS,
-        EGameVersions.SPLASH,
-        EGameVersions.SPLASH_PLUS,
-        EGameVersions.UNIVERSE,
-        EGameVersions.UNIVERSE_PLUS,
-        EGameVersions.FESTIVAL,
-        EGameVersions.FESTIVAL_PLUS,
-        EGameVersions.BUDDIES,
-        EGameVersions.BUDDIES_PLUS,
-        EGameVersions.PRISM,
-        EGameVersions.PRISM_PLUS,
+    KamaiTachi.GameVersions = {
+        PRISM_PLUS: {
+            kamai: "maimaiでらっくす PRiSM PLUS",
+            DX: "maimai でらっくす PRiSM PLUS",
+            EX: "maimai DX PRiSM PLUS",
+            CN: "",
+        },
+        PRISM: {
+            kamai: "maimaiでらっくす PRiSM",
+            DX: "maimai でらっくす PRiSM",
+            EX: "maimai DX PRiSM",
+            CN: "舞萌DX 2025",
+        },
+        BUDDIES_PLUS: {
+            kamai: "maimaiでらっくす BUDDiES PLUS",
+            DX: "maimai でらっくす BUDDiES PLUS",
+            EX: "maimai DX BUDDiES PLUS",
+            CN: "",
+        },
+        BUDDIES: {
+            kamai: "maimaiでらっくす BUDDiES",
+            DX: "maimai でらっくす BUDDiES",
+            EX: "maimai DX BUDDiES",
+            CN: "舞萌DX 2024",
+        },
+        FESTIVAL_PLUS: {
+            kamai: "maimaiでらっくす FESTiVAL PLUS",
+            DX: "maimai でらっくす FESTiVAL PLUS",
+            EX: "maimai DX FESTiVAL PLUS",
+            CN: "",
+        },
+        FESTIVAL: {
+            kamai: "maimaiでらっくす FESTiVAL",
+            DX: "maimai でらっくす FESTiVAL",
+            EX: "maimai DX FESTiVAL",
+            CN: "舞萌DX 2023",
+        },
+        UNIVERSE_PLUS: {
+            kamai: "maimaiでらっくす UNiVERSE PLUS",
+            DX: "maimai でらっくす UNiVERSE PLUS",
+            EX: "maimai DX UNiVERSE PLUS",
+            CN: "",
+        },
+        UNIVERSE: {
+            kamai: "maimaiでらっくす UNiVERSE",
+            DX: "maimai でらっくす UNiVERSE",
+            EX: "maimai DX UNiVERSE",
+            CN: "舞萌DX 2022",
+        },
+        SPLASH_PLUS: {
+            kamai: "maimaiでらっくす Splash PLUS",
+            DX: "maimai でらっくす Splash PLUS",
+            EX: "maimai DX Splash PLUS",
+            CN: "",
+        },
+        SPLASH: {
+            kamai: "maimaiでらっくす Splash",
+            DX: "maimai でらっくす Splash",
+            EX: "maimai DX Splash",
+            CN: "舞萌DX 2021",
+        },
+        DX_PLUS: {
+            kamai: "maimaiでらっくす PLUS",
+            DX: "maimai でらっくす PLUS",
+            EX: "maimai DX PLUS",
+            CN: "",
+        },
+        DX: {
+            kamai: "maimaiでらっくす",
+            DX: "maimai でらっくす",
+            EX: "maimai DX",
+            CN: "舞萌DX",
+        },
+        FINALE: {
+            kamai: "maimai FiNALE",
+            DX: "maimai FiNALE",
+            EX: "maimai FiNALE",
+            CN: "maimai FiNALE",
+        },
+        MILK_PLUS: {
+            kamai: "maimai MiLK PLUS",
+            DX: "maimai MiLK PLUS",
+            EX: "maimai MiLK PLUS",
+            CN: "maimai MiLK PLUS",
+        },
+        MILK: {
+            kamai: "maimai MiLK",
+            DX: "maimai MiLK",
+            EX: "maimai MiLK",
+            CN: "maimai MiLK",
+        },
+        MURASAKI_PLUS: {
+            kamai: "maimai MURASAKi PLUS",
+            DX: "maimai MURASAKi PLUS",
+            EX: "maimai MURASAKi PLUS",
+            CN: "maimai MURASAKi PLUS",
+        },
+        MURASAKI: {
+            kamai: "maimai MURASAKi",
+            DX: "maimai MURASAKi",
+            EX: "maimai MURASAKi",
+            CN: "maimai MURASAKi",
+        },
+        PINK_PLUS: {
+            kamai: "maimai PiNK PLUS",
+            DX: "maimai PiNK PLUS",
+            EX: "maimai PiNK PLUS",
+            CN: "maimai PiNK PLUS",
+        },
+        PINK: {
+            kamai: "maimai PiNK",
+            DX: "maimai PiNK",
+            EX: "maimai PiNK",
+            CN: "maimai PiNK",
+        },
+        ORANGE_PLUS: {
+            kamai: "maimai ORANGE PLUS",
+            DX: "maimai ORANGE PLUS",
+            EX: "maimai ORANGE PLUS",
+            CN: "maimai ORANGE PLUS",
+        },
+        ORANGE: {
+            kamai: "maimai ORANGE",
+            DX: "maimai ORANGE",
+            EX: "maimai ORANGE",
+            CN: "maimai ORANGE",
+        },
+        GREEN_PLUS: {
+            kamai: "maimai GreeN PLUS",
+            DX: "maimai GreeN PLUS",
+            EX: "maimai GreeN PLUS",
+            CN: "maimai GreeN PLUS",
+        },
+        GREEN: {
+            kamai: "maimai GreeN",
+            DX: "maimai GreeN",
+            EX: "maimai GreeN",
+            CN: "maimai GreeN",
+        },
+        MAIMAI_PLUS: {
+            kamai: "maimai PLUS",
+            DX: "maimai PLUS",
+            EX: "maimai PLUS",
+            CN: "maimai PLUS",
+        },
+        MAIMAI: {
+            kamai: "maimai",
+            DX: "maimai",
+            EX: "maimai",
+            CN: "maimai",
+        },
+    };
+    const GameVersionOrder = [
+        KamaiTachi.GameVersions.MAIMAI,
+        KamaiTachi.GameVersions.MAIMAI_PLUS,
+        KamaiTachi.GameVersions.GREEN,
+        KamaiTachi.GameVersions.GREEN_PLUS,
+        KamaiTachi.GameVersions.ORANGE,
+        KamaiTachi.GameVersions.ORANGE_PLUS,
+        KamaiTachi.GameVersions.PINK,
+        KamaiTachi.GameVersions.PINK_PLUS,
+        KamaiTachi.GameVersions.MURASAKI,
+        KamaiTachi.GameVersions.MURASAKI_PLUS,
+        KamaiTachi.GameVersions.MILK,
+        KamaiTachi.GameVersions.MILK_PLUS,
+        KamaiTachi.GameVersions.FINALE,
+        KamaiTachi.GameVersions.DX,
+        KamaiTachi.GameVersions.DX_PLUS,
+        KamaiTachi.GameVersions.SPLASH,
+        KamaiTachi.GameVersions.SPLASH_PLUS,
+        KamaiTachi.GameVersions.UNIVERSE,
+        KamaiTachi.GameVersions.UNIVERSE_PLUS,
+        KamaiTachi.GameVersions.FESTIVAL,
+        KamaiTachi.GameVersions.FESTIVAL_PLUS,
+        KamaiTachi.GameVersions.BUDDIES,
+        KamaiTachi.GameVersions.BUDDIES_PLUS,
+        KamaiTachi.GameVersions.PRISM,
+        KamaiTachi.GameVersions.PRISM_PLUS,
     ];
+    function getGameVersion(payload) {
+        for (const version of Object.values(KamaiTachi.GameVersions)) {
+            if (version.kamai.toLowerCase() === payload.toLowerCase() ||
+                version.DX.toLowerCase() === payload.toLowerCase() ||
+                version.EX.toLowerCase() === payload.toLowerCase() ||
+                version.CN.toLowerCase() === payload.toLowerCase()) {
+                return version;
+            }
+        }
+        return null;
+    }
+    KamaiTachi.getGameVersion = getGameVersion;
     /**
      * Compare two game versions and calculate which is newer.
      *
@@ -476,7 +728,13 @@ exports.KamaiTachi = KamaiTachi;
      * @returns positive if a is newer, negative if b is newer, 0 if they are the same.
      */
     function compareGameVersions(a, b) {
-        return GameVersions.indexOf(a) - GameVersions.indexOf(b);
+        if (!a && !b)
+            return 0;
+        if (!a)
+            return -1; // b is newer
+        if (!b)
+            return 1; // a is newer
+        return GameVersionOrder.indexOf(a) - GameVersionOrder.indexOf(b);
     }
     KamaiTachi.compareGameVersions = compareGameVersions;
 })(KamaiTachi || (exports.KamaiTachi = KamaiTachi = {}));