@rian8337/osu-base 4.0.0-beta.25 → 4.0.0-beta.27

package/dist/index.js

@@ -390,6 +390,42 @@ class BeatmapDifficulty {
     set ar(value) {
         this._ar = value;
     }
+    /**
+     * Maps a difficulty value [0, 10] to a two-piece linear range of values.
+     *
+     * @param difficulty The difficulty value to be mapped.
+     * @param min Minimum of the resulting range which will be achieved by a difficulty value of 0.
+     * @param mid Midpoint of the resulting range which will be achieved by a difficulty value of 5.
+     * @param max Maximum of the resulting range which will be achieved by a difficulty value of 10.
+     */
+    static difficultyRange(difficulty, min, mid, max) {
+        switch (true) {
+            case difficulty > 5:
+                return mid + ((max - mid) * (difficulty - 5)) / 5;
+            case difficulty < 5:
+                return mid + ((mid - min) * (difficulty - 5)) / 5;
+            default:
+                return mid;
+        }
+    }
+    /**
+     * Inverse function to `difficultyRange`. Maps a value returned by the function back to the
+     * difficulty that produced it.
+     *
+     * @param difficultyValue The difficulty-dependent value to be unmapped.
+     * @param diff0 Minimum of the resulting range which will be achieved by a difficulty value of 0.
+     * @param diff5 Midpoint of the resulting range which will be achieved by a difficulty value of 5.
+     * @param diff10 Maximum of the resulting range which will be achieved by a difficulty value of 10.
+     * @return The value to which the difficulty value maps in the specified range.
+     */
+    static inverseDifficultyRange(difficultyValue, diff0, diff5, diff10) {
+        if (Math.sign(difficultyValue - diff5) == Math.sign(diff10 - diff0)) {
+            return ((difficultyValue - diff5) / (diff10 - diff5)) * 5 + 5;
+        }
+        else {
+            return ((difficultyValue - diff5) / (diff5 - diff0)) * 5 + 5;
+        }
+    }
     constructor(shallowCopy) {
         /**
          * The circle size of the beatmap.
@@ -568,477 +604,6 @@ CircleSizeCalculator.brokenGamefieldRoundingAllowance = 1.00041;
  */
 CircleSizeCalculator.assumedDroidHeight = 681;
 
-/**
- * Represents a mod.
- */
-class Mod {
-    /**
-     * Whether this mod can be applied to osu!droid.
-     */
-    isApplicableToDroid() {
-        return "droidRanked" in this;
-    }
-    /**
-     * Whether this mod can be applied to osu!standard.
-     */
-    isApplicableToOsu() {
-        return "pcRanked" in this;
-    }
-    /**
-     * Whether this mod can be applied to a beatmap.
-     */
-    isApplicableToBeatmap() {
-        return "applyToBeatmap" in this;
-    }
-    /**
-     * Whether this mod can be applied to a beatmap difficulty.
-     */
-    isApplicableToDifficulty() {
-        return "applyToDifficulty" in this;
-    }
-    /**
-     * Whether this mod can be applied to a beatmap difficulty relative to other mods and settings.
-     */
-    isApplicableToDifficultyWithSettings() {
-        return "applyToDifficultyWithSettings" in this;
-    }
-    /**
-     * Whether this mod can be applied to a hitobject.
-     */
-    isApplicableToHitObject() {
-        return "applyToHitObject" in this;
-    }
-}
-
-/**
- * Represents the difficulty adjust (DA) mod.
- *
- * This is not a real mod in osu! but is used to force difficulty values in the game.
- */
-class ModDifficultyAdjust extends Mod {
-    constructor(values) {
-        super();
-        this.acronym = "DA";
-        this.name = "Difficulty Adjust";
-        this.droidRanked = false;
-        this.droidScoreMultiplier = 1;
-        this.droidString = "";
-        this.isDroidLegacyMod = false;
-        this.pcRanked = false;
-        this.pcScoreMultiplier = 1;
-        this.bitwise = 0;
-        this.cs = values === null || values === void 0 ? void 0 : values.cs;
-        this.ar = values === null || values === void 0 ? void 0 : values.ar;
-        this.od = values === null || values === void 0 ? void 0 : values.od;
-        this.hp = values === null || values === void 0 ? void 0 : values.hp;
-    }
-    applyToDifficulty(mode, difficulty) {
-        if (this.cs !== undefined) {
-            difficulty.cs = this.cs;
-        }
-        if (this.ar !== undefined) {
-            difficulty.ar = this.ar;
-        }
-        if (this.od !== undefined) {
-            difficulty.od = this.od;
-        }
-        if (this.hp !== undefined) {
-            difficulty.hp = this.hp;
-        }
-    }
-}
-
-/**
- * Represents the DoubleTime mod.
- */
-class ModDoubleTime extends Mod {
-    constructor() {
-        super(...arguments);
-        this.acronym = "DT";
-        this.name = "DoubleTime";
-        this.droidRanked = true;
-        this.droidScoreMultiplier = 1.12;
-        this.droidString = "d";
-        this.isDroidLegacyMod = false;
-        this.pcRanked = true;
-        this.pcScoreMultiplier = 1.12;
-        this.bitwise = 1 << 6;
-    }
-}
-
-/**
- * Represents the HalfTime mod.
- */
-class ModHalfTime extends Mod {
-    constructor() {
-        super(...arguments);
-        this.acronym = "HT";
-        this.name = "HalfTime";
-        this.droidRanked = true;
-        this.droidScoreMultiplier = 0.3;
-        this.droidString = "t";
-        this.isDroidLegacyMod = false;
-        this.pcRanked = true;
-        this.pcScoreMultiplier = 0.3;
-        this.bitwise = 1 << 8;
-    }
-}
-
-/**
- * Represents the NightCore mod.
- */
-class ModNightCore extends Mod {
-    constructor() {
-        super(...arguments);
-        this.acronym = "NC";
-        this.name = "NightCore";
-        this.droidRanked = true;
-        this.droidString = "c";
-        this.isDroidLegacyMod = false;
-        this.droidScoreMultiplier = 1.12;
-        this.pcRanked = true;
-        this.pcScoreMultiplier = 1.12;
-        this.bitwise = 1 << 9;
-    }
-}
-
-/**
- * Represents the Precise mod.
- */
-class ModPrecise extends Mod {
-    constructor() {
-        super(...arguments);
-        this.acronym = "PR";
-        this.name = "Precise";
-        this.droidRanked = true;
-        this.droidScoreMultiplier = 1.06;
-        this.droidString = "s";
-        this.isDroidLegacyMod = false;
-    }
-}
-
-/**
- * Represents the SpeedUp mod.
- */
-class ModSpeedUp extends Mod {
-    constructor() {
-        super(...arguments);
-        this.acronym = "SU";
-        this.name = "Speed Up";
-        this.droidRanked = false;
-        this.droidScoreMultiplier = 1.06;
-        this.droidString = "b";
-        this.isDroidLegacyMod = true;
-    }
-}
-
-class HitWindow {
-    /**
-     * @param overallDifficulty The overall difficulty of this hit window.
-     */
-    constructor(overallDifficulty) {
-        this.overallDifficulty = overallDifficulty;
-    }
-}
-/**
- * Represents the hit window of osu!droid.
- */
-class DroidHitWindow extends HitWindow {
-    /**
-     * Calculates the overall difficulty value of a great hit window.
-     *
-     * @param value The value of the hit window, in milliseconds.
-     * @param isPrecise Whether to calculate for Precise mod.
-     * @returns The overall difficulty value.
-     */
-    static hitWindow300ToOD(value, isPrecise) {
-        if (isPrecise) {
-            return 5 - (value - 55) / 6;
-        }
-        else {
-            return 5 - (value - 75) / 5;
-        }
-    }
-    /**
-     * Calculates the overall difficulty value of a good hit window.
-     *
-     * @param value The value of the hit window, in milliseconds.
-     * @param isPrecise Whether to calculate for Precise mod.
-     * @returns The overall difficulty value.
-     */
-    static hitWindow100ToOD(value, isPrecise) {
-        if (isPrecise) {
-            return 5 - (value - 120) / 8;
-        }
-        else {
-            return 5 - (value - 150) / 10;
-        }
-    }
-    /**
-     * Calculates the overall difficulty value of a meh hit window.
-     *
-     * @param value The value of the hit window, in milliseconds.
-     * @param isPrecise Whether to calculate for Precise mod.
-     * @returns The overall difficulty value.
-     */
-    static hitWindow50ToOD(value, isPrecise) {
-        if (isPrecise) {
-            return 5 - (value - 180) / 10;
-        }
-        else {
-            return 5 - (value - 250) / 10;
-        }
-    }
-    hitWindowFor300(isPrecise) {
-        if (isPrecise) {
-            return 55 + 6 * (5 - this.overallDifficulty);
-        }
-        else {
-            return 75 + 5 * (5 - this.overallDifficulty);
-        }
-    }
-    hitWindowFor100(isPrecise) {
-        if (isPrecise) {
-            return 120 + 8 * (5 - this.overallDifficulty);
-        }
-        else {
-            return 150 + 10 * (5 - this.overallDifficulty);
-        }
-    }
-    hitWindowFor50(isPrecise) {
-        if (isPrecise) {
-            return 180 + 10 * (5 - this.overallDifficulty);
-        }
-        else {
-            return 250 + 10 * (5 - this.overallDifficulty);
-        }
-    }
-}
-/**
- * Represents the hit window of osu!standard.
- */
-class OsuHitWindow extends HitWindow {
-    /**
-     * Calculates the overall difficulty value of a great hit window.
-     *
-     * @param value The value of the hit window, in milliseconds.
-     * @returns The overall difficulty value.
-     */
-    static hitWindow300ToOD(value) {
-        return (80 - value) / 6;
-    }
-    /**
-     * Calculates the overall difficulty value of a good hit window.
-     *
-     * @param value The value of the hit window, in milliseconds.
-     * @returns The overall difficulty value.
-     */
-    static hitWindow100ToOD(value) {
-        return (140 - value) / 8;
-    }
-    /**
-     * Calculates the overall difficulty value of a meh hit window.
-     *
-     * @param value The value of the hit window, in milliseconds.
-     * @returns The overall difficulty value.
-     */
-    static hitWindow50ToOD(value) {
-        return (200 - value) / 10;
-    }
-    hitWindowFor300() {
-        return 80 - 6 * this.overallDifficulty;
-    }
-    hitWindowFor100() {
-        return 140 - 8 * this.overallDifficulty;
-    }
-    hitWindowFor50() {
-        return 200 - 10 * this.overallDifficulty;
-    }
-}
-
-/**
- * Calculates the osu!droid difficulty statistics of a beatmap.
- *
- * This provides functionality to apply speed-changing mods to the difficulty statistics.
- *
- * @param options The options for the difficulty statistics calculator.
- * @returns The difficulty statistics of the beatmap.
- */
-function calculateDroidDifficultyStatistics(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
-    const overallSpeedMultiplier = calculateSpeedMultiplierFromMods((_a = options.mods) !== null && _a !== void 0 ? _a : [], options.oldStatistics) * ((_b = options.customSpeedMultiplier) !== null && _b !== void 0 ? _b : 1);
-    const difficulty = new BeatmapDifficulty();
-    difficulty.cs = (_c = options.circleSize) !== null && _c !== void 0 ? _c : difficulty.cs;
-    difficulty.ar = (_d = options.approachRate) !== null && _d !== void 0 ? _d : difficulty.ar;
-    difficulty.od = (_e = options.overallDifficulty) !== null && _e !== void 0 ? _e : difficulty.od;
-    difficulty.hp = (_f = options.healthDrain) !== null && _f !== void 0 ? _f : difficulty.hp;
-    const difficultyAdjustMod = (_g = options.mods) === null || _g === void 0 ? void 0 : _g.find((mod) => mod instanceof ModDifficultyAdjust);
-    (_h = options.mods) === null || _h === void 0 ? void 0 : _h.forEach((mod) => {
-        if (mod.isApplicableToDifficulty()) {
-            mod.applyToDifficulty(exports.Modes.droid, difficulty);
-        }
-    });
-    // Special handling for difficulty adjust mod where difficulty statistics are forced.
-    difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.applyToDifficulty(exports.Modes.droid, difficulty);
-    (_j = options.mods) === null || _j === void 0 ? void 0 : _j.forEach((mod, _, arr) => {
-        var _a;
-        if (mod.isApplicableToDifficultyWithSettings()) {
-            mod.applyToDifficultyWithSettings(exports.Modes.droid, difficulty, arr, (_a = options.customSpeedMultiplier) !== null && _a !== void 0 ? _a : 1);
-        }
-    });
-    if (options.circleSize !== undefined &&
-        options.convertCircleSize !== false) {
-        const scale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
-        const radius = CircleSizeCalculator.droidScaleToStandardRadius(scale);
-        difficulty.cs = CircleSizeCalculator.standardRadiusToStandardCS(radius, true);
-    }
-    // Apply speed-changing mods
-    if (options.approachRate !== undefined &&
-        (difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.ar) === undefined) {
-        const approachRateMilliseconds = convertApproachRateToMilliseconds(difficulty.ar) /
-            overallSpeedMultiplier;
-        difficulty.ar = convertApproachRateMilliseconds(approachRateMilliseconds);
-    }
-    if (options.overallDifficulty !== undefined) {
-        const isPrecise = (_l = (_k = options.mods) === null || _k === void 0 ? void 0 : _k.some((mod) => mod instanceof ModPrecise)) !== null && _l !== void 0 ? _l : false;
-        let hitWindowGreat = new DroidHitWindow(difficulty.od).hitWindowFor300(isPrecise);
-        if ((difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.od) === undefined) {
-            hitWindowGreat /= overallSpeedMultiplier;
-        }
-        difficulty.od =
-            options.convertOverallDifficulty !== false
-                ? OsuHitWindow.hitWindow300ToOD(hitWindowGreat)
-                : DroidHitWindow.hitWindow300ToOD(hitWindowGreat, isPrecise);
-    }
-    return {
-        circleSize: (options.circleSize !== undefined
-            ? difficulty.cs
-            : undefined),
-        approachRate: (options.approachRate !== undefined
-            ? difficulty.ar
-            : undefined),
-        overallDifficulty: (options.overallDifficulty !== undefined
-            ? difficulty.od
-            : undefined),
-        healthDrain: (options.healthDrain !== undefined
-            ? difficulty.hp
-            : undefined),
-        overallSpeedMultiplier: overallSpeedMultiplier,
-    };
-}
-/**
- * Calculates the osu!standard difficulty statistics of a beatmap.
- *
- * This provides functionality to apply speed-changing mods to the difficulty statistics.
- *
- * @param options The options for the difficulty statistics calculator.
- * @returns The difficulty statistics of the beatmap.
- */
-function calculateOsuDifficultyStatistics(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    const overallSpeedMultiplier = calculateSpeedMultiplierFromMods((_a = options.mods) !== null && _a !== void 0 ? _a : []) *
-        ((_b = options.customSpeedMultiplier) !== null && _b !== void 0 ? _b : 1);
-    const difficulty = new BeatmapDifficulty();
-    difficulty.cs = (_c = options.circleSize) !== null && _c !== void 0 ? _c : difficulty.cs;
-    difficulty.ar = (_d = options.approachRate) !== null && _d !== void 0 ? _d : difficulty.ar;
-    difficulty.od = (_e = options.overallDifficulty) !== null && _e !== void 0 ? _e : difficulty.od;
-    difficulty.hp = (_f = options.healthDrain) !== null && _f !== void 0 ? _f : difficulty.hp;
-    const difficultyAdjustMod = (_g = options.mods) === null || _g === void 0 ? void 0 : _g.find((mod) => mod instanceof ModDifficultyAdjust);
-    (_h = options.mods) === null || _h === void 0 ? void 0 : _h.forEach((mod) => {
-        if (mod.isApplicableToDifficulty()) {
-            mod.applyToDifficulty(exports.Modes.osu, difficulty);
-        }
-    });
-    // Special handling for difficulty adjust mod where difficulty statistics are forced.
-    difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.applyToDifficulty(exports.Modes.osu, difficulty);
-    (_j = options.mods) === null || _j === void 0 ? void 0 : _j.forEach((mod, _, arr) => {
-        var _a;
-        if (mod.isApplicableToDifficultyWithSettings()) {
-            mod.applyToDifficultyWithSettings(exports.Modes.osu, difficulty, arr, (_a = options.customSpeedMultiplier) !== null && _a !== void 0 ? _a : 1);
-        }
-    });
-    // Apply speed-changing mods
-    if (options.approachRate !== undefined &&
-        (difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.ar) === undefined) {
-        const approachRateMilliseconds = convertApproachRateToMilliseconds(difficulty.ar) /
-            overallSpeedMultiplier;
-        difficulty.ar = convertApproachRateMilliseconds(approachRateMilliseconds);
-    }
-    if (options.overallDifficulty !== undefined &&
-        (difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.od) === undefined) {
-        const hitWindowGreat = new OsuHitWindow(difficulty.od).hitWindowFor300() /
-            overallSpeedMultiplier;
-        difficulty.od = OsuHitWindow.hitWindow300ToOD(hitWindowGreat);
-    }
-    return {
-        circleSize: (options.circleSize !== undefined
-            ? difficulty.cs
-            : undefined),
-        approachRate: (options.approachRate !== undefined
-            ? difficulty.ar
-            : undefined),
-        overallDifficulty: (options.overallDifficulty !== undefined
-            ? difficulty.od
-            : undefined),
-        healthDrain: (options.healthDrain !== undefined
-            ? difficulty.hp
-            : undefined),
-        overallSpeedMultiplier: overallSpeedMultiplier,
-    };
-}
-/**
- * Calculates the speed multiplier obtained from mods.
- *
- * @param mods The mods to calculate the speed multiplier from.
- * @param oldStatistics Whether to calculate for old statistics for osu!droid (1.6.7 and older). Defaults to `false`.
- * @returns The speed multiplier obtained from the mods.
- */
-function calculateSpeedMultiplierFromMods(mods, oldStatistics) {
-    let speedMultiplier = 1;
-    for (const mod of mods) {
-        switch (true) {
-            case mod instanceof ModDoubleTime:
-                speedMultiplier *= 1.5;
-                break;
-            case mod instanceof ModHalfTime:
-                speedMultiplier *= 0.75;
-                break;
-            case mod instanceof ModNightCore:
-                speedMultiplier *= oldStatistics ? 1.39 : 1.5;
-                break;
-            case mod instanceof ModSpeedUp:
-                speedMultiplier *= 1.25;
-                break;
-        }
-    }
-    return speedMultiplier;
-}
-const AR0_MS = 1800;
-const AR5_MS = 1200;
-const AR10_MS = 450;
-const AR_MS_STEP1 = (AR0_MS - AR5_MS) / 5;
-const AR_MS_STEP2 = (AR5_MS - AR10_MS) / 5;
-/**
- * Converts an approach rate value to its milliseconds counterpart.
- *
- * @param ar The approach rate to convert.
- * @returns The converted approach rate in milliseconds.
- */
-function convertApproachRateToMilliseconds(ar) {
-    return ar < 5 ? AR0_MS - AR_MS_STEP1 * ar : AR5_MS - AR_MS_STEP2 * (ar - 5);
-}
-/**
- * Converts an approach rate value in milliseconds to its approach rate value counterpart.
- *
- * @param ms The approach rate in milliseconds to convert.
- * @returns The converted approach rate value.
- */
-function convertApproachRateMilliseconds(ms) {
-    return ms > AR5_MS
-        ? (AR0_MS - ms) / AR_MS_STEP1
-        : 5 + (AR5_MS - ms) / AR_MS_STEP2;
-}
-
 /**
  * Represents a hitobject in a beatmap.
  */
@@ -1162,17 +727,18 @@ class HitObject {
      * @param mode The gamemode to apply defaults for.
      */
     applyDefaults(controlPoints, difficulty, mode) {
-        this.timePreempt = convertApproachRateToMilliseconds(difficulty.ar);
+        this.timePreempt = BeatmapDifficulty.difficultyRange(difficulty.ar, HitObject.preemptMax, HitObject.preemptMid, HitObject.preemptMin);
         // Preempt time can go below 450ms. Normally, this is achieved via the DT mod which uniformly speeds up all animations game wide regardless of AR.
         // This uniform speedup is hard to match 1:1, however we can at least make AR>10 (via mods) feel good by extending the upper linear function above.
         // Note that this doesn't exactly match the AR>10 visuals as they're classically known, but it feels good.
         // This adjustment is necessary for AR>10, otherwise timePreempt can become smaller leading to hit circles not fully fading in.
-        this.timeFadeIn = 400 * Math.min(1, this.timePreempt / AR10_MS);
+        this.timeFadeIn =
+            400 * Math.min(1, this.timePreempt / HitObject.preemptMin);
         switch (mode) {
             case exports.Modes.droid: {
-                const cs = calculateDroidDifficultyStatistics({
-                    circleSize: difficulty.cs,
-                }).circleSize;
+                const droidScale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
+                const radius = CircleSizeCalculator.droidScaleToStandardRadius(droidScale);
+                const cs = CircleSizeCalculator.standardRadiusToStandardCS(radius, true);
                 this.scale = CircleSizeCalculator.standardCSToStandardScale(cs, true);
                 break;
             }
@@ -1261,6 +827,18 @@ class HitObject {
  * The base radius of all hitobjects.
  */
 HitObject.baseRadius = 64;
+/**
+ * Maximum preempt time at AR=0.
+ */
+HitObject.preemptMax = 1800;
+/**
+ * Median preempt time at AR=5.
+ */
+HitObject.preemptMid = 1200;
+/**
+ * Minimum preempt time at AR=10.
+ */
+HitObject.preemptMin = 450;
 /**
  * A small adjustment to the start time of control points to account for rounding/precision errors.
  */
@@ -2588,8 +2166,9 @@ class BeatmapProcessor {
         for (let i = 0; i < objects.length - 1; ++i) {
             const current = objects[i];
             const next = objects[i + 1];
-            if (next.startTime - current.startTime <
-                2000 * this.beatmap.general.stackLeniency &&
+            if (current instanceof Circle &&
+                next.startTime - current.startTime <
+                    2000 * this.beatmap.general.stackLeniency &&
                 next.position.getDistance(current.position) <
                     Math.sqrt(convertedScale)) {
                 next.stackHeight = current.stackHeight + 1;
@@ -3037,9 +2616,6 @@ class Beatmap {
                 mod.applyToDifficulty(mode, converted.difficulty);
             }
         });
-        // Special handling for difficulty adjust mod where difficulty statistics are forced.
-        const difficultyAdjustMod = mods.find((m) => m instanceof ModDifficultyAdjust);
-        difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.applyToDifficulty(mode, converted.difficulty);
         mods.forEach((mod) => {
             if (mod.isApplicableToDifficultyWithSettings()) {
                 mod.applyToDifficultyWithSettings(mode, converted.difficulty, mods, customSpeedMultiplier);
@@ -3054,6 +2630,13 @@ class Beatmap {
                 }
             }
         });
+        mods.forEach((mod) => {
+            if (mod.isApplicableToHitObjectWithSettings()) {
+                for (const hitObject of converted.hitObjects.objects) {
+                    mod.applyToHitObjectWithSettings(mode, hitObject, mods, customSpeedMultiplier);
+                }
+            }
+        });
         new BeatmapProcessor(converted).postProcess(mode);
         mods.forEach((mod) => {
             if (mod.isApplicableToBeatmap()) {
@@ -5658,7 +5241,7 @@ class BeatmapBaseEncoder extends BaseEncoder {
  */
 class BeatmapColorEncoder extends BeatmapBaseEncoder {
     encodeInternal() {
-        const colors = this.map.colors;
+        const { colors } = this.map;
         if (colors.combo.length === 0 &&
             !colors.sliderBorder &&
             !colors.sliderTrackOverride) {
@@ -5778,7 +5361,7 @@ class BeatmapDifficultyEncoder extends BeatmapBaseEncoder {
         if (this.encodeSections) {
             this.writeLine("[Difficulty]");
         }
-        const difficulty = this.map.difficulty;
+        const { difficulty } = this.map;
         this.writeLine(`HPDrainRate: ${difficulty.hp}`);
         this.writeLine(`CircleSize: ${difficulty.cs}`);
         this.writeLine(`OverallDifficulty: ${difficulty.od}`);
@@ -5796,7 +5379,7 @@ class BeatmapEditorEncoder extends BeatmapBaseEncoder {
         if (this.encodeSections) {
             this.writeLine("[Editor]");
         }
-        const editor = this.map.editor;
+        const { editor } = this.map;
         if (editor.bookmarks.length > 0) {
             this.writeLine(editor.bookmarks.join());
         }
@@ -6010,7 +5593,7 @@ class StoryboardEncoder extends Encoder {
     reset() {
         this.finalResult = "";
         this.encoders = [
-            // The variable decoder is put first as variable need to be on top of a .osb file.
+            // The variable decoder is put first as variables need to be on top of a .osb file.
             new StoryboardVariablesEncoder(this.target, this.encodeSections),
             new StoryboardEventsEncoder(this.target, this.encodeSections),
         ];
@@ -6026,7 +5609,7 @@ class BeatmapEventsEncoder extends BeatmapBaseEncoder {
             this.writeLine("[Events]");
         }
         this.writeLine("//Background and Video Events");
-        const events = this.map.events;
+        const { events } = this.map;
         if (events.background) {
             this.writeLine(`0,0,"${events.background.filename}",${events.background.offset.x},${events.background.offset.y}`);
         }
@@ -6059,7 +5642,7 @@ class BeatmapGeneralEncoder extends BeatmapBaseEncoder {
         if (this.encodeSections) {
             this.writeLine("[General]");
         }
-        const general = this.map.general;
+        const { general } = this.map;
         if (general.audioFilename) {
             this.writeLine(`AudioFilename: ${general.audioFilename}`);
         }
@@ -6196,7 +5779,7 @@ class BeatmapMetadataEncoder extends BeatmapBaseEncoder {
         if (this.encodeSections) {
             this.writeLine("[Metadata]");
         }
-        const metadata = this.map.metadata;
+        const { metadata } = this.map;
         this.writeLine(`Title: ${metadata.title}`);
         if (metadata.titleUnicode) {
             this.writeLine(`TitleUnicode: ${metadata.titleUnicode}`);
@@ -6659,7 +6242,7 @@ class APIRequestBuilder {
      * @param value The value to add for the parameter.
      */
     addParameter(param, value) {
-        this.params.set(param, value);
+        this.params.set(param, value.toString());
         return this;
     }
     /**
@@ -7509,13 +7092,137 @@ ErrorFunction.ervInvImpGn = [
     0.13588013010892486e-14, -0.3488903933999489e-21,
 ];
 /**
- * Polynomial coefficients for a denominator of erfInvImp
- * calculation for erf^-1(z) in the interval [0.75, 1] with x greater than 44.
+ * Polynomial coefficients for a denominator of erfInvImp
+ * calculation for erf^-1(z) in the interval [0.75, 1] with x greater than 44.
+ */
+ErrorFunction.ervInvImpGd = [
+    1, 0.08457462340018994, 0.002820929847262647, 0.4682929219408942e-4,
+    0.3999688121938621e-6, 0.1618092908879045e-8, 0.2315586083102596e-11,
+];
+
+class HitWindow {
+    /**
+     * @param overallDifficulty The overall difficulty of this hit window.
+     */
+    constructor(overallDifficulty) {
+        this.overallDifficulty = overallDifficulty;
+    }
+}
+/**
+ * Represents the hit window of osu!droid.
+ */
+class DroidHitWindow extends HitWindow {
+    /**
+     * Calculates the overall difficulty value of a great hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @param isPrecise Whether to calculate for Precise mod.
+     * @returns The overall difficulty value.
+     */
+    static hitWindow300ToOD(value, isPrecise) {
+        if (isPrecise) {
+            return 5 - (value - 55) / 6;
+        }
+        else {
+            return 5 - (value - 75) / 5;
+        }
+    }
+    /**
+     * Calculates the overall difficulty value of a good hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @param isPrecise Whether to calculate for Precise mod.
+     * @returns The overall difficulty value.
+     */
+    static hitWindow100ToOD(value, isPrecise) {
+        if (isPrecise) {
+            return 5 - (value - 120) / 8;
+        }
+        else {
+            return 5 - (value - 150) / 10;
+        }
+    }
+    /**
+     * Calculates the overall difficulty value of a meh hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @param isPrecise Whether to calculate for Precise mod.
+     * @returns The overall difficulty value.
+     */
+    static hitWindow50ToOD(value, isPrecise) {
+        if (isPrecise) {
+            return 5 - (value - 180) / 10;
+        }
+        else {
+            return 5 - (value - 250) / 10;
+        }
+    }
+    hitWindowFor300(isPrecise) {
+        if (isPrecise) {
+            return 55 + 6 * (5 - this.overallDifficulty);
+        }
+        else {
+            return 75 + 5 * (5 - this.overallDifficulty);
+        }
+    }
+    hitWindowFor100(isPrecise) {
+        if (isPrecise) {
+            return 120 + 8 * (5 - this.overallDifficulty);
+        }
+        else {
+            return 150 + 10 * (5 - this.overallDifficulty);
+        }
+    }
+    hitWindowFor50(isPrecise) {
+        if (isPrecise) {
+            return 180 + 10 * (5 - this.overallDifficulty);
+        }
+        else {
+            return 250 + 10 * (5 - this.overallDifficulty);
+        }
+    }
+}
+/**
+ * Represents the hit window of osu!standard.
  */
-ErrorFunction.ervInvImpGd = [
-    1, 0.08457462340018994, 0.002820929847262647, 0.4682929219408942e-4,
-    0.3999688121938621e-6, 0.1618092908879045e-8, 0.2315586083102596e-11,
-];
+class OsuHitWindow extends HitWindow {
+    /**
+     * Calculates the overall difficulty value of a great hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @returns The overall difficulty value.
+     */
+    static hitWindow300ToOD(value) {
+        return (80 - value) / 6;
+    }
+    /**
+     * Calculates the overall difficulty value of a good hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @returns The overall difficulty value.
+     */
+    static hitWindow100ToOD(value) {
+        return (140 - value) / 8;
+    }
+    /**
+     * Calculates the overall difficulty value of a meh hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @returns The overall difficulty value.
+     */
+    static hitWindow50ToOD(value) {
+        return (200 - value) / 10;
+    }
+    hitWindowFor300() {
+        return 80 - 6 * this.overallDifficulty;
+    }
+    hitWindowFor100() {
+        return 140 - 8 * this.overallDifficulty;
+    }
+    hitWindowFor50() {
+        return 200 - 10 * this.overallDifficulty;
+    }
+}
 
 /**
  * Holds interpolation methods for numbers and vectors.
@@ -7779,12 +7486,13 @@ class MapInfo {
         });
     }
     /**
-     * Constructs a `MapInfo` from an osu! API response.
+     * Constructs a `MapInfo` from an osu! API response and (optionally) a parsed `Beatmap`.
      *
      * @param mapinfo The osu! API response.
-     * @returns A `MapInfo` instance representing the osu! API response.
+     * @param parsedBeatmap The parsed `Beatmap`.
+     * @returns A `MapInfo` instance representing the osu! API response and parsed `Beatmap`.
      */
-    static from(mapinfo) {
+    static from(mapinfo, parsedBeatmap) {
         const map = new MapInfo();
         const parseDate = (str) => {
             const t = str.split(/[- :]/).map((e) => parseInt(e));
@@ -7842,6 +7550,9 @@ class MapInfo {
         map.videoAvailable = !!parseInt(mapinfo.video);
         map.downloadAvailable = !parseInt(mapinfo.download_unavailable);
         map.audioAvailable = !parseInt(mapinfo.audio_unavailable);
+        if (parsedBeatmap) {
+            map.cachedBeatmap = parsedBeatmap;
+        }
         return map;
     }
     /**
@@ -7939,6 +7650,60 @@ class MapInfo {
     }
 }
 
+/**
+ * Represents a mod.
+ */
+class Mod {
+    /**
+     * Whether this `Mod` can be applied to osu!droid.
+     */
+    isApplicableToDroid() {
+        return "droidRanked" in this;
+    }
+    /**
+     * Whether this `Mod` can be applied to osu!standard.
+     */
+    isApplicableToOsu() {
+        return "pcRanked" in this;
+    }
+    /**
+     * Whether this `Mod` can be applied to a `Beatmap`.
+     */
+    isApplicableToBeatmap() {
+        return "applyToBeatmap" in this;
+    }
+    /**
+     * Whether this `Mod` can be applied to a `BeatmapDifficulty`.
+     */
+    isApplicableToDifficulty() {
+        return "applyToDifficulty" in this;
+    }
+    /**
+     * Whether this `Mod` can be applied to a `BeatmapDifficulty` relative to other `Mod`s and settings.
+     */
+    isApplicableToDifficultyWithSettings() {
+        return "applyToDifficultyWithSettings" in this;
+    }
+    /**
+     * Whether this `Mod` can be applied to a `HitObject`.
+     */
+    isApplicableToHitObject() {
+        return "applyToHitObject" in this;
+    }
+    /**
+     * Whether this `Mod` can be applied to a `HitObject` relative to other `Mod`s and settings.
+     */
+    isApplicableToHitObjectWithSettings() {
+        return "applyToHitObjectWithSettings" in this;
+    }
+    /**
+     * Whether this `Mod`s can be applied to a track's playback rate.
+     */
+    isApplicableToTrackRate() {
+        return "applyToRate" in this;
+    }
+}
+
 /**
  * Represents the Auto mod.
  */
@@ -7975,6 +7740,27 @@ class ModAutopilot extends Mod {
     }
 }
 
+/**
+ * Represents the DoubleTime mod.
+ */
+class ModDoubleTime extends Mod {
+    constructor() {
+        super(...arguments);
+        this.acronym = "DT";
+        this.name = "DoubleTime";
+        this.droidRanked = true;
+        this.droidScoreMultiplier = 1.12;
+        this.droidString = "d";
+        this.isDroidLegacyMod = false;
+        this.pcRanked = true;
+        this.pcScoreMultiplier = 1.12;
+        this.bitwise = 1 << 6;
+    }
+    applyToRate(rate) {
+        return rate * 1.5;
+    }
+}
+
 /**
  * Represents the Easy mod.
  */
@@ -8025,6 +7811,27 @@ class ModFlashlight extends Mod {
     }
 }
 
+/**
+ * Represents the HalfTime mod.
+ */
+class ModHalfTime extends Mod {
+    constructor() {
+        super(...arguments);
+        this.acronym = "HT";
+        this.name = "HalfTime";
+        this.droidRanked = true;
+        this.droidScoreMultiplier = 0.3;
+        this.droidString = "t";
+        this.isDroidLegacyMod = false;
+        this.pcRanked = true;
+        this.pcScoreMultiplier = 0.3;
+        this.bitwise = 1 << 8;
+    }
+    applyToRate(rate) {
+        return rate * 0.75;
+    }
+}
+
 /**
  * Represents the osu! playfield.
  */
@@ -8125,6 +7932,27 @@ class ModHidden extends Mod {
 ModHidden.fadeInDurationMultiplier = 0.4;
 ModHidden.fadeOutDurationMultiplier = 0.3;
 
+/**
+ * Represents the NightCore mod.
+ */
+class ModNightCore extends Mod {
+    constructor() {
+        super(...arguments);
+        this.acronym = "NC";
+        this.name = "NightCore";
+        this.droidRanked = true;
+        this.droidString = "c";
+        this.isDroidLegacyMod = false;
+        this.droidScoreMultiplier = 1.12;
+        this.pcRanked = true;
+        this.pcScoreMultiplier = 1.12;
+        this.bitwise = 1 << 9;
+    }
+    applyToRate(rate, oldStatistics) {
+        return rate * (oldStatistics ? 1.39 : 1.5);
+    }
+}
+
 /**
  * Represents the NoFail mod.
  */
@@ -8161,6 +7989,21 @@ class ModPerfect extends Mod {
     }
 }
 
+/**
+ * Represents the Precise mod.
+ */
+class ModPrecise extends Mod {
+    constructor() {
+        super(...arguments);
+        this.acronym = "PR";
+        this.name = "Precise";
+        this.droidRanked = true;
+        this.droidScoreMultiplier = 1.06;
+        this.droidString = "s";
+        this.isDroidLegacyMod = false;
+    }
+}
+
 /**
  * Represents the ReallyEasy mod.
  */
@@ -8268,6 +8111,25 @@ class ModSmallCircle extends Mod {
     }
 }
 
+/**
+ * Represents the SpeedUp mod.
+ */
+class ModSpeedUp extends Mod {
+    constructor() {
+        super(...arguments);
+        this.acronym = "SU";
+        this.name = "Speed Up";
+        this.droidRanked = false;
+        this.droidScoreMultiplier = 1.06;
+        this.droidString = "b";
+        this.isDroidLegacyMod = true;
+        this.trackRateMultiplier = 1.25;
+    }
+    applyToRate(rate) {
+        return rate * 1.25;
+    }
+}
+
 /**
  * Represents the SpunOut mod.
  */
@@ -8420,6 +8282,42 @@ class ModUtil {
             .slice()
             .filter((m) => !this.speedChangingMods.some((v) => m.acronym === v.acronym));
     }
+    /**
+     * Applies the selected `Mod`s to a `BeatmapDifficulty`.
+     *
+     * @param difficulty The `BeatmapDifficulty` to apply the `Mod`s to.
+     * @param mode The game mode to apply the `Mod`s for.
+     * @param mods The selected `Mod`s.
+     * @param customSpeedMultiplier The custom speed multiplier to apply.
+     */
+    static applyModsToBeatmapDifficulty(difficulty, mode, mods, customSpeedMultiplier = 1) {
+        for (const mod of mods) {
+            if (mod.isApplicableToDifficulty()) {
+                mod.applyToDifficulty(mode, difficulty);
+            }
+        }
+        for (const mod of mods) {
+            if (mod.isApplicableToDifficultyWithSettings()) {
+                mod.applyToDifficultyWithSettings(mode, difficulty, mods, customSpeedMultiplier);
+            }
+        }
+    }
+    /**
+     * Calculates the rate for the track with the selected `Mod`s.
+     *
+     * @param mods The list of selected `Mod`s.
+     * @param oldStatistics Whether to enforce old statistics. Some `Mod`s behave differently with this flag.
+     * @returns The rate with `Mod`s.
+     */
+    static calculateRateWithMods(mods, oldStatistics) {
+        let rate = 1;
+        for (const mod of mods) {
+            if (mod.isApplicableToTrackRate()) {
+                rate = mod.applyToRate(rate, oldStatistics);
+            }
+        }
+        return rate;
+    }
     /**
      * Processes parsing options.
      *
@@ -8492,6 +8390,56 @@ ModUtil.speedChangingMods = [
  */
 ModUtil.mapChangingMods = _a.speedChangingMods.concat(new ModEasy(), new ModHardRock(), new ModReallyEasy(), new ModSmallCircle());
 
+/**
+ * Represents the difficulty adjust (DA) mod.
+ *
+ * This is not a real mod in osu! but is used to force difficulty values in the game.
+ */
+class ModDifficultyAdjust extends Mod {
+    constructor(values) {
+        super();
+        this.acronym = "DA";
+        this.name = "Difficulty Adjust";
+        this.droidRanked = false;
+        this.droidScoreMultiplier = 1;
+        this.droidString = "";
+        this.isDroidLegacyMod = false;
+        this.pcRanked = false;
+        this.pcScoreMultiplier = 1;
+        this.bitwise = 0;
+        this.cs = values === null || values === void 0 ? void 0 : values.cs;
+        this.ar = values === null || values === void 0 ? void 0 : values.ar;
+        this.od = values === null || values === void 0 ? void 0 : values.od;
+        this.hp = values === null || values === void 0 ? void 0 : values.hp;
+    }
+    applyToDifficultyWithSettings(mode, difficulty, mods, customSpeedMultiplier) {
+        var _a, _b, _c, _d;
+        difficulty.cs = (_a = this.cs) !== null && _a !== void 0 ? _a : difficulty.cs;
+        difficulty.ar = (_b = this.ar) !== null && _b !== void 0 ? _b : difficulty.ar;
+        difficulty.od = (_c = this.od) !== null && _c !== void 0 ? _c : difficulty.od;
+        difficulty.hp = (_d = this.hp) !== null && _d !== void 0 ? _d : difficulty.hp;
+        // Special case for force AR, where the AR value is kept constant with respect to game time.
+        // This makes the player perceive the AR as is under all speed multipliers.
+        if (this.ar !== undefined) {
+            const preempt = BeatmapDifficulty.difficultyRange(this.ar, HitObject.preemptMax, HitObject.preemptMid, HitObject.preemptMin);
+            const trackRate = this.calculateTrackRate(mods, customSpeedMultiplier);
+            difficulty.ar = BeatmapDifficulty.inverseDifficultyRange(preempt * trackRate, HitObject.preemptMax, HitObject.preemptMid, HitObject.preemptMin);
+        }
+    }
+    applyToHitObjectWithSettings(mode, hitObject, mods, customSpeedMultiplier) {
+        // Special case for force AR, where the AR value is kept constant with respect to game time.
+        // This makes the player perceive the fade in animation as is under all speed multipliers.
+        if (this.ar === undefined) {
+            return;
+        }
+        const trackRate = this.calculateTrackRate(mods, customSpeedMultiplier);
+        hitObject.timeFadeIn *= trackRate;
+    }
+    calculateTrackRate(mods, customSpeedMultiplier) {
+        return ModUtil.calculateRateWithMods(mods) * customSpeedMultiplier;
+    }
+}
+
 /**
  * Continuous Univariate Normal distribution, also known as Gaussian distribution.
  *
@@ -8519,9 +8467,6 @@ class NormalDistribution {
 
 dotenv.config();
 
-exports.AR0_MS = AR0_MS;
-exports.AR10_MS = AR10_MS;
-exports.AR5_MS = AR5_MS;
 exports.Accuracy = Accuracy;
 exports.BankHitSampleInfo = BankHitSampleInfo;
 exports.Beatmap = Beatmap;
@@ -8618,9 +8563,4 @@ exports.TimingControlPointManager = TimingControlPointManager;
 exports.Utils = Utils;
 exports.Vector2 = Vector2;
 exports.ZeroCrossingBracketing = ZeroCrossingBracketing;
-exports.calculateDroidDifficultyStatistics = calculateDroidDifficultyStatistics;
-exports.calculateOsuDifficultyStatistics = calculateOsuDifficultyStatistics;
-exports.calculateSpeedMultiplierFromMods = calculateSpeedMultiplierFromMods;
-exports.convertApproachRateMilliseconds = convertApproachRateMilliseconds;
-exports.convertApproachRateToMilliseconds = convertApproachRateToMilliseconds;
 //# sourceMappingURL=index.js.map