@rian8337/osu-base 1.0.0

package/dist/tools/MapInfo.js

@@ -0,0 +1,559 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapInfo = void 0;
+const request_1 = __importDefault(require("request"));
+const MapStats_1 = require("../utils/MapStats");
+const Parser_1 = require("../beatmap/Parser");
+const rankedStatus_1 = require("../constants/rankedStatus");
+const Slider_1 = require("../beatmap/hitobjects/Slider");
+const SliderTick_1 = require("../beatmap/hitobjects/sliderObjects/SliderTick");
+const APIRequestBuilder_1 = require("../utils/APIRequestBuilder");
+const Precision_1 = require("../utils/Precision");
+const Utils_1 = require("../utils/Utils");
+/**
+ * Represents a beatmap with general information.
+ */
+class MapInfo {
+    constructor() {
+        /**
+         * The title of the song of the beatmap.
+         */
+        this.title = "";
+        /**
+         * The artist of the song of the beatmap.
+         */
+        this.artist = "";
+        /**
+         * The creator of the beatmap.
+         */
+        this.creator = "";
+        /**
+         * The difficulty name of the beatmap.
+         */
+        this.version = "";
+        /**
+         * The source of the song, if any.
+         */
+        this.source = "";
+        /**
+         * The ranking status of the beatmap.
+         */
+        this.approved = 0;
+        /**
+         * The ID of the beatmap.
+         */
+        this.beatmapID = 0;
+        /**
+         * The ID of the beatmapset containing the beatmap.
+         */
+        this.beatmapsetID = 0;
+        /**
+         * The amount of times the beatmap has been played.
+         */
+        this.plays = 0;
+        /**
+         * The amount of times the beatmap has been favorited.
+         */
+        this.favorites = 0;
+        /**
+         * The date of which the beatmap was submitted.
+         */
+        this.submitDate = new Date(0);
+        /**
+         * The date of which the beatmap was last updated.
+         */
+        this.lastUpdate = new Date(0);
+        /**
+         * The duration of the beatmap not including breaks.
+         */
+        this.hitLength = 0;
+        /**
+         * The duration of the beatmap including breaks.
+         */
+        this.totalLength = 0;
+        /**
+         * The BPM of the beatmap.
+         */
+        this.bpm = 0;
+        /**
+         * The amount of circles in the beatmap.
+         */
+        this.circles = 0;
+        /**
+         * The amount of sliders in the beatmap.
+         */
+        this.sliders = 0;
+        /**
+         * The amount of spinners in the beatmap.
+         */
+        this.spinners = 0;
+        /**
+         * The maximum combo of the beatmap.
+         */
+        this.maxCombo = 0;
+        /**
+         * The circle size of the beatmap.
+         */
+        this.cs = 0;
+        /**
+         * The approach rate of the beatmap.
+         */
+        this.ar = 0;
+        /**
+         * The overall difficulty of the beatmap.
+         */
+        this.od = 0;
+        /**
+         * The health drain rate of the beatmap.
+         */
+        this.hp = 0;
+        /**
+         * The beatmap packs that contain this beatmap, represented by their ID.
+         */
+        this.packs = [];
+        /**
+         * The aim difficulty rating of the beatmap.
+         */
+        this.aimDifficulty = 0;
+        /**
+         * The speed difficulty rating of the beatmap.
+         */
+        this.speedDifficulty = 0;
+        /**
+         * The generic difficulty rating of the beatmap.
+         */
+        this.totalDifficulty = 0;
+        /**
+         * The MD5 hash of the beatmap.
+         */
+        this.hash = "";
+        /**
+         * Whether or not this beatmap has a storyboard.
+         */
+        this.storyboardAvailable = false;
+        /**
+         * Whether or not this beatmap has a video.
+         */
+        this.videoAvailable = false;
+    }
+    /**
+     * The full title of the beatmap, which is `Artist - Title (Creator) [Difficulty Name]`.
+     */
+    get fullTitle() {
+        return `${this.artist} - ${this.title} (${this.creator}) [${this.version}]`;
+    }
+    /**
+     * The amount of objects in the beatmap.
+     */
+    get objects() {
+        return this.circles + this.sliders + this.spinners;
+    }
+    /**
+     * The parsed beatmap from beatmap parser.
+     */
+    get map() {
+        return Utils_1.Utils.deepCopy(this.cachedBeatmap);
+    }
+    /**
+     * Retrieve a beatmap's general information.
+     *
+     * Either beatmap ID or MD5 hash of the beatmap must be specified. If both are specified, beatmap ID is taken.
+     */
+    static async getInformation(params) {
+        params.file ??= true;
+        const beatmapID = params.beatmapID;
+        const hash = params.hash;
+        if (!beatmapID && !hash) {
+            throw new Error("Beatmap ID or MD5 hash must be defined");
+        }
+        const apiRequestBuilder = new APIRequestBuilder_1.OsuAPIRequestBuilder().setEndpoint("get_beatmaps");
+        if (beatmapID) {
+            apiRequestBuilder.addParameter("b", beatmapID);
+        }
+        else if (hash) {
+            apiRequestBuilder.addParameter("h", hash);
+        }
+        const map = new MapInfo();
+        const result = await apiRequestBuilder.sendRequest();
+        if (result.statusCode !== 200) {
+            throw new Error("API error");
+        }
+        const mapinfo = JSON.parse(result.data.toString("utf-8"))[0];
+        if (!mapinfo) {
+            return map;
+        }
+        if (parseInt(mapinfo.mode) !== 0) {
+            return map;
+        }
+        map.fillMetadata(mapinfo);
+        if (params.file) {
+            await map.retrieveBeatmapFile();
+        }
+        return map;
+    }
+    /**
+     * Fills the current instance with map data.
+     *
+     * @param mapinfo The map data.
+     */
+    fillMetadata(mapinfo) {
+        this.title = mapinfo.title;
+        this.artist = mapinfo.artist;
+        this.creator = mapinfo.creator;
+        this.version = mapinfo.version;
+        this.source = mapinfo.source;
+        this.approved = parseInt(mapinfo.approved);
+        this.beatmapID = parseInt(mapinfo.beatmap_id);
+        this.beatmapsetID = parseInt(mapinfo.beatmapset_id);
+        this.plays = parseInt(mapinfo.playcount);
+        this.favorites = parseInt(mapinfo.favourite_count);
+        const t = mapinfo.last_update
+            .split(/[- :]/)
+            .map((e) => parseInt(e));
+        this.lastUpdate = new Date(Date.UTC(t[0], t[1] - 1, t[2], t[3], t[4], t[5]));
+        const s = mapinfo.submit_date
+            .split(/[- :]/)
+            .map((e) => parseInt(e));
+        this.submitDate = new Date(Date.UTC(s[0], s[1] - 1, s[2], s[3], s[4], s[5]));
+        this.hitLength = parseInt(mapinfo.hit_length);
+        this.totalLength = parseInt(mapinfo.total_length);
+        this.bpm = parseFloat(mapinfo.bpm);
+        this.circles = mapinfo.count_normal
+            ? parseInt(mapinfo.count_normal)
+            : 0;
+        this.sliders = mapinfo.count_slider
+            ? parseInt(mapinfo.count_slider)
+            : 0;
+        this.spinners = mapinfo.count_spinner
+            ? parseInt(mapinfo.count_spinner)
+            : 0;
+        this.maxCombo = parseInt(mapinfo.max_combo);
+        this.cs = parseFloat(mapinfo.diff_size);
+        this.ar = parseFloat(mapinfo.diff_approach);
+        this.od = parseFloat(mapinfo.diff_overall);
+        this.hp = parseFloat(mapinfo.diff_drain);
+        if (mapinfo.packs) {
+            this.packs = mapinfo.packs.split(",").map((pack) => pack.trim());
+        }
+        this.aimDifficulty = mapinfo.diff_aim
+            ? parseFloat(mapinfo.diff_aim)
+            : 0;
+        this.speedDifficulty = mapinfo.diff_speed
+            ? parseFloat(mapinfo.diff_speed)
+            : 0;
+        this.totalDifficulty = mapinfo.difficultyrating
+            ? parseFloat(mapinfo.difficultyrating)
+            : 0;
+        this.hash = mapinfo.file_md5;
+        this.storyboardAvailable = !!parseInt(mapinfo.storyboard);
+        this.videoAvailable = !!parseInt(mapinfo.video);
+        return this;
+    }
+    /**
+     * Retrieves the .osu file of the beatmap.
+     *
+     * @param forceDownload Whether or not to download the file regardless if it's already available.
+     */
+    retrieveBeatmapFile(forceDownload) {
+        return new Promise((resolve) => {
+            if (this.cachedBeatmap && !forceDownload) {
+                return resolve(this);
+            }
+            const url = `https://osu.ppy.sh/osu/${this.beatmapID}`;
+            const dataArray = [];
+            (0, request_1.default)(url, { timeout: 10000 })
+                .on("data", (chunk) => {
+                dataArray.push(Buffer.from(chunk));
+            })
+                .on("complete", (response) => {
+                if (response.statusCode !== 200) {
+                    return resolve(this);
+                }
+                this.cachedBeatmap = new Parser_1.Parser().parse(Buffer.concat(dataArray).toString("utf8")).map;
+                resolve(this);
+            });
+        });
+    }
+    /**
+     * Converts the beatmap's BPM if speed-changing mods are applied.
+     */
+    convertBPM(stats) {
+        let bpm = this.bpm;
+        bpm *= stats.speedMultiplier;
+        return parseFloat(bpm.toFixed(2));
+    }
+    /**
+     * Converts the beatmap's status into a string.
+     */
+    convertStatus() {
+        let status = "Unknown";
+        for (const stat in rankedStatus_1.rankedStatus) {
+            if (rankedStatus_1.rankedStatus[stat] ===
+                this.approved) {
+                status = stat;
+                break;
+            }
+        }
+        return status !== "WIP"
+            ? status.charAt(0) + status.slice(1).toLowerCase()
+            : status;
+    }
+    /**
+     * Converts the beatmap's length if speed-changing mods are applied.
+     */
+    convertTime(stats) {
+        let hitLength = this.hitLength;
+        let totalLength = this.totalLength;
+        hitLength /= stats.speedMultiplier;
+        totalLength /= stats.speedMultiplier;
+        return `${this.timeString(this.hitLength)}${this.hitLength === hitLength
+            ? ""
+            : ` (${this.timeString(hitLength)})`}/${this.timeString(this.totalLength)}${this.totalLength === totalLength
+            ? ""
+            : ` (${this.timeString(totalLength)})`}`;
+    }
+    /**
+     * Time string parsing function for statistics utility.
+     */
+    timeString(second) {
+        let str = new Date(1000 * Math.ceil(second))
+            .toISOString()
+            .substr(11, 8)
+            .replace(/^[0:]+/, "");
+        if (second < 60) {
+            str = "0:" + str;
+        }
+        return str;
+    }
+    /**
+     * Shows the beatmap's statistics based on applied statistics and option.
+     *
+     * - Option `0`: return map title and mods used if defined
+     * - Option `1`: return song source and map download link to beatmap mirrors
+     * - Option `2`: return CS, AR, OD, HP
+     * - Option `3`: return BPM, map length, max combo
+     * - Option `4`: return last update date and map status
+     * - Option `5`: return favorite count and play count
+     *
+     * @param option The option to pick.
+     * @param stats The custom statistics to apply. This will only be used to apply mods, custom speed multiplier, and force AR.
+     */
+    showStatistics(option, stats) {
+        const mapParams = {
+            cs: this.cs,
+            ar: this.ar,
+            od: this.od,
+            hp: this.hp,
+            mods: stats?.mods ?? [],
+            isForceAR: false,
+            speedMultiplier: 1,
+        };
+        if (stats) {
+            if (stats.isForceAR) {
+                mapParams.ar = stats.ar ?? mapParams.ar;
+            }
+            mapParams.isForceAR = stats.isForceAR ?? mapParams.isForceAR;
+            mapParams.speedMultiplier =
+                stats.speedMultiplier ?? mapParams.speedMultiplier;
+        }
+        const mapStatistics = new MapStats_1.MapStats(mapParams).calculate();
+        mapStatistics.cs = parseFloat(mapStatistics.cs.toFixed(2));
+        mapStatistics.ar = parseFloat(mapStatistics.ar.toFixed(2));
+        mapStatistics.od = parseFloat(mapStatistics.od.toFixed(2));
+        mapStatistics.hp = parseFloat(mapStatistics.hp.toFixed(2));
+        switch (option) {
+            case 0: {
+                let string = `${this.fullTitle}${(mapStatistics.mods.length ?? 0) > 0
+                    ? ` +${mapStatistics.mods
+                        .map((m) => m.acronym)
+                        .join("")}`
+                    : ""}`;
+                if (mapParams.speedMultiplier !== 1 ||
+                    mapStatistics.isForceAR) {
+                    string += " (";
+                    if (mapStatistics.isForceAR) {
+                        string += `AR${mapStatistics.ar}`;
+                    }
+                    if (mapParams.speedMultiplier !== 1) {
+                        if (mapStatistics.isForceAR) {
+                            string += ", ";
+                        }
+                        string += `${mapParams.speedMultiplier}x`;
+                    }
+                    string += ")";
+                }
+                return string;
+            }
+            case 1: {
+                let string = `${this.source ? `**Source**: ${this.source}\n` : ""}**Download**: [osu!](https://osu.ppy.sh/d/${this.beatmapsetID})${this.videoAvailable
+                    ? ` [(no video)](https://osu.ppy.sh/d/${this.beatmapsetID}n)`
+                    : ""} - [Chimu](https://chimu.moe/en/d/${this.beatmapsetID}) - [Sayobot](https://txy1.sayobot.cn/beatmaps/download/full/${this.beatmapsetID})${this.videoAvailable
+                    ? ` [(no video)](https://txy1.sayobot.cn/beatmaps/download/novideo/${this.beatmapsetID})`
+                    : ""} - [Beatconnect](https://beatconnect.io/b/${this.beatmapsetID}/) - [Nerina](https://nerina.pw/d/${this.beatmapsetID})${this.approved >= rankedStatus_1.rankedStatus.RANKED &&
+                    this.approved !== rankedStatus_1.rankedStatus.QUALIFIED
+                    ? ` - [Ripple](https://storage.ripple.moe/d/${this.beatmapsetID})`
+                    : ""}`;
+                if (this.packs.length > 0) {
+                    string += "\n**Beatmap Pack**: ";
+                    for (let i = 0; i < this.packs.length; i++) {
+                        string += `[${this.packs[i]}](https://osu.ppy.sh/beatmaps/packs/${this.packs[i]})`;
+                        if (i + 1 < this.packs.length) {
+                            string += " - ";
+                        }
+                    }
+                }
+                string += `\n🖼️ ${this.storyboardAvailable ? "✅" : "❎"} **|** 🎞️ ${this.videoAvailable ? "✅" : "❎"}`;
+                return string;
+            }
+            case 2:
+                return `**Circles**: ${this.circles} - **Sliders**: ${this.sliders} - **Spinners**: ${this.spinners}\n**CS**: ${this.cs}${this.cs === mapStatistics.cs ? "" : ` (${mapStatistics.cs})`} - **AR**: ${this.ar}${this.ar === mapStatistics.ar ? "" : ` (${mapStatistics.ar})`} - **OD**: ${this.od}${this.od === mapStatistics.od ? "" : ` (${mapStatistics.od})`} - **HP**: ${this.hp}${this.hp === mapStatistics.hp ? "" : ` (${mapStatistics.hp})`}`;
+            case 3: {
+                const maxScore = this.maxScore(mapStatistics);
+                const convertedBPM = this.convertBPM(mapStatistics);
+                let string = "**BPM**: ";
+                if (this.map) {
+                    const uninheritedTimingPoints = this.map.timingPoints;
+                    if (uninheritedTimingPoints.length === 1) {
+                        string += `${this.bpm}${!Precision_1.Precision.almostEqualsNumber(this.bpm, convertedBPM)
+                            ? ` (${convertedBPM})`
+                            : ""} - **Length**: ${this.convertTime(mapStatistics)} - **Max Combo**: ${this.maxCombo}x${maxScore > 0
+                            ? `\n**Max Score**: ${maxScore.toLocaleString()}`
+                            : ""}`;
+                    }
+                    else {
+                        let maxBPM = this.bpm;
+                        let minBPM = this.bpm;
+                        for (const t of uninheritedTimingPoints) {
+                            const bpm = parseFloat((60000 / t.msPerBeat).toFixed(2));
+                            maxBPM = Math.max(maxBPM, bpm);
+                            minBPM = Math.min(minBPM, bpm);
+                        }
+                        maxBPM = Math.round(maxBPM);
+                        minBPM = Math.round(minBPM);
+                        const speedMulMinBPM = Math.round(minBPM * mapStatistics.speedMultiplier);
+                        const speedMulMaxBPM = Math.round(maxBPM * mapStatistics.speedMultiplier);
+                        string +=
+                            Precision_1.Precision.almostEqualsNumber(minBPM, this.bpm) &&
+                                Precision_1.Precision.almostEqualsNumber(maxBPM, this.bpm)
+                                ? `${this.bpm} `
+                                : `${minBPM}-${maxBPM} (${this.bpm}) `;
+                        if (!Precision_1.Precision.almostEqualsNumber(this.bpm, convertedBPM)) {
+                            if (!Precision_1.Precision.almostEqualsNumber(speedMulMinBPM, speedMulMaxBPM)) {
+                                string += `(${speedMulMinBPM}-${speedMulMaxBPM} (${convertedBPM})) `;
+                            }
+                            else {
+                                string += `(${convertedBPM}) `;
+                            }
+                        }
+                        string += `- **Length**: ${this.convertTime(mapStatistics)} - **Max Combo**: ${this.maxCombo}x${maxScore > 0
+                            ? `\n**Max score**: ${maxScore.toLocaleString()}`
+                            : ""}`;
+                    }
+                }
+                else {
+                    string += `${this.bpm}${!Precision_1.Precision.almostEqualsNumber(this.bpm, convertedBPM)
+                        ? ` (${convertedBPM})`
+                        : ""} - **Length**: ${this.convertTime(mapStatistics)} - **Max Combo**: ${this.maxCombo}x${maxScore > 0
+                        ? `\n**Max score**: ${maxScore.toLocaleString()}`
+                        : ""}`;
+                }
+                return string;
+            }
+            case 4:
+                return `**Last Update**: ${this.lastUpdate.toUTCString()} | **${this.convertStatus()}**`;
+            case 5:
+                return `❤️ **${this.favorites.toLocaleString()}** - ▶️ **${this.plays.toLocaleString()}**`;
+            default:
+                throw {
+                    name: "NotSupportedError",
+                    message: `This mode (${option}) is not supported`,
+                };
+        }
+    }
+    /**
+     * Returns a color integer based on the beatmap's ranking status.
+     *
+     * Useful to make embed messages.
+     */
+    get statusColor() {
+        switch (this.approved) {
+            case -2:
+                return 16711711; // Graveyard: red
+            case -1:
+                return 9442302; // WIP: purple
+            case 0:
+                return 16312092; // Pending: yellow
+            case 1:
+                return 2483712; // Ranked: green
+            case 2:
+                return 16741376; // Approved: tosca
+            case 3:
+                return 5301186; // Qualified: light blue
+            case 4:
+                return 16711796; // Loved: pink
+            default:
+                return 0;
+        }
+    }
+    /**
+     * Calculates the osu!droid maximum score of the beatmap.
+     *
+     * This requires .osu file to be downloaded.
+     */
+    maxScore(stats) {
+        if (!this.map) {
+            return 0;
+        }
+        const difficultyMultiplier = 1 + this.od / 10 + this.hp / 10 + (this.cs - 3) / 4;
+        // score multiplier
+        let scoreMultiplier = 1;
+        if (stats.mods.every((m) => m.droidRanked)) {
+            let scoreSpeedMultiplier = 1;
+            const speedMultiplier = stats.speedMultiplier;
+            if (speedMultiplier > 1) {
+                scoreSpeedMultiplier += (speedMultiplier - 1) * 0.24;
+            }
+            else if (speedMultiplier < 1) {
+                scoreSpeedMultiplier = Math.pow(0.3, (1 - speedMultiplier) * 4);
+            }
+            scoreMultiplier =
+                stats.mods.reduce((a, v) => a * v.scoreMultiplier, 1) *
+                    scoreSpeedMultiplier;
+        }
+        else {
+            scoreMultiplier = 0;
+        }
+        const objects = this.map.objects;
+        let combo = 0;
+        let score = 0;
+        for (let i = 0; i < objects.length; ++i) {
+            const object = objects[i];
+            if (!(object instanceof Slider_1.Slider)) {
+                score += Math.floor(300 +
+                    (300 * combo * difficultyMultiplier * scoreMultiplier) /
+                        25);
+                ++combo;
+                continue;
+            }
+            const tickCount = object.nestedHitObjects.filter((v) => v instanceof SliderTick_1.SliderTick).length;
+            // Apply sliderhead, slider repeats, and slider ticks
+            score += 30 * (object.repeatPoints + 1) + 10 * tickCount;
+            combo += tickCount + (object.repeatPoints + 1);
+            // Apply sliderend
+            score += Math.floor(300 +
+                (300 * combo * difficultyMultiplier * scoreMultiplier) / 25);
+            ++combo;
+        }
+        return score;
+    }
+    /**
+     * Returns a string representative of the class.
+     */
+    toString() {
+        return `${this.fullTitle}\nCS: ${this.cs} - AR: ${this.ar} - OD: ${this.od} - HP: ${this.hp}\nBPM: ${this.bpm} - Length: ${this.hitLength}/${this.totalLength} - Max Combo: ${this.maxCombo}\nLast Update: ${this.lastUpdate}`;
+    }
+}
+exports.MapInfo = MapInfo;

package/dist/utils/APIRequestBuilder.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OsuAPIRequestBuilder = exports.DroidAPIRequestBuilder = void 0;
+const request_1 = __importDefault(require("request"));
+const Utils_1 = require("./Utils");
+class APIRequestBuilder {
+    constructor() {
+        /**
+         * Whether or not to include the API key in the request URL.
+         */
+        this.requiresAPIkey = true;
+        /**
+         * The endpoint of this builder.
+         */
+        this.endpoint = "";
+        /**
+         * The parameters of this builder.
+         */
+        this.params = new Map();
+        this.fetchAttempts = 0;
+    }
+    /**
+     * Sets if this builder includes the API key in the request URL.
+     *
+     * @param requireAPIkey Whether or not to include the API key in the request URL.
+     */
+    setRequireAPIkey(requireAPIkey) {
+        this.requiresAPIkey = requireAPIkey;
+        return this;
+    }
+    /**
+     * Builds the URL to request the API.
+     */
+    buildURL() {
+        let url = this.host + this.endpoint;
+        if (this instanceof DroidAPIRequestBuilder &&
+            this.endpoint === "upload") {
+            url += "/";
+            for (const [, value] of this.params.entries()) {
+                url += value;
+            }
+            return url;
+        }
+        url += "?";
+        if (this.requiresAPIkey) {
+            if (!this.APIkey) {
+                throw new Error("An API key is not specified as environment variable");
+            }
+            url += this.APIkeyParam;
+        }
+        for (const [param, value] of this.params.entries()) {
+            url += `${param}=${encodeURIComponent(value)}&`;
+        }
+        return url;
+    }
+    /**
+     * Sends a request to the API using built parameters.
+     *
+     * If the request fails, it will be redone 5 times.
+     */
+    sendRequest() {
+        return new Promise((resolve) => {
+            const url = this.buildURL();
+            const dataArray = [];
+            (0, request_1.default)(url)
+                .on("data", (chunk) => {
+                dataArray.push(Buffer.from(chunk));
+            })
+                .on("complete", async (response) => {
+                ++this.fetchAttempts;
+                if (response.statusCode !== 200 && this.fetchAttempts < 5) {
+                    console.error(`Request to ${url} failed; ${this.fetchAttempts} attempts so far; retrying`);
+                    await Utils_1.Utils.sleep(0.2);
+                    return resolve(this.sendRequest());
+                }
+                return resolve({
+                    data: Buffer.concat(dataArray),
+                    statusCode: response.statusCode,
+                });
+            })
+                .on("error", (e) => {
+                throw e;
+            });
+        });
+    }
+    /**
+     * Adds a parameter to the builder.
+     *
+     * @param param The parameter to add.
+     * @param value The value to add for the parameter.
+     */
+    addParameter(param, value) {
+        this.params.set(param, value);
+        return this;
+    }
+    /**
+     * Removes a parameter from the builder.
+     *
+     * @param param The parameter to remove.
+     */
+    removeParameter(param) {
+        if (this.params.get(param)) {
+            this.params.delete(param);
+        }
+        return this;
+    }
+}
+/**
+ * API request builder for osu!droid.
+ */
+class DroidAPIRequestBuilder extends APIRequestBuilder {
+    constructor() {
+        super(...arguments);
+        this.host = "http://ops.dgsrz.com/api/";
+        this.APIkey = process.env
+            .DROID_API_KEY;
+        this.APIkeyParam = `apiKey=${this.APIkey}&`;
+    }
+    setEndpoint(endpoint) {
+        this.endpoint = endpoint;
+        return this;
+    }
+}
+exports.DroidAPIRequestBuilder = DroidAPIRequestBuilder;
+/**
+ * API request builder for osu!standard.
+ */
+class OsuAPIRequestBuilder extends APIRequestBuilder {
+    constructor() {
+        super(...arguments);
+        this.host = "https://osu.ppy.sh/api/";
+        this.APIkey = process.env
+            .OSU_API_KEY;
+        this.APIkeyParam = `k=${this.APIkey}&`;
+    }
+    setEndpoint(endpoint) {
+        this.endpoint = endpoint;
+        return this;
+    }
+}
+exports.OsuAPIRequestBuilder = OsuAPIRequestBuilder;