@rian8337/osu-base 4.0.0-beta.66 → 4.0.0-beta.68

package/dist/index.js

@@ -1,7 +1,5 @@
 'use strict';
 
-var node_path = require('node:path');
-
 /**
  * Some math utility functions.
  */
@@ -788,68 +786,114 @@ class BeatmapDifficulty {
  */
 class CircleSizeCalculator {
     /**
-     * Converts osu!droid CS to osu!droid scale.
+     * Converts osu!droid circle size to osu!droid scale.
+     *
+     * @param cs The circle size to convert.
+     * @returns The calculated osu!droid scale.
+     */
+    static droidCSToDroidScale(cs) {
+        // 6.8556344386 was derived by converting the old osu!droid gameplay scale unit into osu!pixels (by dividing it
+        // with (height / 480)) and then fitting the function to the osu!standard scale function. The height in the old
+        // osu!droid gameplay scale function was set to 576, which was chosen after sampling the top 100 most used
+        // devices by players from Firebase. This is done to ensure that the new scale is as close to the old scale as
+        // possible for most players.
+        // The fitting of both functions can be found under the following graph: https://www.desmos.com/calculator/rjfxqc3yic
+        return Math.max(1e-3, this.standardCSToStandardScale(cs - 6.8556344386, true));
+    }
+    /**
+     * Converts osu!droid scale to osu!droid circle size.
+     *
+     * @param scale The osu!droid scale to convert.
+     * @returns The calculated osu!droid circle size.
+     */
+    static droidScaleToDroidCS(scale) {
+        return (this.standardScaleToStandardCS(Math.max(1e-3, scale), true) +
+            6.8556344386);
+    }
+    /**
+     * Converts osu!droid CS to old osu!droid scale.
      *
      * @param cs The CS to convert.
      * @param mods The mods to apply.
      * @returns The calculated osu!droid scale.
      */
-    static droidCSToDroidScale(cs, mods) {
+    static droidCSToOldDroidScale(cs, mods) {
         // Create a dummy beatmap difficulty for circle size calculation.
         const difficulty = new BeatmapDifficulty();
         difficulty.cs = cs;
         if (mods !== undefined) {
+            const adjustmentMods = new ModMap();
+            for (const mod of mods.values()) {
+                if (mod.facilitatesAdjustment()) {
+                    adjustmentMods.set(mod);
+                }
+            }
             for (const mod of mods.values()) {
                 if (mod.isApplicableToDifficulty()) {
-                    mod.applyToDifficulty(exports.Modes.droid, difficulty);
+                    mod.applyToDifficulty(exports.Modes.droid, difficulty, adjustmentMods);
                 }
             }
             for (const mod of mods.values()) {
-                if (mod.isApplicableToDifficultyWithSettings()) {
-                    mod.applyToDifficultyWithSettings(exports.Modes.droid, difficulty, mods);
+                if (mod.isApplicableToDifficultyWithMods()) {
+                    mod.applyToDifficultyWithMods(exports.Modes.droid, difficulty, mods);
                 }
             }
         }
-        return Math.max(((this.assumedDroidHeight / 480) *
-            (54.42 - difficulty.cs * 4.48) *
-            2) /
-            128 +
-            (0.5 * (11 - 5.2450170716245195)) / 5, 1e-3);
+        return Math.max(((this.oldAssumedDroidHeight / 480) *
+            (54.42 - difficulty.cs * 4.48)) /
+            HitObject.baseRadius +
+            this.oldDroidScaleMultiplier, 1e-3);
     }
     /**
-     * Converts osu!droid scale to osu!droid circle size.
+     * Converts old osu!droid scale to osu!droid circle size.
      *
      * @param scale The osu!droid scale to convert.
      * @returns The calculated osu!droid circle size.
      */
-    static droidScaleToDroidCS(scale) {
+    static oldDroidScaleToDroidCS(scale) {
         return ((54.42 -
-            ((((Math.max(1e-3, scale) -
-                (0.5 * (11 - 5.2450170716245195)) / 5) *
-                128) /
-                2) *
+            ((Math.max(1e-3, scale) - this.oldDroidScaleMultiplier) *
+                HitObject.baseRadius *
                 480) /
-                this.assumedDroidHeight) /
+                this.oldAssumedDroidHeight) /
             4.48);
     }
     /**
-     * Converts osu!droid scale to osu!standard radius.
+     * Converts old osu!droid difficulty scale that is in **screen pixels** to **osu!pixels**.
+     *
+     * @param scale The osu!droid scale to convert.
+     * @returns The converted scale.
+     */
+    static oldDroidScaleScreenPixelsToOsuPixels(scale) {
+        return (scale * 480) / this.oldAssumedDroidHeight;
+    }
+    /**
+     * Converts old osu!droid scale that is in **osu!pixels** to **screen pixels**.
+     *
+     * @param scale The osu!droid scale to convert.
+     * @returns The converted scale.
+     */
+    static oldDroidScaleOsuPixelsToScreenPixels(scale) {
+        return (scale * this.oldAssumedDroidHeight) / 480;
+    }
+    /**
+     * Converts old osu!droid scale to osu!standard radius.
      *
      * @param scale The osu!droid scale to convert.
      * @returns The osu!standard radius of the given osu!droid scale.
      */
-    static droidScaleToStandardRadius(scale) {
+    static oldDroidScaleToStandardRadius(scale) {
         return ((HitObject.baseRadius * Math.max(1e-3, scale)) /
-            ((this.assumedDroidHeight * 0.85) / 384));
+            ((this.oldAssumedDroidHeight * 0.85) / 384));
     }
     /**
-     * Converts osu!standard radius to osu!droid scale.
+     * Converts osu!standard radius to old osu!droid scale.
      *
      * @param radius The osu!standard radius to convert.
      * @returns The osu!droid scale of the given osu!standard radius.
      */
-    static standardRadiusToDroidScale(radius) {
-        return Math.max(1e-3, (radius * ((this.assumedDroidHeight * 0.85) / 384)) /
+    static standardRadiusToOldDroidScale(radius) {
+        return Math.max(1e-3, (radius * ((this.oldAssumedDroidHeight * 0.85) / 384)) /
             HitObject.baseRadius);
     }
     /**
@@ -892,26 +936,16 @@ class CircleSizeCalculator {
         return this.standardScaleToStandardCS(radius / HitObject.baseRadius, applyFudge);
     }
     /**
-     * Converts osu!standard scale to osu!droid scale.
+     * Converts osu!standard scale to old osu!droid scale.
      *
      * @param scale The osu!standard scale to convert.
      * @param applyFudge Whether to apply a fudge that was historically applied to osu!standard. Defaults to `false`.
-     * @returns The osu!droid scale of the given osu!standard scale.
+     * @returns The old osu!droid scale of the given osu!standard scale.
      */
-    static standardScaleToDroidScale(scale, applyFudge = false) {
-        return this.standardRadiusToDroidScale((HitObject.baseRadius * scale) /
+    static standardScaleToOldDroidScale(scale, applyFudge = false) {
+        return this.standardRadiusToOldDroidScale((HitObject.baseRadius * scale) /
             (applyFudge ? this.brokenGamefieldRoundingAllowance : 1));
     }
-    /**
-     * Converts osu!standard circle size to osu!droid scale.
-     *
-     * @param cs The osu!standard circle size to convert.
-     * @param applyFudge Whether to apply a fudge that was historically applied to osu!standard. Defaults to `false`.
-     * @returns The osu!droid scale of the given osu!droid scale.
-     */
-    static standardCSToDroidScale(cs, applyFudge = false) {
-        return this.standardScaleToDroidScale(this.standardCSToStandardScale(cs, applyFudge));
-    }
 }
 /**
  * The following comment is copied verbatim from osu!lazer and osu!stable:
@@ -925,10 +959,11 @@ class CircleSizeCalculator {
  */
 CircleSizeCalculator.brokenGamefieldRoundingAllowance = 1.00041;
 /**
- * NOTE: This is not the real height that is used in the game, but rather an
- * assumption so that we can treat circle sizes similarly across all devices.
+ * This was not the real height that is used in the game, but rather an assumption so that we can treat circle sizes
+ * similarly across all devices. This is used in difficulty calculation.
  */
-CircleSizeCalculator.assumedDroidHeight = 681;
+CircleSizeCalculator.oldAssumedDroidHeight = 681;
+CircleSizeCalculator.oldDroidScaleMultiplier = (0.5 * (11 - 5.2450170716245195)) / 5;
 
 /**
  * Represents a hitobject in a beatmap.
@@ -1090,13 +1125,9 @@ class HitObject {
         this.timeFadeIn =
             400 * Math.min(1, this.timePreempt / HitObject.preemptMin);
         switch (mode) {
-            case exports.Modes.droid: {
-                const droidScale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
-                const radius = CircleSizeCalculator.droidScaleToStandardRadius(droidScale);
-                const cs = CircleSizeCalculator.standardRadiusToStandardCS(radius, true);
-                this.scale = CircleSizeCalculator.standardCSToStandardScale(cs, true);
+            case exports.Modes.droid:
+                this.scale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
                 break;
-            }
             case exports.Modes.osu:
                 this.scale = CircleSizeCalculator.standardCSToStandardScale(difficulty.cs, true);
                 break;
@@ -1142,14 +1173,7 @@ class HitObject {
      * @returns The stack offset with respect to the gamemode.
      */
     getStackOffset(mode) {
-        switch (mode) {
-            case exports.Modes.droid:
-                return new Vector2(this.stackHeight *
-                    CircleSizeCalculator.standardScaleToDroidScale(this.scale, true) *
-                    4);
-            case exports.Modes.osu:
-                return new Vector2(this.stackHeight * this.scale * -6.4);
-        }
+        return new Vector2(this.stackHeight * this.scale * (mode === exports.Modes.droid ? -4 : -6.4));
     }
     /**
      * Evaluates the stacked position of the hitobject.
@@ -1239,16 +1263,101 @@ HitObject.preemptMin = 450;
  */
 HitObject.controlPointLeniency = 1;
 
+/**
+ * Represents a `Mod` specific setting.
+ */
+class ModSetting {
+    /**
+     * The value of this `ModSetting`.
+     */
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        if (this._value !== value) {
+            const oldValue = this._value;
+            this._value = value;
+            for (const listener of this.valueChangedListeners) {
+                listener(oldValue, value);
+            }
+        }
+    }
+    /**
+     * Whether this `ModSetting` is set to its default value.
+     */
+    get isDefault() {
+        return this._value === this.defaultValue;
+    }
+    constructor(name, description, defaultValue) {
+        /**
+         * The formatter to display the value of this `ModSetting`.
+         */
+        this.displayFormatter = (v) => `${v}`;
+        this.valueChangedListeners = new Set();
+        this.name = name;
+        this.description = description;
+        this.defaultValue = defaultValue;
+        this._value = defaultValue;
+    }
+    /**
+     * Returns a string representation of this `ModSetting`'s value.
+     *
+     * @returns A string representation of this `ModSetting`'s value.
+     */
+    toDisplayString() {
+        return this.displayFormatter(this.value);
+    }
+    /**
+     * Binds an action that will be called when the value of this `ModSetting` changes.
+     *
+     * @param listener The action to call when the value of this `ModSetting` changes.
+     * @param runOnceImmediately Whether to call the action immediately with the current value of this `ModSetting`.
+     */
+    bindValueChanged(listener, runOnceImmediately = false) {
+        this.valueChangedListeners.add(listener);
+        if (runOnceImmediately) {
+            listener(this.value, this.value);
+        }
+    }
+    /**
+     * Unbinds an action that was previously bound to this `ModSetting`.
+     *
+     * @param listener The action to unbind.
+     */
+    unbindValueChanged(listener) {
+        this.valueChangedListeners.delete(listener);
+    }
+}
+
 /**
  * Represents a mod.
  */
 class Mod {
     constructor() {
+        /**
+         * Whether this `Mod` is playable by a real human user.
+         *
+         * Should be `false` for cases where the user is not meant to apply the `Mod` by themselves.
+         */
+        this.userPlayable = true;
         /**
          * `Mod`s that are incompatible with this `Mod`.
          */
         this.incompatibleMods = new Set();
     }
+    /**
+     * `ModSetting`s that are specific to this `Mod`.
+     */
+    get settings() {
+        const settings = [];
+        for (const prop in this) {
+            const value = this[prop];
+            if (value instanceof ModSetting) {
+                settings.push(value);
+            }
+        }
+        return settings;
+    }
     /**
      * Serializes this `Mod` to a `SerializedMod`.
      */
@@ -1307,8 +1416,8 @@ class Mod {
     /**
      * Whether this `Mod` can be applied to a `BeatmapDifficulty` relative to other `Mod`s and settings.
      */
-    isApplicableToDifficultyWithSettings() {
-        return "applyToDifficultyWithSettings" in this;
+    isApplicableToDifficultyWithMods() {
+        return "applyToDifficultyWithMods" in this;
     }
     /**
      * Whether this `Mod` can be applied to a `HitObject`.
@@ -1319,8 +1428,8 @@ class Mod {
     /**
      * Whether this `Mod` can be applied to a `HitObject` relative to other `Mod`s and settings.
      */
-    isApplicableToHitObjectWithSettings() {
-        return "applyToHitObjectWithSettings" in this;
+    isApplicableToHitObjectWithMods() {
+        return "applyToHitObjectWithMods" in this;
     }
     /**
      * Whether this `Mod` can be applied to a track's playback rate.
@@ -1334,6 +1443,12 @@ class Mod {
     isMigratableDroidMod() {
         return "migrateDroidMod" in this;
     }
+    /**
+     * Whether this `Mod` facilitates adjustment to a `HitObject` or `BeatmapDifficulty`.
+     */
+    facilitatesAdjustment() {
+        return "facilitateAdjustment" in this;
+    }
     /**
      * Serializes the settings of this `Mod` to an object that can be converted to a JSON.
      *
@@ -1342,6 +1457,15 @@ class Mod {
     serializeSettings() {
         return null;
     }
+    /**
+     * Compares this `Mod` to another `Mod` for equality.
+     *
+     * @param other The object to compare to.
+     * @returns `true` if the object is the same `Mod`, `false` otherwise.
+     */
+    equals(other) {
+        return this === other || this.acronym === other.acronym;
+    }
     /**
      * Returns the string representation of this `Mod`.
      */
@@ -1431,6 +1555,72 @@ class ModAuto extends Mod {
     }
 }
 
+/**
+ * Represents a `Mod` specific setting that is constrained to a range of values.
+ */
+class RangeConstrainedModSetting extends ModSetting {
+    get value() {
+        return super.value;
+    }
+    set value(value) {
+        super.value = this.processValue(value);
+    }
+    constructor(name, description, defaultValue, min, max, step) {
+        super(name, description, defaultValue);
+        this.min = min;
+        this.max = max;
+        this.step = step;
+    }
+}
+
+/**
+ * Represents a `Mod` specific setting that is constrained to a number of values.
+ */
+class NumberModSetting extends RangeConstrainedModSetting {
+    constructor(name, description, defaultValue, min, max, step) {
+        super(name, description, defaultValue, min, max, step);
+        this.displayFormatter = (v) => v.toString();
+        if (min > max) {
+            throw new RangeError(`The minimum value (${min}) must be less than or equal to the maximum value (${max}).`);
+        }
+        if (step < 0) {
+            throw new RangeError(`The step size (${step}) must be greater than or equal to 0.`);
+        }
+        if (defaultValue < min || defaultValue > max) {
+            throw new RangeError(`The default value (${defaultValue}) must be between the minimum (${min}) and maximum (${max}) values.`);
+        }
+    }
+    processValue(value) {
+        return MathUtils.clamp(Math.round(value / this.step) * this.step, this.min, this.max);
+    }
+}
+
+/**
+ * Represents a `Mod` specific setting that is constrained to a range of decimal values.
+ */
+class DecimalModSetting extends NumberModSetting {
+    constructor(name, description, defaultValue, min = -Number.MAX_VALUE, max = Number.MAX_VALUE, step = 0, precision = null) {
+        super(name, description, defaultValue, min, max, step);
+        this.displayFormatter = (v) => {
+            if (this.precision !== null) {
+                return v.toFixed(this.precision);
+            }
+            return super.toDisplayString();
+        };
+        if (precision !== null && precision < 0) {
+            throw new RangeError(`The precision (${precision}) must be greater than or equal to 0.`);
+        }
+        this.precision = precision;
+    }
+    processValue(value) {
+        const processedValue = super.processValue(value);
+        if (this.precision !== null) {
+            return parseFloat(processedValue.toFixed(this.precision));
+        }
+        return processedValue;
+    }
+}
+
 /**
  * Represents a `Mod` that adjusts the playback rate of a track.
  */
@@ -1439,18 +1629,27 @@ 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);
+        return this.trackRateMultiplier.value >= 1
+            ? 1 + (this.trackRateMultiplier.value - 1) * 0.24
+            : Math.pow(0.3, (1 - this.trackRateMultiplier.value) * 4);
     }
     /**
      * Generic getter to determine if this `ModRateAdjust` is relevant.
      */
     get isRelevant() {
-        return this.trackRateMultiplier !== 1;
+        return this.trackRateMultiplier.value !== 1;
     }
-    applyToRate(time, rate) {
-        return rate * this.trackRateMultiplier;
+    constructor(trackRateMultiplier = 1) {
+        super();
+        this.trackRateMultiplier = new DecimalModSetting("Track rate multiplier", "The multiplier for the track's playback rate after applying this mod.", trackRateMultiplier, 0.5, 2, 0.05, 2);
+    }
+    applyToRate(_, rate) {
+        return rate * this.trackRateMultiplier.value;
+    }
+    equals(other) {
+        return (super.equals(other) &&
+            other instanceof ModRateAdjust &&
+            this.trackRateMultiplier.value === other.trackRateMultiplier.value);
     }
 }
 
@@ -1460,19 +1659,18 @@ class ModRateAdjust extends 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();
+    constructor() {
+        super(...arguments);
         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;
+        this.trackRateMultiplier.value =
+            (_b = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.rateMultiplier) !== null && _b !== void 0 ? _b : this.trackRateMultiplier.value;
     }
     get isDroidRelevant() {
         return this.isRelevant;
@@ -1485,16 +1683,18 @@ class ModCustomSpeed extends ModRateAdjust {
     }
     get osuScoreMultiplier() {
         // Round to the nearest multiple of 0.1.
-        let value = Math.trunc(this.trackRateMultiplier * 10) / 10;
+        let value = Math.trunc(this.trackRateMultiplier.value * 10) / 10;
         // Offset back to 0.
         --value;
-        return this.trackRateMultiplier >= 1 ? 1 + value / 5 : 0.6 + value;
+        return this.trackRateMultiplier.value >= 1
+            ? 1 + value / 5
+            : 0.6 + value;
     }
     serializeSettings() {
-        return { rateMultiplier: this.trackRateMultiplier };
+        return { rateMultiplier: this.trackRateMultiplier.value };
     }
     toString() {
-        return `${super.toString()} (${this.trackRateMultiplier.toFixed(2)}x)`;
+        return `${super.toString()} (${this.trackRateMultiplier.toDisplayString()}x)`;
     }
 }
 
@@ -2021,6 +2221,11 @@ class Slider extends HitObject {
         this.endPositionCache.invalidate();
         this.head.position = this.position;
         this.tail.position = this.endPosition;
+        for (let i = 1; i < this.nestedHitObjects.length - 1; ++i) {
+            const nestedObject = this.nestedHitObjects[i];
+            const progress = (nestedObject.startTime - this.startTime) / this.duration;
+            nestedObject.position = this.position.add(this.curvePositionAt(progress));
+        }
     }
     createSlidingSamples(controlPoints) {
         this.auxiliarySamples.length = 0;
@@ -2103,34 +2308,89 @@ Slider.baseWhistleSlideSample = new BankHitSampleInfo("sliderwhistle");
 Slider.baseTickSample = new BankHitSampleInfo("slidertick");
 Slider.legacyLastTickOffset = 36;
 
+/**
+ * Represents a `Mod` specific setting that is constrained to a number of values.
+ *
+ * The value can be `null`, which is treated as a special case.
+ */
+class NullableDecimalModSetting extends RangeConstrainedModSetting {
+    constructor(name, description, defaultValue, min = -Number.MAX_VALUE, max = Number.MAX_VALUE, step = 0, precision = null) {
+        super(name, description, defaultValue, min, max, step);
+        this.displayFormatter = (v) => {
+            if (v === null) {
+                return "None";
+            }
+            if (this.precision !== null) {
+                return v.toFixed(this.precision);
+            }
+            return super.toDisplayString();
+        };
+        if (min > max) {
+            throw new RangeError(`The minimum value (${min}) must be less than or equal to the maximum value (${max}).`);
+        }
+        if (step < 0) {
+            throw new RangeError(`The step size (${step}) must be greater than or equal to 0.`);
+        }
+        if (defaultValue !== null &&
+            (defaultValue < min || defaultValue > max)) {
+            throw new RangeError(`The default value (${defaultValue}) must be between the minimum (${min}) and maximum (${max}) values.`);
+        }
+        this.precision = precision;
+    }
+    processValue(value) {
+        if (value === null) {
+            return null;
+        }
+        const processedValue = MathUtils.clamp(Math.round(value / this.step) * this.step, this.min, this.max);
+        if (this.precision !== null) {
+            return parseFloat(processedValue.toFixed(this.precision));
+        }
+        return processedValue;
+    }
+}
+
 /**
  * Represents the Difficulty Adjust mod.
  */
 class ModDifficultyAdjust extends Mod {
     get isRelevant() {
-        return (this.cs !== undefined ||
-            this.ar !== undefined ||
-            this.od !== undefined ||
-            this.hp !== undefined);
+        return (this.cs.value !== null ||
+            this.ar.value !== null ||
+            this.od.value !== null ||
+            this.hp.value !== null);
     }
     constructor(values) {
+        var _a, _b, _c, _d;
         super();
         this.acronym = "DA";
         this.name = "Difficulty Adjust";
         this.droidRanked = false;
         this.osuRanked = false;
-        this.cs = values === null || values === void 0 ? void 0 : values.cs;
-        this.ar = values === null || values === void 0 ? void 0 : values.ar;
-        this.od = values === null || values === void 0 ? void 0 : values.od;
-        this.hp = values === null || values === void 0 ? void 0 : values.hp;
+        /**
+         * The circle size to enforce.
+         */
+        this.cs = new NullableDecimalModSetting("Circle size", "The circle size to enforce.", null, 0, 15, 0.1, 1);
+        /**
+         * The approach rate to enforce.
+         */
+        this.ar = new NullableDecimalModSetting("Approach rate", "The approach rate to enforce.", null, 0, 11, 0.1, 1);
+        /**
+         * The overall difficulty to enforce.
+         */
+        this.od = new NullableDecimalModSetting("Overall difficulty", "The overall difficulty to enforce.", null, 0, 11, 0.1, 1);
+        this.hp = new NullableDecimalModSetting("Health drain", "The health drain to enforce.", null, 0, 11, 0.1, 1);
+        this.cs.value = (_a = values === null || values === void 0 ? void 0 : values.cs) !== null && _a !== void 0 ? _a : null;
+        this.ar.value = (_b = values === null || values === void 0 ? void 0 : values.ar) !== null && _b !== void 0 ? _b : null;
+        this.od.value = (_c = values === null || values === void 0 ? void 0 : values.od) !== null && _c !== void 0 ? _c : null;
+        this.hp.value = (_d = values === null || values === void 0 ? void 0 : values.hp) !== null && _d !== void 0 ? _d : null;
     }
     copySettings(mod) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         super.copySettings(mod);
-        this.cs = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.cs;
-        this.ar = (_b = mod.settings) === null || _b === void 0 ? void 0 : _b.ar;
-        this.od = (_c = mod.settings) === null || _c === void 0 ? void 0 : _c.od;
-        this.hp = (_d = mod.settings) === null || _d === void 0 ? void 0 : _d.hp;
+        this.cs.value = ((_b = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.cs) !== null && _b !== void 0 ? _b : null);
+        this.ar.value = ((_d = (_c = mod.settings) === null || _c === void 0 ? void 0 : _c.ar) !== null && _d !== void 0 ? _d : null);
+        this.od.value = ((_f = (_e = mod.settings) === null || _e === void 0 ? void 0 : _e.od) !== null && _f !== void 0 ? _f : null);
+        this.hp.value = ((_h = (_g = mod.settings) === null || _g === void 0 ? void 0 : _g.hp) !== null && _h !== void 0 ? _h : null);
     }
     get isDroidRelevant() {
         return this.isRelevant;
@@ -2138,15 +2398,15 @@ class ModDifficultyAdjust extends Mod {
     calculateDroidScoreMultiplier(difficulty) {
         // Graph: https://www.desmos.com/calculator/yrggkhrkzz
         let multiplier = 1;
-        if (this.cs !== undefined) {
-            const diff = this.cs - difficulty.cs;
+        if (this.cs.value !== null) {
+            const diff = this.cs.value - difficulty.cs;
             multiplier *=
                 diff >= 0
                     ? 1 + 0.0075 * Math.pow(diff, 1.5)
                     : 2 / (1 + Math.exp(-0.5 * diff));
         }
-        if (this.od !== undefined) {
-            const diff = this.od - difficulty.od;
+        if (this.od.value !== null) {
+            const diff = this.od.value - difficulty.od;
             multiplier *=
                 diff >= 0
                     ? 1 + 0.005 * Math.pow(diff, 1.3)
@@ -2160,24 +2420,24 @@ class ModDifficultyAdjust extends Mod {
     get osuScoreMultiplier() {
         return 0.5;
     }
-    applyToDifficultyWithSettings(_, difficulty, mods) {
+    applyToDifficultyWithMods(_, 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;
-        difficulty.od = (_c = this.od) !== null && _c !== void 0 ? _c : difficulty.od;
-        difficulty.hp = (_d = this.hp) !== null && _d !== void 0 ? _d : difficulty.hp;
+        difficulty.cs = (_a = this.cs.value) !== null && _a !== void 0 ? _a : difficulty.cs;
+        difficulty.ar = (_b = this.ar.value) !== null && _b !== void 0 ? _b : difficulty.ar;
+        difficulty.od = (_c = this.od.value) !== null && _c !== void 0 ? _c : difficulty.od;
+        difficulty.hp = (_d = this.hp.value) !== null && _d !== void 0 ? _d : difficulty.hp;
         // Special case for force AR, where the AR value is kept constant with respect to game time.
         // This makes the player perceive the AR as is under all speed multipliers.
-        if (this.ar !== undefined) {
-            const preempt = BeatmapDifficulty.difficultyRange(this.ar, HitObject.preemptMax, HitObject.preemptMid, HitObject.preemptMin);
+        if (this.ar.value !== null) {
+            const preempt = BeatmapDifficulty.difficultyRange(this.ar.value, HitObject.preemptMax, HitObject.preemptMid, HitObject.preemptMin);
             const trackRate = this.calculateTrackRate(mods.values());
             difficulty.ar = BeatmapDifficulty.inverseDifficultyRange(preempt * trackRate, HitObject.preemptMax, HitObject.preemptMid, HitObject.preemptMin);
         }
     }
-    applyToHitObjectWithSettings(_, hitObject, mods) {
+    applyToHitObjectWithMods(_, 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) {
+        if (this.ar.value === null) {
             return;
         }
         this.applyFadeAdjustment(hitObject, mods);
@@ -2188,24 +2448,21 @@ class ModDifficultyAdjust extends Mod {
         }
     }
     serializeSettings() {
-        if (this.cs === undefined &&
-            this.ar === undefined &&
-            this.od === undefined &&
-            this.hp === undefined) {
+        if (!this.isRelevant) {
             return null;
         }
         const settings = {};
-        if (this.cs !== undefined) {
-            settings.cs = this.cs;
+        if (this.cs.value !== null) {
+            settings.cs = this.cs.value;
         }
-        if (this.ar !== undefined) {
-            settings.ar = this.ar;
+        if (this.ar.value !== null) {
+            settings.ar = this.ar.value;
         }
-        if (this.od !== undefined) {
-            settings.od = this.od;
+        if (this.od.value !== null) {
+            settings.od = this.od.value;
         }
-        if (this.hp !== undefined) {
-            settings.hp = this.hp;
+        if (this.hp.value !== null) {
+            settings.hp = this.hp.value;
         }
         return settings;
     }
@@ -2228,22 +2485,30 @@ class ModDifficultyAdjust extends Mod {
         }
         return rate;
     }
+    equals(other) {
+        return (super.equals(other) &&
+            other instanceof ModDifficultyAdjust &&
+            this.cs.value === other.cs.value &&
+            this.ar.value === other.ar.value &&
+            this.od.value === other.od.value &&
+            this.hp.value === other.hp.value);
+    }
     toString() {
         if (!this.isRelevant) {
             return super.toString();
         }
         const settings = [];
-        if (this.cs !== undefined) {
-            settings.push(`CS${this.cs.toFixed(1)}`);
+        if (this.cs.value !== null) {
+            settings.push(`CS${this.cs.toDisplayString()}`);
         }
-        if (this.ar !== undefined) {
-            settings.push(`AR${this.ar.toFixed(1)}`);
+        if (this.ar.value !== null) {
+            settings.push(`AR${this.ar.toDisplayString()}`);
         }
-        if (this.od !== undefined) {
-            settings.push(`OD${this.od.toFixed(1)}`);
+        if (this.od.value !== null) {
+            settings.push(`OD${this.od.toDisplayString()}`);
         }
-        if (this.hp !== undefined) {
-            settings.push(`HP${this.hp.toFixed(1)}`);
+        if (this.hp.value !== null) {
+            settings.push(`HP${this.hp.toDisplayString()}`);
         }
         return `${super.toString()} (${settings.join(", ")})`;
     }
@@ -2254,10 +2519,9 @@ class ModDifficultyAdjust extends Mod {
  */
 class ModNightCore extends ModRateAdjust {
     constructor() {
-        super();
+        super(1.5);
         this.acronym = "NC";
         this.name = "NightCore";
-        this.trackRateMultiplier = 1.5;
         this.droidRanked = true;
         this.osuRanked = true;
         this.bitwise = 1 << 9;
@@ -2282,10 +2546,9 @@ class ModNightCore extends ModRateAdjust {
  */
 class ModHalfTime extends ModRateAdjust {
     constructor() {
-        super();
+        super(0.75);
         this.acronym = "HT";
         this.name = "HalfTime";
-        this.trackRateMultiplier = 0.75;
         this.droidRanked = true;
         this.osuRanked = true;
         this.bitwise = 1 << 8;
@@ -2310,10 +2573,9 @@ class ModHalfTime extends ModRateAdjust {
  */
 class ModDoubleTime extends ModRateAdjust {
     constructor() {
-        super();
+        super(1.5);
         this.acronym = "DT";
         this.name = "DoubleTime";
-        this.trackRateMultiplier = 1.5;
         this.droidRanked = true;
         this.osuRanked = true;
         this.bitwise = 1 << 6;
@@ -2333,67 +2595,235 @@ class ModDoubleTime extends ModRateAdjust {
     }
 }
 
+/**
+ * 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 Circle extends HitObject {
+    constructor(values) {
+        super(values);
+    }
+    toString() {
+        return `Position: [${this._position.x}, ${this._position.y}]`;
+    }
+}
+
+var _a$1;
 /**
  * Represents the osu! playfield.
  */
 class Playfield {
 }
+_a$1 = Playfield;
 /**
  * The size of the playfield, which is 512x384.
  */
 Playfield.baseSize = new Vector2(512, 384);
+/**
+ * The center of the playfield, which is at (256, 192).
+ */
+Playfield.center = _a$1.baseSize.scale(0.5);
 
 /**
- * Types of slider paths.
+ * Represents a spinner in a beatmap.
+ *
+ * All we need from spinners is their duration. The
+ * position of a spinner is always at 256x192.
  */
-exports.PathType = void 0;
-(function (PathType) {
-    PathType["Catmull"] = "C";
-    PathType["Bezier"] = "B";
-    PathType["Linear"] = "L";
-    PathType["PerfectCurve"] = "P";
-})(exports.PathType || (exports.PathType = {}));
+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");
 
 /**
- * Precision utilities.
+ * Represents a four-dimensional vector.
  */
-class Precision {
+class Vector4 {
+    constructor(xOrValueOrXZ, yOrYW, z, w) {
+        if (yOrYW === undefined) {
+            this.x = xOrValueOrXZ;
+            this.y = xOrValueOrXZ;
+            this.z = xOrValueOrXZ;
+            this.w = xOrValueOrXZ;
+            return;
+        }
+        if (typeof z === "undefined") {
+            this.x = xOrValueOrXZ;
+            this.y = yOrYW;
+            this.z = xOrValueOrXZ;
+            this.w = yOrYW;
+            return;
+        }
+        this.x = xOrValueOrXZ;
+        this.y = yOrYW;
+        this.z = z;
+        this.w = w;
+    }
     /**
-     * Checks if two numbers are equal with a given tolerance.
-     *
-     * @param value1 The first number.
-     * @param value2 The second number.
-     * @param acceptableDifference The acceptable difference as threshold. Default is `Precision.FLOAT_EPSILON = 1e-3`.
+     * The X coordinate of the left edge of this vector.
      */
-    static almostEqualsNumber(value1, value2, acceptableDifference = this.FLOAT_EPSILON) {
-        return Math.abs(value1 - value2) <= acceptableDifference;
+    get left() {
+        return this.x;
     }
     /**
-     * Checks if two vectors are equal with a given tolerance.
-     *
-     * @param vec1 The first vector.
-     * @param vec2 The second vector.
-     * @param acceptableDifference The acceptable difference as threshold. Default is `Precision.FLOAT_EPSILON = 1e-3`.
+     * The Y coordinate of the top edge of this vector.
      */
-    static almostEqualsVector(vec1, vec2, acceptableDifference = this.FLOAT_EPSILON) {
-        return (this.almostEqualsNumber(vec1.x, vec2.x, acceptableDifference) &&
-            this.almostEqualsNumber(vec1.y, vec2.y, acceptableDifference));
+    get top() {
+        return this.y;
     }
     /**
-     * Checks whether two real numbers are almost equal.
-     *
-     * @param a The first number.
-     * @param b The second number.
-     * @param maximumError The accuracy required for being almost equal. Defaults to `10 * 2^(-53)`.
-     * @returns Whether the two values differ by no more than 10 * 2^(-52).
+     * The X coordinate of the right edge of this vector.
      */
-    static almostEqualRelative(a, b, maximumError = 10 * Math.pow(2, -53)) {
-        return this.almostEqualNormRelative(a, b, a - b, maximumError);
+    get right() {
+        return this.z;
     }
     /**
-     * Compares two numbers and determines if they are equal within the specified maximum error.
-     *
-     * @param a The norm of the first value (can be negative).
+     * The Y coordinate of the bottom edge of this vector.
+     */
+    get bottom() {
+        return this.w;
+    }
+    /**
+     * The top left corner of this vector.
+     */
+    get topLeft() {
+        return new Vector2(this.left, this.top);
+    }
+    /**
+     * The top right corner of this vector.
+     */
+    get topRight() {
+        return new Vector2(this.right, this.top);
+    }
+    /**
+     * The bottom left corner of this vector.
+     */
+    get bottomLeft() {
+        return new Vector2(this.left, this.bottom);
+    }
+    /**
+     * The bottom right corner of this vector.
+     */
+    get bottomRight() {
+        return new Vector2(this.right, this.bottom);
+    }
+    /**
+     * The width of the rectangle defined by this vector.
+     */
+    get width() {
+        return this.right - this.left;
+    }
+    /**
+     * The height of the rectangle defined by this vector.
+     */
+    get height() {
+        return this.bottom - this.top;
+    }
+}
+
+/**
+ * Contains infromation about the position of a {@link HitObject}.
+ */
+class HitObjectPositionInfo {
+    constructor(hitObject) {
+        /**
+         * The jump angle from the previous {@link HitObject} to this one, relative to the previous
+         * {@link HitObject}'s jump angle.
+         *
+         * The `relativeAngle` of the first {@link HitObject} in a beatmap represents the absolute angle from the
+         * center of the playfield to the {@link HitObject}.
+         *
+         * If `relativeAngle` is 0, the player's cursor does not need to change its direction of movement when
+         * passing from the previous {@link HitObject} to this one.
+         */
+        this.relativeAngle = 0;
+        /**
+         * The jump distance from the previous {@link HitObject} to this one.
+         *
+         * The `distanceFromPrevious` of the first {@link HitObject} in a beatmap is relative to the center of
+         * the playfield.
+         */
+        this.distanceFromPrevious = 0;
+        /**
+         * The rotation of this {@link HitObject} relative to its jump angle.
+         *
+         * For `Slider`s, this is defined as the angle from the `Slider`'s start position to the end of its path
+         * relative to its jump angle. For `HitCircle`s and `Spinner`s, this property is ignored.
+         */
+        this.rotation = 0;
+        this.hitObject = hitObject;
+    }
+}
+
+/**
+ * Precision utilities.
+ */
+class Precision {
+    /**
+     * Checks if two numbers are equal with a given tolerance.
+     *
+     * @param value1 The first number.
+     * @param value2 The second number.
+     * @param acceptableDifference The acceptable difference as threshold. Default is `Precision.FLOAT_EPSILON = 1e-3`.
+     */
+    static almostEqualsNumber(value1, value2, acceptableDifference = this.FLOAT_EPSILON) {
+        return Math.abs(value1 - value2) <= acceptableDifference;
+    }
+    /**
+     * Checks if two vectors are equal with a given tolerance.
+     *
+     * @param vec1 The first vector.
+     * @param vec2 The second vector.
+     * @param acceptableDifference The acceptable difference as threshold. Default is `Precision.FLOAT_EPSILON = 1e-3`.
+     */
+    static almostEqualsVector(vec1, vec2, acceptableDifference = this.FLOAT_EPSILON) {
+        return (this.almostEqualsNumber(vec1.x, vec2.x, acceptableDifference) &&
+            this.almostEqualsNumber(vec1.y, vec2.y, acceptableDifference));
+    }
+    /**
+     * Checks whether two real numbers are almost equal.
+     *
+     * @param a The first number.
+     * @param b The second number.
+     * @param maximumError The accuracy required for being almost equal. Defaults to `10 * 2^(-53)`.
+     * @returns Whether the two values differ by no more than 10 * 2^(-52).
+     */
+    static almostEqualRelative(a, b, maximumError = 10 * Math.pow(2, -53)) {
+        return this.almostEqualNormRelative(a, b, a - b, maximumError);
+    }
+    /**
+     * Compares two numbers and determines if they are equal within the specified maximum error.
+     *
+     * @param a The norm of the first value (can be negative).
      * @param b The norm of the second value (can be negative).
      * @param diff The norm of the difference of the two values (can be negative).
      * @param maximumError The accuracy required for being almost equal.
@@ -2425,6 +2855,17 @@ class Precision {
 }
 Precision.FLOAT_EPSILON = 1e-3;
 
+/**
+ * Types of slider paths.
+ */
+exports.PathType = void 0;
+(function (PathType) {
+    PathType["Catmull"] = "C";
+    PathType["Bezier"] = "B";
+    PathType["Linear"] = "L";
+    PathType["PerfectCurve"] = "P";
+})(exports.PathType || (exports.PathType = {}));
+
 /**
  * Path approximator for sliders.
  */
@@ -2822,6 +3263,31 @@ class SliderPath {
         const d = this.progressToDistance(progress);
         return this.interpolateVerticles(this.indexOfDistance(d), d);
     }
+    /**
+     * Computes the slider path until a given progress that ranges from 0 (beginning of the slider) to
+     * 1 (end of the slider).
+     *
+     * @param p0 Start progress. Ranges from 0 (beginning of the slider) to 1 (end of the slider).
+     * @param p1 End progress. Ranges from 0 (beginning of the slider) to 1 (end of the slider).
+     * @return The computed path between the two ranges.
+     */
+    pathToProgress(p0, p1) {
+        const path = [];
+        const d0 = this.progressToDistance(p0);
+        const d1 = this.progressToDistance(p1);
+        let i = 0;
+        while (i < this.calculatedPath.length &&
+            this.cumulativeLength[i] < d0) {
+            ++i;
+        }
+        path.push(this.interpolateVerticles(i, d0));
+        while (i < this.calculatedPath.length &&
+            this.cumulativeLength[i] <= d1) {
+            path.push(this.calculatedPath[i++]);
+        }
+        path.push(this.interpolateVerticles(i, d1));
+        return path;
+    }
     /**
      * Returns the progress of reaching expected distance.
      */
@@ -2885,31 +3351,94 @@ class SliderPath {
     }
 }
 
+var _a;
 /**
  * Utilities for {@link HitObject} generation.
  */
 class HitObjectGenerationUtils {
+    //#region Rotation
+    /**
+     * Rotates a {@link HitObject} away from the edge of the playfield while keeping a constant distance from
+     * the previous {@link HitObject}.
+     *
+     * @param previousObjectPosition The position of the previous {@link HitObject}.
+     * @param positionRelativeToPrevious The position of the {@link HitObject} to be rotated relative to the
+     * previous {@link HitObject}.
+     * @param rotationRatio The extent of the rotation. 0 means the {@link HitObject} is never rotated, while 1
+     * means the {@link HitObject} will be fully rotated towards the center of the playfield when it is originally
+     * at the edge of the playfield.
+     * @return The new position of the {@link HitObject} relative to the previous {@link HitObject}.
+     */
+    static rotateAwayFromEdge(previousObjectPosition, positionRelativeToPrevious, rotationRatio = 0.5) {
+        const relativeRotationDistance = Math.max((previousObjectPosition.x < Playfield.center.x
+            ? this.borderDistance.x - previousObjectPosition.x
+            : previousObjectPosition.x -
+                (Playfield.baseSize.x - this.borderDistance.x)) /
+            this.borderDistance.x, (previousObjectPosition.y < Playfield.center.y
+            ? this.borderDistance.y - previousObjectPosition.y
+            : previousObjectPosition.y -
+                (Playfield.baseSize.y - this.borderDistance.y)) /
+            this.borderDistance.y, 0);
+        return this.rotateVectorTowardsVector(positionRelativeToPrevious, Playfield.center.subtract(previousObjectPosition), Math.min(1, relativeRotationDistance * rotationRatio));
+    }
+    /**
+     * Rotates a {@link Vector2} towards another {@link Vector2}.
+     *
+     * @param initial The {@link Vector2} to be rotated.
+     * @param destination The {@link Vector2} that `initial` should be rotated towards.
+     * @param rotationRatio How much `initial` should be rotated. 0 means no rotation. 1 mean `initial` is fully
+     * rotated to equal `destination`.
+     * @return The rotated {@link Vector2}.
+     */
+    static rotateVectorTowardsVector(initial, destination, rotationRatio) {
+        const initialAngle = Math.atan2(initial.y, initial.x);
+        const destinationAngle = Math.atan2(destination.y, destination.x);
+        let diff = destinationAngle - initialAngle;
+        // Normalize angle
+        while (diff < -Math.PI) {
+            diff += 2 * Math.PI;
+        }
+        while (diff > Math.PI) {
+            diff -= 2 * Math.PI;
+        }
+        const finalAngle = initialAngle + diff * rotationRatio;
+        return new Vector2(initial.x * Math.cos(finalAngle), initial.y * Math.sin(finalAngle));
+    }
+    /**
+     * Obtains the absolute rotation of a {@link Slider}, defined as the angle from its start position to the
+     * end of its path.
+     *
+     * @param slider The {@link Slider} to obtain the rotation from.
+     * @return The angle in radians.
+     */
+    static getSliderRotation(slider) {
+        const pathEndPosition = slider.path.positionAt(1);
+        return Math.atan2(pathEndPosition.y, pathEndPosition.x);
+    }
+    /**
+     * Rotates a {@link Vector2} by the specified angle.
+     *
+     * @param vec The {@link Vector2} to be rotated.
+     * @param rotation The angle to rotate `vec` by, in radians.
+     * @return The rotated {@link Vector2}.
+     */
+    static rotateVector(vec, rotation) {
+        const angle = Math.atan2(vec.y, vec.x) + rotation;
+        const { length } = vec;
+        return new Vector2(length * Math.cos(angle), length * Math.sin(angle));
+    }
+    //#endregion
+    //#region Reflection
     /**
      * Reflects the position of a {@link HitObject} horizontally along the playfield.
      *
      * @param hitObject The {@link HitObject} to reflect.
      */
     static reflectHorizontallyAlongPlayfield(hitObject) {
-        // Reflect the position of the hit object.
         hitObject.position = this.reflectVectorHorizontallyAlongPlayfield(hitObject.position);
-        if (!(hitObject instanceof Slider)) {
-            return;
+        if (hitObject instanceof Slider) {
+            this.modifySlider(hitObject, (v) => new Vector2(-v.x, v.y));
         }
-        // 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) => new Vector2(-v.x, v.y)),
-            expectedDistance: hitObject.path.expectedDistance,
-        });
-        // Reflect the position of slider ticks and repeats.
-        hitObject.nestedHitObjects.slice(1, -1).forEach((obj) => {
-            obj.position = this.reflectVectorHorizontallyAlongPlayfield(obj.position);
-        });
     }
     /**
      * Reflects the position of a {@link HitObject} vertically along the playfield.
@@ -2919,18 +3448,32 @@ class HitObjectGenerationUtils {
     static reflectVerticallyAlongPlayfield(hitObject) {
         // Reflect the position of the hit object.
         hitObject.position = this.reflectVectorVerticallyAlongPlayfield(hitObject.position);
-        if (!(hitObject instanceof Slider)) {
-            return;
+        if (hitObject instanceof Slider) {
+            this.modifySlider(hitObject, (v) => new Vector2(v.x, -v.y));
         }
-        // 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) => new Vector2(v.x, -v.y)),
-            expectedDistance: hitObject.path.expectedDistance,
-        });
-        // Reflect the position of slider ticks and repeats.
-        hitObject.nestedHitObjects.slice(1, -1).forEach((obj) => {
-            obj.position = this.reflectVectorVerticallyAlongPlayfield(obj.position);
+    }
+    /**
+     * Flips the position of a {@link Slider} around its start position horizontally.
+     *
+     * @param slider The {@link Slider} to be flipped.
+     */
+    static flipSliderInPlaceHorizontally(slider) {
+        this.modifySlider(slider, (v) => new Vector2(-v.x, v.y));
+    }
+    /**
+     * Rotates a {@link Slider} around its start position by the specified angle.
+     *
+     * @param slider The {@link Slider} to rotate.
+     * @param rotation The angle to rotate `slider` by, in radians.
+     */
+    static rotateSlider(slider, rotation) {
+        this.modifySlider(slider, (v) => this.rotateVector(v, rotation));
+    }
+    static modifySlider(slider, modifyControlPoint) {
+        slider.path = new SliderPath({
+            pathType: slider.path.pathType,
+            controlPoints: slider.path.controlPoints.map(modifyControlPoint),
+            expectedDistance: slider.path.expectedDistance,
         });
     }
     static reflectVectorHorizontallyAlongPlayfield(vector) {
@@ -2939,6 +3482,329 @@ class HitObjectGenerationUtils {
     static reflectVectorVerticallyAlongPlayfield(vector) {
         return new Vector2(vector.x, Playfield.baseSize.y - vector.y);
     }
+    //#endregion
+    //#region Reposition
+    /**
+     * Generates a list of {@link HitObjectPositionInfo}s containing information for how the given list of
+     * {@link HitObject}s are positioned.
+     *
+     * @param hitObjects A list of {@link HitObject}s to process.
+     * @return A list of {@link HitObjectPositionInfo}s describing how each {@link HitObject} is positioned
+     * relative to the previous one.
+     */
+    static generatePositionInfos(hitObjects) {
+        const positionInfos = [];
+        let previousPosition = Playfield.center;
+        let previousAngle = 0;
+        for (const hitObject of hitObjects) {
+            const relativePosition = hitObject.position.subtract(previousPosition);
+            let absoluteAngle = Math.atan2(relativePosition.y, relativePosition.x);
+            const relativeAngle = absoluteAngle - previousAngle;
+            const positionInfo = new HitObjectPositionInfo(hitObject);
+            positionInfo.relativeAngle = relativeAngle;
+            positionInfo.distanceFromPrevious = relativePosition.length;
+            if (hitObject instanceof Slider) {
+                const absoluteRotation = this.getSliderRotation(hitObject);
+                positionInfo.rotation = absoluteRotation - absoluteAngle;
+                absoluteAngle = absoluteRotation;
+            }
+            previousPosition = hitObject.endPosition;
+            previousAngle = absoluteAngle;
+            positionInfos.push(positionInfo);
+        }
+        return positionInfos;
+    }
+    static repositionHitObjects(positionInfos) {
+        const workingObjects = positionInfos.map((p) => new WorkingObject(p));
+        let previous = null;
+        for (let i = 0; i < workingObjects.length; ++i) {
+            const current = workingObjects[i];
+            const { hitObject } = current;
+            if (hitObject instanceof Spinner) {
+                previous = current;
+                continue;
+            }
+            this.computeModifiedPosition(current, previous, i > 1 ? workingObjects[i - 2] : null);
+            // Move hit objects back into the playfield if they are outside of it.
+            let shift;
+            if (hitObject instanceof Circle) {
+                shift = this.clampHitCircleToPlayfield(current);
+            }
+            else if (hitObject instanceof Slider) {
+                shift = this.clampSliderToPlayfield(current);
+            }
+            else {
+                shift = new Vector2(0);
+            }
+            if (shift.x !== 0 || shift.y !== 0) {
+                const toBeShifted = [];
+                for (let j = i - 1; j >= Math.max(0, i - this.precedingObjectsToShift); --j) {
+                    // Only shift hit circles.
+                    if (!(workingObjects[j].hitObject instanceof Circle)) {
+                        break;
+                    }
+                    toBeShifted.push(workingObjects[j].hitObject);
+                }
+                this.applyDecreasingShift(toBeShifted, shift);
+            }
+            previous = current;
+        }
+        return workingObjects.map((w) => w.hitObject);
+    }
+    /**
+     * Determines whether a {@link HitObject} is on a beat.
+     *
+     * @param beatmap The {@link Beatmap} the {@link HitObject} is a part of.
+     * @param hitObject The {@link HitObject} to check.
+     * @param downbeatsOnly If `true`, whether this method only returns `true` is on a downbeat.
+     * @return `true` if the {@link HitObject} is on a (down-)beat, `false` otherwise.
+     */
+    static isHitObjectOnBeat(beatmap, hitObject, downbeatsOnly = false) {
+        const timingPoint = beatmap.controlPoints.timing.controlPointAt(hitObject.startTime);
+        const timeSinceTimingPoint = hitObject.startTime - timingPoint.time;
+        let beatLength = timingPoint.msPerBeat;
+        if (downbeatsOnly) {
+            beatLength *= timingPoint.timeSignature;
+        }
+        // Ensure within 1ms of expected location.
+        return Math.abs(timeSinceTimingPoint + 1) % beatLength < 2;
+    }
+    /**
+     * Generates a random number from a Normal distribution using the Box-Muller transform.
+     *
+     * @param random A {@link Random} to get the random number from.
+     * @param mean The mean of the distribution.
+     * @param stdDev The standard deviation of the distribution.
+     * @return The random number.
+     */
+    static randomGaussian(random, mean = 0, stdDev = 1) {
+        // Generate 2 random numbers in the interval (0,1].
+        // x1 must not be 0 since log(0) = undefined.
+        const x1 = 1 - random.nextDouble();
+        const x2 = 1 - random.nextDouble();
+        const stdNormal = Math.sqrt(-2 * Math.log(x1)) * Math.sin(2 * Math.PI * x2);
+        return mean + stdDev * stdNormal;
+    }
+    /**
+     * Calculates a {@link Vector4} which contains all possible movements of a {@link Slider} (in relative
+     * X/Y coordinates) such that the entire {@link Slider} is inside the playfield.
+     *
+     * If the {@link Slider} is larger than the playfield, the returned {@link Vector4} may have a Z/W component
+     * that is smaller than its X/Y component.
+     *
+     * @param slider The {@link Slider} whose movement bound is to be calculated.
+     * @return A {@link Vector4} which contains all possible movements of a {@link Slider} (in relative X/Y
+     * coordinates) such that the entire {@link Slider} is inside the playfield.
+     */
+    static calculatePossibleMovementBounds(slider) {
+        const pathPositions = slider.path.pathToProgress(0, 1);
+        let minX = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY;
+        let minY = Number.POSITIVE_INFINITY;
+        let maxY = Number.NEGATIVE_INFINITY;
+        // Compute the bounding box of the slider.
+        for (const position of pathPositions) {
+            minX = Math.min(minX, position.x);
+            maxX = Math.max(maxX, position.x);
+            minY = Math.min(minY, position.y);
+            maxY = Math.max(maxY, position.y);
+        }
+        // Take the radius into account.
+        const { radius } = slider;
+        minX -= radius;
+        minY -= radius;
+        maxX += radius;
+        maxY += radius;
+        // Given the bounding box of the slider (via min/max X/Y), the amount that the slider can move to the left is
+        // minX (with the sign flipped, since positive X is to the right), and the amount that it can move to the right
+        // is WIDTH - maxX. The same calculation applies for the Y axis.
+        const left = -minX;
+        const right = Playfield.baseSize.x - maxX;
+        const top = -minY;
+        const bottom = Playfield.baseSize.y - maxY;
+        return new Vector4(left, top, right, bottom);
+    }
+    /**
+     * Computes the modified position of a {@link HitObject} while attempting to keep it inside the playfield.
+     *
+     * @param current The {@link WorkingObject} representing the {@link HitObject} to have the modified
+     * position computed for.
+     * @param previous The {@link WorkingObject} representing the {@link HitObject} immediately preceding
+     * `current`.
+     * @param beforePrevious The {@link WorkingObject} representing the {@link HitObject} immediately preceding
+     * `previous`.
+     */
+    static computeModifiedPosition(current, previous, beforePrevious) {
+        var _b, _c;
+        let previousAbsoluteAngle = 0;
+        if (previous !== null) {
+            if (previous.hitObject instanceof Slider) {
+                previousAbsoluteAngle = this.getSliderRotation(previous.hitObject);
+            }
+            else {
+                const earliestPosition = (_b = beforePrevious === null || beforePrevious === void 0 ? void 0 : beforePrevious.hitObject.endPosition) !== null && _b !== void 0 ? _b : Playfield.center;
+                const relativePosition = previous.hitObject.position.subtract(earliestPosition);
+                previousAbsoluteAngle = Math.atan2(relativePosition.y, relativePosition.x);
+            }
+        }
+        let absoluteAngle = previousAbsoluteAngle + current.positionInfo.relativeAngle;
+        let positionRelativeToPrevious = new Vector2(current.positionInfo.distanceFromPrevious * Math.cos(absoluteAngle), current.positionInfo.distanceFromPrevious * Math.sin(absoluteAngle));
+        const lastEndPosition = (_c = previous === null || previous === void 0 ? void 0 : previous.endPositionModified) !== null && _c !== void 0 ? _c : Playfield.center;
+        positionRelativeToPrevious = this.rotateAwayFromEdge(lastEndPosition, positionRelativeToPrevious);
+        current.positionModified = lastEndPosition.add(positionRelativeToPrevious);
+        if (!(current.hitObject instanceof Slider)) {
+            return;
+        }
+        absoluteAngle = Math.atan2(positionRelativeToPrevious.y, positionRelativeToPrevious.x);
+        const centerOfMassOriginal = this.calculateCenterOfMass(current.hitObject);
+        const centerOfMassModified = this.rotateAwayFromEdge(current.positionModified, this.rotateVector(centerOfMassOriginal, current.positionInfo.rotation +
+            absoluteAngle -
+            this.getSliderRotation(current.hitObject)));
+        const relativeRotation = Math.atan2(centerOfMassModified.y, centerOfMassModified.x) -
+            Math.atan2(centerOfMassOriginal.y, centerOfMassOriginal.x);
+        if (!Precision.almostEqualsNumber(relativeRotation, 0)) {
+            this.rotateSlider(current.hitObject, relativeRotation);
+        }
+    }
+    /**
+     * Moves the modified position of a {@link Circle} so that it fits inside the playfield.
+     *
+     * @param workingObject The {@link WorkingObject} that represents the {@link Circle}.
+     * @return The deviation from the original modified position in order to fit within the playfield.
+     */
+    static clampHitCircleToPlayfield(workingObject) {
+        const previousPosition = workingObject.positionModified;
+        workingObject.positionModified = this.clampToPlayfield(workingObject.positionModified, workingObject.hitObject.radius);
+        workingObject.endPositionModified = workingObject.positionModified;
+        workingObject.hitObject.position = workingObject.positionModified;
+        return workingObject.positionModified.subtract(previousPosition);
+    }
+    /**
+     * Moves a {@link Slider} and all necessary `SliderHitObject`s into the playfield if they are not in
+     * the playfield.
+     *
+     * @param workingObject The {@link WorkingObject} that represents the {@link Slider}.
+     * @return The deviation from the original modified position in order to fit within the playfield.
+     */
+    static clampSliderToPlayfield(workingObject) {
+        const slider = workingObject.hitObject;
+        let possibleMovementBounds = this.calculatePossibleMovementBounds(slider);
+        // The slider rotation applied in computeModifiedPosition might make it impossible to fit the slider
+        // into the playfield. For example, a long horizontal slider will be off-screen when rotated by 90
+        // degrees. In this case, limit the rotation to either 0 or 180 degrees.
+        if (possibleMovementBounds.width < 0 ||
+            possibleMovementBounds.height < 0) {
+            const currentRotation = this.getSliderRotation(slider);
+            const diff1 = this.getAngleDifference(workingObject.rotationOriginal, currentRotation);
+            const diff2 = this.getAngleDifference(workingObject.rotationOriginal + Math.PI, currentRotation);
+            if (diff1 < diff2) {
+                this.rotateSlider(slider, workingObject.rotationOriginal - currentRotation);
+            }
+            else {
+                this.rotateSlider(slider, workingObject.rotationOriginal + Math.PI - currentRotation);
+            }
+            possibleMovementBounds =
+                this.calculatePossibleMovementBounds(slider);
+        }
+        const previousPosition = workingObject.positionModified;
+        // Clamp slider position to the placement area.
+        // If the slider is larger than the playfield, at least make sure that the head circle is
+        // inside the playfield.
+        const newX = possibleMovementBounds.width < 0
+            ? MathUtils.clamp(possibleMovementBounds.left, 0, Playfield.baseSize.x)
+            : MathUtils.clamp(previousPosition.x, possibleMovementBounds.left, possibleMovementBounds.right);
+        const newY = possibleMovementBounds.height < 0
+            ? MathUtils.clamp(possibleMovementBounds.top, 0, Playfield.baseSize.y)
+            : MathUtils.clamp(previousPosition.y, possibleMovementBounds.top, possibleMovementBounds.bottom);
+        workingObject.positionModified = new Vector2(newX, newY);
+        slider.position = workingObject.positionModified;
+        workingObject.endPositionModified = slider.endPosition;
+        return workingObject.positionModified.subtract(previousPosition);
+    }
+    /**
+     * Clamps a {@link Vector2} into the playfield, keeping a specified distance from the edge of the playfield.
+     *
+     * @param vec The {@link Vector2} to clamp.
+     * @param padding The minimum distance allowed from the edge of the playfield.
+     * @return The clamped {@link Vector2}.
+     */
+    static clampToPlayfield(vec, padding) {
+        return new Vector2(MathUtils.clamp(vec.x, padding, Playfield.baseSize.x - padding), MathUtils.clamp(vec.y, padding, Playfield.baseSize.y - padding));
+    }
+    /**
+     * Decreasingly shifts a list of {@link HitObject}s by a specified amount.
+     *
+     * The first item in the list is shifted by the largest amount, while the last item is shifted by the
+     * smallest amount.
+     *
+     * @param hitObjects The list of {@link HitObject}s to be shifted.
+     * @param shift The amount to shift the {@link HitObject}s by.
+     */
+    static applyDecreasingShift(hitObjects, shift) {
+        for (let i = 0; i < hitObjects.length; ++i) {
+            const hitObject = hitObjects[i];
+            // The first object is shifted by a vector slightly smaller than shift.
+            // The last object is shifted by a vector slightly larger than zero.
+            const position = hitObject.position.add(shift.scale((hitObjects.length - i) / (hitObjects.length + 1)));
+            hitObject.position = this.clampToPlayfield(position, hitObject.radius);
+        }
+    }
+    /**
+     * Estimates the center of mass of a {@link Slider} relative to its start position.
+     *
+     * @param slider The {@link Slider} whose center mass is to be estimated.
+     * @return The estimated center of mass of `slider`.
+     */
+    static calculateCenterOfMass(slider) {
+        const sampleStep = 50;
+        // Only sample the start and end positions if the slider is too short.
+        if (slider.distance <= sampleStep) {
+            return slider.path.positionAt(1).divide(2);
+        }
+        let count = 0;
+        let sum = new Vector2(0);
+        for (let i = 0; i < slider.distance; i += sampleStep) {
+            sum = sum.add(slider.path.positionAt(i / slider.distance));
+            ++count;
+        }
+        return sum.divide(count);
+    }
+    /**
+     * Calculates the absolute difference between two angles in radians.
+     *
+     * @param angle1 The first angle.
+     * @param angle2 The second angle.
+     * @return THe absolute difference within interval `[0, Math.PI]`.
+     */
+    static getAngleDifference(angle1, angle2) {
+        const diff = Math.abs(angle1 - angle2) % (2 * Math.PI);
+        return Math.min(diff, 2 * Math.PI - diff);
+    }
+}
+_a = HitObjectGenerationUtils;
+/**
+ * The relative distance to the edge of the playfield before {@link HitObject} positions should start
+ * to "turn around" and curve towards the middle. The closer the {@link HitObject}s draw to the border,
+ * the sharper the turn.
+ */
+HitObjectGenerationUtils.playfieldEdgeRatio = 0.375;
+/**
+ * The amount of previous {@link HitObject}s to be shifted together when a {@link HitObject} is being moved.
+ */
+HitObjectGenerationUtils.precedingObjectsToShift = 10;
+HitObjectGenerationUtils.borderDistance = Playfield.baseSize.scale(_a.playfieldEdgeRatio);
+class WorkingObject {
+    get hitObject() {
+        return this.positionInfo.hitObject;
+    }
+    constructor(positionInfo) {
+        this.rotationOriginal = this.hitObject instanceof Slider
+            ? HitObjectGenerationUtils.getSliderRotation(this.hitObject)
+            : 0;
+        this.positionModified = this.hitObject.position;
+        this.endPositionModified = this.hitObject.endPosition;
+        this.positionInfo = positionInfo;
+    }
 }
 
 /**
@@ -2954,7 +3820,7 @@ class ModMirror extends Mod {
         /**
          * The axes to reflect the `HitObject`s along.
          */
-        this.flippedAxes = exports.Axes.x;
+        this.flippedAxes = new ModSetting("Flipped axes", "The axes to reflect the hit objects along.", exports.Axes.x);
         this.incompatibleMods.add(ModHardRock);
     }
     get isDroidRelevant() {
@@ -2974,18 +3840,18 @@ class ModMirror extends Mod {
         super.copySettings(mod);
         switch ((_a = mod.settings) === null || _a === void 0 ? void 0 : _a.flippedAxes) {
             case 0:
-                this.flippedAxes = exports.Axes.x;
+                this.flippedAxes.value = exports.Axes.x;
                 break;
             case 1:
-                this.flippedAxes = exports.Axes.y;
+                this.flippedAxes.value = exports.Axes.y;
                 break;
             case 2:
-                this.flippedAxes = exports.Axes.both;
+                this.flippedAxes.value = exports.Axes.both;
                 break;
         }
     }
     applyToHitObject(_, hitObject) {
-        switch (this.flippedAxes) {
+        switch (this.flippedAxes.value) {
             case exports.Axes.x:
                 HitObjectGenerationUtils.reflectHorizontallyAlongPlayfield(hitObject);
                 break;
@@ -2999,20 +3865,83 @@ class ModMirror extends Mod {
         }
     }
     serializeSettings() {
-        return { flippedAxes: this.flippedAxes - 1 };
+        return { flippedAxes: this.flippedAxes.value - 1 };
+    }
+    equals(other) {
+        return (super.equals(other) &&
+            other instanceof ModMirror &&
+            other.flippedAxes.value === this.flippedAxes.value);
     }
     toString() {
         const settings = [];
-        if (this.flippedAxes === exports.Axes.x || this.flippedAxes === exports.Axes.both) {
+        if (this.flippedAxes.value === exports.Axes.x ||
+            this.flippedAxes.value === exports.Axes.both) {
             settings.push("↔");
         }
-        if (this.flippedAxes === exports.Axes.y || this.flippedAxes === exports.Axes.both) {
+        if (this.flippedAxes.value === exports.Axes.y ||
+            this.flippedAxes.value === exports.Axes.both) {
             settings.push("↕");
         }
         return `${super.toString()} (${settings.join(", ")})`;
     }
 }
 
+/**
+ * Represents the Replay V6 mod.
+ *
+ * Some behavior of beatmap parsing was changed in replay version 7. More specifically, object stacking
+ * behavior now matches osu!stable and osu!lazer.
+ *
+ * This `Mod` is meant to reapply the stacking behavior prior to replay version 7 to a `Beatmap` that
+ * was played in replays recorded in version 6 and older for replayability and difficulty calculation.
+ */
+class ModReplayV6 extends Mod {
+    constructor() {
+        super(...arguments);
+        this.name = "Replay V6";
+        this.acronym = "RV6";
+        this.userPlayable = false;
+        this.droidRanked = false;
+        this.facilitateAdjustment = true;
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1;
+    }
+    applyToBeatmap(beatmap) {
+        const { objects } = beatmap.hitObjects;
+        if (objects.length === 0) {
+            return;
+        }
+        // Reset stacking
+        objects.forEach((h) => {
+            h.stackHeight = 0;
+        });
+        for (let i = 0; i < objects.length - 1; ++i) {
+            const current = objects[i];
+            const next = objects[i + 1];
+            this.revertObjectScale(current, beatmap.difficulty);
+            this.revertObjectScale(next, beatmap.difficulty);
+            const convertedScale = CircleSizeCalculator.standardScaleToOldDroidScale(objects[0].scale);
+            if (current instanceof Circle &&
+                next.startTime - current.startTime <
+                    2000 * beatmap.general.stackLeniency &&
+                next.position.getDistance(current.position) <
+                    Math.sqrt(convertedScale)) {
+                next.stackHeight = current.stackHeight + 1;
+            }
+        }
+    }
+    revertObjectScale(hitObject, difficulty) {
+        const droidScale = CircleSizeCalculator.droidCSToOldDroidScale(difficulty.cs);
+        const radius = CircleSizeCalculator.oldDroidScaleToStandardRadius(droidScale);
+        const standardCS = CircleSizeCalculator.standardRadiusToStandardCS(radius, true);
+        hitObject.scale = CircleSizeCalculator.standardCSToStandardScale(standardCS, true);
+    }
+}
+
 /**
  * Represents the HardRock mod.
  */
@@ -3039,17 +3968,15 @@ 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;
-            }
-            case exports.Modes.osu:
-                // CS uses a custom 1.3 ratio.
-                difficulty.cs = this.applySetting(difficulty.cs, 1.3);
-                break;
+    applyToDifficulty(mode, difficulty, adjustmentMods) {
+        if (mode === exports.Modes.osu || !adjustmentMods.has(ModReplayV6)) {
+            difficulty.cs = this.applySetting(difficulty.cs, 1.3);
+        }
+        else {
+            const scale = CircleSizeCalculator.droidCSToOldDroidScale(difficulty.cs);
+            // The 0.125 scale that was added before replay version 7 was in screen pixels. We need it in osu! pixels.
+            difficulty.cs = CircleSizeCalculator.oldDroidScaleToDroidCS(scale -
+                CircleSizeCalculator.oldDroidScaleScreenPixelsToOsuPixels(0.125));
         }
         difficulty.ar = this.applySetting(difficulty.ar);
         difficulty.od = this.applySetting(difficulty.od);
@@ -3058,12 +3985,6 @@ class ModHardRock extends Mod {
     applyToHitObject(_, hitObject) {
         HitObjectGenerationUtils.reflectVerticallyAlongPlayfield(hitObject);
     }
-    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);
     }
@@ -3094,15 +4015,15 @@ 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;
+    applyToDifficulty(mode, difficulty, adjustmentMods) {
+        if (mode === exports.Modes.osu || !adjustmentMods.has(ModReplayV6)) {
+            difficulty.cs /= 2;
+        }
+        else {
+            const scale = CircleSizeCalculator.droidCSToOldDroidScale(difficulty.cs);
+            // The 0.125 scale that was added before replay version 7 was in screen pixels. We need it in osu! pixels.
+            difficulty.cs = CircleSizeCalculator.oldDroidScaleToDroidCS(scale +
+                CircleSizeCalculator.oldDroidScaleScreenPixelsToOsuPixels(0.125));
         }
         difficulty.ar /= 2;
         difficulty.od /= 2;
@@ -3124,13 +4045,13 @@ class ModFlashlight extends Mod {
         /**
          * The amount of seconds until the Flashlight follow area reaches the cursor.
          */
-        this.followDelay = ModFlashlight.defaultFollowDelay;
+        this.followDelay = new DecimalModSetting("Flashlight follow delay", "The amount of seconds until the Flashlight follow area reaches the cursor.", ModFlashlight.defaultFollowDelay, ModFlashlight.defaultFollowDelay, ModFlashlight.defaultFollowDelay * 10, ModFlashlight.defaultFollowDelay, 2);
     }
     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.followDelay.value =
+            (_b = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.areaFollowDelay) !== null && _b !== void 0 ? _b : this.followDelay.value;
     }
     get isDroidRelevant() {
         return true;
@@ -3145,13 +4066,18 @@ class ModFlashlight extends Mod {
         return 1.12;
     }
     serializeSettings() {
-        return { areaFollowDelay: this.followDelay };
+        return { areaFollowDelay: this.followDelay.value };
+    }
+    equals(other) {
+        return (super.equals(other) &&
+            other instanceof ModFlashlight &&
+            other.followDelay.value === this.followDelay.value);
     }
     toString() {
-        if (this.followDelay === ModFlashlight.defaultFollowDelay) {
+        if (this.followDelay.value === ModFlashlight.defaultFollowDelay) {
             return super.toString();
         }
-        return `${super.toString()} (${this.followDelay.toFixed(2)}s follow delay)`;
+        return `${super.toString()} (${this.followDelay.toDisplayString()}s follow delay)`;
     }
 }
 /**
@@ -3185,6 +4111,16 @@ class ModTraceable extends Mod {
     }
 }
 
+/**
+ * Represents a `Mod` specific setting that is constrained to a boolean value.
+ */
+class BooleanModSetting extends ModSetting {
+    constructor() {
+        super(...arguments);
+        this.displayFormatter = (v) => v ? "Enabled" : "Disabled";
+    }
+}
+
 /**
  * Represents the Hidden mod.
  */
@@ -3196,6 +4132,12 @@ class ModHidden extends Mod {
         this.droidRanked = true;
         this.osuRanked = true;
         this.bitwise = 1 << 3;
+        /**
+         * Whether to only fade approach circles.
+         *
+         * The main object body will not fade when enabled.
+         */
+        this.onlyFadeApproachCircles = new BooleanModSetting("Only fade approach circles", "The main object body will not fade when enabled.", false);
         this.incompatibleMods.add(ModTraceable);
     }
     get isDroidRelevant() {
@@ -3210,6 +4152,12 @@ class ModHidden extends Mod {
     get osuScoreMultiplier() {
         return 1.06;
     }
+    copySettings(mod) {
+        var _a, _b;
+        super.copySettings(mod);
+        this.onlyFadeApproachCircles.value =
+            (_b = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.onlyFadeApproachCircles) !== null && _b !== void 0 ? _b : this.onlyFadeApproachCircles.value;
+    }
     applyToBeatmap(beatmap) {
         const applyFadeInAdjustment = (hitObject) => {
             hitObject.timeFadeIn =
@@ -3220,6 +4168,23 @@ class ModHidden extends Mod {
         };
         beatmap.hitObjects.objects.forEach(applyFadeInAdjustment);
     }
+    serializeSettings() {
+        return this.onlyFadeApproachCircles.value
+            ? { onlyFadeApproachCircles: this.onlyFadeApproachCircles.value }
+            : null;
+    }
+    equals(other) {
+        return (super.equals(other) &&
+            other instanceof ModHidden &&
+            other.onlyFadeApproachCircles.value ===
+                this.onlyFadeApproachCircles.value);
+    }
+    toString() {
+        if (!this.onlyFadeApproachCircles.value) {
+            return super.toString();
+        }
+        return `${super.toString()} (approach circles only)`;
+    }
 }
 ModHidden.fadeInDurationMultiplier = 0.4;
 ModHidden.fadeOutDurationMultiplier = 0.3;
@@ -3306,72 +4271,347 @@ class ModNoFail extends Mod {
 }
 
 /**
- * Represents a spinner in a beatmap.
- *
- * All we need from spinners is their duration. The
- * position of a spinner is always at 256x192.
+ * Represents the Precise mod.
  */
-class Spinner extends HitObject {
-    get endTime() {
-        return this._endTime;
+class ModPrecise extends Mod {
+    constructor() {
+        super(...arguments);
+        this.acronym = "PR";
+        this.name = "Precise";
+        this.droidRanked = true;
     }
-    constructor(values) {
-        super(Object.assign(Object.assign({}, values), { position: Playfield.baseSize.divide(2) }));
-        this._endTime = values.endTime;
+    get isDroidRelevant() {
+        return true;
     }
-    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)))));
+    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);
+        }
+    }
+}
+
+/**
+ * Some utilities, no biggie.
+ */
+class Utils {
+    /**
+     * Returns a random element of an array.
+     *
+     * @param array The array to get the element from.
+     */
+    static getRandomArrayElement(array) {
+        return array[Math.floor(Math.random() * array.length)];
+    }
+    /**
+     * Creates an array with specific length that's prefilled with an initial value.
+     *
+     * @param length The length of the array.
+     * @param initialValue The initial value of each element, or a function that returns the initial value of each element.
+     * @returns The array.
+     */
+    static initializeArray(length, initialValue) {
+        const array = new Array(length);
+        if (initialValue !== undefined) {
+            for (let i = 0; i < length; ++i) {
+                array[i] =
+                    typeof initialValue === "function"
+                        ? initialValue(i)
+                        : initialValue;
+            }
+        }
+        return array;
+    }
+    /**
+     * Pauses the execution of a function for
+     * the specified duration.
+     *
+     * @param duration The duration to pause for, in seconds.
+     */
+    static sleep(duration) {
+        return new Promise((resolve) => setTimeout(resolve, duration * 1000));
+    }
+}
+
+/**
+ * A pseudo-random number generator that shares the same implementation with
+ * {@link https://github.com/dotnet/runtime/blob/v9.0.4/src/libraries/System.Private.CoreLib/src/System/Random.Net5CompatImpl.cs .NET 5's `System.Random`}.
+ *
+ * Used in the Random mod to ensure that a seed generates the result that users expect.
+ */
+class Random {
+    /**
+     * Constructs a new instance of the `Random` class using the specified seed.
+     *
+     * @param seed The seed to use for the random number generator. This value is clamped to the range [-2147483648, 2147483647] and must be an integer.
+     */
+    constructor(seed) {
+        this.seedArray = Utils.initializeArray(56, 0);
+        this.iNext = 0;
+        this.iNextP = 21;
+        seed = Math.trunc(seed);
+        const subtraction = seed <= Random.MIN_VALUE ? Random.MAX_VALUE : Math.abs(seed);
+        // Magic number based on Phi (golden ratio).
+        let mj = 161803398 - subtraction;
+        this.seedArray[55] = mj;
+        let mk = 1;
+        let ii = 0;
+        for (let i = 1; i < 55; ++i) {
+            // The range [1..55] is special (Knuth) and so we're wasting the 0'th position.
+            ii = (21 * i) % 55;
+            this.seedArray[ii] = mk;
+            mk = mj - mk;
+            if (mk < 0) {
+                mk += Random.MAX_VALUE;
+            }
+            mj = this.seedArray[ii];
+        }
+        for (let k = 1; k < 5; ++k) {
+            for (let i = 1; i < 56; ++i) {
+                const n = (i + 30) % 55;
+                this.seedArray[i] -= this.seedArray[n + 1];
+                if (this.seedArray[i] < 0) {
+                    this.seedArray[i] += Random.MAX_VALUE;
+                }
+            }
+        }
+    }
+    nextDouble() {
+        return this.sample();
     }
-    getStackedPosition() {
-        return this.position;
+    sample() {
+        return this.internalSample() / 2147483647;
     }
-    getStackedEndPosition() {
-        return this.position;
+    internalSample() {
+        let locINext = this.iNext;
+        if (++locINext >= 56) {
+            locINext = 1;
+        }
+        let locINextP = this.iNextP;
+        if (++locINextP >= 56) {
+            locINextP = 1;
+        }
+        let retVal = this.seedArray[locINext] - this.seedArray[locINextP];
+        if (retVal === Random.MAX_VALUE) {
+            --retVal;
+        }
+        if (retVal < 0) {
+            retVal += Random.MAX_VALUE;
+        }
+        this.seedArray[locINext] = retVal;
+        this.iNext = locINext;
+        this.iNextP = locINextP;
+        return retVal;
     }
-    createHitWindow() {
-        return new EmptyHitWindow();
+}
+Random.MIN_VALUE = -2147483648;
+Random.MAX_VALUE = 2147483647;
+
+/**
+ * Represents a `Mod` specific setting that is constrained to a number of values.
+ *
+ * The value can be `null`, which is treated as a special case.
+ */
+class NullableIntegerModSetting extends RangeConstrainedModSetting {
+    constructor(name, description, defaultValue, min = -2147483648, max = 2147483647) {
+        super(name, description, defaultValue, min, max, 1);
+        this.displayFormatter = (v) => { var _a; return (_a = v === null || v === void 0 ? void 0 : v.toString()) !== null && _a !== void 0 ? _a : "None"; };
+        if (min > max) {
+            throw new RangeError(`The minimum value (${min}) must be less than or equal to the maximum value (${max}).`);
+        }
+        if (defaultValue !== null &&
+            (defaultValue < min || defaultValue > max)) {
+            throw new RangeError(`The default value (${defaultValue}) must be between the minimum (${min}) and maximum (${max}) values.`);
+        }
     }
-    toString() {
-        return `Position: [${this._position.x}, ${this._position.y}], duration: ${this.duration}`;
+    processValue(value) {
+        if (value === null) {
+            return null;
+        }
+        return Math.trunc(MathUtils.clamp(value, this.min, this.max));
     }
 }
-Spinner.baseSpinnerSpinSample = new BankHitSampleInfo("spinnerspin");
-Spinner.baseSpinnerBonusSample = new BankHitSampleInfo("spinnerbonus");
 
 /**
- * Represents the Precise mod.
+ * Represents the Random mod.
  */
-class ModPrecise extends Mod {
+class ModRandom extends Mod {
     constructor() {
         super(...arguments);
-        this.acronym = "PR";
-        this.name = "Precise";
-        this.droidRanked = true;
+        this.name = "Random";
+        this.acronym = "RD";
+        this.droidRanked = false;
+        this.osuRanked = false;
+        /**
+         * The seed to use.
+         */
+        this.seed = new NullableIntegerModSetting("Seed", "Use a custom seed instead of a random one.", null, 0);
+        /**
+         * Defines how sharp the angles of `HitObject`s should be.
+         */
+        this.angleSharpness = new DecimalModSetting("Angle sharpness", "Defines how sharp the angles of hit objects should be.", 7, 1, 10, 0.1, 1);
+        this.random = null;
     }
     get isDroidRelevant() {
         return true;
     }
     calculateDroidScoreMultiplier() {
-        return 1.06;
+        return 1;
     }
-    applyToHitObject(mode, hitObject) {
-        var _a, _b;
-        if (mode !== exports.Modes.droid || hitObject instanceof Spinner) {
-            return;
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1;
+    }
+    copySettings(mod) {
+        super.copySettings(mod);
+        const { settings } = mod;
+        if (typeof (settings === null || settings === void 0 ? void 0 : settings.seed) === "number") {
+            this.seed.value = settings.seed;
         }
-        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);
+        if (typeof (settings === null || settings === void 0 ? void 0 : settings.angleSharpness) === "number") {
+            this.angleSharpness.value = settings.angleSharpness;
         }
-        else {
-            hitObject.hitWindow = new PreciseDroidHitWindow((_b = hitObject.hitWindow) === null || _b === void 0 ? void 0 : _b.overallDifficulty);
+    }
+    applyToBeatmap(beatmap) {
+        var _a;
+        var _b;
+        (_a = (_b = this.seed).value) !== null && _a !== void 0 ? _a : (_b.value = Math.floor(Math.random() * 2147483647));
+        this.random = new Random(this.seed.value);
+        const positionInfos = HitObjectGenerationUtils.generatePositionInfos(beatmap.hitObjects.objects);
+        // Offsets the angles of all hit objects in a "section" by the same amount.
+        let sectionOffset = 0;
+        // Whether the angles are positive or negative (clockwise or counter-clockwise flow).
+        let flowDirection = false;
+        for (let i = 0; i < positionInfos.length; ++i) {
+            const positionInfo = positionInfos[i];
+            if (this.shouldStartNewSection(beatmap, positionInfos, i)) {
+                sectionOffset = this.getRandomOffset(0.0008);
+                flowDirection = !flowDirection;
+            }
+            if (positionInfo.hitObject instanceof Slider &&
+                this.random.nextDouble() < 0.5) {
+                HitObjectGenerationUtils.flipSliderInPlaceHorizontally(positionInfo.hitObject);
+            }
+            if (i === 0) {
+                positionInfo.distanceFromPrevious =
+                    this.random.nextDouble() * Playfield.center.y;
+                positionInfo.relativeAngle =
+                    this.random.nextDouble() * 2 * Math.PI - Math.PI;
+            }
+            else {
+                // Offsets only the angle of the current hit object if a flow change occurs.
+                let flowChangeOffset = 0;
+                // Offsets only the angle of the current hit object.
+                const oneTimeOffset = this.getRandomOffset(0.002);
+                if (this.shouldApplyFlowChange(positionInfos, i)) {
+                    flowChangeOffset = this.getRandomOffset(0.002);
+                    flowDirection = !flowDirection;
+                }
+                const totalOffset = 
+                // sectionOffset and oneTimeOffset should mainly affect patterns with large spacing.
+                (sectionOffset + oneTimeOffset) *
+                    positionInfo.distanceFromPrevious +
+                    // flowChangeOffset should mainly affect streams.
+                    flowChangeOffset *
+                        (ModRandom.playfieldDiagonal -
+                            positionInfo.distanceFromPrevious);
+                positionInfo.relativeAngle = this.getRelativeTargetAngle(positionInfo.distanceFromPrevious, totalOffset, flowDirection);
+            }
+        }
+        const repositionedHitObjects = HitObjectGenerationUtils.repositionHitObjects(positionInfos);
+        for (let i = 0; i < repositionedHitObjects.length; ++i) {
+            beatmap.hitObjects.objects[i] = repositionedHitObjects[i];
+        }
+    }
+    serializeSettings() {
+        const settings = {};
+        if (this.seed.value !== null) {
+            settings.seed = this.seed.value;
+        }
+        settings.angleSharpness = this.angleSharpness.value;
+        return settings;
+    }
+    getRandomOffset(stdDev) {
+        // Range: [0.5, 2]
+        // Higher angle sharpness -> lower multiplier
+        const customMultiplier = (1.5 * this.angleSharpness.max - this.angleSharpness.value) /
+            (1.5 * this.angleSharpness.max - this.angleSharpness.defaultValue);
+        return HitObjectGenerationUtils.randomGaussian(this.random, 0, stdDev * customMultiplier);
+    }
+    /**
+     * @param targetDistance The target distance between the previous and the current `HitObject`.
+     * @param offset The angle (in radians) by which the target angle should be offset.
+     * @param flowDirection Whether the relative angle should be positive (`false`) or negative (`true`).
+     */
+    getRelativeTargetAngle(targetDistance, offset, flowDirection) {
+        // Range: [0.1, 1]
+        const angleSharpness = this.angleSharpness.value / this.angleSharpness.max;
+        // Range: [0, 0.9]
+        const angleWideness = 1 - angleSharpness;
+        // Range: [-60, 30]
+        const customOffsetX = angleSharpness * 100 - 70;
+        // Range: [-0.075, 0.15]
+        const customOffsetY = angleWideness * 0.25 - 0.075;
+        const angle = 2.16 /
+            (1 +
+                200 *
+                    Math.exp(0.036 * (targetDistance + customOffsetX * 2 - 310))) +
+            0.5 +
+            offset +
+            customOffsetY;
+        const relativeAngle = Math.PI - angle;
+        return flowDirection ? -relativeAngle : relativeAngle;
+    }
+    /**
+     * Determines whether a new section should be started at the current [HitObject].
+     */
+    shouldStartNewSection(beatmap, positionInfos, i) {
+        if (i === 0) {
+            return true;
+        }
+        // Exclude new-combo-spam and 1-2-combos.
+        const previousObjectStartedCombo = positionInfos[Math.max(0, i - 2)].hitObject.indexInCurrentCombo >
+            1 && positionInfos[i - 1].hitObject.isNewCombo;
+        const previousObjectWasOnDownBeat = HitObjectGenerationUtils.isHitObjectOnBeat(beatmap, positionInfos[i - 1].hitObject, true);
+        const previousObjectWasOnBeat = HitObjectGenerationUtils.isHitObjectOnBeat(beatmap, positionInfos[i - 1].hitObject);
+        return ((previousObjectStartedCombo && this.random.nextDouble() < 0.6) ||
+            previousObjectWasOnDownBeat ||
+            (previousObjectWasOnBeat && this.random.nextDouble() < 0.4));
+    }
+    shouldApplyFlowChange(positionInfos, i) {
+        // Exclude new-combo-spam and 1-2-combos.
+        const previousObjectStartedCombo = positionInfos[Math.max(0, i - 2)].hitObject.indexInCurrentCombo >
+            1 && positionInfos[i - 1].hitObject.isNewCombo;
+        return previousObjectStartedCombo && this.random.nextDouble() < 0.6;
+    }
+    equals(other) {
+        return (super.equals(other) &&
+            other instanceof ModRandom &&
+            other.seed.value === this.seed.value &&
+            other.angleSharpness.value === this.angleSharpness.value);
+    }
+    toString() {
+        const settings = [];
+        if (this.seed.value !== null) {
+            settings.push(`seed: ${this.seed.value}`);
         }
+        settings.push(`angle sharpness: ${this.angleSharpness.toDisplayString()}`);
+        return `${super.toString()} (${settings.join(", ")})`;
     }
 }
+ModRandom.playfieldDiagonal = Playfield.baseSize.length;
 
 /**
  * Represents the ReallyEasy mod.
@@ -3389,29 +4629,36 @@ class ModReallyEasy extends Mod {
     calculateDroidScoreMultiplier() {
         return 0.4;
     }
-    applyToDifficultyWithSettings(mode, difficulty, mods) {
+    applyToDifficultyWithMods(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) {
+        const difficultyAdjust = mods.get(ModDifficultyAdjust);
+        if (typeof (difficultyAdjust === null || difficultyAdjust === void 0 ? void 0 : difficultyAdjust.ar.value) !== "number") {
             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;
+            difficulty.ar -= ((_a = customSpeed === null || customSpeed === void 0 ? void 0 : customSpeed.trackRateMultiplier.value) !== 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 (typeof (difficultyAdjust === null || difficultyAdjust === void 0 ? void 0 : difficultyAdjust.cs.value) !== "number") {
+            if (!mods.has(ModReplayV6)) {
+                difficulty.cs /= 2;
+            }
+            else {
+                const scale = CircleSizeCalculator.droidCSToOldDroidScale(difficulty.cs);
+                // The 0.125 scale that was added before replay version 7 was in screen pixels. We need it in osu! pixels.
+                difficulty.cs = CircleSizeCalculator.oldDroidScaleToDroidCS(scale +
+                    CircleSizeCalculator.oldDroidScaleScreenPixelsToOsuPixels(0.125));
+            }
         }
-        if ((difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.od) === undefined) {
+        if (typeof (difficultyAdjust === null || difficultyAdjust === void 0 ? void 0 : difficultyAdjust.od.value) !== "number") {
             difficulty.od /= 2;
         }
-        if ((difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.hp) === undefined) {
+        if (typeof (difficultyAdjust === null || difficultyAdjust === void 0 ? void 0 : difficultyAdjust.hp.value) !== "number") {
             difficulty.hp /= 2;
         }
     }
@@ -3464,19 +4711,13 @@ class ModSmallCircle extends Mod {
     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;
-            }
-            case exports.Modes.osu:
-                difficulty.cs += 4;
+    applyToDifficulty(mode, difficulty, adjustmentMods) {
+        if (mode === exports.Modes.osu || !adjustmentMods.has(ModDifficultyAdjust)) {
+            difficulty.cs += 4;
+        }
+        else {
+            const scale = CircleSizeCalculator.droidCSToOldDroidScale(difficulty.cs);
+            difficulty.cs = CircleSizeCalculator.oldDroidScaleToDroidCS(scale + CircleSizeCalculator.droidCSToOldDroidScale(4));
         }
     }
 }
@@ -3778,8 +5019,10 @@ class ModTimeRamp extends Mod {
         var _a, _b;
         super.copySettings(mod);
         const { settings } = mod;
-        this.initialRate = (_a = settings === null || settings === void 0 ? void 0 : settings.initialRate) !== null && _a !== void 0 ? _a : 1;
-        this.finalRate = (_b = settings === null || settings === void 0 ? void 0 : settings.finalRate) !== null && _b !== void 0 ? _b : 1;
+        this.initialRate.value =
+            (_a = settings === null || settings === void 0 ? void 0 : settings.initialRate) !== null && _a !== void 0 ? _a : this.initialRate.value;
+        this.finalRate.value =
+            (_b = settings === null || settings === void 0 ? void 0 : settings.finalRate) !== null && _b !== void 0 ? _b : this.finalRate.value;
     }
     applyToBeatmap(beatmap) {
         var _a, _b, _c, _d;
@@ -3790,13 +5033,22 @@ class ModTimeRamp extends Mod {
         const amount = (time - this.initialRateTime) /
             (this.finalRateTime - this.initialRateTime);
         return (rate *
-            Interpolation.lerp(this.initialRate, this.finalRate, MathUtils.clamp(amount, 0, 1)));
+            Interpolation.lerp(this.initialRate.value, this.finalRate.value, MathUtils.clamp(amount, 0, 1)));
     }
     serializeSettings() {
-        return { initialRate: this.initialRate, finalRate: this.finalRate };
+        return {
+            initialRate: this.initialRate.value,
+            finalRate: this.finalRate.value,
+        };
+    }
+    equals(other) {
+        return (super.equals(other) &&
+            other instanceof ModTimeRamp &&
+            other.initialRate.value === this.initialRate.value &&
+            other.finalRate.value === this.finalRate.value);
     }
     toString() {
-        return `${super.toString()} (${this.initialRate.toFixed(2)}x - ${this.finalRate.toFixed(2)}x)`;
+        return `${super.toString()} (${this.initialRate.toDisplayString()}x - ${this.finalRate.toDisplayString()}x)`;
     }
 }
 /**
@@ -3809,31 +5061,23 @@ ModTimeRamp.finalRateProgress = 0.75;
  */
 class ModWindDown extends ModTimeRamp {
     constructor() {
-        super(...arguments);
+        super();
         this.name = "Wind Down";
         this.acronym = "WD";
-        this._initialRate = 1;
-        this._finalRate = 0.75;
         this.droidRanked = false;
         this.osuRanked = false;
-    }
-    get initialRate() {
-        return this._initialRate;
-    }
-    set initialRate(value) {
-        this._initialRate = value;
-        if (value <= this.finalRate) {
-            this.finalRate = value - 0.01;
-        }
-    }
-    get finalRate() {
-        return this._finalRate;
-    }
-    set finalRate(value) {
-        this._finalRate = value;
-        if (value >= this.initialRate) {
-            this.initialRate = value + 0.01;
-        }
+        this.initialRate = new DecimalModSetting("Initial rate", "The starting speed of the track.", 1, 0.51, 2, 0.01, 2);
+        this.finalRate = new DecimalModSetting("Final rate", "The final speed to ramp to.", 0.75, 0.5, 1.99, 0.01, 2);
+        this.initialRate.bindValueChanged((_, value) => {
+            if (value <= this.finalRate.value) {
+                this.finalRate.value = value - this.finalRate.step;
+            }
+        });
+        this.finalRate.bindValueChanged((_, value) => {
+            if (value >= this.initialRate.value) {
+                this.initialRate.value = value + this.initialRate.step;
+            }
+        });
     }
     get isDroidRelevant() {
         return true;
@@ -3854,31 +5098,23 @@ class ModWindDown extends ModTimeRamp {
  */
 class ModWindUp extends ModTimeRamp {
     constructor() {
-        super(...arguments);
+        super();
         this.name = "Wind Up";
         this.acronym = "WU";
-        this._initialRate = 1;
-        this._finalRate = 1;
         this.droidRanked = false;
         this.osuRanked = false;
-    }
-    get initialRate() {
-        return this._initialRate;
-    }
-    set initialRate(value) {
-        this._initialRate = value;
-        if (value >= this.finalRate) {
-            this.finalRate = value + 0.01;
-        }
-    }
-    get finalRate() {
-        return this._finalRate;
-    }
-    set finalRate(value) {
-        this._finalRate = value;
-        if (value <= this.initialRate) {
-            this.initialRate = value - 0.01;
-        }
+        this.initialRate = new DecimalModSetting("Initial rate", "The starting speed of the track.", 1, 0.5, 1.99, 0.01, 2);
+        this.finalRate = new DecimalModSetting("Final rate", "The final speed to ramp to.", 1.5, 0.51, 2, 0.01, 2);
+        this.initialRate.bindValueChanged((_, value) => {
+            if (value >= this.finalRate.value) {
+                this.finalRate.value = value + this.finalRate.step;
+            }
+        });
+        this.finalRate.bindValueChanged((_, value) => {
+            if (value <= this.initialRate.value) {
+                this.initialRate.value = value - this.initialRate.step;
+            }
+        });
     }
     get isDroidRelevant() {
         return true;
@@ -3921,11 +5157,15 @@ class ModUtil {
      * Serializes a list of `Mod`s.
      *
      * @param mods The list of `Mod`s to serialize.
+     * @param includeNonUserPlayable Whether to include non-user-playable mods. Defaults to `true`.
      * @returns The serialized list of `Mod`s.
      */
-    static serializeMods(mods) {
+    static serializeMods(mods, includeNonUserPlayable = true) {
         const serializedMods = [];
         for (const mod of mods) {
+            if (!includeNonUserPlayable && !mod.userPlayable) {
+                continue;
+            }
             serializedMods.push(mod.serialize());
         }
         return serializedMods;
@@ -3962,9 +5202,8 @@ class ModUtil {
         str = str.toLowerCase();
         while (str) {
             let nchars = 1;
-            for (const acronym of this.allMods.keys()) {
+            for (const [acronym, modType] of this.allMods) {
                 if (str.startsWith(acronym.toLowerCase())) {
-                    const modType = this.allMods.get(acronym);
                     map.set(modType);
                     nchars = acronym.length;
                     break;
@@ -3994,15 +5233,16 @@ class ModUtil {
      * Converts a list of `Mod`s into an ordered string based on {@link allMods}.
      *
      * @param mods The list of `Mod`s to convert.
+     * @param includeNonUserPlayable Whether to include non-user-playable mods. Defaults to `true`.
      * @returns The string representing the `Mod`s in ordered form.
      */
-    static modsToOrderedString(mods) {
+    static modsToOrderedString(mods, includeNonUserPlayable = true) {
         const strs = [];
         for (const modType of this.allMods.values()) {
             const mod = mods instanceof ModMap
                 ? mods.get(modType)
                 : mods.find((m) => m instanceof modType);
-            if (mod) {
+            if (mod && (includeNonUserPlayable || mod.userPlayable)) {
                 strs.push(mod.toString());
                 continue;
             }
@@ -4028,17 +5268,23 @@ class ModUtil {
      */
     static applyModsToBeatmapDifficulty(difficulty, mode, mods, withRateChange = false) {
         if (mods !== undefined) {
+            const adjustmentMods = new ModMap();
+            for (const mod of mods.values()) {
+                if (mod.facilitatesAdjustment()) {
+                    adjustmentMods.set(mod);
+                }
+            }
             for (const mod of mods.values()) {
                 if (mod.isApplicableToDifficulty()) {
-                    mod.applyToDifficulty(mode, difficulty);
+                    mod.applyToDifficulty(mode, difficulty, adjustmentMods);
                 }
             }
         }
         let rate = 1;
         if (mods !== undefined) {
             for (const mod of mods.values()) {
-                if (mod.isApplicableToDifficultyWithSettings()) {
-                    mod.applyToDifficultyWithSettings(mode, difficulty, mods);
+                if (mod.isApplicableToDifficultyWithMods()) {
+                    mod.applyToDifficultyWithMods(mode, difficulty, mods);
                 }
                 if (mod.isApplicableToTrackRate()) {
                     rate = mod.applyToRate(0, rate);
@@ -4112,8 +5358,10 @@ ModUtil.allMods = (() => {
         ModSuddenDeath,
         ModPerfect,
         ModPrecise,
+        ModRandom,
         ModReallyEasy,
         ModSynesthesia,
+        ModReplayV6,
         ModScoreV2,
         ModSmallCircle,
         ModSpunOut,
@@ -4194,25 +5442,41 @@ class ModMap extends Map {
     }
     /**
      * Serializes all `Mod`s that are in this map.
+     *
+     * @param includeNonUserPlayable Whether to include non-user-playable mods. Defaults to `true`.
      */
-    serializeMods() {
-        return ModUtil.serializeMods(this.values());
+    serializeMods(includeNonUserPlayable = true) {
+        return ModUtil.serializeMods(this.values(), includeNonUserPlayable);
     }
-}
-
-/**
- * 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 Circle extends HitObject {
-    constructor(values) {
-        super(values);
+    /**
+     * Determines whether this `ModMap` is equal to another `ModMap`.
+     *
+     * This equality check succeeds if and only if the two `ModMap`s have the same size and
+     * all `Mod`s in this `ModMap` are equal to the corresponding `Mod`s in the other `ModMap`.
+     *
+     * @param other The other `ModMap` to compare to.
+     * @returns Whether the two `ModMap`s are equal.
+     */
+    equals(other) {
+        if (this.size !== other.size) {
+            return false;
+        }
+        for (const [key, value] of this) {
+            const otherValue = other.get(key);
+            if (!(otherValue === null || otherValue === void 0 ? void 0 : otherValue.equals(value))) {
+                return false;
+            }
+        }
+        return true;
     }
-    toString() {
-        return `Position: [${this._position.x}, ${this._position.y}]`;
+    /**
+     * Returns a string representation of this `ModMap`.
+     *
+     * @param includeNonUserPlayable Whether to include non-user-playable mods. Defaults to `true`.
+     * @returns A string representation of this `ModMap`.
+     */
+    toString(includeNonUserPlayable = true) {
+        return ModUtil.modsToOrderedString(this, includeNonUserPlayable);
     }
 }
 
@@ -4221,17 +5485,14 @@ class Circle extends HitObject {
  */
 class BeatmapHitObjects {
     constructor() {
-        this._objects = [];
+        /**
+         * The objects of the beatmap.
+         */
+        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.
      */
@@ -4284,7 +5545,7 @@ class BeatmapHitObjects {
             // 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);
+            this.objects.splice(this.findInsertionIndex(object.startTime), 0, object);
             if (object instanceof Circle) {
                 ++this._circles;
             }
@@ -4304,7 +5565,7 @@ class BeatmapHitObjects {
      */
     removeAt(index) {
         var _a;
-        const object = (_a = this._objects.splice(index, 1)[0]) !== null && _a !== void 0 ? _a : null;
+        const object = (_a = this.objects.splice(index, 1)[0]) !== null && _a !== void 0 ? _a : null;
         if (object instanceof Circle) {
             --this._circles;
         }
@@ -4320,7 +5581,7 @@ class BeatmapHitObjects {
      * Clears all hitobjects.
      */
     clear() {
-        this._objects.length = 0;
+        this.objects.length = 0;
         this._circles = 0;
         this._sliders = 0;
         this._spinners = 0;
@@ -4331,21 +5592,21 @@ class BeatmapHitObjects {
      * @param startTime The start time of the hitobject.
      */
     findInsertionIndex(startTime) {
-        if (this._objects.length === 0 ||
-            startTime < this._objects[0].startTime) {
+        if (this.objects.length === 0 ||
+            startTime < this.objects[0].startTime) {
             return 0;
         }
-        if (startTime >= this._objects.at(-1).startTime) {
-            return this._objects.length;
+        if (startTime >= this.objects.at(-1).startTime) {
+            return this.objects.length;
         }
         let l = 0;
-        let r = this._objects.length - 2;
+        let r = this.objects.length - 2;
         while (l <= r) {
             const pivot = l + ((r - l) >> 1);
-            if (this._objects[pivot].startTime < startTime) {
+            if (this.objects[pivot].startTime < startTime) {
                 l = pivot + 1;
             }
-            else if (this._objects[pivot].startTime > startTime) {
+            else if (this.objects[pivot].startTime > startTime) {
                 r = pivot - 1;
             }
             else {
@@ -4458,10 +5719,8 @@ class BeatmapProcessor {
      * 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) {
+    postProcess() {
         const objects = this.beatmap.hitObjects.objects;
         if (objects.length === 0) {
             return;
@@ -4470,39 +5729,14 @@ class BeatmapProcessor {
         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;
+        if (this.beatmap.formatVersion >= 6) {
+            this.applyStacking();
         }
-        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;
-            }
+        else {
+            this.applyOldStacking();
         }
     }
-    applyStandardStacking() {
+    applyStacking() {
         const objects = this.beatmap.hitObjects.objects;
         const startIndex = 0;
         const endIndex = objects.length - 1;
@@ -4631,7 +5865,7 @@ class BeatmapProcessor {
             }
         }
     }
-    applyStandardOldStacking() {
+    applyOldStacking() {
         const objects = this.beatmap.hitObjects.objects;
         for (let i = 0; i < objects.length; ++i) {
             const currentObject = objects[i];
@@ -5598,15 +6832,21 @@ class Beatmap {
         }
         // Convert
         const converted = new BeatmapConverter(this).convert();
+        const adjustmentMods = new ModMap();
+        for (const mod of mods.values()) {
+            if (mod.facilitatesAdjustment()) {
+                adjustmentMods.set(mod);
+            }
+        }
         // Apply difficulty mods
         mods.forEach((mod) => {
             if (mod.isApplicableToDifficulty()) {
-                mod.applyToDifficulty(mode, converted.difficulty);
+                mod.applyToDifficulty(mode, converted.difficulty, adjustmentMods);
             }
         });
         mods.forEach((mod) => {
-            if (mod.isApplicableToDifficultyWithSettings()) {
-                mod.applyToDifficultyWithSettings(mode, converted.difficulty, mods);
+            if (mod.isApplicableToDifficultyWithMods()) {
+                mod.applyToDifficultyWithMods(mode, converted.difficulty, mods);
             }
         });
         const processor = new BeatmapProcessor(converted);
@@ -5616,18 +6856,18 @@ class Beatmap {
         mods.forEach((mod) => {
             if (mod.isApplicableToHitObject()) {
                 for (const hitObject of converted.hitObjects.objects) {
-                    mod.applyToHitObject(mode, hitObject);
+                    mod.applyToHitObject(mode, hitObject, adjustmentMods);
                 }
             }
         });
         mods.forEach((mod) => {
-            if (mod.isApplicableToHitObjectWithSettings()) {
+            if (mod.isApplicableToHitObjectWithMods()) {
                 for (const hitObject of converted.hitObjects.objects) {
-                    mod.applyToHitObjectWithSettings(mode, hitObject, mods);
+                    mod.applyToHitObjectWithMods(mode, hitObject, mods);
                 }
             }
         });
-        processor.postProcess(mode);
+        processor.postProcess();
         mods.forEach((mod) => {
             if (mod.isApplicableToBeatmap()) {
                 mod.applyToBeatmap(converted);
@@ -5718,48 +6958,6 @@ var ParserConstants;
     ParserConstants[ParserConstants["MAX_MSPERBEAT_VALUE"] = 60000] = "MAX_MSPERBEAT_VALUE";
 })(ParserConstants || (ParserConstants = {}));
 
-/**
- * Some utilities, no biggie.
- */
-class Utils {
-    /**
-     * Returns a random element of an array.
-     *
-     * @param array The array to get the element from.
-     */
-    static getRandomArrayElement(array) {
-        return array[Math.floor(Math.random() * array.length)];
-    }
-    /**
-     * Creates an array with specific length that's prefilled with an initial value.
-     *
-     * @param length The length of the array.
-     * @param initialValue The initial value of each element, or a function that returns the initial value of each element.
-     * @returns The array.
-     */
-    static initializeArray(length, initialValue) {
-        const array = new Array(length);
-        if (initialValue !== undefined) {
-            for (let i = 0; i < length; ++i) {
-                array[i] =
-                    typeof initialValue === "function"
-                        ? initialValue(i)
-                        : initialValue;
-            }
-        }
-        return array;
-    }
-    /**
-     * Pauses the execution of a function for
-     * the specified duration.
-     *
-     * @param duration The duration to pause for, in seconds.
-     */
-    static sleep(duration) {
-        return new Promise((resolve) => setTimeout(resolve, duration * 1000));
-    }
-}
-
 /**
  * Represents an information about a hitobject-specific sample bank.
  */
@@ -6646,6 +7844,118 @@ class BeatmapColorDecoder extends SectionDecoder {
     }
 }
 
+/**
+ * Normalize a string path, reducing '..' and '.' parts.
+ * When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash,
+ * it is preserved.
+ *
+ * This function's implementation matches Node.js v10.3 API.
+ *
+ * @param path string path to normalize.
+ * @returns The normalized path.
+ * @throws {TypeError} if `path` is not a string.
+ */
+function normalize(path) {
+    if (typeof path !== "string") {
+        throw new TypeError(`Expected a string, got ${typeof path}`);
+    }
+    if (path.length === 0) {
+        return ".";
+    }
+    const isAbsolute = path.charCodeAt(0) === 47; /*/*/
+    const trailingSeparator = path.charCodeAt(path.length - 1) === 47; /*/*/
+    // Normalize the path
+    path = normalizeStringPosix(path, !isAbsolute);
+    if (path.length === 0 && !isAbsolute) {
+        path = ".";
+    }
+    if (path.length > 0 && trailingSeparator) {
+        path += "/";
+    }
+    if (isAbsolute) {
+        return "/" + path;
+    }
+    return path;
+}
+// Resolves . and .. elements in a path with directory names
+function normalizeStringPosix(path, allowAboveRoot) {
+    let res = "";
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let code;
+    for (let i = 0; i <= path.length; ++i) {
+        if (i < path.length) {
+            code = path.charCodeAt(i);
+        }
+        else if (code === 47 /*/*/) {
+            break;
+        }
+        else {
+            code = 47 /*/*/;
+        }
+        if (code === 47 /*/*/) {
+            if (lastSlash === i - 1 || dots === 1) ;
+            else if (lastSlash !== i - 1 && dots === 2) {
+                if (res.length < 2 ||
+                    lastSegmentLength !== 2 ||
+                    res.charCodeAt(res.length - 1) !== 46 /*.*/ ||
+                    res.charCodeAt(res.length - 2) !== 46 /*.*/) {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.lastIndexOf("/");
+                        if (lastSlashIndex !== res.length - 1) {
+                            if (lastSlashIndex === -1) {
+                                res = "";
+                                lastSegmentLength = 0;
+                            }
+                            else {
+                                res = res.slice(0, lastSlashIndex);
+                                lastSegmentLength =
+                                    res.length - 1 - res.lastIndexOf("/");
+                            }
+                            lastSlash = i;
+                            dots = 0;
+                            continue;
+                        }
+                    }
+                    else if (res.length === 2 || res.length === 1) {
+                        res = "";
+                        lastSegmentLength = 0;
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    if (res.length > 0)
+                        res += "/..";
+                    else
+                        res = "..";
+                    lastSegmentLength = 2;
+                }
+            }
+            else {
+                if (res.length > 0) {
+                    res += "/" + path.slice(lastSlash + 1, i);
+                }
+                else {
+                    res = path.slice(lastSlash + 1, i);
+                }
+                lastSegmentLength = i - lastSlash - 1;
+            }
+            lastSlash = i;
+            dots = 0;
+        }
+        else if (code === 46 /*.*/ && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+
 /**
  * Determines how color blending should be done.
  */
@@ -7389,7 +8699,7 @@ class StoryboardEventsDecoder extends SectionDecoder {
         while (end > start && name.charAt(end - 1) === '"') {
             --end;
         }
-        return node_path.normalize(start > 0 || end < name.length ? name.substring(start, end) : name);
+        return normalize(start > 0 || end < name.length ? name.substring(start, end) : name);
     }
 }
 
@@ -7548,7 +8858,7 @@ class BeatmapDecoder extends Decoder {
             h.applyDefaults(this.finalResult.controlPoints, this.finalResult.difficulty, mode);
             h.applySamples(this.finalResult.controlPoints);
         });
-        processor.postProcess(mode);
+        processor.postProcess();
         return this;
     }
     decodeLine(line) {
@@ -8810,7 +10120,7 @@ class DroidLegacyModConverter {
                         flashlight = new ModFlashlight();
                         map.set(flashlight);
                     }
-                    flashlight.followDelay = parseFloat(s.slice(3));
+                    flashlight.followDelay.value = parseFloat(s.slice(3));
                     break;
                 }
                 // Speed multiplier
@@ -8820,7 +10130,7 @@ class DroidLegacyModConverter {
                         customSpeed = new ModCustomSpeed();
                         map.set(customSpeed);
                     }
-                    customSpeed.trackRateMultiplier = parseFloat(s.slice(1));
+                    customSpeed.trackRateMultiplier.value = parseFloat(s.slice(1));
                     break;
                 }
             }
@@ -9639,6 +10949,15 @@ ErrorFunction.ervInvImpGd = [
     0.3999688121938621e-6, 0.1618092908879045e-8, 0.2315586083102596e-11,
 ];
 
+/**
+ * Represents a `Mod` specific setting that is constrained to a range of integer values.
+ */
+class IntegerModSetting extends NumberModSetting {
+    constructor(name, description, defaultValue, min = -2147483648, max = 2147483647) {
+        super(name, description, defaultValue, min, max, 1);
+    }
+}
+
 /**
  * Ranking status of a beatmap.
  */
@@ -10073,8 +11392,8 @@ class MapInfo {
  */
 class ModOldNightCore extends ModNightCore {
     constructor() {
-        super(...arguments);
-        this.trackRateMultiplier = 1.39;
+        super();
+        this.trackRateMultiplier.value = 1.39;
     }
     calculateDroidScoreMultiplier() {
         return 1.12;
@@ -10124,6 +11443,7 @@ exports.BeatmapMetadata = BeatmapMetadata;
 exports.BeatmapProcessor = BeatmapProcessor;
 exports.BeatmapVideo = BeatmapVideo;
 exports.BlendingParameters = BlendingParameters;
+exports.BooleanModSetting = BooleanModSetting;
 exports.BreakPoint = BreakPoint;
 exports.Brent = Brent;
 exports.Circle = Circle;
@@ -10134,6 +11454,7 @@ exports.CommandTimeline = CommandTimeline;
 exports.CommandTimelineGroup = CommandTimelineGroup;
 exports.CommandTrigger = CommandTrigger;
 exports.ControlPointManager = ControlPointManager;
+exports.DecimalModSetting = DecimalModSetting;
 exports.DifficultyControlPoint = DifficultyControlPoint;
 exports.DifficultyControlPointManager = DifficultyControlPointManager;
 exports.DroidAPIRequestBuilder = DroidAPIRequestBuilder;
@@ -10149,6 +11470,7 @@ exports.HitObject = HitObject;
 exports.HitObjectGenerationUtils = HitObjectGenerationUtils;
 exports.HitSampleInfo = HitSampleInfo;
 exports.HitWindow = HitWindow;
+exports.IntegerModSetting = IntegerModSetting;
 exports.Interpolation = Interpolation;
 exports.MapInfo = MapInfo;
 exports.MathUtils = MathUtils;
@@ -10170,10 +11492,13 @@ exports.ModNoFail = ModNoFail;
 exports.ModOldNightCore = ModOldNightCore;
 exports.ModPerfect = ModPerfect;
 exports.ModPrecise = ModPrecise;
+exports.ModRandom = ModRandom;
 exports.ModRateAdjust = ModRateAdjust;
 exports.ModReallyEasy = ModReallyEasy;
 exports.ModRelax = ModRelax;
+exports.ModReplayV6 = ModReplayV6;
 exports.ModScoreV2 = ModScoreV2;
+exports.ModSetting = ModSetting;
 exports.ModSmallCircle = ModSmallCircle;
 exports.ModSpunOut = ModSpunOut;
 exports.ModSuddenDeath = ModSuddenDeath;
@@ -10184,6 +11509,8 @@ exports.ModUtil = ModUtil;
 exports.ModWindDown = ModWindDown;
 exports.ModWindUp = ModWindUp;
 exports.NormalDistribution = NormalDistribution;
+exports.NullableDecimalModSetting = NullableDecimalModSetting;
+exports.NumberModSetting = NumberModSetting;
 exports.OsuAPIRequestBuilder = OsuAPIRequestBuilder;
 exports.OsuHitWindow = OsuHitWindow;
 exports.OsuPlayableBeatmap = OsuPlayableBeatmap;
@@ -10194,6 +11521,8 @@ exports.Polynomial = Polynomial;
 exports.PreciseDroidHitWindow = PreciseDroidHitWindow;
 exports.Precision = Precision;
 exports.RGBColor = RGBColor;
+exports.Random = Random;
+exports.RangeConstrainedModSetting = RangeConstrainedModSetting;
 exports.SampleBankInfo = SampleBankInfo;
 exports.SampleControlPoint = SampleControlPoint;
 exports.SampleControlPointManager = SampleControlPointManager;
@@ -10219,5 +11548,7 @@ exports.TimingControlPoint = TimingControlPoint;
 exports.TimingControlPointManager = TimingControlPointManager;
 exports.Utils = Utils;
 exports.Vector2 = Vector2;
+exports.Vector4 = Vector4;
 exports.ZeroCrossingBracketing = ZeroCrossingBracketing;
+exports.normalize = normalize;
 //# sourceMappingURL=index.js.map