@rian8337/osu-base 4.0.0-beta.55 → 4.0.0-beta.58

package/dist/index.js

@@ -388,143 +388,6 @@ exports.Modes = void 0;
     Modes["osu"] = "osu";
 })(exports.Modes || (exports.Modes = {}));
 
-/**
- * Represents a mod.
- */
-class Mod {
-    constructor() {
-        /**
-         * `Mod`s that are incompatible with this `Mod`.
-         */
-        this.incompatibleMods = new Set();
-    }
-    /**
-     * Serializes this `Mod` to a `SerializedMod`.
-     */
-    serialize() {
-        var _a;
-        const serialized = {
-            acronym: this.acronym,
-            settings: (_a = this.serializeSettings()) !== null && _a !== void 0 ? _a : undefined,
-        };
-        if (!serialized.settings) {
-            delete serialized.settings;
-        }
-        return serialized;
-    }
-    /**
-     * Copies the settings of a `SerializedMod` to this `Mod`.
-     *
-     * @param mod The `SerializedMod` to copy the settings from. Must be the same `Mod` type.
-     * @throws {TypeError} If the `SerializedMod` is not the same type as this `Mod`.
-     */
-    copySettings(mod) {
-        if (mod.acronym !== this.acronym) {
-            throw new TypeError(`Cannot copy settings from ${mod.acronym} to ${this.acronym}`);
-        }
-    }
-    /**
-     * 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 "osuRanked" in this;
-    }
-    /**
-     * Whether this `Mod` can be applied to osu!standard, specifically the osu!stable client.
-     */
-    isApplicableToOsuStable() {
-        return "bitwise" 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` can be applied to a track's playback rate.
-     */
-    isApplicableToTrackRate() {
-        return "applyToRate" in this;
-    }
-    /**
-     * Whether this `Mod` is migratable to a new `Mod` in osu!droid.
-     */
-    isMigratableDroidMod() {
-        return "migrateDroidMod" in this;
-    }
-    /**
-     * Serializes the settings of this `Mod` to an object that can be converted to a JSON.
-     *
-     * @returns The serialized settings of this `Mod`, or `null` if there are no settings.
-     */
-    serializeSettings() {
-        return null;
-    }
-    /**
-     * Returns the string representation of this `Mod`.
-     */
-    toString() {
-        return this.acronym;
-    }
-}
-
-/**
- * Represents the ScoreV2 mod.
- */
-class ModScoreV2 extends Mod {
-    constructor() {
-        super(...arguments);
-        this.acronym = "V2";
-        this.name = "ScoreV2";
-        this.droidRanked = false;
-        this.osuRanked = false;
-        this.bitwise = 1 << 29;
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 1;
-    }
-    get isOsuRelevant() {
-        return true;
-    }
-    get osuScoreMultiplier() {
-        return 1;
-    }
-}
-
 /**
  * Bitmask constant of object types. This is needed as osu! uses bits to determine object types.
  */
@@ -766,18 +629,20 @@ class CircleSizeCalculator {
      * @param mods The mods to apply.
      * @returns The calculated osu!droid scale.
      */
-    static droidCSToDroidScale(cs, mods = []) {
+    static droidCSToDroidScale(cs, mods) {
         // Create a dummy beatmap difficulty for circle size calculation.
         const difficulty = new BeatmapDifficulty();
         difficulty.cs = cs;
-        for (const mod of mods) {
-            if (mod.isApplicableToDifficulty()) {
-                mod.applyToDifficulty(exports.Modes.droid, difficulty);
+        if (mods !== undefined) {
+            for (const mod of mods.values()) {
+                if (mod.isApplicableToDifficulty()) {
+                    mod.applyToDifficulty(exports.Modes.droid, difficulty);
+                }
             }
-        }
-        for (const mod of mods) {
-            if (mod.isApplicableToDifficultyWithSettings()) {
-                mod.applyToDifficultyWithSettings(exports.Modes.droid, difficulty, mods);
+            for (const mod of mods.values()) {
+                if (mod.isApplicableToDifficultyWithSettings()) {
+                    mod.applyToDifficultyWithSettings(exports.Modes.droid, difficulty, mods);
+                }
             }
         }
         return Math.max(((this.assumedDroidHeight / 480) *
@@ -1310,68 +1175,311 @@ HitObject.preemptMin = 450;
 HitObject.controlPointLeniency = 1;
 
 /**
- * Represents a circle in a beatmap.
- *
- * All we need from circles is their position. All positions
- * stored in the objects are in playfield coordinates (512*384
- * rectangle).
+ * Represents a mod.
  */
-class Circle extends HitObject {
-    constructor(values) {
-        super(values);
+class Mod {
+    constructor() {
+        /**
+         * `Mod`s that are incompatible with this `Mod`.
+         */
+        this.incompatibleMods = new Set();
     }
-    toString() {
-        return `Position: [${this._position.x}, ${this._position.y}]`;
+    /**
+     * Serializes this `Mod` to a `SerializedMod`.
+     */
+    serialize() {
+        var _a;
+        const serialized = {
+            acronym: this.acronym,
+            settings: (_a = this.serializeSettings()) !== null && _a !== void 0 ? _a : undefined,
+        };
+        if (!serialized.settings) {
+            delete serialized.settings;
+        }
+        return serialized;
     }
-}
-
-/**
- * Represents a hitobject that can be nested within a slider.
- */
-class SliderNestedHitObject extends HitObject {
-    constructor(values) {
-        super(values);
-        this.spanIndex = values.spanIndex;
-        this.spanStartTime = values.spanStartTime;
+    /**
+     * Copies the settings of a `SerializedMod` to this `Mod`.
+     *
+     * @param mod The `SerializedMod` to copy the settings from. Must be the same `Mod` type.
+     * @throws {TypeError} If the `SerializedMod` is not the same type as this `Mod`.
+     */
+    copySettings(mod) {
+        if (mod.acronym !== this.acronym) {
+            throw new TypeError(`Cannot copy settings from ${mod.acronym} to ${this.acronym}`);
+        }
     }
-    toString() {
-        return `Position: [${this._position.x}, ${this._position.y}], span index: ${this.spanIndex}, span start time: ${this.spanStartTime}`;
+    /**
+     * Whether this `Mod` can be applied to osu!droid.
+     */
+    isApplicableToDroid() {
+        return "droidRanked" in this;
     }
-}
-
-/**
- * Represents the head of a slider.
- */
-class SliderHead extends SliderNestedHitObject {
-    constructor(values) {
-        super(Object.assign(Object.assign({}, values), { spanIndex: 0, spanStartTime: values.startTime }));
+    /**
+     * Whether this `Mod` can be applied to osu!standard.
+     */
+    isApplicableToOsu() {
+        return "osuRanked" in this;
     }
-}
-
-/**
- * An empty `HitWindow` that does not have any hit windows.
- *
- * No time values are provided (meaning instantaneous hit or miss).
- */
-class EmptyHitWindow extends HitWindow {
-    constructor() {
-        super(0);
+    /**
+     * Whether this `Mod` can be applied to osu!standard, specifically the osu!stable client.
+     */
+    isApplicableToOsuStable() {
+        return "bitwise" in this;
     }
-    get greatWindow() {
-        return 0;
+    /**
+     * Whether this `Mod` can be applied to a `Beatmap`.
+     */
+    isApplicableToBeatmap() {
+        return "applyToBeatmap" in this;
     }
-    get okWindow() {
-        return 0;
+    /**
+     * Whether this `Mod` can be applied to a `BeatmapDifficulty`.
+     */
+    isApplicableToDifficulty() {
+        return "applyToDifficulty" in this;
     }
-    get mehWindow() {
-        return 0;
+    /**
+     * Whether this `Mod` can be applied to a `BeatmapDifficulty` relative to other `Mod`s and settings.
+     */
+    isApplicableToDifficultyWithSettings() {
+        return "applyToDifficultyWithSettings" in this;
     }
-}
-
-/**
- * Represents a nested hit object that is at the end of a slider path (either repeat or tail).
- */
-class SliderEndCircle extends SliderNestedHitObject {
+    /**
+     * 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` can be applied to a track's playback rate.
+     */
+    isApplicableToTrackRate() {
+        return "applyToRate" in this;
+    }
+    /**
+     * Whether this `Mod` is migratable to a new `Mod` in osu!droid.
+     */
+    isMigratableDroidMod() {
+        return "migrateDroidMod" in this;
+    }
+    /**
+     * Serializes the settings of this `Mod` to an object that can be converted to a JSON.
+     *
+     * @returns The serialized settings of this `Mod`, or `null` if there are no settings.
+     */
+    serializeSettings() {
+        return null;
+    }
+    /**
+     * Returns the string representation of this `Mod`.
+     */
+    toString() {
+        return this.acronym;
+    }
+}
+
+/**
+ * Represents the Relax mod.
+ */
+class ModRelax extends Mod {
+    constructor() {
+        super();
+        this.acronym = "RX";
+        this.name = "Relax";
+        this.droidRanked = false;
+        this.osuRanked = false;
+        this.bitwise = 1 << 7;
+        this.incompatibleMods.add(ModAuto).add(ModAutopilot);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 0.001;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 0;
+    }
+}
+
+/**
+ * Represents the Autopilot mod.
+ */
+class ModAutopilot extends Mod {
+    constructor() {
+        super();
+        this.acronym = "AP";
+        this.name = "Autopilot";
+        this.droidRanked = false;
+        this.osuRanked = false;
+        this.bitwise = 1 << 13;
+        this.incompatibleMods.add(ModRelax).add(ModAuto);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 0.001;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 0;
+    }
+}
+
+/**
+ * Represents the Auto mod.
+ */
+class ModAuto extends Mod {
+    constructor() {
+        super();
+        this.acronym = "AT";
+        this.name = "Autoplay";
+        this.droidRanked = false;
+        this.osuRanked = false;
+        this.bitwise = 1 << 11;
+        this.incompatibleMods.add(ModAutopilot).add(ModRelax);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1;
+    }
+}
+
+/**
+ * Represents a `Mod` that adjusts the playback rate of a track.
+ */
+class ModRateAdjust extends Mod {
+    /**
+     * The generic osu!droid score multiplier of this `Mod`.
+     */
+    get droidScoreMultiplier() {
+        return this.trackRateMultiplier >= 1
+            ? 1 + (this.trackRateMultiplier - 1) * 0.24
+            : Math.pow(0.3, (1 - this.trackRateMultiplier) * 4);
+    }
+    /**
+     * Generic getter to determine if this `ModRateAdjust` is relevant.
+     */
+    get isRelevant() {
+        return this.trackRateMultiplier !== 1;
+    }
+    applyToRate(time, rate) {
+        return rate * this.trackRateMultiplier;
+    }
+}
+
+/**
+ * Represents the Custom Speed mod.
+ *
+ * This is a replacement `Mod` for speed modify in osu!droid and custom rates in osu!lazer.
+ */
+class ModCustomSpeed extends ModRateAdjust {
+    constructor(trackRateMultiplier = 1) {
+        super();
+        this.acronym = "CS";
+        this.name = "Custom Speed";
+        this.droidRanked = true;
+        this.osuRanked = false;
+        this.trackRateMultiplier = trackRateMultiplier;
+    }
+    copySettings(mod) {
+        var _a, _b;
+        super.copySettings(mod);
+        this.trackRateMultiplier =
+            (_b = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.rateMultiplier) !== null && _b !== void 0 ? _b : this.trackRateMultiplier;
+    }
+    get isDroidRelevant() {
+        return this.isRelevant;
+    }
+    calculateDroidScoreMultiplier() {
+        return this.droidScoreMultiplier;
+    }
+    get isOsuRelevant() {
+        return this.isRelevant;
+    }
+    get osuScoreMultiplier() {
+        // Round to the nearest multiple of 0.1.
+        let value = Math.trunc(this.trackRateMultiplier * 10) / 10;
+        // Offset back to 0.
+        --value;
+        return this.trackRateMultiplier >= 1 ? 1 + value / 5 : 0.6 + value;
+    }
+    serializeSettings() {
+        return { rateMultiplier: this.trackRateMultiplier };
+    }
+    toString() {
+        return `${super.toString()} (${this.trackRateMultiplier.toFixed(2)}x)`;
+    }
+}
+
+/**
+ * Represents a hitobject that can be nested within a slider.
+ */
+class SliderNestedHitObject extends HitObject {
+    constructor(values) {
+        super(values);
+        this.spanIndex = values.spanIndex;
+        this.spanStartTime = values.spanStartTime;
+    }
+    toString() {
+        return `Position: [${this._position.x}, ${this._position.y}], span index: ${this.spanIndex}, span start time: ${this.spanStartTime}`;
+    }
+}
+
+/**
+ * Represents the head of a slider.
+ */
+class SliderHead extends SliderNestedHitObject {
+    constructor(values) {
+        super(Object.assign(Object.assign({}, values), { spanIndex: 0, spanStartTime: values.startTime }));
+    }
+}
+
+/**
+ * An empty `HitWindow` that does not have any hit windows.
+ *
+ * No time values are provided (meaning instantaneous hit or miss).
+ */
+class EmptyHitWindow extends HitWindow {
+    constructor() {
+        super(0);
+    }
+    get greatWindow() {
+        return 0;
+    }
+    get okWindow() {
+        return 0;
+    }
+    get mehWindow() {
+        return 0;
+    }
+}
+
+/**
+ * Represents a nested hit object that is at the end of a slider path (either repeat or tail).
+ */
+class SliderEndCircle extends SliderNestedHitObject {
     constructor(values) {
         super(values);
         this.sliderSpanDuration = values.sliderSpanDuration;
@@ -1941,731 +2049,7 @@ Slider.baseTickSample = new BankHitSampleInfo("slidertick");
 Slider.legacyLastTickOffset = 36;
 
 /**
- * Represents the osu! playfield.
- */
-class Playfield {
-}
-/**
- * The size of the playfield, which is 512x384.
- */
-Playfield.baseSize = new Vector2(512, 384);
-
-/**
- * Represents a spinner in a beatmap.
- *
- * All we need from spinners is their duration. The
- * position of a spinner is always at 256x192.
- */
-class Spinner extends HitObject {
-    get endTime() {
-        return this._endTime;
-    }
-    constructor(values) {
-        super(Object.assign(Object.assign({}, values), { position: Playfield.baseSize.divide(2) }));
-        this._endTime = values.endTime;
-    }
-    applySamples(controlPoints) {
-        super.applySamples(controlPoints);
-        const samplePoints = controlPoints.sample.between(this.startTime + HitObject.controlPointLeniency, this.endTime + HitObject.controlPointLeniency);
-        this.auxiliarySamples.length = 0;
-        this.auxiliarySamples.push(new SequenceHitSampleInfo(samplePoints.map((s) => new TimedHitSampleInfo(s.time, s.applyTo(Spinner.baseSpinnerSpinSample)))));
-        this.auxiliarySamples.push(new SequenceHitSampleInfo(samplePoints.map((s) => new TimedHitSampleInfo(s.time, s.applyTo(Spinner.baseSpinnerBonusSample)))));
-    }
-    getStackedPosition() {
-        return this.position;
-    }
-    getStackedEndPosition() {
-        return this.position;
-    }
-    createHitWindow() {
-        return new EmptyHitWindow();
-    }
-    toString() {
-        return `Position: [${this._position.x}, ${this._position.y}], duration: ${this.duration}`;
-    }
-}
-Spinner.baseSpinnerSpinSample = new BankHitSampleInfo("spinnerspin");
-Spinner.baseSpinnerBonusSample = new BankHitSampleInfo("spinnerbonus");
-
-/**
- * Contains information about hit objects of a beatmap.
- */
-class BeatmapHitObjects {
-    constructor() {
-        this._objects = [];
-        this._circles = 0;
-        this._sliders = 0;
-        this._spinners = 0;
-    }
-    /**
-     * The objects of the beatmap.
-     */
-    get objects() {
-        return this._objects;
-    }
-    /**
-     * The amount of circles in the beatmap.
-     */
-    get circles() {
-        return this._circles;
-    }
-    /**
-     * The amount of sliders in the beatmap.
-     */
-    get sliders() {
-        return this._sliders;
-    }
-    /**
-     * The amount of spinners in the beatmap.
-     */
-    get spinners() {
-        return this._spinners;
-    }
-    /**
-     * The amount of slider ticks in the beatmap.
-     *
-     * This iterates through all objects and should be stored locally or used sparingly.
-     */
-    get sliderTicks() {
-        return this.objects.reduce((acc, cur) => (cur instanceof Slider ? acc + cur.ticks : acc), 0);
-    }
-    /**
-     * The amount of sliderends in the beatmap.
-     */
-    get sliderEnds() {
-        return this.sliders;
-    }
-    /**
-     * The amount of slider repeat points in the beatmap.
-     *
-     * This iterates through all objects and should be stored locally or used sparingly.
-     */
-    get sliderRepeatPoints() {
-        return this.objects.reduce((acc, cur) => (cur instanceof Slider ? acc + cur.repeatCount : acc), 0);
-    }
-    /**
-     * Adds hitobjects.
-     *
-     * The sorting order of hitobjects will be maintained.
-     *
-     * @param objects The hitobjects to add.
-     */
-    add(...objects) {
-        for (const object of objects) {
-            // Objects may be out of order *only* if a user has manually edited an .osu file.
-            // Unfortunately there are "ranked" maps in this state (example: https://osu.ppy.sh/s/594828).
-            // Finding index is used to guarantee that the parsing order of hitobjects with equal start times is maintained (stably-sorted).
-            this._objects.splice(this.findInsertionIndex(object.startTime), 0, object);
-            if (object instanceof Circle) {
-                ++this._circles;
-            }
-            else if (object instanceof Slider) {
-                ++this._sliders;
-            }
-            else {
-                ++this._spinners;
-            }
-        }
-    }
-    /**
-     * Removes a hitobject at an index.
-     *
-     * @param index The index of the hitobject to remove.
-     * @returns The hitobject that was removed, `null` if no hitobject was removed.
-     */
-    removeAt(index) {
-        var _a;
-        const object = (_a = this._objects.splice(index, 1)[0]) !== null && _a !== void 0 ? _a : null;
-        if (object instanceof Circle) {
-            --this._circles;
-        }
-        else if (object instanceof Slider) {
-            --this._sliders;
-        }
-        else if (object instanceof Spinner) {
-            --this._spinners;
-        }
-        return object;
-    }
-    /**
-     * Clears all hitobjects.
-     */
-    clear() {
-        this._objects.length = 0;
-        this._circles = 0;
-        this._sliders = 0;
-        this._spinners = 0;
-    }
-    /**
-     * Finds the insertion index of a hitobject in a given time.
-     *
-     * @param startTime The start time of the hitobject.
-     */
-    findInsertionIndex(startTime) {
-        if (this._objects.length === 0 ||
-            startTime < this._objects[0].startTime) {
-            return 0;
-        }
-        if (startTime >= this._objects.at(-1).startTime) {
-            return this._objects.length;
-        }
-        let l = 0;
-        let r = this._objects.length - 2;
-        while (l <= r) {
-            const pivot = l + ((r - l) >> 1);
-            if (this._objects[pivot].startTime < startTime) {
-                l = pivot + 1;
-            }
-            else if (this._objects[pivot].startTime > startTime) {
-                r = pivot - 1;
-            }
-            else {
-                return pivot;
-            }
-        }
-        return l;
-    }
-}
-
-/**
- * Converts a beatmap for another mode.
- */
-class BeatmapConverter {
-    constructor(beatmap) {
-        this.beatmap = beatmap;
-    }
-    /**
-     * Converts the beatmap.
-     *
-     * @returns The converted beatmap.
-     */
-    convert() {
-        const converted = new Beatmap(this.beatmap);
-        // Shallow clone isn't enough to ensure we don't mutate some beatmap properties unexpectedly.
-        converted.difficulty = new BeatmapDifficulty(this.beatmap.difficulty);
-        converted.hitObjects = this.convertHitObjects();
-        return converted;
-    }
-    convertHitObjects() {
-        const hitObjects = new BeatmapHitObjects();
-        this.beatmap.hitObjects.objects.forEach((hitObject) => {
-            hitObjects.add(this.convertHitObject(hitObject));
-        });
-        return hitObjects;
-    }
-    convertHitObject(hitObject) {
-        let object;
-        if (hitObject instanceof Circle) {
-            object = new Circle({
-                startTime: hitObject.startTime,
-                position: hitObject.position,
-                newCombo: hitObject.isNewCombo,
-                type: hitObject.type,
-                comboOffset: hitObject.comboOffset,
-            });
-        }
-        else if (hitObject instanceof Slider) {
-            object = new Slider({
-                startTime: hitObject.startTime,
-                position: hitObject.position,
-                newCombo: hitObject.isNewCombo,
-                type: hitObject.type,
-                path: hitObject.path,
-                repeatCount: hitObject.repeatCount,
-                nodeSamples: hitObject.nodeSamples,
-                comboOffset: hitObject.comboOffset,
-                tickDistanceMultiplier: 
-                // Prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
-                // This results in more (or less) ticks being generated in <v8 maps for the same time duration.
-                this.beatmap.formatVersion < 8
-                    ? 1 /
-                        this.beatmap.controlPoints.difficulty.controlPointAt(hitObject.startTime).speedMultiplier
-                    : 1,
-            });
-        }
-        else {
-            object = new Spinner({
-                startTime: hitObject.startTime,
-                endTime: hitObject.endTime,
-                type: hitObject.type,
-            });
-        }
-        object.samples = hitObject.samples;
-        object.auxiliarySamples = hitObject.auxiliarySamples;
-        return object;
-    }
-}
-
-/**
- * Provides functionality to alter a beatmap after it has been converted.
- */
-class BeatmapProcessor {
-    constructor(beatmap) {
-        this.beatmap = beatmap;
-    }
-    /**
-     * Processes the converted beatmap prior to `HitObject.applyDefaults` being invoked.
-     *
-     * Nested hitobjects generated during `HitObject.applyDefaults` will not be present by this point,
-     * and no mods will have been applied to the hitobjects.
-     *
-     * This can only be used to add alterations to hitobjects generated directly through the conversion process.
-     */
-    preProcess() {
-        let last = null;
-        for (const object of this.beatmap.hitObjects.objects) {
-            object.updateComboInformation(last);
-            last = object;
-        }
-        // Mark the last object in the beatmap as last in combo.
-        if (last) {
-            last.isLastInCombo = true;
-        }
-    }
-    /**
-     * Processes the converted beatmap after `HitObject.applyDefaults` has been invoked.
-     *
-     * Nested hitobjects generated during `HitObject.applyDefaults` wil be present by this point,
-     * and mods will have been applied to all hitobjects.
-     *
-     * This should be used to add alterations to hitobjects while they are in their most playable state.
-     *
-     * @param mode The mode to add alterations for.
-     */
-    postProcess(mode) {
-        const objects = this.beatmap.hitObjects.objects;
-        if (objects.length === 0) {
-            return;
-        }
-        // Reset stacking
-        objects.forEach((h) => {
-            h.stackHeight = 0;
-        });
-        switch (mode) {
-            case exports.Modes.droid:
-                this.applyDroidStacking();
-                break;
-            case exports.Modes.osu:
-                if (this.beatmap.formatVersion >= 6) {
-                    this.applyStandardStacking();
-                }
-                else {
-                    this.applyStandardOldStacking();
-                }
-                break;
-        }
-    }
-    applyDroidStacking() {
-        const objects = this.beatmap.hitObjects.objects;
-        if (objects.length === 0) {
-            return;
-        }
-        const convertedScale = CircleSizeCalculator.standardScaleToDroidScale(objects[0].scale);
-        for (let i = 0; i < objects.length - 1; ++i) {
-            const current = objects[i];
-            const next = objects[i + 1];
-            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;
-            }
-        }
-    }
-    applyStandardStacking() {
-        const objects = this.beatmap.hitObjects.objects;
-        const startIndex = 0;
-        const endIndex = objects.length - 1;
-        let extendedEndIndex = endIndex;
-        if (endIndex < objects.length - 1) {
-            for (let i = endIndex; i >= startIndex; --i) {
-                let stackBaseIndex = i;
-                for (let n = stackBaseIndex + 1; n < objects.length; ++n) {
-                    const stackBaseObject = objects[stackBaseIndex];
-                    if (stackBaseObject instanceof Spinner) {
-                        break;
-                    }
-                    const objectN = objects[n];
-                    if (objectN instanceof Spinner) {
-                        break;
-                    }
-                    const stackThreshold = objectN.timePreempt *
-                        this.beatmap.general.stackLeniency;
-                    if (objectN.startTime - stackBaseObject.endTime >
-                        stackThreshold) {
-                        // We are no longer within stacking range of the next object.
-                        break;
-                    }
-                    const endPositionDistanceCheck = stackBaseObject instanceof Slider
-                        ? stackBaseObject.endPosition.getDistance(objectN.position) < BeatmapProcessor.stackDistance
-                        : false;
-                    if (stackBaseObject.position.getDistance(objectN.position) <
-                        BeatmapProcessor.stackDistance ||
-                        endPositionDistanceCheck) {
-                        stackBaseIndex = n;
-                        // Hit objects after the specified update range haven't been reset yet
-                        objectN.stackHeight = 0;
-                    }
-                }
-                if (stackBaseIndex > extendedEndIndex) {
-                    extendedEndIndex = stackBaseIndex;
-                    if (extendedEndIndex === objects.length - 1) {
-                        break;
-                    }
-                }
-            }
-        }
-        // Reverse pass for stack calculation.
-        let extendedStartIndex = startIndex;
-        for (let i = extendedEndIndex; i > startIndex; --i) {
-            let n = i;
-            // We should check every note which has not yet got a stack.
-            // Consider the case we have two inter-wound stacks and this will make sense.
-            //
-            // o <-1      o <-2
-            //  o <-3      o <-4
-            //
-            // We first process starting from 4 and handle 2,
-            // then we come backwards on the i loop iteration until we reach 3 and handle 1.
-            // 2 and 1 will be ignored in the i loop because they already have a stack value.
-            let objectI = objects[i];
-            if (objectI.stackHeight !== 0 || objectI instanceof Spinner) {
-                continue;
-            }
-            const stackThreshold = objectI.timePreempt * this.beatmap.general.stackLeniency;
-            // If this object is a hit circle, then we enter this "special" case.
-            // It either ends with a stack of hit circles only, or a stack of hit circles that are underneath a slider.
-            // Any other case is handled by the "instanceof Slider" code below this.
-            if (objectI instanceof Circle) {
-                while (--n >= 0) {
-                    const objectN = objects[n];
-                    if (objectN instanceof Spinner) {
-                        continue;
-                    }
-                    if (objectI.startTime - objectN.endTime > stackThreshold) {
-                        // We are no longer within stacking range of the previous object.
-                        break;
-                    }
-                    // Hit objects before the specified update range haven't been reset yet
-                    if (n < extendedStartIndex) {
-                        objectN.stackHeight = 0;
-                        extendedStartIndex = n;
-                    }
-                    // This is a special case where hit circles are moved DOWN and RIGHT (negative stacking) if they are under the *last* slider in a stacked pattern.
-                    // o==o <- slider is at original location
-                    //     o <- hitCircle has stack of -1
-                    //      o <- hitCircle has stack of -2
-                    if (objectN instanceof Slider &&
-                        objectN.endPosition.getDistance(objectI.position) <
-                            BeatmapProcessor.stackDistance) {
-                        const offset = objectI.stackHeight - objectN.stackHeight + 1;
-                        for (let j = n + 1; j <= i; ++j) {
-                            // For each object which was declared under this slider, we will offset it to appear *below* the slider end (rather than above).
-                            const objectJ = objects[j];
-                            if (objectN.endPosition.getDistance(objectJ.position) < BeatmapProcessor.stackDistance) {
-                                objectJ.stackHeight -= offset;
-                            }
-                        }
-                        // We have hit a slider. We should restart calculation using this as the new base.
-                        // Breaking here will mean that the slider still has a stack count of 0, so will be handled in the i-outer-loop.
-                        break;
-                    }
-                    if (objectN.position.getDistance(objectI.position) <
-                        BeatmapProcessor.stackDistance) {
-                        // Keep processing as if there are no sliders. If we come across a slider, this gets cancelled out.
-                        // NOTE: Sliders with start positions stacking are a special case that is also handled here.
-                        objectN.stackHeight = objectI.stackHeight + 1;
-                        objectI = objectN;
-                    }
-                }
-            }
-            else if (objectI instanceof Slider) {
-                // We have hit the first slider in a possible stack.
-                // From this point on, we ALWAYS stack positive regardless.
-                while (--n >= startIndex) {
-                    const objectN = objects[n];
-                    if (objectN instanceof Spinner) {
-                        continue;
-                    }
-                    if (objectI.startTime - objectN.startTime >
-                        stackThreshold) {
-                        // We are no longer within stacking range of the previous object.
-                        break;
-                    }
-                    if (objectN.endPosition.getDistance(objectI.position) <
-                        BeatmapProcessor.stackDistance) {
-                        objectN.stackHeight = objectI.stackHeight + 1;
-                        objectI = objectN;
-                    }
-                }
-            }
-        }
-    }
-    applyStandardOldStacking() {
-        const objects = this.beatmap.hitObjects.objects;
-        for (let i = 0; i < objects.length; ++i) {
-            const currentObject = objects[i];
-            if (currentObject.stackHeight !== 0 &&
-                !(currentObject instanceof Slider)) {
-                continue;
-            }
-            let startTime = currentObject.endTime;
-            let sliderStack = 0;
-            const stackThreshold = currentObject.timePreempt * this.beatmap.general.stackLeniency;
-            for (let j = i + 1; j < objects.length; ++j) {
-                if (objects[j].startTime - stackThreshold > startTime) {
-                    break;
-                }
-                // Note the use of `startTime` in the code below doesn't match osu!stable's use of `endTime`.
-                // This is because in osu!stable's implementation, `UpdateCalculations` is not called on the inner-loop hitobject (j)
-                // and therefore it does not have a correct `endTime`, but instead the default of `endTime = startTime`.
-                //
-                // Effects of this can be seen on https://osu.ppy.sh/beatmapsets/243#osu/1146 at sliders around 86647 ms, where
-                // if we use `endTime` here it would result in unexpected stacking.
-                //
-                // Reference: https://github.com/ppy/osu/pull/24188
-                if (objects[j].position.getDistance(currentObject.position) <
-                    BeatmapProcessor.stackDistance) {
-                    ++currentObject.stackHeight;
-                    startTime = objects[j].startTime;
-                }
-                else if (objects[j].position.getDistance(currentObject.endPosition) <
-                    BeatmapProcessor.stackDistance) {
-                    // Case for sliders - bump notes down and right, rather than up and left.
-                    ++sliderStack;
-                    objects[j].stackHeight -= sliderStack;
-                    startTime = objects[j].startTime;
-                }
-            }
-        }
-    }
-}
-BeatmapProcessor.stackDistance = 3;
-
-/**
- * Represents the hit window of osu!droid _with_ the Precise mod.
- */
-class PreciseDroidHitWindow extends HitWindow {
-    /**
-     * Calculates the overall difficulty value of a great (300) hit window.
-     *
-     * @param value The value of the hit window, in milliseconds.
-     * @returns The overall difficulty value.
-     */
-    static greatWindowToOD(value) {
-        return 5 - (value - 55) / 6;
-    }
-    /**
-     * Calculates the overall difficulty value of a good (100) hit window.
-     *
-     * @param value The value of the hit window, in milliseconds.
-     * @returns The overall difficulty value.
-     */
-    static okWindowToOD(value) {
-        return 5 - (value - 120) / 8;
-    }
-    /**
-     * Calculates the overall difficulty value of a meh (50) hit window.
-     *
-     * @param value The value of the hit window, in milliseconds.
-     * @returns The overall difficulty value.
-     */
-    static mehWindowToOD(value) {
-        return 5 - (value - 180) / 10;
-    }
-    get greatWindow() {
-        return 55 + 6 * (5 - this.overallDifficulty);
-    }
-    get okWindow() {
-        return 120 + 8 * (5 - this.overallDifficulty);
-    }
-    get mehWindow() {
-        return 180 + 10 * (5 - this.overallDifficulty);
-    }
-}
-
-/**
- * Represents the Precise mod.
- */
-class ModPrecise extends Mod {
-    constructor() {
-        super(...arguments);
-        this.acronym = "PR";
-        this.name = "Precise";
-        this.droidRanked = true;
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 1.06;
-    }
-    applyToHitObject(mode, hitObject) {
-        var _a, _b;
-        if (mode !== exports.Modes.droid || hitObject instanceof Spinner) {
-            return;
-        }
-        if (hitObject instanceof Slider) {
-            // For sliders, the hit window is enforced in the head - everything else is an instant hit or miss.
-            hitObject.head.hitWindow = new PreciseDroidHitWindow((_a = hitObject.head.hitWindow) === null || _a === void 0 ? void 0 : _a.overallDifficulty);
-        }
-        else {
-            hitObject.hitWindow = new PreciseDroidHitWindow((_b = hitObject.hitWindow) === null || _b === void 0 ? void 0 : _b.overallDifficulty);
-        }
-    }
-}
-
-/**
- * Represents the Relax mod.
- */
-class ModRelax extends Mod {
-    constructor() {
-        super();
-        this.acronym = "RX";
-        this.name = "Relax";
-        this.droidRanked = false;
-        this.osuRanked = false;
-        this.bitwise = 1 << 7;
-        this.incompatibleMods.add(ModAuto).add(ModAutopilot);
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 0.001;
-    }
-    get isOsuRelevant() {
-        return true;
-    }
-    get osuScoreMultiplier() {
-        return 0;
-    }
-}
-
-/**
- * Represents the Autopilot mod.
- */
-class ModAutopilot extends Mod {
-    constructor() {
-        super();
-        this.acronym = "AP";
-        this.name = "Autopilot";
-        this.droidRanked = false;
-        this.osuRanked = false;
-        this.bitwise = 1 << 13;
-        this.incompatibleMods.add(ModRelax).add(ModAuto);
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 0.001;
-    }
-    get isOsuRelevant() {
-        return true;
-    }
-    get osuScoreMultiplier() {
-        return 0;
-    }
-}
-
-/**
- * Represents the Auto mod.
- */
-class ModAuto extends Mod {
-    constructor() {
-        super();
-        this.acronym = "AT";
-        this.name = "Autoplay";
-        this.droidRanked = false;
-        this.osuRanked = false;
-        this.bitwise = 1 << 11;
-        this.incompatibleMods.add(ModAutopilot).add(ModRelax);
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 1;
-    }
-    get isOsuRelevant() {
-        return true;
-    }
-    get osuScoreMultiplier() {
-        return 1;
-    }
-}
-
-/**
- * Represents a `Mod` that adjusts the playback rate of a track.
- */
-class ModRateAdjust extends Mod {
-    /**
-     * The generic osu!droid score multiplier of this `Mod`.
-     */
-    get droidScoreMultiplier() {
-        return this.trackRateMultiplier >= 1
-            ? 1 + (this.trackRateMultiplier - 1) * 0.24
-            : Math.pow(0.3, (1 - this.trackRateMultiplier) * 4);
-    }
-    /**
-     * Generic getter to determine if this `ModRateAdjust` is relevant.
-     */
-    get isRelevant() {
-        return this.trackRateMultiplier !== 1;
-    }
-    applyToRate(time, rate) {
-        return rate * this.trackRateMultiplier;
-    }
-}
-
-/**
- * Represents the Custom Speed mod.
- *
- * This is a replacement `Mod` for speed modify in osu!droid and custom rates in osu!lazer.
- */
-class ModCustomSpeed extends ModRateAdjust {
-    constructor(trackRateMultiplier = 1) {
-        super();
-        this.acronym = "CS";
-        this.name = "Custom Speed";
-        this.droidRanked = true;
-        this.osuRanked = false;
-        this.trackRateMultiplier = trackRateMultiplier;
-    }
-    copySettings(mod) {
-        var _a, _b;
-        super.copySettings(mod);
-        this.trackRateMultiplier =
-            (_b = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.rateMultiplier) !== null && _b !== void 0 ? _b : this.trackRateMultiplier;
-    }
-    get isDroidRelevant() {
-        return this.isRelevant;
-    }
-    calculateDroidScoreMultiplier() {
-        return this.droidScoreMultiplier;
-    }
-    get isOsuRelevant() {
-        return this.isRelevant;
-    }
-    get osuScoreMultiplier() {
-        // Round to the nearest multiple of 0.1.
-        let value = Math.trunc(this.trackRateMultiplier * 10) / 10;
-        // Offset back to 0.
-        --value;
-        return this.trackRateMultiplier >= 1 ? 1 + value / 5 : 0.6 + value;
-    }
-    serializeSettings() {
-        return { rateMultiplier: this.trackRateMultiplier };
-    }
-    toString() {
-        return `${super.toString()} (${this.trackRateMultiplier.toFixed(2)}x)`;
-    }
-}
-
-/**
- * Represents the Difficulty Adjust mod.
+ * Represents the Difficulty Adjust mod.
  */
 class ModDifficultyAdjust extends Mod {
     get isRelevant() {
@@ -2721,7 +2105,7 @@ class ModDifficultyAdjust extends Mod {
     get osuScoreMultiplier() {
         return 0.5;
     }
-    applyToDifficultyWithSettings(mode, difficulty, mods) {
+    applyToDifficultyWithSettings(_, difficulty, mods) {
         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;
@@ -2731,19 +2115,22 @@ class ModDifficultyAdjust extends Mod {
         // 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);
+            const trackRate = this.calculateTrackRate(mods.values());
             difficulty.ar = BeatmapDifficulty.inverseDifficultyRange(preempt * trackRate, HitObject.preemptMax, HitObject.preemptMid, HitObject.preemptMin);
         }
     }
-    applyToHitObjectWithSettings(mode, hitObject, mods) {
+    applyToHitObjectWithSettings(_, hitObject, mods) {
         // 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;
         }
-        // IMPORTANT: This does not use `ModUtil.calculateRateWithMods` to avoid circular dependency.
-        const trackRate = this.calculateTrackRate(mods);
-        hitObject.timeFadeIn *= trackRate;
+        this.applyFadeAdjustment(hitObject, mods);
+        if (hitObject instanceof Slider) {
+            for (const nested of hitObject.nestedHitObjects) {
+                this.applyFadeAdjustment(nested, mods);
+            }
+        }
     }
     serializeSettings() {
         if (this.cs === undefined &&
@@ -2767,11 +2154,24 @@ class ModDifficultyAdjust extends Mod {
         }
         return settings;
     }
+    applyFadeAdjustment(hitObject, mods) {
+        // IMPORTANT: These do not use `ModUtil.calculateRateWithMods` to avoid circular dependency.
+        const initialTrackRate = this.calculateTrackRate(mods.values());
+        const currentTrackRate = this.calculateTrackRate(mods.values(), hitObject.startTime);
+        // Cancel the rate that was initially applied to timePreempt (via applyToDifficulty above and
+        // HitObject.applyDefaults) and apply the current one.
+        hitObject.timePreempt *= currentTrackRate / initialTrackRate;
+        hitObject.timeFadeIn *= currentTrackRate;
+    }
     calculateTrackRate(mods, time = 0) {
         // IMPORTANT: This does not use `ModUtil.calculateRateWithMods` to avoid circular dependency.
-        return mods.reduce((rate, mod) => mod.isApplicableToTrackRate()
-            ? mod.applyToRate(time, rate)
-            : rate, 1);
+        let rate = 1;
+        for (const mod of mods) {
+            if (mod.isApplicableToTrackRate()) {
+                rate = mod.applyToRate(time, rate);
+            }
+        }
+        return rate;
     }
     toString() {
         const settings = [];
@@ -2875,6 +2275,16 @@ class ModDoubleTime extends ModRateAdjust {
     }
 }
 
+/**
+ * Represents the osu! playfield.
+ */
+class Playfield {
+}
+/**
+ * The size of the playfield, which is 512x384.
+ */
+Playfield.baseSize = new Vector2(512, 384);
+
 /**
  * Types of slider paths.
  */
@@ -3418,17 +2828,202 @@ class SliderPath {
 }
 
 /**
- * Represents the HardRock mod.
+ * Represents the HardRock mod.
+ */
+class ModHardRock extends Mod {
+    constructor() {
+        super();
+        this.acronym = "HR";
+        this.name = "HardRock";
+        this.droidRanked = true;
+        this.osuRanked = true;
+        this.bitwise = 1 << 4;
+        this.incompatibleMods.add(ModEasy);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1.06;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1.06;
+    }
+    applyToDifficulty(mode, difficulty) {
+        switch (mode) {
+            case exports.Modes.droid: {
+                const scale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
+                difficulty.cs = CircleSizeCalculator.droidScaleToDroidCS(scale - 0.125);
+                break;
+            }
+            case exports.Modes.osu:
+                // CS uses a custom 1.3 ratio.
+                difficulty.cs = this.applySetting(difficulty.cs, 1.3);
+                break;
+        }
+        difficulty.ar = this.applySetting(difficulty.ar);
+        difficulty.od = this.applySetting(difficulty.od);
+        difficulty.hp = this.applySetting(difficulty.hp);
+    }
+    applyToHitObject(_, hitObject) {
+        // Reflect the position of the hit object.
+        hitObject.position = this.reflectVector(hitObject.position);
+        if (!(hitObject instanceof Slider)) {
+            return;
+        }
+        // Reflect the control points of the slider. This will reflect the positions of head and tail circles.
+        hitObject.path = new SliderPath({
+            pathType: hitObject.path.pathType,
+            controlPoints: hitObject.path.controlPoints.map((v) => this.reflectControlPoint(v)),
+            expectedDistance: hitObject.path.expectedDistance,
+        });
+        // Reflect the position of slider ticks and repeats.
+        hitObject.nestedHitObjects.slice(1, -1).forEach((obj) => {
+            obj.position = this.reflectVector(obj.position);
+        });
+    }
+    reflectVector(vector) {
+        return new Vector2(vector.x, Playfield.baseSize.y - vector.y);
+    }
+    reflectControlPoint(vector) {
+        return new Vector2(vector.x, -vector.y);
+    }
+    applySetting(value, ratio = 1.4) {
+        return Math.min(value * ratio, 10);
+    }
+}
+
+/**
+ * Represents the Easy mod.
+ */
+class ModEasy extends Mod {
+    constructor() {
+        super();
+        this.acronym = "EZ";
+        this.name = "Easy";
+        this.droidRanked = true;
+        this.osuRanked = true;
+        this.bitwise = 1 << 1;
+        this.incompatibleMods.add(ModHardRock);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 0.5;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 0.5;
+    }
+    applyToDifficulty(mode, difficulty) {
+        switch (mode) {
+            case exports.Modes.droid: {
+                const scale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
+                difficulty.cs = CircleSizeCalculator.droidScaleToDroidCS(scale + 0.125);
+                break;
+            }
+            case exports.Modes.osu:
+                difficulty.cs /= 2;
+        }
+        difficulty.ar /= 2;
+        difficulty.od /= 2;
+        difficulty.hp /= 2;
+    }
+}
+
+/**
+ * Represents the Flashlight mod.
+ */
+class ModFlashlight extends Mod {
+    constructor() {
+        super(...arguments);
+        this.acronym = "FL";
+        this.name = "Flashlight";
+        this.droidRanked = true;
+        this.osuRanked = true;
+        this.bitwise = 1 << 10;
+        /**
+         * The amount of seconds until the Flashlight follow area reaches the cursor.
+         */
+        this.followDelay = ModFlashlight.defaultFollowDelay;
+    }
+    copySettings(mod) {
+        var _a, _b;
+        super.copySettings(mod);
+        this.followDelay =
+            (_b = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.areaFollowDelay) !== null && _b !== void 0 ? _b : this.followDelay;
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1.12;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1.12;
+    }
+    serializeSettings() {
+        return { areaFollowDelay: this.followDelay };
+    }
+    toString() {
+        if (this.followDelay === ModFlashlight.defaultFollowDelay) {
+            return super.toString();
+        }
+        return `${super.toString()} (${this.followDelay.toFixed(2)}s follow delay)`;
+    }
+}
+/**
+ * The default amount of seconds until the Flashlight follow area reaches the cursor.
+ */
+ModFlashlight.defaultFollowDelay = 0.12;
+
+/**
+ * Represents the Traceable mod.
+ */
+class ModTraceable extends Mod {
+    constructor() {
+        super();
+        this.acronym = "TC";
+        this.name = "Traceable";
+        this.droidRanked = false;
+        this.osuRanked = false;
+        this.incompatibleMods.add(ModHidden);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1.06;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1;
+    }
+}
+
+/**
+ * Represents the Hidden mod.
  */
-class ModHardRock extends Mod {
+class ModHidden extends Mod {
     constructor() {
         super();
-        this.acronym = "HR";
-        this.name = "HardRock";
+        this.acronym = "HD";
+        this.name = "Hidden";
         this.droidRanked = true;
         this.osuRanked = true;
-        this.bitwise = 1 << 4;
-        this.incompatibleMods.add(ModEasy);
+        this.bitwise = 1 << 3;
+        this.incompatibleMods.add(ModTraceable);
     }
     get isDroidRelevant() {
         return true;
@@ -3442,62 +3037,86 @@ class ModHardRock extends Mod {
     get osuScoreMultiplier() {
         return 1.06;
     }
-    applyToDifficulty(mode, difficulty) {
-        switch (mode) {
-            case exports.Modes.droid: {
-                const scale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
-                difficulty.cs = CircleSizeCalculator.droidScaleToDroidCS(scale - 0.125);
-                break;
+    applyToBeatmap(beatmap) {
+        const applyFadeInAdjustment = (hitObject) => {
+            hitObject.timeFadeIn =
+                hitObject.timePreempt * ModHidden.fadeInDurationMultiplier;
+            if (hitObject instanceof Slider) {
+                hitObject.nestedHitObjects.forEach(applyFadeInAdjustment);
             }
-            case exports.Modes.osu:
-                // CS uses a custom 1.3 ratio.
-                difficulty.cs = this.applySetting(difficulty.cs, 1.3);
-                break;
-        }
-        difficulty.ar = this.applySetting(difficulty.ar);
-        difficulty.od = this.applySetting(difficulty.od);
-        difficulty.hp = this.applySetting(difficulty.hp);
+        };
+        beatmap.hitObjects.objects.forEach(applyFadeInAdjustment);
     }
-    applyToHitObject(_, hitObject) {
-        // Reflect the position of the hit object.
-        hitObject.position = this.reflectVector(hitObject.position);
-        if (!(hitObject instanceof Slider)) {
-            return;
-        }
-        // Reflect the control points of the slider. This will reflect the positions of head and tail circles.
-        hitObject.path = new SliderPath({
-            pathType: hitObject.path.pathType,
-            controlPoints: hitObject.path.controlPoints.map((v) => this.reflectControlPoint(v)),
-            expectedDistance: hitObject.path.expectedDistance,
-        });
-        // Reflect the position of slider ticks and repeats.
-        hitObject.nestedHitObjects.slice(1, -1).forEach((obj) => {
-            obj.position = this.reflectVector(obj.position);
-        });
+}
+ModHidden.fadeInDurationMultiplier = 0.4;
+ModHidden.fadeOutDurationMultiplier = 0.3;
+
+/**
+ * Represents the SuddenDeath mod.
+ */
+class ModSuddenDeath extends Mod {
+    constructor() {
+        super();
+        this.acronym = "SD";
+        this.name = "Sudden Death";
+        this.droidRanked = true;
+        this.osuRanked = true;
+        this.bitwise = 1 << 5;
+        this.incompatibleMods.add(ModNoFail).add(ModPerfect);
     }
-    reflectVector(vector) {
-        return new Vector2(vector.x, Playfield.baseSize.y - vector.y);
+    get isDroidRelevant() {
+        return true;
     }
-    reflectControlPoint(vector) {
-        return new Vector2(vector.x, -vector.y);
+    calculateDroidScoreMultiplier() {
+        return 1;
     }
-    applySetting(value, ratio = 1.4) {
-        return Math.min(value * ratio, 10);
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1;
     }
 }
 
 /**
- * Represents the Easy mod.
+ * Represents the Perfect mod.
  */
-class ModEasy extends Mod {
+class ModPerfect extends Mod {
     constructor() {
         super();
-        this.acronym = "EZ";
-        this.name = "Easy";
+        this.acronym = "PF";
+        this.name = "Perfect";
         this.droidRanked = true;
         this.osuRanked = true;
-        this.bitwise = 1 << 1;
-        this.incompatibleMods.add(ModHardRock);
+        this.bitwise = 1 << 14;
+        this.incompatibleMods.add(ModNoFail).add(ModSuddenDeath);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1;
+    }
+}
+
+/**
+ * Represents the NoFail mod.
+ */
+class ModNoFail extends Mod {
+    constructor() {
+        super();
+        this.acronym = "NF";
+        this.name = "NoFail";
+        this.droidRanked = true;
+        this.osuRanked = true;
+        this.bitwise = 1 << 0;
+        this.incompatibleMods.add(ModPerfect).add(ModSuddenDeath);
     }
     get isDroidRelevant() {
         return true;
@@ -3511,88 +3130,179 @@ class ModEasy extends Mod {
     get osuScoreMultiplier() {
         return 0.5;
     }
-    applyToDifficulty(mode, difficulty) {
-        switch (mode) {
-            case exports.Modes.droid: {
-                const scale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
-                difficulty.cs = CircleSizeCalculator.droidScaleToDroidCS(scale + 0.125);
-                break;
-            }
-            case exports.Modes.osu:
-                difficulty.cs /= 2;
+}
+
+/**
+ * Represents a spinner in a beatmap.
+ *
+ * All we need from spinners is their duration. The
+ * position of a spinner is always at 256x192.
+ */
+class Spinner extends HitObject {
+    get endTime() {
+        return this._endTime;
+    }
+    constructor(values) {
+        super(Object.assign(Object.assign({}, values), { position: Playfield.baseSize.divide(2) }));
+        this._endTime = values.endTime;
+    }
+    applySamples(controlPoints) {
+        super.applySamples(controlPoints);
+        const samplePoints = controlPoints.sample.between(this.startTime + HitObject.controlPointLeniency, this.endTime + HitObject.controlPointLeniency);
+        this.auxiliarySamples.length = 0;
+        this.auxiliarySamples.push(new SequenceHitSampleInfo(samplePoints.map((s) => new TimedHitSampleInfo(s.time, s.applyTo(Spinner.baseSpinnerSpinSample)))));
+        this.auxiliarySamples.push(new SequenceHitSampleInfo(samplePoints.map((s) => new TimedHitSampleInfo(s.time, s.applyTo(Spinner.baseSpinnerBonusSample)))));
+    }
+    getStackedPosition() {
+        return this.position;
+    }
+    getStackedEndPosition() {
+        return this.position;
+    }
+    createHitWindow() {
+        return new EmptyHitWindow();
+    }
+    toString() {
+        return `Position: [${this._position.x}, ${this._position.y}], duration: ${this.duration}`;
+    }
+}
+Spinner.baseSpinnerSpinSample = new BankHitSampleInfo("spinnerspin");
+Spinner.baseSpinnerBonusSample = new BankHitSampleInfo("spinnerbonus");
+
+/**
+ * Represents the hit window of osu!droid _with_ the Precise mod.
+ */
+class PreciseDroidHitWindow extends HitWindow {
+    /**
+     * Calculates the overall difficulty value of a great (300) hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @returns The overall difficulty value.
+     */
+    static greatWindowToOD(value) {
+        return 5 - (value - 55) / 6;
+    }
+    /**
+     * Calculates the overall difficulty value of a good (100) hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @returns The overall difficulty value.
+     */
+    static okWindowToOD(value) {
+        return 5 - (value - 120) / 8;
+    }
+    /**
+     * Calculates the overall difficulty value of a meh (50) hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @returns The overall difficulty value.
+     */
+    static mehWindowToOD(value) {
+        return 5 - (value - 180) / 10;
+    }
+    get greatWindow() {
+        return 55 + 6 * (5 - this.overallDifficulty);
+    }
+    get okWindow() {
+        return 120 + 8 * (5 - this.overallDifficulty);
+    }
+    get mehWindow() {
+        return 180 + 10 * (5 - this.overallDifficulty);
+    }
+}
+
+/**
+ * Represents the Precise mod.
+ */
+class ModPrecise extends Mod {
+    constructor() {
+        super(...arguments);
+        this.acronym = "PR";
+        this.name = "Precise";
+        this.droidRanked = true;
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1.06;
+    }
+    applyToHitObject(mode, hitObject) {
+        var _a, _b;
+        if (mode !== exports.Modes.droid || hitObject instanceof Spinner) {
+            return;
+        }
+        if (hitObject instanceof Slider) {
+            // For sliders, the hit window is enforced in the head - everything else is an instant hit or miss.
+            hitObject.head.hitWindow = new PreciseDroidHitWindow((_a = hitObject.head.hitWindow) === null || _a === void 0 ? void 0 : _a.overallDifficulty);
+        }
+        else {
+            hitObject.hitWindow = new PreciseDroidHitWindow((_b = hitObject.hitWindow) === null || _b === void 0 ? void 0 : _b.overallDifficulty);
         }
-        difficulty.ar /= 2;
-        difficulty.od /= 2;
-        difficulty.hp /= 2;
     }
 }
 
 /**
- * Represents the Flashlight mod.
+ * Represents the ReallyEasy mod.
  */
-class ModFlashlight extends Mod {
+class ModReallyEasy extends Mod {
     constructor() {
         super(...arguments);
-        this.acronym = "FL";
-        this.name = "Flashlight";
-        this.droidRanked = true;
-        this.osuRanked = true;
-        this.bitwise = 1 << 10;
-        /**
-         * The amount of seconds until the Flashlight follow area reaches the cursor.
-         */
-        this.followDelay = ModFlashlight.defaultFollowDelay;
-    }
-    copySettings(mod) {
-        var _a, _b;
-        super.copySettings(mod);
-        this.followDelay =
-            (_b = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.areaFollowDelay) !== null && _b !== void 0 ? _b : this.followDelay;
+        this.acronym = "RE";
+        this.name = "ReallyEasy";
+        this.droidRanked = false;
     }
     get isDroidRelevant() {
         return true;
     }
     calculateDroidScoreMultiplier() {
-        return 1.12;
-    }
-    get isOsuRelevant() {
-        return true;
-    }
-    get osuScoreMultiplier() {
-        return 1.12;
-    }
-    serializeSettings() {
-        return { areaFollowDelay: this.followDelay };
+        return 0.4;
     }
-    toString() {
-        if (this.followDelay === ModFlashlight.defaultFollowDelay) {
-            return super.toString();
+    applyToDifficultyWithSettings(mode, difficulty, mods) {
+        var _a;
+        if (mode !== exports.Modes.droid) {
+            return;
+        }
+        const difficultyAdjustMod = mods.get(ModDifficultyAdjust);
+        if ((difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.ar) === undefined) {
+            if (mods.has(ModEasy)) {
+                difficulty.ar *= 2;
+                difficulty.ar -= 0.5;
+            }
+            const customSpeed = mods.get(ModCustomSpeed);
+            difficulty.ar -= 0.5;
+            difficulty.ar -= ((_a = customSpeed === null || customSpeed === void 0 ? void 0 : customSpeed.trackRateMultiplier) !== null && _a !== void 0 ? _a : 1) - 1;
+        }
+        if ((difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.cs) === undefined) {
+            const scale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
+            difficulty.cs = CircleSizeCalculator.droidScaleToDroidCS(scale + 0.125);
+        }
+        if ((difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.od) === undefined) {
+            difficulty.od /= 2;
+        }
+        if ((difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.hp) === undefined) {
+            difficulty.hp /= 2;
         }
-        return `${super.toString()} (${this.followDelay.toFixed(2)}s follow delay)`;
     }
 }
-/**
- * The default amount of seconds until the Flashlight follow area reaches the cursor.
- */
-ModFlashlight.defaultFollowDelay = 0.12;
 
 /**
- * Represents the Traceable mod.
+ * Represents the ScoreV2 mod.
  */
-class ModTraceable extends Mod {
+class ModScoreV2 extends Mod {
     constructor() {
-        super();
-        this.acronym = "TC";
-        this.name = "Traceable";
+        super(...arguments);
+        this.acronym = "V2";
+        this.name = "ScoreV2";
         this.droidRanked = false;
         this.osuRanked = false;
-        this.incompatibleMods.add(ModHidden);
+        this.bitwise = 1 << 29;
     }
     get isDroidRelevant() {
         return true;
     }
     calculateDroidScoreMultiplier() {
-        return 1.06;
+        return 1;
     }
     get isOsuRelevant() {
         return true;
@@ -3603,17 +3313,16 @@ class ModTraceable extends Mod {
 }
 
 /**
- * Represents the Hidden mod.
+ * Represents the SmallCircle mod.
+ *
+ * This is a legacy osu!droid mod that may still be exist when parsing replays.
  */
-class ModHidden extends Mod {
+class ModSmallCircle extends Mod {
     constructor() {
-        super();
-        this.acronym = "HD";
-        this.name = "Hidden";
-        this.droidRanked = true;
-        this.osuRanked = true;
-        this.bitwise = 1 << 3;
-        this.incompatibleMods.add(ModTraceable);
+        super(...arguments);
+        this.acronym = "SC";
+        this.name = "SmallCircle";
+        this.droidRanked = false;
     }
     get isDroidRelevant() {
         return true;
@@ -3621,71 +3330,55 @@ class ModHidden extends Mod {
     calculateDroidScoreMultiplier() {
         return 1.06;
     }
-    get isOsuRelevant() {
-        return true;
-    }
-    get osuScoreMultiplier() {
-        return 1.06;
+    migrateDroidMod(difficulty) {
+        return new ModDifficultyAdjust({ cs: difficulty.cs + 4 });
     }
-    applyToBeatmap(beatmap) {
-        const applyFadeInAdjustment = (hitObject) => {
-            hitObject.timeFadeIn =
-                hitObject.timePreempt * ModHidden.fadeInDurationMultiplier;
-            if (hitObject instanceof Slider) {
-                hitObject.nestedHitObjects.forEach(applyFadeInAdjustment);
+    applyToDifficulty(mode, difficulty) {
+        switch (mode) {
+            case exports.Modes.droid: {
+                const scale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
+                difficulty.cs = CircleSizeCalculator.droidScaleToDroidCS(scale -
+                    ((CircleSizeCalculator.assumedDroidHeight / 480) *
+                        (4 * 4.48) *
+                        2) /
+                        128);
+                break;
             }
-        };
-        beatmap.hitObjects.objects.forEach(applyFadeInAdjustment);
+            case exports.Modes.osu:
+                difficulty.cs += 4;
+        }
     }
 }
-ModHidden.fadeInDurationMultiplier = 0.4;
-ModHidden.fadeOutDurationMultiplier = 0.3;
 
 /**
- * Represents the SuddenDeath mod.
+ * Represents the SpunOut mod.
  */
-class ModSuddenDeath extends Mod {
+class ModSpunOut extends Mod {
     constructor() {
-        super();
-        this.acronym = "SD";
-        this.name = "Sudden Death";
-        this.droidRanked = true;
+        super(...arguments);
+        this.acronym = "SO";
+        this.name = "SpunOut";
         this.osuRanked = true;
-        this.bitwise = 1 << 5;
-        this.incompatibleMods.add(ModNoFail).add(ModPerfect);
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 1;
+        this.bitwise = 1 << 12;
     }
     get isOsuRelevant() {
         return true;
     }
     get osuScoreMultiplier() {
-        return 1;
+        return 0.9;
     }
 }
 
 /**
- * Represents the Perfect mod.
+ * Represents the TouchDevice mod.
  */
-class ModPerfect extends Mod {
+class ModTouchDevice extends Mod {
     constructor() {
-        super();
-        this.acronym = "PF";
-        this.name = "Perfect";
-        this.droidRanked = true;
+        super(...arguments);
+        this.acronym = "TD";
+        this.name = "TouchDevice";
         this.osuRanked = true;
-        this.bitwise = 1 << 14;
-        this.incompatibleMods.add(ModNoFail).add(ModSuddenDeath);
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 1;
+        this.bitwise = 1 << 2;
     }
     get isOsuRelevant() {
         return true;
@@ -3696,417 +3389,771 @@ class ModPerfect extends Mod {
 }
 
 /**
- * Represents the NoFail mod.
+ * Utilities for mods.
  */
-class ModNoFail extends Mod {
-    constructor() {
-        super();
-        this.acronym = "NF";
-        this.name = "NoFail";
-        this.droidRanked = true;
-        this.osuRanked = true;
-        this.bitwise = 1 << 0;
-        this.incompatibleMods.add(ModPerfect).add(ModSuddenDeath);
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 0.5;
+class ModUtil {
+    /**
+     * Gets a list of mods from a PC modbits.
+     *
+     * @param modbits The modbits.
+     * @returns The list of mods.
+     */
+    static pcModbitsToMods(modbits) {
+        const map = new ModMap();
+        if (modbits === 0) {
+            return map;
+        }
+        for (const modType of this.allMods.values()) {
+            const mod = new modType();
+            if (mod.isApplicableToOsuStable() && (mod.bitwise & modbits) > 0) {
+                map.set(mod);
+            }
+        }
+        return map;
     }
-    get isOsuRelevant() {
-        return true;
+    /**
+     * Serializes a list of `Mod`s.
+     *
+     * @param mods The list of `Mod`s to serialize.
+     * @returns The serialized list of `Mod`s.
+     */
+    static serializeMods(mods) {
+        const serializedMods = [];
+        for (const mod of mods) {
+            serializedMods.push(mod.serialize());
+        }
+        return serializedMods;
     }
-    get osuScoreMultiplier() {
-        return 0.5;
+    /**
+     * Deserializes a list of `SerializedMod`s.
+     *
+     * @param mods The list of `SerializedMod`s to deserialize.
+     * @returns The deserialized list of `Mod`s.
+     */
+    static deserializeMods(mods) {
+        const map = new ModMap();
+        for (const serializedMod of mods) {
+            const modType = this.allMods.get(serializedMod.acronym);
+            if (!modType) {
+                continue;
+            }
+            const mod = new modType();
+            if (serializedMod.settings) {
+                mod.copySettings(serializedMod);
+            }
+            map.set(mod);
+        }
+        return map;
     }
-}
-
-/**
- * Represents the ReallyEasy mod.
- */
-class ModReallyEasy extends Mod {
-    constructor() {
-        super(...arguments);
-        this.acronym = "RE";
-        this.name = "ReallyEasy";
-        this.droidRanked = false;
+    /**
+     * Gets a list of mods from a PC mod string, such as "HDHR".
+     *
+     * @param str The string.
+     * @returns The list of mods.
+     */
+    static pcStringToMods(str) {
+        const map = new ModMap();
+        str = str.toLowerCase();
+        while (str) {
+            let nchars = 1;
+            for (const acronym of this.allMods.keys()) {
+                if (str.startsWith(acronym.toLowerCase())) {
+                    const modType = this.allMods.get(acronym);
+                    map.set(modType);
+                    nchars = acronym.length;
+                    break;
+                }
+            }
+            str = str.slice(nchars);
+        }
+        return map;
     }
-    get isDroidRelevant() {
-        return true;
+    /**
+     * Converts a list of mods into its osu!standard string counterpart.
+     *
+     * @param mods The array of mods to convert.
+     * @returns The string representing the mods in osu!standard.
+     */
+    static modsToOsuString(mods) {
+        let str = "";
+        for (const mod of mods) {
+            if (mod instanceof ModDifficultyAdjust) {
+                continue;
+            }
+            str += mod.acronym;
+        }
+        return str;
     }
-    calculateDroidScoreMultiplier() {
-        return 0.4;
+    /**
+     * Converts an array of `Mod`s into an ordered string based on {@link allMods}.
+     *
+     * @param mods The array of `Mod`s to convert.
+     * @returns The string representing the `Mod`s in ordered form.
+     */
+    static modsToOrderedString(mods) {
+        const strs = [];
+        for (const modType of this.allMods.values()) {
+            for (const mod of mods) {
+                if (mod instanceof modType) {
+                    strs.push(mod.toString());
+                    break;
+                }
+            }
+        }
+        return strs.join();
     }
-    applyToDifficultyWithSettings(mode, difficulty, mods) {
-        var _a;
-        if (mode !== exports.Modes.droid) {
-            return;
+    /**
+     * Removes speed-changing mods from an array of mods.
+     *
+     * @param mods The array of mods.
+     * @returns A new array with speed changing mods filtered out.
+     */
+    static removeSpeedChangingMods(mods) {
+        return mods.filter((m) => !(m instanceof ModRateAdjust));
+    }
+    /**
+     * 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. Defaults to No Mod.
+     * @param withRateChange Whether to apply rate changes. Defaults to `false`.
+     */
+    static applyModsToBeatmapDifficulty(difficulty, mode, mods, withRateChange = false) {
+        if (mods !== undefined) {
+            for (const mod of mods.values()) {
+                if (mod.isApplicableToDifficulty()) {
+                    mod.applyToDifficulty(mode, difficulty);
+                }
+            }
         }
-        const difficultyAdjustMod = mods.find((m) => m instanceof ModDifficultyAdjust);
-        if ((difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.ar) === undefined) {
-            if (mods.some((m) => m instanceof ModEasy)) {
-                difficulty.ar *= 2;
-                difficulty.ar -= 0.5;
+        let rate = 1;
+        if (mods !== undefined) {
+            for (const mod of mods.values()) {
+                if (mod.isApplicableToDifficultyWithSettings()) {
+                    mod.applyToDifficultyWithSettings(mode, difficulty, mods);
+                }
+                if (mod.isApplicableToTrackRate()) {
+                    rate = mod.applyToRate(0, rate);
+                }
             }
-            const customSpeed = mods.find((m) => m instanceof ModCustomSpeed);
-            difficulty.ar -= 0.5;
-            difficulty.ar -= ((_a = customSpeed === null || customSpeed === void 0 ? void 0 : customSpeed.trackRateMultiplier) !== null && _a !== void 0 ? _a : 1) - 1;
         }
-        if ((difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.cs) === undefined) {
-            const scale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
-            difficulty.cs = CircleSizeCalculator.droidScaleToDroidCS(scale + 0.125);
+        if (!withRateChange) {
+            return;
         }
-        if ((difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.od) === undefined) {
-            difficulty.od /= 2;
+        // Apply rate adjustments
+        const preempt = BeatmapDifficulty.difficultyRange(difficulty.ar, HitObject.preemptMax, HitObject.preemptMid, HitObject.preemptMin) / rate;
+        difficulty.ar = BeatmapDifficulty.inverseDifficultyRange(preempt, HitObject.preemptMax, HitObject.preemptMid, HitObject.preemptMin);
+        switch (mode) {
+            case exports.Modes.droid:
+                if (mods === null || mods === void 0 ? void 0 : mods.has(ModPrecise)) {
+                    const hitWindow = new PreciseDroidHitWindow(difficulty.od);
+                    difficulty.od = PreciseDroidHitWindow.greatWindowToOD(hitWindow.greatWindow / rate);
+                }
+                else {
+                    const hitWindow = new DroidHitWindow(difficulty.od);
+                    difficulty.od = DroidHitWindow.greatWindowToOD(hitWindow.greatWindow / rate);
+                }
+                break;
+            case exports.Modes.osu: {
+                const hitWindow = new OsuHitWindow(difficulty.od);
+                difficulty.od = OsuHitWindow.greatWindowToOD(hitWindow.greatWindow / rate);
+                break;
+            }
         }
-        if ((difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.hp) === undefined) {
-            difficulty.hp /= 2;
+    }
+    /**
+     * Calculates the playback rate for the track with the selected `Mod`s at the given time.
+     *
+     * @param mods The list of selected `Mod`s.
+     * @param time The time at which the playback rate is queried, in milliseconds. Defaults to 0.
+     * @returns The rate with `Mod`s.
+     */
+    static calculateRateWithMods(mods, time = 0) {
+        let rate = 1;
+        for (const mod of mods) {
+            if (mod.isApplicableToTrackRate()) {
+                rate = mod.applyToRate(time, rate);
+            }
         }
+        return rate;
     }
 }
+/**
+ * All `Mod`s that exists, mapped by their acronym.
+ */
+ModUtil.allMods = (() => {
+    const mods = [
+        // Janky order to keep the order on what players are used to
+        ModAuto,
+        ModRelax,
+        ModAutopilot,
+        ModEasy,
+        ModNoFail,
+        ModHidden,
+        ModTraceable,
+        ModDoubleTime,
+        ModNightCore,
+        ModHalfTime,
+        ModCustomSpeed,
+        ModHardRock,
+        ModDifficultyAdjust,
+        ModFlashlight,
+        ModSuddenDeath,
+        ModPerfect,
+        ModPrecise,
+        ModReallyEasy,
+        ModScoreV2,
+        ModSmallCircle,
+        ModSpunOut,
+        ModTouchDevice,
+    ];
+    const map = new Map();
+    for (const mod of mods) {
+        map.set(new mod().acronym, mod);
+    }
+    return map;
+})();
 
 /**
- * Represents the SmallCircle mod.
+ * A map that stores `Mod`s depending on their type.
  *
- * This is a legacy osu!droid mod that may still be exist when parsing replays.
+ * This also has additional utilities to eliminate unnecessary `Mod`s.
  */
-class ModSmallCircle extends Mod {
-    constructor() {
-        super(...arguments);
-        this.acronym = "SC";
-        this.name = "SmallCircle";
-        this.droidRanked = false;
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 1.06;
-    }
-    migrateDroidMod(difficulty) {
-        return new ModDifficultyAdjust({ cs: difficulty.cs + 4 });
-    }
-    applyToDifficulty(mode, difficulty) {
-        switch (mode) {
-            case exports.Modes.droid: {
-                const scale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
-                difficulty.cs = CircleSizeCalculator.droidScaleToDroidCS(scale -
-                    ((CircleSizeCalculator.assumedDroidHeight / 480) *
-                        (4 * 4.48) *
-                        2) /
-                        128);
-                break;
+class ModMap extends Map {
+    /**
+     * Whether this map is empty.
+     */
+    get isEmpty() {
+        return this.size === 0;
+    }
+    constructor(iterable) {
+        if (Array.isArray(iterable)) {
+            for (const [key, value] of iterable) {
+                // Ensure the mod type corresponds to the mod instance.
+                if (key !== value.constructor) {
+                    throw new TypeError(`Key ${key.name} does not match value ${value.constructor.name}`);
+                }
+            }
+        }
+        super(iterable);
+    }
+    get(key) {
+        return super.get(key);
+    }
+    set(keyOrValue) {
+        const key = (keyOrValue instanceof Mod ? keyOrValue.constructor : keyOrValue);
+        const value = keyOrValue instanceof Mod ? keyOrValue : new key();
+        // Ensure the mod type corresponds to the mod instance.
+        if (key !== value.constructor) {
+            throw new TypeError(`Key ${key.name} does not match value ${value.constructor.name}`);
+        }
+        const existing = this.get(key);
+        // If all difficulty statistics are set, all other difficulty adjusting mods are irrelevant, so we remove them.
+        // This prevents potential abuse cases where score multipliers from non-affecting mods stack (i.e., forcing
+        // all difficulty statistics while using the Hard Rock mod).
+        const removeDifficultyAdjustmentMods = value instanceof ModDifficultyAdjust &&
+            value.cs !== undefined &&
+            value.ar !== undefined &&
+            value.od !== undefined &&
+            value.hp !== undefined;
+        if (removeDifficultyAdjustmentMods) {
+            this.delete(ModEasy);
+            this.delete(ModHardRock);
+            this.delete(ModReallyEasy);
+            this.delete(ModSmallCircle);
+        }
+        // Check if there are any mods that are incompatible with the new mod.
+        // If so, remove them.
+        for (const incompatibleMod of value.incompatibleMods) {
+            for (const mod of this.values()) {
+                if (mod instanceof incompatibleMod) {
+                    this.delete(mod.constructor);
+                }
             }
-            case exports.Modes.osu:
-                difficulty.cs += 4;
         }
+        super.set(key, value);
+        return existing !== null && existing !== void 0 ? existing : null;
+    }
+    /**
+     * Serializes all `Mod`s that are in this map.
+     */
+    serializeMods() {
+        return ModUtil.serializeMods(this.values());
     }
 }
 
 /**
- * Represents the SpunOut mod.
+ * Represents a circle in a beatmap.
+ *
+ * All we need from circles is their position. All positions
+ * stored in the objects are in playfield coordinates (512*384
+ * rectangle).
  */
-class ModSpunOut extends Mod {
-    constructor() {
-        super(...arguments);
-        this.acronym = "SO";
-        this.name = "SpunOut";
-        this.osuRanked = true;
-        this.bitwise = 1 << 12;
-    }
-    get isOsuRelevant() {
-        return true;
+class Circle extends HitObject {
+    constructor(values) {
+        super(values);
     }
-    get osuScoreMultiplier() {
-        return 0.9;
+    toString() {
+        return `Position: [${this._position.x}, ${this._position.y}]`;
     }
 }
 
 /**
- * Represents the TouchDevice mod.
+ * Contains information about hit objects of a beatmap.
  */
-class ModTouchDevice extends Mod {
+class BeatmapHitObjects {
     constructor() {
-        super(...arguments);
-        this.acronym = "TD";
-        this.name = "TouchDevice";
-        this.osuRanked = true;
-        this.bitwise = 1 << 2;
+        this._objects = [];
+        this._circles = 0;
+        this._sliders = 0;
+        this._spinners = 0;
     }
-    get isOsuRelevant() {
-        return true;
+    /**
+     * The objects of the beatmap.
+     */
+    get objects() {
+        return this._objects;
     }
-    get osuScoreMultiplier() {
-        return 1;
+    /**
+     * The amount of circles in the beatmap.
+     */
+    get circles() {
+        return this._circles;
     }
-}
-
-/**
- * Utilities for mods.
- */
-class ModUtil {
     /**
-     * Gets a list of mods from a PC modbits.
+     * The amount of sliders in the beatmap.
+     */
+    get sliders() {
+        return this._sliders;
+    }
+    /**
+     * The amount of spinners in the beatmap.
+     */
+    get spinners() {
+        return this._spinners;
+    }
+    /**
+     * The amount of slider ticks in the beatmap.
      *
-     * @param modbits The modbits.
-     * @param options Options for parsing behavior.
+     * This iterates through all objects and should be stored locally or used sparingly.
      */
-    static pcModbitsToMods(modbits, options) {
-        if (modbits === 0) {
-            return [];
-        }
-        const mods = [];
-        for (const modType of this.allMods.values()) {
-            const mod = new modType();
-            if (mod.isApplicableToOsuStable() && (mod.bitwise & modbits) > 0) {
-                mods.push(mod);
-            }
-        }
-        return this.processParsingOptions(mods, options);
+    get sliderTicks() {
+        return this.objects.reduce((acc, cur) => (cur instanceof Slider ? acc + cur.ticks : acc), 0);
     }
     /**
-     * Serializes a list of `Mod`s.
+     * The amount of sliderends in the beatmap.
+     */
+    get sliderEnds() {
+        return this.sliders;
+    }
+    /**
+     * The amount of slider repeat points in the beatmap.
      *
-     * @param mods The list of `Mod`s to serialize.
-     * @returns The serialized list of `Mod`s.
+     * This iterates through all objects and should be stored locally or used sparingly.
      */
-    static serializeMods(mods) {
-        const serializedMods = [];
-        for (const mod of mods) {
-            serializedMods.push(mod.serialize());
-        }
-        return serializedMods;
+    get sliderRepeatPoints() {
+        return this.objects.reduce((acc, cur) => (cur instanceof Slider ? acc + cur.repeatCount : acc), 0);
     }
     /**
-     * Deserializes a list of `SerializedMod`s.
+     * Adds hitobjects.
      *
-     * @param mods The list of `SerializedMod`s to deserialize.
-     * @returns The deserialized list of `Mod`s.
+     * The sorting order of hitobjects will be maintained.
+     *
+     * @param objects The hitobjects to add.
      */
-    static deserializeMods(mods) {
-        const deserializedMods = [];
-        for (const serializedMod of mods) {
-            const modType = this.allMods.get(serializedMod.acronym);
-            if (!modType) {
-                continue;
+    add(...objects) {
+        for (const object of objects) {
+            // Objects may be out of order *only* if a user has manually edited an .osu file.
+            // Unfortunately there are "ranked" maps in this state (example: https://osu.ppy.sh/s/594828).
+            // Finding index is used to guarantee that the parsing order of hitobjects with equal start times is maintained (stably-sorted).
+            this._objects.splice(this.findInsertionIndex(object.startTime), 0, object);
+            if (object instanceof Circle) {
+                ++this._circles;
             }
-            const mod = new modType();
-            if (serializedMod.settings) {
-                mod.copySettings(serializedMod);
+            else if (object instanceof Slider) {
+                ++this._sliders;
+            }
+            else {
+                ++this._spinners;
             }
-            deserializedMods.push(mod);
         }
-        return deserializedMods;
     }
     /**
-     * Gets a list of mods from a PC mod string, such as "HDHR".
+     * Removes a hitobject at an index.
      *
-     * @param str The string.
-     * @param options Options for parsing behavior.
+     * @param index The index of the hitobject to remove.
+     * @returns The hitobject that was removed, `null` if no hitobject was removed.
      */
-    static pcStringToMods(str, options) {
-        const finalMods = [];
-        str = str.toLowerCase();
-        while (str) {
-            let nchars = 1;
-            for (const acronym of this.allMods.keys()) {
-                if (str.startsWith(acronym.toLowerCase())) {
-                    const modType = this.allMods.get(acronym);
-                    finalMods.push(new modType());
-                    nchars = acronym.length;
-                    break;
-                }
-            }
-            str = str.slice(nchars);
+    removeAt(index) {
+        var _a;
+        const object = (_a = this._objects.splice(index, 1)[0]) !== null && _a !== void 0 ? _a : null;
+        if (object instanceof Circle) {
+            --this._circles;
         }
-        return this.processParsingOptions(finalMods, options);
+        else if (object instanceof Slider) {
+            --this._sliders;
+        }
+        else if (object instanceof Spinner) {
+            --this._spinners;
+        }
+        return object;
     }
     /**
-     * Converts an array of mods into its osu!standard string counterpart.
-     *
-     * @param mods The array of mods to convert.
-     * @returns The string representing the mods in osu!standard.
+     * Clears all hitobjects.
      */
-    static modsToOsuString(mods) {
-        return mods.reduce((a, v) => {
-            if (v instanceof ModDifficultyAdjust) {
-                return a;
-            }
-            return a + v.acronym;
-        }, "");
+    clear() {
+        this._objects.length = 0;
+        this._circles = 0;
+        this._sliders = 0;
+        this._spinners = 0;
     }
     /**
-     * Converts an array of `Mod`s into an ordered string based on {@link allMods}.
+     * Finds the insertion index of a hitobject in a given time.
      *
-     * @param mods The array of `Mod`s to convert.
-     * @returns The string representing the `Mod`s in ordered form.
+     * @param startTime The start time of the hitobject.
      */
-    static modsToOrderedString(mods) {
-        const strs = [];
-        for (const modType of this.allMods.values()) {
-            for (const mod of mods) {
-                if (mod instanceof modType) {
-                    strs.push(mod.toString());
-                    break;
-                }
+    findInsertionIndex(startTime) {
+        if (this._objects.length === 0 ||
+            startTime < this._objects[0].startTime) {
+            return 0;
+        }
+        if (startTime >= this._objects.at(-1).startTime) {
+            return this._objects.length;
+        }
+        let l = 0;
+        let r = this._objects.length - 2;
+        while (l <= r) {
+            const pivot = l + ((r - l) >> 1);
+            if (this._objects[pivot].startTime < startTime) {
+                l = pivot + 1;
+            }
+            else if (this._objects[pivot].startTime > startTime) {
+                r = pivot - 1;
+            }
+            else {
+                return pivot;
             }
         }
-        return strs.join();
+        return l;
     }
-    /**
-     * Checks for mods that are duplicated.
-     *
-     * @param mods The mods to check for.
-     * @returns Mods that have been filtered.
-     */
-    static checkDuplicateMods(mods) {
-        return Array.from(new Set(mods));
+}
+
+/**
+ * Converts a beatmap for another mode.
+ */
+class BeatmapConverter {
+    constructor(beatmap) {
+        this.beatmap = beatmap;
     }
     /**
-     * Checks for mods that are incompatible with each other.
+     * Converts the beatmap.
      *
-     * @param mods The mods to check for.
-     * @returns Mods that have been filtered.
+     * @returns The converted beatmap.
      */
-    static checkIncompatibleMods(mods) {
-        for (let i = 0; i < mods.length; ++i) {
-            const mod = mods[i];
-            for (const incompatibleMod of mod.incompatibleMods) {
-                if (mods.some((m) => m !== mod && m instanceof incompatibleMod)) {
-                    mods = mods.filter((m) => 
-                    // Keep the mod itself.
-                    m === mod || !(m instanceof incompatibleMod));
-                }
-            }
+    convert() {
+        const converted = new Beatmap(this.beatmap);
+        // Shallow clone isn't enough to ensure we don't mutate some beatmap properties unexpectedly.
+        converted.difficulty = new BeatmapDifficulty(this.beatmap.difficulty);
+        converted.hitObjects = this.convertHitObjects();
+        return converted;
+    }
+    convertHitObjects() {
+        const hitObjects = new BeatmapHitObjects();
+        this.beatmap.hitObjects.objects.forEach((hitObject) => {
+            hitObjects.add(this.convertHitObject(hitObject));
+        });
+        return hitObjects;
+    }
+    convertHitObject(hitObject) {
+        let object;
+        if (hitObject instanceof Circle) {
+            object = new Circle({
+                startTime: hitObject.startTime,
+                position: hitObject.position,
+                newCombo: hitObject.isNewCombo,
+                type: hitObject.type,
+                comboOffset: hitObject.comboOffset,
+            });
+        }
+        else if (hitObject instanceof Slider) {
+            object = new Slider({
+                startTime: hitObject.startTime,
+                position: hitObject.position,
+                newCombo: hitObject.isNewCombo,
+                type: hitObject.type,
+                path: hitObject.path,
+                repeatCount: hitObject.repeatCount,
+                nodeSamples: hitObject.nodeSamples,
+                comboOffset: hitObject.comboOffset,
+                tickDistanceMultiplier: 
+                // Prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
+                // This results in more (or less) ticks being generated in <v8 maps for the same time duration.
+                this.beatmap.formatVersion < 8
+                    ? 1 /
+                        this.beatmap.controlPoints.difficulty.controlPointAt(hitObject.startTime).speedMultiplier
+                    : 1,
+            });
+        }
+        else {
+            object = new Spinner({
+                startTime: hitObject.startTime,
+                endTime: hitObject.endTime,
+                type: hitObject.type,
+            });
         }
-        return mods;
+        object.samples = hitObject.samples;
+        object.auxiliarySamples = hitObject.auxiliarySamples;
+        return object;
+    }
+}
+
+/**
+ * Provides functionality to alter a beatmap after it has been converted.
+ */
+class BeatmapProcessor {
+    constructor(beatmap) {
+        this.beatmap = beatmap;
     }
     /**
-     * Removes speed-changing mods from an array of mods.
+     * Processes the converted beatmap prior to `HitObject.applyDefaults` being invoked.
      *
-     * @param mods The array of mods.
-     * @returns A new array with speed changing mods filtered out.
+     * Nested hitobjects generated during `HitObject.applyDefaults` will not be present by this point,
+     * and no mods will have been applied to the hitobjects.
+     *
+     * This can only be used to add alterations to hitobjects generated directly through the conversion process.
      */
-    static removeSpeedChangingMods(mods) {
-        return mods.filter((m) => !(m instanceof ModRateAdjust));
+    preProcess() {
+        let last = null;
+        for (const object of this.beatmap.hitObjects.objects) {
+            object.updateComboInformation(last);
+            last = object;
+        }
+        // Mark the last object in the beatmap as last in combo.
+        if (last) {
+            last.isLastInCombo = true;
+        }
     }
     /**
-     * Applies the selected `Mod`s to a `BeatmapDifficulty`.
+     * Processes the converted beatmap after `HitObject.applyDefaults` has been invoked.
      *
-     * @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 withRateChange Whether to apply rate changes.
-     * @param oldStatistics Whether to enforce old statistics. Some `Mod`s behave differently with this flag.
+     * Nested hitobjects generated during `HitObject.applyDefaults` wil be present by this point,
+     * and mods will have been applied to all hitobjects.
+     *
+     * This should be used to add alterations to hitobjects while they are in their most playable state.
+     *
+     * @param mode The mode to add alterations for.
      */
-    static applyModsToBeatmapDifficulty(difficulty, mode, mods, withRateChange = false) {
-        for (const mod of mods) {
-            if (mod.isApplicableToDifficulty()) {
-                mod.applyToDifficulty(mode, difficulty);
-            }
-        }
-        let rate = 1;
-        for (const mod of mods) {
-            if (mod.isApplicableToDifficultyWithSettings()) {
-                mod.applyToDifficultyWithSettings(mode, difficulty, mods);
-            }
-            if (mod.isApplicableToTrackRate()) {
-                rate = mod.applyToRate(0, rate);
-            }
-        }
-        if (!withRateChange) {
+    postProcess(mode) {
+        const objects = this.beatmap.hitObjects.objects;
+        if (objects.length === 0) {
             return;
         }
-        // Apply rate adjustments
-        const preempt = BeatmapDifficulty.difficultyRange(difficulty.ar, HitObject.preemptMax, HitObject.preemptMid, HitObject.preemptMin) / rate;
-        difficulty.ar = BeatmapDifficulty.inverseDifficultyRange(preempt, HitObject.preemptMax, HitObject.preemptMid, HitObject.preemptMin);
+        // Reset stacking
+        objects.forEach((h) => {
+            h.stackHeight = 0;
+        });
         switch (mode) {
             case exports.Modes.droid:
-                if (mods.some((m) => m instanceof ModPrecise)) {
-                    const hitWindow = new PreciseDroidHitWindow(difficulty.od);
-                    difficulty.od = PreciseDroidHitWindow.greatWindowToOD(hitWindow.greatWindow / rate);
+                this.applyDroidStacking();
+                break;
+            case exports.Modes.osu:
+                if (this.beatmap.formatVersion >= 6) {
+                    this.applyStandardStacking();
                 }
                 else {
-                    const hitWindow = new DroidHitWindow(difficulty.od);
-                    difficulty.od = DroidHitWindow.greatWindowToOD(hitWindow.greatWindow / rate);
+                    this.applyStandardOldStacking();
                 }
                 break;
-            case exports.Modes.osu: {
-                const hitWindow = new OsuHitWindow(difficulty.od);
-                difficulty.od = OsuHitWindow.greatWindowToOD(hitWindow.greatWindow / rate);
-                break;
-            }
         }
     }
-    /**
-     * Calculates the playback rate for the track with the selected `Mod`s at the given time.
-     *
-     * @param mods The list of selected `Mod`s.
-     * @param time The time at which the playback rate is queried, in milliseconds. Defaults to 0.
-     * @returns The rate with `Mod`s.
-     */
-    static calculateRateWithMods(mods, time = 0) {
-        let rate = 1;
-        for (const mod of mods) {
-            if (mod.isApplicableToTrackRate()) {
-                rate = mod.applyToRate(time, rate);
+    applyDroidStacking() {
+        const objects = this.beatmap.hitObjects.objects;
+        if (objects.length === 0) {
+            return;
+        }
+        const convertedScale = CircleSizeCalculator.standardScaleToDroidScale(objects[0].scale);
+        for (let i = 0; i < objects.length - 1; ++i) {
+            const current = objects[i];
+            const next = objects[i + 1];
+            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;
             }
         }
-        return rate;
     }
-    /**
-     * Processes parsing options.
-     *
-     * @param mods The mods to process.
-     * @param options The options to process.
-     * @returns The processed mods.
-     */
-    static processParsingOptions(mods, options) {
-        if ((options === null || options === void 0 ? void 0 : options.checkDuplicate) !== false) {
-            mods = this.checkDuplicateMods(mods);
+    applyStandardStacking() {
+        const objects = this.beatmap.hitObjects.objects;
+        const startIndex = 0;
+        const endIndex = objects.length - 1;
+        let extendedEndIndex = endIndex;
+        if (endIndex < objects.length - 1) {
+            for (let i = endIndex; i >= startIndex; --i) {
+                let stackBaseIndex = i;
+                for (let n = stackBaseIndex + 1; n < objects.length; ++n) {
+                    const stackBaseObject = objects[stackBaseIndex];
+                    if (stackBaseObject instanceof Spinner) {
+                        break;
+                    }
+                    const objectN = objects[n];
+                    if (objectN instanceof Spinner) {
+                        break;
+                    }
+                    const stackThreshold = objectN.timePreempt *
+                        this.beatmap.general.stackLeniency;
+                    if (objectN.startTime - stackBaseObject.endTime >
+                        stackThreshold) {
+                        // We are no longer within stacking range of the next object.
+                        break;
+                    }
+                    const endPositionDistanceCheck = stackBaseObject instanceof Slider
+                        ? stackBaseObject.endPosition.getDistance(objectN.position) < BeatmapProcessor.stackDistance
+                        : false;
+                    if (stackBaseObject.position.getDistance(objectN.position) <
+                        BeatmapProcessor.stackDistance ||
+                        endPositionDistanceCheck) {
+                        stackBaseIndex = n;
+                        // Hit objects after the specified update range haven't been reset yet
+                        objectN.stackHeight = 0;
+                    }
+                }
+                if (stackBaseIndex > extendedEndIndex) {
+                    extendedEndIndex = stackBaseIndex;
+                    if (extendedEndIndex === objects.length - 1) {
+                        break;
+                    }
+                }
+            }
+        }
+        // Reverse pass for stack calculation.
+        let extendedStartIndex = startIndex;
+        for (let i = extendedEndIndex; i > startIndex; --i) {
+            let n = i;
+            // We should check every note which has not yet got a stack.
+            // Consider the case we have two inter-wound stacks and this will make sense.
+            //
+            // o <-1      o <-2
+            //  o <-3      o <-4
+            //
+            // We first process starting from 4 and handle 2,
+            // then we come backwards on the i loop iteration until we reach 3 and handle 1.
+            // 2 and 1 will be ignored in the i loop because they already have a stack value.
+            let objectI = objects[i];
+            if (objectI.stackHeight !== 0 || objectI instanceof Spinner) {
+                continue;
+            }
+            const stackThreshold = objectI.timePreempt * this.beatmap.general.stackLeniency;
+            // If this object is a hit circle, then we enter this "special" case.
+            // It either ends with a stack of hit circles only, or a stack of hit circles that are underneath a slider.
+            // Any other case is handled by the "instanceof Slider" code below this.
+            if (objectI instanceof Circle) {
+                while (--n >= 0) {
+                    const objectN = objects[n];
+                    if (objectN instanceof Spinner) {
+                        continue;
+                    }
+                    if (objectI.startTime - objectN.endTime > stackThreshold) {
+                        // We are no longer within stacking range of the previous object.
+                        break;
+                    }
+                    // Hit objects before the specified update range haven't been reset yet
+                    if (n < extendedStartIndex) {
+                        objectN.stackHeight = 0;
+                        extendedStartIndex = n;
+                    }
+                    // This is a special case where hit circles are moved DOWN and RIGHT (negative stacking) if they are under the *last* slider in a stacked pattern.
+                    // o==o <- slider is at original location
+                    //     o <- hitCircle has stack of -1
+                    //      o <- hitCircle has stack of -2
+                    if (objectN instanceof Slider &&
+                        objectN.endPosition.getDistance(objectI.position) <
+                            BeatmapProcessor.stackDistance) {
+                        const offset = objectI.stackHeight - objectN.stackHeight + 1;
+                        for (let j = n + 1; j <= i; ++j) {
+                            // For each object which was declared under this slider, we will offset it to appear *below* the slider end (rather than above).
+                            const objectJ = objects[j];
+                            if (objectN.endPosition.getDistance(objectJ.position) < BeatmapProcessor.stackDistance) {
+                                objectJ.stackHeight -= offset;
+                            }
+                        }
+                        // We have hit a slider. We should restart calculation using this as the new base.
+                        // Breaking here will mean that the slider still has a stack count of 0, so will be handled in the i-outer-loop.
+                        break;
+                    }
+                    if (objectN.position.getDistance(objectI.position) <
+                        BeatmapProcessor.stackDistance) {
+                        // Keep processing as if there are no sliders. If we come across a slider, this gets cancelled out.
+                        // NOTE: Sliders with start positions stacking are a special case that is also handled here.
+                        objectN.stackHeight = objectI.stackHeight + 1;
+                        objectI = objectN;
+                    }
+                }
+            }
+            else if (objectI instanceof Slider) {
+                // We have hit the first slider in a possible stack.
+                // From this point on, we ALWAYS stack positive regardless.
+                while (--n >= startIndex) {
+                    const objectN = objects[n];
+                    if (objectN instanceof Spinner) {
+                        continue;
+                    }
+                    if (objectI.startTime - objectN.startTime >
+                        stackThreshold) {
+                        // We are no longer within stacking range of the previous object.
+                        break;
+                    }
+                    if (objectN.endPosition.getDistance(objectI.position) <
+                        BeatmapProcessor.stackDistance) {
+                        objectN.stackHeight = objectI.stackHeight + 1;
+                        objectI = objectN;
+                    }
+                }
+            }
         }
-        if ((options === null || options === void 0 ? void 0 : options.checkIncompatible) !== false) {
-            mods = this.checkIncompatibleMods(mods);
+    }
+    applyStandardOldStacking() {
+        const objects = this.beatmap.hitObjects.objects;
+        for (let i = 0; i < objects.length; ++i) {
+            const currentObject = objects[i];
+            if (currentObject.stackHeight !== 0 &&
+                !(currentObject instanceof Slider)) {
+                continue;
+            }
+            let startTime = currentObject.endTime;
+            let sliderStack = 0;
+            const stackThreshold = currentObject.timePreempt * this.beatmap.general.stackLeniency;
+            for (let j = i + 1; j < objects.length; ++j) {
+                if (objects[j].startTime - stackThreshold > startTime) {
+                    break;
+                }
+                // Note the use of `startTime` in the code below doesn't match osu!stable's use of `endTime`.
+                // This is because in osu!stable's implementation, `UpdateCalculations` is not called on the inner-loop hitobject (j)
+                // and therefore it does not have a correct `endTime`, but instead the default of `endTime = startTime`.
+                //
+                // Effects of this can be seen on https://osu.ppy.sh/beatmapsets/243#osu/1146 at sliders around 86647 ms, where
+                // if we use `endTime` here it would result in unexpected stacking.
+                //
+                // Reference: https://github.com/ppy/osu/pull/24188
+                if (objects[j].position.getDistance(currentObject.position) <
+                    BeatmapProcessor.stackDistance) {
+                    ++currentObject.stackHeight;
+                    startTime = objects[j].startTime;
+                }
+                else if (objects[j].position.getDistance(currentObject.endPosition) <
+                    BeatmapProcessor.stackDistance) {
+                    // Case for sliders - bump notes down and right, rather than up and left.
+                    ++sliderStack;
+                    objects[j].stackHeight -= sliderStack;
+                    startTime = objects[j].startTime;
+                }
+            }
         }
-        return mods;
     }
 }
-/**
- * All `Mod`s that exists, mapped by their acronym.
- */
-ModUtil.allMods = (() => {
-    const mods = [
-        // Janky order to keep the order on what players are used to
-        ModAuto,
-        ModRelax,
-        ModAutopilot,
-        ModEasy,
-        ModNoFail,
-        ModHidden,
-        ModTraceable,
-        ModDoubleTime,
-        ModNightCore,
-        ModHalfTime,
-        ModCustomSpeed,
-        ModHardRock,
-        ModDifficultyAdjust,
-        ModFlashlight,
-        ModSuddenDeath,
-        ModPerfect,
-        ModPrecise,
-        ModReallyEasy,
-        ModScoreV2,
-        ModSmallCircle,
-        ModSpunOut,
-        ModTouchDevice,
-    ];
-    const map = new Map();
-    for (const mod of mods) {
-        map.set(new mod().acronym, mod);
-    }
-    return map;
-})();
+BeatmapProcessor.stackDistance = 3;
 
 /**
  * Represents a beatmap that is in a playable state for a specific game mode.
@@ -4137,8 +4184,8 @@ class PlayableBeatmap {
         this.colors = baseBeatmap.colors;
         this.hitObjects = baseBeatmap.hitObjects;
         this.maxCombo = baseBeatmap.maxCombo;
-        this.mods = mods.slice();
-        this.speedMultiplier = ModUtil.calculateRateWithMods(this.mods);
+        this.mods = mods;
+        this.speedMultiplier = ModUtil.calculateRateWithMods(this.mods.values());
     }
 }
 
@@ -4147,7 +4194,7 @@ class PlayableBeatmap {
  */
 class DroidPlayableBeatmap extends PlayableBeatmap {
     createHitWindow() {
-        if (this.mods.some((m) => m instanceof ModPrecise)) {
+        if (this.mods.has(ModPrecise)) {
             return new PreciseDroidHitWindow(this.difficulty.od);
         }
         else {
@@ -5008,7 +5055,7 @@ class Beatmap {
      * @param mods The `Mod`s to apply to the `Beatmap`. Defaults to No Mod.
      * @return The constructed `DroidPlayableBeatmap`.
      */
-    createDroidPlayableBeatmap(mods = []) {
+    createDroidPlayableBeatmap(mods = new ModMap()) {
         return new DroidPlayableBeatmap(this.createPlayableBeatmap(mods, exports.Modes.droid), mods);
     }
     /**
@@ -5020,11 +5067,11 @@ class Beatmap {
      * @param mods The `Mod`s to apply to the `Beatmap`. Defaults to No Mod.
      * @return The constructed `OsuPlayableBeatmap`.
      */
-    createOsuPlayableBeatmap(mods = []) {
+    createOsuPlayableBeatmap(mods = new ModMap()) {
         return new OsuPlayableBeatmap(this.createPlayableBeatmap(mods, exports.Modes.osu), mods);
     }
     createPlayableBeatmap(mods, mode) {
-        if (this.mode === mode && mods.length === 0) {
+        if (this.mode === mode && mods.size === 0) {
             // Beatmap is already in a playable state.
             return this;
         }
@@ -8186,14 +8233,14 @@ class DroidLegacyModConverter {
      * @returns An array of `Mod`s.
      */
     static convert(str, difficulty) {
+        const map = new ModMap();
         if (!str) {
-            return [];
+            return map;
         }
         const data = str.split("|");
         if (!data[0]) {
-            return [];
+            return map;
         }
-        const mods = [];
         for (const c of data[0]) {
             const modType = this.droidLegacyStorableMods.get(c);
             if (!modType) {
@@ -8201,24 +8248,24 @@ class DroidLegacyModConverter {
             }
             const mod = new modType();
             if (mod.isMigratableDroidMod() && difficulty) {
-                mods.push(mod.migrateDroidMod(difficulty));
+                map.set(mod.migrateDroidMod(difficulty));
             }
             else {
-                mods.push(mod);
+                map.set(mod);
             }
         }
         if (data.length > 1) {
-            this.parseExtraModString(mods, data.slice(1));
+            this.parseExtraModString(map, data.slice(1));
         }
-        return mods;
+        return map;
     }
     /**
      * Parses the extra strings of a mod string.
      *
-     * @param mods The current `Mod`s.
+     * @param map The current `Mod`s.
      * @param extraStrings The extra strings to parse.
      */
-    static parseExtraModString(mods, extraStrings) {
+    static parseExtraModString(map, extraStrings) {
         let customCS;
         let customAR;
         let customOD;
@@ -8240,20 +8287,20 @@ class DroidLegacyModConverter {
                     break;
                 // FL follow delay
                 case s.startsWith("FLD"): {
-                    let flashlight = mods.find((m) => m instanceof ModFlashlight);
+                    let flashlight = map.get(ModFlashlight);
                     if (!flashlight) {
                         flashlight = new ModFlashlight();
-                        mods.push(flashlight);
+                        map.set(flashlight);
                     }
                     flashlight.followDelay = parseFloat(s.slice(3));
                     break;
                 }
                 // Speed multiplier
                 case s.startsWith("x"): {
-                    let customSpeed = mods.find((m) => m instanceof ModCustomSpeed);
+                    let customSpeed = map.get(ModCustomSpeed);
                     if (!customSpeed) {
                         customSpeed = new ModCustomSpeed();
-                        mods.push(customSpeed);
+                        map.set(customSpeed);
                     }
                     customSpeed.trackRateMultiplier = parseFloat(s.slice(1));
                     break;
@@ -8264,7 +8311,7 @@ class DroidLegacyModConverter {
             customAR !== undefined ||
             customOD !== undefined ||
             customHP !== undefined) {
-            mods.push(new ModDifficultyAdjust({
+            map.set(new ModDifficultyAdjust({
                 cs: customCS,
                 ar: customAR,
                 od: customOD,
@@ -9817,6 +9864,7 @@ exports.ModFlashlight = ModFlashlight;
 exports.ModHalfTime = ModHalfTime;
 exports.ModHardRock = ModHardRock;
 exports.ModHidden = ModHidden;
+exports.ModMap = ModMap;
 exports.ModNightCore = ModNightCore;
 exports.ModNoFail = ModNoFail;
 exports.ModOldNightCore = ModOldNightCore;