hypixel-api-reborn 11.3.4 → 12.0.0-0

package/dist/src/utils/Guild.js

@@ -0,0 +1,71 @@
+import GuildMember from '../structures/Guild/GuildMember';
+import GuildRank from '../structures/Guild/GuildRank';
+const dateRegExp = /(\d{4})-(\d{2})-(\d{2})/;
+export function parseDate(date) {
+    date[1] -= 1;
+    return new Date(Math.round(new Date(new Date().setUTCFullYear(...date)).setUTCHours(5, 0, 0) / 1000) * 1000);
+}
+export function parseHistory(historyData) {
+    return Object.entries(historyData).map((x, index) => ({
+        day: x[0],
+        date: x[0].match(dateRegExp)
+            ? parseDate(x[0]
+                .match(dateRegExp)
+                .slice(1)
+                .map((x) => parseInt(x, 10)))
+            : undefined,
+        exp: x[1] || 0,
+        totalExp: Object.values(historyData)
+            .slice(0, index + 1)
+            .reduce((pV, cV) => pV + cV, 0) || 0
+    }));
+}
+export function getGuildLevel(exp) {
+    const EXP_NEEDED = [
+        100000, 150000, 250000, 500000, 750000, 1000000, 1250000, 1500000, 2000000, 2500000, 2500000, 2500000, 2500000,
+        2500000, 3000000
+    ];
+    let level = 0;
+    for (let i = 0; 1000 >= i; i += 1) {
+        let need;
+        if (i >= EXP_NEEDED.length) {
+            need = EXP_NEEDED[EXP_NEEDED.length - 1];
+        }
+        else {
+            need = EXP_NEEDED[i];
+        }
+        if (0 > exp - need) {
+            return Math.round((level + exp / need) * 100) / 100;
+        }
+        level += 1;
+        exp -= need;
+    }
+    return 1000;
+}
+export function ranks(data) {
+    return data.ranks && data.ranks.length
+        ? data.ranks.map((r) => new GuildRank(r)).sort((a, b) => a.priority - b.priority)
+        : [];
+}
+export function expLimit(exp) {
+    return 2e5 < exp ? (7e5 < exp ? 2.5e5 + Math.round(exp * 0.03) : 2e5 + Math.round((exp - 2e5) / 10)) : exp;
+}
+export function calculateExpHistory(data) {
+    const finalObj = {};
+    for (const day of Object.keys(data.members[0].expHistory)) {
+        let gexp = 0;
+        for (const member of data.members) {
+            gexp += member.expHistory[day] || 0;
+        }
+        finalObj[day] = expLimit(gexp);
+    }
+    return parseHistory(finalObj);
+}
+export function members(data) {
+    return data.members.length ? data.members.map((m) => new GuildMember(m)) : [];
+}
+export function totalWeeklyGexp(data) {
+    return members(data)
+        .map((m) => m.weeklyExperience)
+        .reduce((acc, cur) => acc + cur);
+}

package/dist/src/utils/Player.js

@@ -0,0 +1,88 @@
+export function getRank(player) {
+    if (player.prefix) {
+        switch (player.prefix.replace(/§[0-9|a-z]|\[|\]/g, '')) {
+            case 'EVENTS':
+                return 'Events';
+            case 'MOJANG':
+                return 'Mojang';
+            case 'PIG+++':
+                return 'PIG+++';
+            case 'INNIT':
+                return 'Innit';
+            default:
+                return 'Default';
+        }
+    }
+    else if (player.rank) {
+        switch (player.rank) {
+            case 'ADMIN':
+                return 'Admin';
+            case 'GAME_MASTER':
+                return 'Game Master';
+            default:
+                return 'Default';
+        }
+    }
+    else {
+        switch (player.newPackageRank) {
+            case 'MVP_PLUS':
+                return 'SUPERSTAR' !== player.monthlyPackageRank ? 'MVP+' : 'MVP++';
+            case 'MVP':
+                return 'MVP';
+            case 'VIP_PLUS':
+                return 'VIP+';
+            case 'VIP':
+                return 'VIP';
+            default:
+                return 'Default';
+        }
+    }
+}
+export function getPlayerLevel(exp) {
+    const base = 10000;
+    const growth = 2500;
+    const reversePqPrefix = -(base - 0.5 * growth) / growth;
+    const reverseConst = reversePqPrefix * reversePqPrefix;
+    const growthdivides2 = 2 / growth;
+    const num = 1 + reversePqPrefix + Math.sqrt(reverseConst + growthdivides2 * exp);
+    const level = Math.round(num * 100) / 100;
+    return level;
+}
+export function xpToNextLevel(xp) {
+    const lvl = getPlayerLevel(xp);
+    const xpToNext = 2500 * Math.floor(lvl) + 5000;
+    if (10000 > xp)
+        return 10000;
+    return xpToNext;
+}
+export function levelToXP(xp) {
+    let level = Number(Math.floor(getPlayerLevel(xp)));
+    level = level - 1;
+    return 1250 * level ** 2 + 8750 * level;
+}
+export function playerLevelProgress(xp) {
+    const xpFromLevel = levelToXP(xp);
+    let currentXP = xp - xpFromLevel;
+    const xpToNext = xpToNextLevel(xp);
+    const remainingXP = xpToNext - currentXP + 2500;
+    currentXP = currentXP - 2500;
+    const percent = Math.round((currentXP / xpToNext) * 100 * 100) / 100;
+    const percentRemaining = Math.round((100 - percent) * 100) / 100;
+    return { xpToNext, remainingXP, currentXP, percent, percentRemaining };
+}
+export function getSocialMedia(data) {
+    const links = data?.links || {};
+    const formattedNames = ['Twitter', 'YouTube', 'Instagram', 'Twitch', 'Hypixel', 'Discord'];
+    const upperNames = ['TWITTER', 'YOUTUBE', 'INSTAGRAM', 'TWITCH', 'HYPIXEL', 'DISCORD'];
+    return Object.keys(links)
+        .map((x) => upperNames.indexOf(x))
+        .filter((x) => -1 !== x)
+        .map((x) => ({ name: formattedNames[x], link: links[upperNames[x]], id: upperNames[x] }));
+}
+export function parseClaimedRewards(data) {
+    return Object.keys(data)
+        .map((x) => x.match(/levelingReward_(\d+)/))
+        .filter((x) => x)
+        .map((x) => (x ? parseInt(x[1], 10) : null))
+        .filter((x) => null !== x);
+}

package/dist/src/utils/Player.test.js

@@ -0,0 +1,82 @@
+/* eslint-disable camelcase */
+import { describe, expect, test } from 'vitest';
+import { getPlayerLevel, getRank, getSocialMedia, levelToXP, parseClaimedRewards, playerLevelProgress, xpToNextLevel } from '../utils/Player';
+test('getRank', () => {
+    expect(getRank({ prefix: '[EVENTS]' })).toBe('Events');
+    expect(getRank({ prefix: '[MOJANG]' })).toBe('Mojang');
+    expect(getRank({ prefix: '[PIG+++]' })).toBe('PIG+++');
+    expect(getRank({ prefix: '[INNIT]' })).toBe('Innit');
+    expect(getRank({ prefix: '[meow]' })).toBe('Default');
+    expect(getRank({ rank: 'ADMIN' })).toBe('Admin');
+    expect(getRank({ rank: 'GAME_MASTER' })).toBe('Game Master');
+    expect(getRank({ rank: 'Meow' })).toBe('Default');
+    expect(getRank({ newPackageRank: 'MVP_PLUS', monthlyPackageRank: 'SUPERSTAR' })).toBe('MVP++');
+    expect(getRank({ newPackageRank: 'MVP_PLUS', monthlyPackageRank: 'Meow' })).toBe('MVP+');
+    expect(getRank({ newPackageRank: 'MVP' })).toBe('MVP');
+    expect(getRank({ newPackageRank: 'VIP_PLUS' })).toBe('VIP+');
+    expect(getRank({ newPackageRank: 'VIP' })).toBe('VIP');
+    expect(getRank({ newPackageRank: 'meow' })).toBe('Default');
+});
+test('getPlayerLevel', () => {
+    describe('should calculate the player level correctly', () => {
+        const exp = 10000;
+        expect(getPlayerLevel(exp)).toBe(1);
+    });
+});
+test('xpToNextLevel', () => {
+    describe('should calculate the XP required for the next level correctly', () => {
+        const xp = 10000;
+        expect(xpToNextLevel(xp)).toBe(25000);
+    });
+    describe('should return 10000 if the XP is less than 10000', () => {
+        const xp = 5000;
+        expect(xpToNextLevel(xp)).toBe(10000);
+    });
+});
+test('levelToXP', () => {
+    describe('should calculate the XP required for a given level correctly', () => {
+        const level = 2;
+        expect(levelToXP(level)).toBe(20000);
+    });
+});
+test('playerLevelProgress', () => {
+    describe('should calculate the player level progress correctly', () => {
+        const xp = 15000;
+        const expectedProgress = {
+            xpToNext: 37500,
+            remainingXP: 22500,
+            currentXP: 12500,
+            percent: 33.33,
+            percentRemaining: 66.67
+        };
+        expect(playerLevelProgress(xp)).toEqual(expectedProgress);
+    });
+});
+test('getSocialMedia', () => {
+    describe('should return the formatted social media links', () => {
+        const data = {
+            links: {
+                TWITTER: 'https://twitter.com/example',
+                YOUTUBE: 'https://youtube.com/example',
+                INSTAGRAM: 'https://instagram.com/example'
+            }
+        };
+        const expectedSocialMedia = [
+            { name: 'Twitter', link: 'https://twitter.com/example', id: 'TWITTER' },
+            { name: 'YouTube', link: 'https://youtube.com/example', id: 'YOUTUBE' },
+            { name: 'Instagram', link: 'https://instagram.com/example', id: 'INSTAGRAM' }
+        ];
+        expect(getSocialMedia(data)).toEqual(expectedSocialMedia);
+    });
+});
+test('parseClaimedRewards', () => {
+    describe('should parse the claimed rewards correctly', () => {
+        const data = {
+            levelingReward_1: true,
+            levelingReward_3: true,
+            levelingReward_5: true
+        };
+        const expectedRewards = [1, 3, 5];
+        expect(parseClaimedRewards(data)).toEqual(expectedRewards);
+    });
+});

package/dist/src/utils/SkyblockUtils.js

@@ -0,0 +1,342 @@
+import Constants from './Constants';
+import { parse, simplify } from 'prismarine-nbt';
+export async function decode(base64, isBuffer = false) {
+    // Credit: https://github.com/SkyCryptWebsite/SkyCryptv2/blob/3b5b3ae4fe77c60eff90691797f09024baf68872/src/lib/server/stats/items/processing.ts#L215-L218
+    const buffer = isBuffer ? base64 : Buffer.from(base64, 'base64');
+    const parseData = await parse(buffer);
+    const data = simplify(parseData.parsed);
+    const newdata = [];
+    for (let i = 0; i < data.i.length; i++) {
+        newdata.push(data.i[i]);
+    }
+    return newdata;
+}
+export function getLevelByXp(xp, type) {
+    let xpTable;
+    switch (type) {
+        case 'runecrafting':
+            xpTable = Constants.runecraftingXp;
+            break;
+        case 'dungeons':
+            xpTable = Constants.dungeonXp;
+            break;
+        case 'hotm':
+            xpTable = Constants.hotmXp;
+            break;
+        case 'social':
+            xpTable = Constants.socialXp;
+            break;
+        case 'garden':
+            xpTable = Constants.garden;
+            break;
+        case 'wheat':
+            xpTable = Constants.wheat;
+            break;
+        case 'carrot':
+            xpTable = Constants.carrot;
+            break;
+        case 'potato':
+            xpTable = Constants.potato;
+            break;
+        case 'melon':
+            xpTable = Constants.melon;
+            break;
+        case 'pumpkin':
+            xpTable = Constants.pumpkin;
+            break;
+        case 'sugarCane':
+            xpTable = Constants.sugarCane;
+            break;
+        case 'cocoaBeans':
+            xpTable = Constants.cocoaBeans;
+            break;
+        case 'cactus':
+            xpTable = Constants.cactus;
+            break;
+        case 'mushroom':
+            xpTable = Constants.mushroom;
+            break;
+        case 'netherWart':
+            xpTable = Constants.netherWart;
+            break;
+        default:
+            xpTable = Constants.levelingXp;
+    }
+    const maxLevel = Math.max(...Object.keys(xpTable).map(Number));
+    if (isNaN(xp)) {
+        return {
+            xp: 0,
+            level: 0,
+            maxLevel,
+            xpCurrent: 0,
+            xpForNext: xpTable[1],
+            progress: 0,
+            cosmetic: Boolean('runecrafting' === type || 'social' === type)
+        };
+    }
+    let xpTotal = 0;
+    let level = 0;
+    let xpForNext = 0;
+    for (let x = 1; x <= maxLevel; x++) {
+        if (!xpTable[x])
+            continue;
+        xpTotal += xpTable[x];
+        if (xpTotal > xp) {
+            xpTotal -= xpTable[x];
+            break;
+        }
+        else {
+            level = x;
+        }
+    }
+    const xpCurrent = Math.floor(xp - xpTotal);
+    if (level < maxLevel)
+        xpForNext = Math.ceil(xpTable[level + 1]);
+    const progress = Math.floor(Math.max(0, Math.min(xpCurrent / xpForNext, 1)) * 100 * 10) / 10;
+    return {
+        xp: xp,
+        level: level,
+        maxLevel: maxLevel,
+        xpCurrent: xpCurrent,
+        xpForNext: xpForNext,
+        progress: progress,
+        cosmetic: Boolean('runecrafting' === type || 'social' === type)
+    };
+}
+export function getSlayerLevel(slayer) {
+    if (!slayer) {
+        return { xp: 0, tier1: 0, tier2: 0, tier3: 0, tier4: 0, tier5: 0, level: 0 };
+    }
+    // eslint-disable-next-line camelcase
+    const { claimed_levels } = slayer;
+    let level = 0;
+    // eslint-disable-next-line camelcase
+    for (const levelName in claimed_levels) {
+        if (Object.prototype.hasOwnProperty.call(claimed_levels, levelName)) {
+            const newLevel = parseInt(levelName.replace('_special', '').split('_').pop() ?? '', 10);
+            if (newLevel > level) {
+                level = newLevel;
+            }
+        }
+    }
+    return {
+        xp: slayer.xp || 0,
+        tier1: slayer.boss_kills_tier_0 || 0,
+        tier2: slayer.boss_kills_tier_1 || 0,
+        tier3: slayer.boss_kills_tier_2 || 0,
+        tier4: slayer.boss_kills_tier_3 || 0,
+        tier5: slayer.boss_kills_tier_4 || 0,
+        level
+    };
+}
+export function getTrophyFishRank(level) {
+    if (1 === level) {
+        return 'Bronze';
+    }
+    else if (2 === level) {
+        return 'Silver';
+    }
+    else if (3 === level) {
+        return 'Gold';
+    }
+    else if (4 === level) {
+        return 'Diamond';
+    }
+    return 'Bronze';
+}
+export function getSkills(data) {
+    const skillsObject = {
+        combat: getLevelByXp(data?.player_data?.experience?.SKILL_COMBAT ?? 0, 'combat'),
+        farming: getLevelByXp(data?.player_data?.experience?.SKILL_FARMING ?? 0, 'farming'),
+        fishing: getLevelByXp(data?.player_data?.experience?.SKILL_FISHING ?? 0, 'fishing'),
+        mining: getLevelByXp(data?.player_data?.experience?.SKILL_MINING ?? 0, 'mining'),
+        foraging: getLevelByXp(data?.player_data?.experience?.SKILL_FORAGING ?? 0, 'foraging'),
+        enchanting: getLevelByXp(data?.player_data?.experience?.SKILL_ENCHANTING ?? 0, 'enchanting'),
+        alchemy: getLevelByXp(data?.player_data?.experience?.SKILL_ALCHEMY ?? 0, 'alchemy'),
+        carpentry: getLevelByXp(data?.player_data?.experience?.SKILL_CARPENTRY ?? 0, 'carpentry'),
+        runecrafting: getLevelByXp(data?.player_data?.experience?.SKILL_RUNECRAFTING ?? 0, 'runecrafting'),
+        taming: getLevelByXp(data?.player_data?.experience?.SKILL_TAMING ?? 0, 'taming'),
+        social: getLevelByXp(data?.player_data?.experience?.SKILL_SOCIAL ?? 0, 'social'),
+        average: 0
+    };
+    const levels = Object.values(skillsObject)
+        .filter((skill) => true !== skill.cosmetic)
+        .map((skill) => skill.level);
+    skillsObject.average = levels.reduce((a, b) => a + b, 0) / levels.length;
+    return skillsObject;
+}
+function formatBestiaryMobs(userProfile, mobs) {
+    const output = [];
+    for (const mob of mobs) {
+        const mobBracket = Constants.bestiaryBrackets[mob.bracket];
+        const totalKills = mob.mobs.reduce((acc, cur) => {
+            return acc + (userProfile.bestiary.kills[cur] ?? 0);
+        }, 0);
+        const maxKills = mob.cap;
+        const nextTierKills = mobBracket.find((tier) => totalKills < tier && tier <= maxKills);
+        const tier = nextTierKills ? mobBracket.indexOf(nextTierKills) : mobBracket.indexOf(maxKills) + 1;
+        output.push({ tier: tier });
+    }
+    return output;
+}
+export function getBestiaryLevel(userProfile) {
+    if (userProfile?.bestiary?.kills === undefined) {
+        return 0;
+    }
+    const output = {};
+    let tiersUnlocked = 0;
+    for (const [category, data] of Object.entries(Constants.bestiary)) {
+        const { mobs } = data;
+        output[category] = {};
+        if ('fishing' === category) {
+            for (const [key, value] of Object.entries(data)) {
+                output[category][key] = { mobs: formatBestiaryMobs(userProfile, value.mobs) };
+                tiersUnlocked += output[category][key].mobs.reduce((acc, cur) => acc + cur.tier, 0);
+            }
+        }
+        else {
+            output[category].mobs = formatBestiaryMobs(userProfile, mobs);
+            tiersUnlocked += output[category].mobs.reduce((acc, cur) => acc + cur.tier, 0);
+        }
+    }
+    return tiersUnlocked / 10;
+}
+export function getSlayer(data) {
+    if (!data?.slayer?.slayer_bosses)
+        return null;
+    return {
+        zombie: getSlayerLevel(data?.slayer?.slayer_bosses?.zombie),
+        spider: getSlayerLevel(data?.slayer?.slayer_bosses?.spider),
+        wolf: getSlayerLevel(data?.slayer?.slayer_bosses?.wolf),
+        enderman: getSlayerLevel(data?.slayer?.slayer_bosses?.enderman),
+        blaze: getSlayerLevel(data?.slayer?.slayer_bosses?.blaze),
+        vampire: getSlayerLevel(data?.slayer?.slayer_bosses?.vampire)
+    };
+}
+export function getDungeons(data) {
+    return {
+        types: { catacombs: getLevelByXp(data?.dungeons?.dungeon_types?.catacombs ?? 0, 'dungeons') },
+        classes: {
+            healer: getLevelByXp(data?.dungeons?.player_classes?.healer ?? 0, 'dungeons'),
+            mage: getLevelByXp(data?.dungeons?.player_classes?.mage ?? 0, 'dungeons'),
+            berserk: getLevelByXp(data?.dungeons?.player_classes?.berserk ?? 0, 'dungeons'),
+            archer: getLevelByXp(data?.dungeons?.player_classes?.archer ?? 0, 'dungeons'),
+            tank: getLevelByXp(data?.dungeons?.player_classes?.tank ?? 0, 'dungeons')
+        }
+    };
+}
+export function getJacobData(data) {
+    return {
+        medals: {
+            bronze: data?.jacobs_contest?.medals_inv?.bronze || 0,
+            silver: data?.jacobs_contest?.medals_inv?.silver || 0,
+            gold: data?.jacobs_contest?.medals_inv?.gold || 0
+        },
+        perks: {
+            doubleDrops: data?.jacobs_contest?.perks?.double_drops || 0,
+            farmingLevelCap: data?.jacobs_contest?.perks?.farming_level_cap || 0,
+            personalBests: data?.jacobs_contest?.perks?.personal_bests || false
+        },
+        contests: data?.jacobs_contestcontests || {}
+    };
+}
+export function getChocolateFactory(data) {
+    if (!data?.events?.easter) {
+        return {
+            employees: { bro: 0, cousin: 0, sis: 0, father: 0, grandma: 0, dog: 0, uncle: 0 },
+            chocolate: { current: 0, total: 0, sincePrestige: 0 },
+            timeTower: { charges: 0, level: 0 },
+            upgrades: { click: 0, multiplier: 0, rabbitRarity: 0 },
+            goldenClick: { amount: 0, year: 0 },
+            barnCapacity: 0,
+            prestige: 0
+        };
+    }
+    return {
+        employees: {
+            bro: data?.events?.easter?.employees?.rabbit_bro || 0,
+            cousin: data?.events?.easter?.employees?.rabbit_cousin || 0,
+            sis: data?.events?.easter?.employees?.rabbit_sis || 0,
+            father: data?.events?.easter?.employees?.rabbit_father || 0,
+            grandma: data?.events?.easter?.employees?.rabbit_grandma || 0,
+            dog: data?.events?.easter?.employees?.rabbit_dog || 0,
+            uncle: data?.events?.easter?.employees?.rabbit_uncle || 0
+        },
+        chocolate: {
+            current: data?.events?.easter?.chocolate || 0,
+            total: data?.events?.easter?.total_chocolate || 0,
+            sincePrestige: data?.events?.easter?.chocolate_since_prestige || 0
+        },
+        timeTower: {
+            charges: data?.events?.easter?.time_tower?.charges || 0,
+            level: data?.events?.easter?.time_tower?.level || 0
+        },
+        upgrades: {
+            click: data?.events?.easter?.click_upgrades || 0,
+            multiplier: data?.events?.easter?.chocolate_multiplier_upgrades || 0,
+            rabbitRarity: data?.events?.easter?.rabbit_rarity_upgrades || 0
+        },
+        goldenClick: {
+            amount: data?.events?.easter?.golden_click_amount || 0,
+            year: data?.events?.easter?.golden_click_year || 0
+        },
+        barnCapacity: data?.events?.easter?.rabbit_barn_capacity_level || 0,
+        prestige: data?.events?.easter?.chocolate_level || 0
+    };
+}
+export function getPetLevel(petExp, offsetRarity, maxLevel) {
+    const rarityOffset = Constants.petRarityOffset[offsetRarity];
+    const levels = Constants.petLevels.slice(rarityOffset, rarityOffset + maxLevel - 1);
+    const xpMaxLevel = levels.reduce((a, b) => a + b, 0);
+    let xpTotal = 0;
+    let level = 1;
+    let xpForNext;
+    for (let i = 0; i < maxLevel; i++) {
+        xpTotal += levels[i];
+        if (xpTotal > petExp) {
+            xpTotal -= levels[i];
+            break;
+        }
+        else {
+            level++;
+        }
+    }
+    let xpCurrent = Math.floor(petExp - xpTotal);
+    let progress;
+    if (level < maxLevel) {
+        xpForNext = Math.ceil(levels[level - 1]);
+        progress = Math.max(0, Math.min(xpCurrent / xpForNext, 1));
+    }
+    else {
+        level = maxLevel;
+        xpCurrent = petExp - levels[maxLevel - 1];
+        xpForNext = 0;
+        progress = 1;
+    }
+    return { level, xpCurrent, xpForNext, progress, xpMaxLevel };
+}
+export function parseRarity(str) {
+    const rarityArray = [
+        'COMMON',
+        'UNCOMMON',
+        'RARE',
+        'EPIC',
+        'LEGENDARY',
+        'MYTHIC',
+        'DIVINE',
+        'SPECIAL',
+        'VERY SPECIAL'
+    ];
+    for (const rarity of rarityArray) {
+        if (str.includes(rarity))
+            return rarity;
+    }
+    return 'COMMON';
+}
+export function parseGearScore(lore) {
+    for (const line of lore) {
+        if (line.match(/Gear Score: §[0-9a-f](\d+)/))
+            return Number(line.match(/Gear Score: §d(\d+)/)[1]);
+    }
+    return 0;
+}

package/dist/src/utils/SkyblockUtils.test.js

@@ -0,0 +1,8 @@
+import { expect, test } from 'vitest';
+import { getTrophyFishRank } from './SkyblockUtils';
+test('getTrophyFishRank', () => {
+    expect(getTrophyFishRank(1)).toBe('Bronze');
+    expect(getTrophyFishRank(2)).toBe('Silver');
+    expect(getTrophyFishRank(3)).toBe('Gold');
+    expect(getTrophyFishRank(4)).toBe('Diamond');
+});

package/dist/src/utils/divide.js

@@ -0,0 +1,6 @@
+export default function divide(a, b) {
+    const out = Number(((a || 0) / (b || 0)).toFixed(2)) || 0;
+    if (isFinite(out))
+        return out;
+    return a;
+}

package/dist/src/utils/divide.test.js

@@ -0,0 +1,12 @@
+import divide from './divide';
+import { expect, expectTypeOf, test } from 'vitest';
+test('Divide', () => {
+    expect(divide(10, 2)).toBe(5);
+    expectTypeOf(divide(10, 2)).toBeNumber();
+    expect(divide(10, 0)).toBe(10);
+    expectTypeOf(divide(10, 0)).toBeNumber();
+    expect(divide(0, 0)).toBe(0);
+    expectTypeOf(divide(0, 0)).toBeNumber();
+    expect(divide(-5, 10)).toBe(-0.5);
+    expectTypeOf(divide(-5, 10)).toBeNumber();
+});

package/dist/src/utils/isGuildID.js

@@ -0,0 +1,3 @@
+export default function isGuildID(id) {
+    return 24 === id.length;
+}

package/dist/src/utils/isGuildID.test.js

@@ -0,0 +1,16 @@
+import isGuildID from './isGuildID';
+import { expect, expectTypeOf, test } from 'vitest';
+const ids = ['5b8dd8cb0cf24573ab84c9ad', '656618008ea8c9dca6f3668d', '5ba94ed50cf2cc24cf043706'];
+const idsInvalid = ['invalid', 'hello why are you here?', ''];
+test('Valid Guild ID', () => {
+    ids.forEach((id) => {
+        expect(isGuildID(id)).toBe(true);
+        expectTypeOf(isGuildID(id)).toBeBoolean();
+    });
+});
+test('Invalid Guild ID', () => {
+    idsInvalid.forEach((id) => {
+        expect(isGuildID(id)).toBe(false);
+        expectTypeOf(isGuildID(id)).toBeBoolean();
+    });
+});

package/dist/src/utils/isUUID.js

@@ -0,0 +1,5 @@
+export default function (uuid) {
+    const regexp = /^[0-9a-f]{32}$/i;
+    uuid = uuid.replace(/-/g, '');
+    return regexp.test(uuid);
+}

package/dist/src/utils/isUUID.test.js

@@ -0,0 +1,31 @@
+import isUUID from './isUUID';
+import { expect, expectTypeOf, test } from 'vitest';
+const valid = [
+    '37501e7512b845ab8796e2baf9e9677a',
+    '17ec71b4e5fa467481344b319a2958c3',
+    '17ec71b4e5fa467481344b319a2958c3'
+];
+const dashs = [
+    'add71246-c46e-455c-8345-c129ea6f146c',
+    '1ac8f319-1ac8-4c44-93ac-fcae2848cd9f',
+    '337a48bf-57e9-44eb-8acb-83b885936e83'
+];
+const Invalid = ['invalid', 'hello why are you here?', ''];
+test('Valid Non Dashed UUIDS', () => {
+    valid.forEach((uuid) => {
+        expect(isUUID(uuid)).toBe(true);
+        expectTypeOf(isUUID(uuid)).toBeBoolean();
+    });
+});
+test('Valid Dashed UUIDS', () => {
+    dashs.forEach((uuid) => {
+        expect(isUUID(uuid)).toBe(true);
+        expectTypeOf(isUUID(uuid)).toBeBoolean();
+    });
+});
+test('Invalid UUID', () => {
+    Invalid.forEach((uuid) => {
+        expect(isUUID(uuid)).toBe(false);
+        expectTypeOf(isUUID(uuid)).toBeBoolean();
+    });
+});

package/dist/src/utils/oscillation.js

@@ -0,0 +1,13 @@
+// See https://github.com/HypixelDev/PublicAPI/blob/db26b5fd3b7bb29da14e40e6d211143ec44a4519/Documentation/misc/Oscillation.md
+// Month oscillation started in December 2014, so every month that is pair ( odd in js!! ) is month A
+// Weekly oscillation started... just refer to the code in the docs
+const weeklyOscillationStart = 1417237200000;
+export function monthAB(month) {
+    if (month === undefined) {
+        month = new Date().getMonth();
+    }
+    return month % 2 ? 'a' : 'b';
+}
+export function weekAB() {
+    return (Math.abs(new Date().getTime() - weeklyOscillationStart) / 604800000) % 2 ? 'a' : 'b';
+}