hypixel-api-reborn 11.3.4 → 12.0.0-0

package/dist/src/structures/MiniGames/Pit.test.js

@@ -0,0 +1,218 @@
+import Client from '../../Client';
+import Pit from './Pit';
+import PitInventoryItem from './PitInventoryItem';
+import { expect, expectTypeOf, test } from 'vitest';
+test('Pit', () => {
+    const data = new Pit({ stats: 'meow' });
+    expect(data).toBeInstanceOf(Pit);
+    expect(data.prestige).toBeDefined();
+    expectTypeOf(data.prestige).toEqualTypeOf();
+    expect(data.prestige).toBeGreaterThanOrEqual(0);
+    expect(data.xp).toBeDefined();
+    expectTypeOf(data.xp).toEqualTypeOf();
+    expect(data.xp).toBeGreaterThanOrEqual(0);
+    expect(data.level).toBeDefined();
+    expectTypeOf(data.level).toEqualTypeOf();
+    expect(data.level).toBeGreaterThanOrEqual(0);
+    expect(data.kills).toBeDefined();
+    expectTypeOf(data.kills).toEqualTypeOf();
+    expect(data.kills).toBeGreaterThanOrEqual(0);
+    expect(data.deaths).toBeDefined();
+    expectTypeOf(data.deaths).toEqualTypeOf();
+    expect(data.deaths).toBeGreaterThanOrEqual(0);
+    expect(data.KDR).toBeDefined();
+    expectTypeOf(data.KDR).toEqualTypeOf();
+    expect(data.KDR).toBeGreaterThanOrEqual(0);
+    expect(data.assists).toBeDefined();
+    expectTypeOf(data.assists).toEqualTypeOf();
+    expect(data.assists).toBeGreaterThanOrEqual(0);
+    expect(data.maxKillStreak).toBeDefined();
+    expectTypeOf(data.maxKillStreak).toEqualTypeOf();
+    expect(data.maxKillStreak).toBeGreaterThanOrEqual(0);
+    expect(data.playtime).toBeDefined();
+    expectTypeOf(data.playtime).toEqualTypeOf();
+    expect(data.playtime).toBeGreaterThanOrEqual(0);
+    expect(data.joins).toBeDefined();
+    expectTypeOf(data.joins).toEqualTypeOf();
+    expect(data.joins).toBeGreaterThanOrEqual(0);
+    expect(data.damageReceived).toBeDefined();
+    expectTypeOf(data.damageReceived).toEqualTypeOf();
+    expect(data.damageReceived).toBeGreaterThanOrEqual(0);
+    expect(data.damageDealt).toBeDefined();
+    expectTypeOf(data.damageDealt).toEqualTypeOf();
+    expect(data.damageDealt).toBeGreaterThanOrEqual(0);
+    expect(data.damageRatio).toBeDefined();
+    expectTypeOf(data.damageRatio).toEqualTypeOf();
+    expect(data.damageRatio).toBeGreaterThanOrEqual(0);
+    expect(data.meleeDamageReceived).toBeDefined();
+    expectTypeOf(data.meleeDamageReceived).toEqualTypeOf();
+    expect(data.meleeDamageReceived).toBeGreaterThanOrEqual(0);
+    expect(data.meleeDamageDealt).toBeDefined();
+    expectTypeOf(data.meleeDamageDealt).toEqualTypeOf();
+    expect(data.meleeDamageDealt).toBeGreaterThanOrEqual(0);
+    expect(data.swordHits).toBeDefined();
+    expectTypeOf(data.swordHits).toEqualTypeOf();
+    expect(data.swordHits).toBeGreaterThanOrEqual(0);
+    expect(data.leftClicks).toBeDefined();
+    expectTypeOf(data.leftClicks).toEqualTypeOf();
+    expect(data.leftClicks).toBeGreaterThanOrEqual(0);
+    expect(data.meleeAccuracy).toBeDefined();
+    expectTypeOf(data.meleeAccuracy).toEqualTypeOf();
+    expect(data.meleeAccuracy).toBeGreaterThanOrEqual(0);
+    expect(data.meleeDamageRatio).toBeDefined();
+    expectTypeOf(data.meleeDamageRatio).toEqualTypeOf();
+    expect(data.meleeDamageRatio).toBeGreaterThanOrEqual(0);
+    expect(data.bowDamageReceived).toBeDefined();
+    expectTypeOf(data.bowDamageReceived).toEqualTypeOf();
+    expect(data.bowDamageReceived).toBeGreaterThanOrEqual(0);
+    expect(data.bowDamageDealt).toBeDefined();
+    expectTypeOf(data.bowDamageDealt).toEqualTypeOf();
+    expect(data.bowDamageDealt).toBeGreaterThanOrEqual(0);
+    expect(data.arrowsHit).toBeDefined();
+    expectTypeOf(data.arrowsHit).toEqualTypeOf();
+    expect(data.arrowsHit).toBeGreaterThanOrEqual(0);
+    expect(data.arrowsFired).toBeDefined();
+    expectTypeOf(data.arrowsFired).toEqualTypeOf();
+    expect(data.arrowsFired).toBeGreaterThanOrEqual(0);
+    expect(data.bowAccuracy).toBeDefined();
+    expectTypeOf(data.bowAccuracy).toEqualTypeOf();
+    expect(data.bowAccuracy).toBeGreaterThanOrEqual(0);
+    expect(data.bowDamageRatio).toBeDefined();
+    expectTypeOf(data.bowDamageRatio).toEqualTypeOf();
+    expect(data.bowDamageRatio).toBeGreaterThanOrEqual(0);
+    expect(data.goldenHeadsEaten).toBeDefined();
+    expectTypeOf(data.goldenHeadsEaten).toEqualTypeOf();
+    expect(data.goldenHeadsEaten).toBeGreaterThanOrEqual(0);
+});
+test('Pit Inventory', async () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    const data = await client.getPlayer('3457688aa57c4d71ab9d22b04f9160db');
+    expect(data.stats.pit.getInventory).toBeDefined();
+    expectTypeOf(data.stats.pit.getInventory).toEqualTypeOf();
+    expect(data.stats.pit.getInventory).toBeInstanceOf(Function);
+    const pitInventory = await data.stats.pit.getInventory();
+    expect(pitInventory).toBeDefined();
+    pitInventory.forEach((item) => {
+        expect(item).toBeDefined();
+        expect(item).toBeInstanceOf(PitInventoryItem);
+        expectTypeOf(item).toEqualTypeOf();
+        expect(item.itemId).toBeDefined();
+        expectTypeOf(item.itemId).toEqualTypeOf();
+        expect(item.count).toBeDefined();
+        expectTypeOf(item.count).toEqualTypeOf();
+        expect(item.name).toBeDefined();
+        expectTypeOf(item.name).toEqualTypeOf();
+        expect(item.lore).toBeDefined();
+        expectTypeOf(item.lore).toEqualTypeOf();
+        expect(item.loreArray).toBeDefined();
+        expectTypeOf(item.loreArray).toEqualTypeOf();
+        expect(item.extraAttributes).toBeDefined();
+        expectTypeOf(item.extraAttributes).toEqualTypeOf();
+    });
+    expect(data.stats.pit.getEnterChest).toBeDefined();
+    expectTypeOf(data.stats.pit.getEnterChest).toEqualTypeOf();
+    expect(data.stats.pit.getEnterChest).toBeInstanceOf(Function);
+    const pitEnterChest = await data.stats.pit.getEnterChest();
+    expect(pitEnterChest).toBeDefined();
+    pitEnterChest.forEach((item) => {
+        expect(item).toBeDefined();
+        expect(item).toBeInstanceOf(PitInventoryItem);
+        expectTypeOf(item).toEqualTypeOf();
+        expect(item.itemId).toBeDefined();
+        expectTypeOf(item.itemId).toEqualTypeOf();
+        expect(item.count).toBeDefined();
+        expectTypeOf(item.count).toEqualTypeOf();
+        expect(item.name).toBeDefined();
+        expectTypeOf(item.name).toEqualTypeOf();
+        expect(item.lore).toBeDefined();
+        expectTypeOf(item.lore).toEqualTypeOf();
+        expect(item.loreArray).toBeDefined();
+        expectTypeOf(item.loreArray).toEqualTypeOf();
+        expect(item.extraAttributes).toBeDefined();
+        expectTypeOf(item.extraAttributes).toEqualTypeOf();
+    });
+    expect(data.stats.pit.getArmor).toBeDefined();
+    expectTypeOf(data.stats.pit.getArmor).toEqualTypeOf();
+    expect(data.stats.pit.getArmor).toBeInstanceOf(Function);
+    const pitArmor = await data.stats.pit.getArmor();
+    expect(pitArmor).toBeDefined();
+    expectTypeOf(pitArmor).toEqualTypeOf();
+    expect(pitArmor.helmet).toBeDefined();
+    expectTypeOf(pitArmor.helmet).toEqualTypeOf();
+    if (null !== pitArmor.helmet) {
+        expect(pitArmor.helmet).toBeDefined();
+        expect(pitArmor.helmet).toBeInstanceOf(PitInventoryItem);
+        expectTypeOf(pitArmor.helmet).toEqualTypeOf();
+        expect(pitArmor.helmet.itemId).toBeDefined();
+        expectTypeOf(pitArmor.helmet.itemId).toEqualTypeOf();
+        expect(pitArmor.helmet.count).toBeDefined();
+        expectTypeOf(pitArmor.helmet.count).toEqualTypeOf();
+        expect(pitArmor.helmet.name).toBeDefined();
+        expectTypeOf(pitArmor.helmet.name).toEqualTypeOf();
+        expect(pitArmor.helmet.lore).toBeDefined();
+        expectTypeOf(pitArmor.helmet.lore).toEqualTypeOf();
+        expect(pitArmor.helmet.loreArray).toBeDefined();
+        expectTypeOf(pitArmor.helmet.loreArray).toEqualTypeOf();
+        expect(pitArmor.helmet.extraAttributes).toBeDefined();
+        expectTypeOf(pitArmor.helmet.extraAttributes).toEqualTypeOf();
+    }
+    expect(pitArmor.chestplate).toBeDefined();
+    expectTypeOf(pitArmor.chestplate).toEqualTypeOf();
+    if (null !== pitArmor.chestplate) {
+        expect(pitArmor.chestplate).toBeDefined();
+        expect(pitArmor.chestplate).toBeInstanceOf(PitInventoryItem);
+        expectTypeOf(pitArmor.chestplate).toEqualTypeOf();
+        expect(pitArmor.chestplate.itemId).toBeDefined();
+        expectTypeOf(pitArmor.chestplate.itemId).toEqualTypeOf();
+        expect(pitArmor.chestplate.count).toBeDefined();
+        expectTypeOf(pitArmor.chestplate.count).toEqualTypeOf();
+        expect(pitArmor.chestplate.name).toBeDefined();
+        expectTypeOf(pitArmor.chestplate.name).toEqualTypeOf();
+        expect(pitArmor.chestplate.lore).toBeDefined();
+        expectTypeOf(pitArmor.chestplate.lore).toEqualTypeOf();
+        expect(pitArmor.chestplate.loreArray).toBeDefined();
+        expectTypeOf(pitArmor.chestplate.loreArray).toEqualTypeOf();
+        expect(pitArmor.chestplate.extraAttributes).toBeDefined();
+        expectTypeOf(pitArmor.chestplate.extraAttributes).toEqualTypeOf();
+    }
+    expect(pitArmor.leggings).toBeDefined();
+    expectTypeOf(pitArmor.leggings).toEqualTypeOf();
+    if (null !== pitArmor.leggings) {
+        expect(pitArmor.leggings).toBeDefined();
+        expect(pitArmor.leggings).toBeInstanceOf(PitInventoryItem);
+        expectTypeOf(pitArmor.leggings).toEqualTypeOf();
+        expect(pitArmor.leggings.itemId).toBeDefined();
+        expectTypeOf(pitArmor.leggings.itemId).toEqualTypeOf();
+        expect(pitArmor.leggings.count).toBeDefined();
+        expectTypeOf(pitArmor.leggings.count).toEqualTypeOf();
+        expect(pitArmor.leggings.name).toBeDefined();
+        expectTypeOf(pitArmor.leggings.name).toEqualTypeOf();
+        expect(pitArmor.leggings.lore).toBeDefined();
+        expectTypeOf(pitArmor.leggings.lore).toEqualTypeOf();
+        expect(pitArmor.leggings.loreArray).toBeDefined();
+        expectTypeOf(pitArmor.leggings.loreArray).toEqualTypeOf();
+        expect(pitArmor.leggings.extraAttributes).toBeDefined();
+        expectTypeOf(pitArmor.leggings.extraAttributes).toEqualTypeOf();
+    }
+    expect(pitArmor.boots).toBeDefined();
+    expectTypeOf(pitArmor.boots).toEqualTypeOf();
+    if (null !== pitArmor.boots) {
+        expect(pitArmor.boots).toBeDefined();
+        expect(pitArmor.boots).toBeInstanceOf(PitInventoryItem);
+        expectTypeOf(pitArmor.boots).toEqualTypeOf();
+        expect(pitArmor.boots.itemId).toBeDefined();
+        expectTypeOf(pitArmor.boots.itemId).toEqualTypeOf();
+        expect(pitArmor.boots.count).toBeDefined();
+        expectTypeOf(pitArmor.boots.count).toEqualTypeOf();
+        expect(pitArmor.boots.name).toBeDefined();
+        expectTypeOf(pitArmor.boots.name).toEqualTypeOf();
+        expect(pitArmor.boots.lore).toBeDefined();
+        expectTypeOf(pitArmor.boots.lore).toEqualTypeOf();
+        expect(pitArmor.boots.loreArray).toBeDefined();
+        expectTypeOf(pitArmor.boots.loreArray).toEqualTypeOf();
+        expect(pitArmor.boots.extraAttributes).toBeDefined();
+        expectTypeOf(pitArmor.boots.extraAttributes).toEqualTypeOf();
+    }
+});

package/dist/src/structures/MiniGames/PitInventoryItem.js

@@ -0,0 +1,19 @@
+class PitInventoryItem {
+    itemId;
+    count;
+    name;
+    lore;
+    loreArray;
+    extraAttributes;
+    constructor(data) {
+        this.itemId = data?.id || 0;
+        this.count = data?.Count || 0;
+        this.name = data?.tag?.display?.Name
+            ? data?.tag?.display?.Name?.toString().replace(/§([1-9]|[a-f])|§/gm, '')
+            : null;
+        this.lore = data?.tag?.display?.Lore ? data?.tag?.display?.Lore?.join('\n') : null;
+        this.loreArray = data?.tag?.display?.Lore ?? [];
+        this.extraAttributes = data?.tag?.ExtraAttributes ?? null;
+    }
+}
+export default PitInventoryItem;

package/dist/src/structures/MiniGames/Quakecraft.js

@@ -0,0 +1,68 @@
+import divide from '../../utils/divide';
+export class QuakecraftMode {
+    wins;
+    kills;
+    deaths;
+    KDR;
+    killstreaks;
+    distanceTravelled;
+    shotsFired;
+    headshots;
+    constructor(data, gamemode) {
+        if (gamemode)
+            gamemode = `_${gamemode}`;
+        this.wins = data?.[`wins${gamemode}`] || 0;
+        this.kills = data?.[`kills${gamemode}`] || 0;
+        this.deaths = data?.[`deaths${gamemode}`] || 0;
+        this.KDR = divide(this.kills, this.deaths);
+        this.killstreaks = data?.[`killstreaks${gamemode}`] || 0;
+        this.distanceTravelled = data?.[`distance_travelled${gamemode}`] || 0;
+        this.shotsFired = data?.[`shots_fired${gamemode}`] || 0;
+        this.headshots = data?.[`headshots${gamemode}`] || 0;
+    }
+}
+class Quakecraft {
+    coins;
+    solo;
+    teams;
+    wins;
+    kills;
+    deaths;
+    KDR;
+    killstreaks;
+    distanceTravelled;
+    shotsFired;
+    headshots;
+    instantRespawn;
+    killPrefixColor;
+    showPrefix;
+    killSound;
+    barrel;
+    case;
+    muzzle;
+    sight;
+    trigger;
+    constructor(data) {
+        this.coins = data?.coins || 0;
+        this.solo = new QuakecraftMode(data);
+        this.teams = new QuakecraftMode(data, 'teams');
+        this.wins = this.solo?.wins + this.teams?.wins;
+        this.kills = this.solo?.kills + this.teams?.kills;
+        this.deaths = this.solo?.deaths + this.teams?.deaths;
+        this.KDR = divide(this.kills, this.deaths);
+        this.killstreaks = this.solo?.killstreaks + this.teams?.killstreaks;
+        this.distanceTravelled = this.solo?.distanceTravelled + this.teams?.distanceTravelled;
+        this.shotsFired = this.solo?.shotsFired + this.teams?.shotsFired;
+        this.headshots = this.solo?.headshots + this.teams?.headshots;
+        this.instantRespawn = data?.instantRespawn || false;
+        this.killPrefixColor = data?.selectedKillPrefix || '';
+        this.showPrefix = data?.showKillPrefix || false;
+        this.killSound = data?.killsound || '';
+        this.barrel = data?.barrel || '';
+        this.case = data?.case || '';
+        this.muzzle = data?.muzzle || '';
+        this.sight = data?.sight || '';
+        this.trigger = data?.trigger || '';
+    }
+}
+export default Quakecraft;

package/dist/src/structures/MiniGames/Quakecraft.test.js

@@ -0,0 +1,105 @@
+import Quakecraft from './Quakecraft';
+import { expect, expectTypeOf, test } from 'vitest';
+test('Quakecraft', () => {
+    const data = new Quakecraft({ stats: 'meow' });
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(Quakecraft);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.coins).toBeDefined();
+    expect(data.coins).greaterThanOrEqual(0);
+    expectTypeOf(data.coins).toEqualTypeOf();
+    expect(data.solo).toBeDefined();
+    expectTypeOf(data.solo).toEqualTypeOf();
+    expect(data.solo.wins).toBeDefined();
+    expect(data.solo.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.wins).toEqualTypeOf();
+    expect(data.solo.kills).toBeDefined();
+    expect(data.solo.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.kills).toEqualTypeOf();
+    expect(data.solo.deaths).toBeDefined();
+    expect(data.solo.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.deaths).toEqualTypeOf();
+    expect(data.solo.KDR).toBeDefined();
+    expect(data.solo.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.KDR).toEqualTypeOf();
+    expect(data.solo.killstreaks).toBeDefined();
+    expect(data.solo.killstreaks).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.killstreaks).toEqualTypeOf();
+    expect(data.solo.distanceTravelled).toBeDefined();
+    expect(data.solo.distanceTravelled).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.distanceTravelled).toEqualTypeOf();
+    expect(data.solo.shotsFired).toBeDefined();
+    expect(data.solo.shotsFired).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.shotsFired).toEqualTypeOf();
+    expect(data.solo.headshots).toBeDefined();
+    expect(data.solo.headshots).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.headshots).toEqualTypeOf();
+    expect(data.teams).toBeDefined();
+    expectTypeOf(data.teams).toEqualTypeOf();
+    expect(data.teams.wins).toBeDefined();
+    expect(data.teams.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.teams.wins).toEqualTypeOf();
+    expect(data.teams.kills).toBeDefined();
+    expect(data.teams.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.teams.kills).toEqualTypeOf();
+    expect(data.teams.deaths).toBeDefined();
+    expect(data.teams.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.teams.deaths).toEqualTypeOf();
+    expect(data.teams.KDR).toBeDefined();
+    expect(data.teams.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.teams.KDR).toEqualTypeOf();
+    expect(data.teams.killstreaks).toBeDefined();
+    expect(data.teams.killstreaks).greaterThanOrEqual(0);
+    expectTypeOf(data.teams.killstreaks).toEqualTypeOf();
+    expect(data.teams.distanceTravelled).toBeDefined();
+    expect(data.teams.distanceTravelled).greaterThanOrEqual(0);
+    expectTypeOf(data.teams.distanceTravelled).toEqualTypeOf();
+    expect(data.teams.shotsFired).toBeDefined();
+    expect(data.teams.shotsFired).greaterThanOrEqual(0);
+    expectTypeOf(data.teams.shotsFired).toEqualTypeOf();
+    expect(data.teams.headshots).toBeDefined();
+    expect(data.teams.headshots).greaterThanOrEqual(0);
+    expectTypeOf(data.teams.headshots).toEqualTypeOf();
+    expect(data.wins).toBeDefined();
+    expect(data.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.wins).toEqualTypeOf();
+    expect(data.kills).toBeDefined();
+    expect(data.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.kills).toEqualTypeOf();
+    expect(data.deaths).toBeDefined();
+    expect(data.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.deaths).toEqualTypeOf();
+    expect(data.KDR).toBeDefined();
+    expect(data.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.KDR).toEqualTypeOf();
+    expect(data.killstreaks).toBeDefined();
+    expect(data.killstreaks).greaterThanOrEqual(0);
+    expectTypeOf(data.killstreaks).toEqualTypeOf();
+    expect(data.distanceTravelled).toBeDefined();
+    expect(data.distanceTravelled).greaterThanOrEqual(0);
+    expectTypeOf(data.distanceTravelled).toEqualTypeOf();
+    expect(data.shotsFired).toBeDefined();
+    expect(data.shotsFired).greaterThanOrEqual(0);
+    expectTypeOf(data.shotsFired).toEqualTypeOf();
+    expect(data.headshots).toBeDefined();
+    expect(data.headshots).greaterThanOrEqual(0);
+    expectTypeOf(data.headshots).toEqualTypeOf();
+    expect(data.instantRespawn).toBeDefined();
+    expectTypeOf(data.instantRespawn).toEqualTypeOf();
+    expect(data.killPrefixColor).toBeDefined();
+    expectTypeOf(data.killPrefixColor).toEqualTypeOf();
+    expect(data.showPrefix).toBeDefined();
+    expectTypeOf(data.showPrefix).toEqualTypeOf();
+    expect(data.killSound).toBeDefined();
+    expectTypeOf(data.killSound).toEqualTypeOf();
+    expect(data.barrel).toBeDefined();
+    expectTypeOf(data.barrel).toEqualTypeOf();
+    expect(data.case).toBeDefined();
+    expectTypeOf(data.case).toEqualTypeOf();
+    expect(data.muzzle).toBeDefined();
+    expectTypeOf(data.muzzle).toEqualTypeOf();
+    expect(data.sight).toBeDefined();
+    expectTypeOf(data.sight).toEqualTypeOf();
+    expect(data.trigger).toBeDefined();
+    expectTypeOf(data.trigger).toEqualTypeOf();
+});

package/dist/src/structures/MiniGames/SkyWars.js

@@ -0,0 +1,264 @@
+import divide from '../../utils/divide';
+import { removeSnakeCaseString } from '../../utils/removeSnakeCase';
+function getSkyWarsPrestige(level) {
+    if (60 <= level)
+        return 'Mythic';
+    return (['Iron', 'Iron', 'Gold', 'Diamond', 'Emerald', 'Sapphire', 'Ruby', 'Crystal', 'Opal', 'Amethyst', 'Rainbow'][Math.floor(level / 5)] || 'Iron');
+}
+function getSkyWarsLevel(xp) {
+    const totalXp = [0, 2, 7, 15, 25, 50, 100, 200, 350, 600, 1000, 1500];
+    if (0 === xp)
+        return 0;
+    if (15000 <= xp)
+        return Math.floor((xp - 15000) / 10000 + 12);
+    const level = totalXp.findIndex((x) => 0 < x * 10 - xp);
+    return -1 === level ? 0 : level;
+}
+function getSkyWarsLevelProgress(xp) {
+    const totalXp = [0, 2, 7, 15, 25, 50, 100, 200, 350, 600, 1000, 1500];
+    const xpToNextLvl = [0, 2, 5, 8, 10, 25, 50, 100, 150, 250, 400, 500];
+    let percent;
+    let xpToNextLevel;
+    let currentLevelXp = xp;
+    if (15000 <= xp) {
+        currentLevelXp -= 15000;
+        if (0 === currentLevelXp)
+            return { currentLevelXp: 0, xpToNextLevel: 10000, percent: 0, xpNextLevel: 10000 };
+        if (10000 < currentLevelXp) {
+            do {
+                currentLevelXp -= 10000;
+            } while (10000 <= currentLevelXp);
+        }
+        xpToNextLevel = 10000 - currentLevelXp;
+        percent = Math.round(currentLevelXp) / 100;
+        const percentRemaining = Math.round((100 - percent) * 100) / 100;
+        return { currentLevelXp, xpToNextLevel, percent, xpNextLevel: 10000, percentRemaining };
+    }
+    const totalXptoNextLevel = xpToNextLvl[totalXp.findIndex((x) => 0 < x * 10 - xp)] * 10;
+    for (let i = 0; i < xpToNextLvl.length; i++) {
+        if (0 > currentLevelXp - xpToNextLvl[i] * 10)
+            break;
+        currentLevelXp -= xpToNextLvl[i] * 10;
+    }
+    xpToNextLevel = totalXptoNextLevel - currentLevelXp;
+    percent = Math.round((currentLevelXp / totalXptoNextLevel) * 10000) / 100;
+    return { currentLevelXp, xpToNextLevel, percent, xpNextLevel: totalXptoNextLevel };
+}
+export class SkywarsMode {
+    kills;
+    deaths;
+    KDR;
+    wins;
+    losses;
+    WLR;
+    constructor(data, gamemode) {
+        this.kills = data?.[`kills_${gamemode}`] || 0;
+        this.deaths = data?.[`deaths_${gamemode}`] || 0;
+        this.KDR = divide(data?.kills, data?.deaths);
+        this.wins = data?.[`wins_${gamemode}`] || 0;
+        this.losses = data?.[`losses_${gamemode}`] || 0;
+        this.WLR = divide(data?.wins, data?.losses);
+    }
+}
+export class SkywarsModeStats {
+    activeKit;
+    killstreak;
+    kills;
+    voidKills;
+    meleeKills;
+    bowKills;
+    mobKills;
+    assists;
+    deaths;
+    KDR;
+    wins;
+    losses;
+    WLR;
+    gamesPlayed;
+    survivedPlayers;
+    chestsOpened;
+    timePlayed;
+    shard;
+    longestBowShot;
+    arrowsShot;
+    arrowsHit;
+    bowAccuracy;
+    fastestWin;
+    heads;
+    normal;
+    insane;
+    constructor(data, gamemode) {
+        this.activeKit = data?.[`activeKit_${gamemode?.toUpperCase()}`] || '';
+        this.killstreak = data?.[`killstreak_${gamemode}`] || 0;
+        this.kills = data?.[`kills_${gamemode}`] || 0;
+        this.voidKills = data?.[`void_kills_${gamemode}`] || 0;
+        this.meleeKills = data?.[`melee_kills_${gamemode}`] || 0;
+        this.bowKills = data?.[`bow_kills_${gamemode}`] || 0;
+        this.mobKills = data?.[`mob_kills_${gamemode}`] || 0;
+        this.assists = data?.[`assists_${gamemode}`] || 0;
+        this.deaths = data?.[`deaths_${gamemode}`] || 0;
+        this.KDR = divide(data?.kills, data?.deaths);
+        this.wins = data?.[`wins_${gamemode}`] || 0;
+        this.losses = data?.[`losses_${gamemode}`] || 0;
+        this.WLR = divide(data?.wins, data?.losses);
+        this.gamesPlayed = data?.[`games_${gamemode}`] || 0;
+        this.survivedPlayers = data?.[`survived_players_${gamemode}`] || 0;
+        this.chestsOpened = data?.[`chests_opened_${gamemode}`] || 0;
+        this.timePlayed = data?.[`time_played_${gamemode}`] || 0;
+        this.shard = data?.[`shard_${gamemode}`] || 0;
+        this.longestBowShot = data?.[`longest_bow_shot_${gamemode}`] || 0;
+        this.arrowsShot = data?.[`arrows_shot_${gamemode}`] || 0;
+        this.arrowsHit = data?.[`arrows_hit_${gamemode}`] || 0;
+        this.bowAccuracy = divide(this.arrowsHit, this.arrowsShot);
+        this.fastestWin = data?.[`fastest_win_${gamemode}`] || 0;
+        this.heads = data?.[`heads_${gamemode}`] || 0;
+        this.insane = new SkywarsMode(data, `${gamemode}_insane`);
+        this.normal = new SkywarsMode(data, `${gamemode}_normal`);
+    }
+}
+class SkywarsKit {
+    kitData;
+    isKit;
+    gameMode;
+    kitType;
+    kitName;
+    constructor(kit) {
+        this.kitData = kit?.match(/^kit_([a-z]+)_([a-z]+)_([a-z]+)$/);
+        this.isKit = Boolean(this.kitData);
+        this.gameMode = this.kitData ? this.kitData?.[2] : '';
+        this.kitType = this.kitData ? this.kitData?.[1] : '';
+        this.kitName = removeSnakeCaseString(this.kitData ? this.kitData?.[3] : '');
+    }
+}
+class SkywarsKits {
+    kits;
+    constructor(kits) {
+        this.kits = kits.map((kit) => new SkywarsKit(kit)).filter((kit) => kit?.isKit);
+    }
+    get(gameMode = '', type = '') {
+        return this.kits.filter((kit) => kit?.gameMode?.startsWith(gameMode) && kit?.kitType.startsWith(type));
+    }
+}
+export class SkywarsPackages {
+    rawPackages;
+    cages;
+    kits;
+    achievements;
+    constructor(data) {
+        this.rawPackages = data;
+        this.cages = this.parseCages();
+        this.kits = new SkywarsKits(data);
+        this.achievements = this.rawPackages
+            ?.map((pkg) => pkg?.match(/^([A-Za-z]+)_?achievement([0-9]?)$/))
+            ?.filter((x) => x)
+            ?.map((x) => x?.slice(1)?.join(''));
+    }
+    parseCages() {
+        return this.rawPackages
+            ?.map((pkg) => pkg?.match(/^cage_([A-Za-z]+)-cage$/))
+            ?.filter((x) => x)
+            ?.map((x) => x[1]?.replace(/-[a-z]/g, (x) => x[1].toUpperCase()));
+    }
+}
+class SkyWars {
+    coins;
+    souls;
+    tokens;
+    experience;
+    level;
+    levelProgress;
+    levelFormatted;
+    prestige;
+    opals;
+    avarice;
+    tenacity;
+    shards;
+    angelOfDeathLevel;
+    killstreak;
+    kills;
+    voidKills;
+    meleeKills;
+    bowKills;
+    mobKills;
+    assists;
+    deaths;
+    KDR;
+    wins;
+    losses;
+    WLR;
+    gamesPlayed;
+    survivedPlayers;
+    chestsOpened;
+    timePlayed;
+    shard;
+    longestBowShot;
+    arrowsShot;
+    arrowsHit;
+    bowAccuracy;
+    fastestWin;
+    heads;
+    blocksPlaced;
+    blocksBroken;
+    eggThrown;
+    enderpearlsThrown;
+    solo;
+    team;
+    mega;
+    megaDoubles;
+    lab;
+    packages;
+    constructor(data) {
+        this.coins = data?.coins || 0;
+        this.souls = data?.souls || 0;
+        this.tokens = data?.cosmetic_tokens || 0;
+        this.experience = data?.skywars_experience || 0;
+        this.level = getSkyWarsLevel(data?.skywars_experience);
+        this.levelProgress = getSkyWarsLevelProgress(data?.skywars_experience);
+        this.levelFormatted = data?.levelFormatted
+            ? data?.levelFormatted
+                ?.replace(/§l/gm, '**')
+                ?.replace(/§([a-f]|[1-9])/gm, '')
+                ?.replace(/§r/gm, '')
+            : null;
+        this.prestige = getSkyWarsPrestige(this.level);
+        this.opals = data?.opals || 0;
+        this.avarice = data?.avarice || 0;
+        this.tenacity = data?.tenacity || 0;
+        this.shards = data?.shard || 0;
+        this.angelOfDeathLevel = data?.angel_of_death_level || 0;
+        this.killstreak = data?.killstreak || 0;
+        this.kills = data?.kills || 0;
+        this.voidKills = data?.void_kills || 0;
+        this.meleeKills = data?.melee_kills || 0;
+        this.bowKills = data?.bow_kills || 0;
+        this.mobKills = data?.mob_kills || 0;
+        this.assists = data?.assists || 0;
+        this.deaths = data?.deaths || 0;
+        this.KDR = divide(data?.kills, data?.deaths);
+        this.wins = data?.wins || 0;
+        this.losses = data?.losses || 0;
+        this.WLR = divide(data?.wins, data?.losses);
+        this.gamesPlayed = data?.games || 0;
+        this.survivedPlayers = data?.survived_players || 0;
+        this.chestsOpened = data?.chests_opened || 0;
+        this.timePlayed = data?.time_played || 0;
+        this.shard = data?.shard || 0;
+        this.longestBowShot = data?.longest_bow_shot || 0;
+        this.arrowsShot = data?.arrows_shot || 0;
+        this.arrowsHit = data?.arrows_hit || 0;
+        this.bowAccuracy = divide(this.arrowsHit, this.arrowsShot);
+        this.fastestWin = data?.fastest_win || 0;
+        this.heads = data?.heads || 0;
+        this.blocksPlaced = data?.blocks_placed || 0;
+        this.blocksBroken = data?.blocks_broken || 0;
+        this.eggThrown = data?.egg_thrown || 0;
+        this.enderpearlsThrown = data?.enderpearls_thrown || 0;
+        this.solo = new SkywarsModeStats(data, 'solo');
+        this.team = new SkywarsModeStats(data, 'team');
+        this.mega = new SkywarsMode(data, 'mega');
+        this.megaDoubles = new SkywarsMode(data, 'mega_doubles');
+        this.lab = new SkywarsMode(data, 'lab');
+        this.packages = new SkywarsPackages(data?.packages || []);
+    }
+}
+export default SkyWars;