@rian8337/osu-base 4.0.0-beta.69 → 4.0.0-beta.71

package/dist/index.js

@@ -1318,7 +1318,7 @@ class ModSetting {
      * The default value of this `ModSetting`.
      */
     get defaultValue() {
-        return this._value;
+        return this._defaultValue;
     }
     set defaultValue(value) {
         this._defaultValue = value;
@@ -1334,7 +1334,7 @@ class ModSetting {
             const oldValue = this._value;
             this._value = value;
             for (const listener of this.valueChangedListeners) {
-                listener(oldValue, value);
+                listener({ oldValue, newValue: value });
             }
         }
     }
@@ -1372,7 +1372,7 @@ class ModSetting {
     bindValueChanged(listener, runOnceImmediately = false) {
         this.valueChangedListeners.add(listener);
         if (runOnceImmediately) {
-            listener(this.value, this.value);
+            listener({ oldValue: this.value, newValue: this.value });
         }
     }
     /**
@@ -1397,7 +1397,14 @@ class Mod {
          */
         this.userPlayable = true;
         /**
-         * `Mod`s that are incompatible with this `Mod`.
+         * The {@link Mod}s this {@link Mod} cannot be enabled with.
+         *
+         * This is merely a static list of {@link Mod} constructors that this {@link Mod} is incompatible with,
+         * regardless of the actual instance of the {@link Mod}.
+         *
+         * Some {@link Mod}s may have additional compatibility requirements that are captured in
+         * {@link isCompatibleWith}. When checking for {@link Mod} compatibility, always use
+         * {@link isCompatibleWith}.
          */
         this.incompatibleMods = new Set();
         this.settingsBacking = null;
@@ -1424,6 +1431,19 @@ class Mod {
     get usesDefaultSettings() {
         return this.settings.every((s) => s.isDefault);
     }
+    /**
+     * Determines whether this {@link Mod} is compatible with another {@link Mod}.
+     *
+     * This extends {@link incompatibleMods} by allowing for dynamic checks against
+     * the actual instance of the {@link Mod} (i.e., its specific settings).
+     *
+     * @param other The {@link Mod} to check compatibility with.
+     * @return `true` if this {@link Mod} is compatible with {@link other}, `false` otherwise.
+     */
+    isCompatibleWith(other) {
+        return (!this.incompatibleMods.has(other.constructor) &&
+            !other.incompatibleMods.has(this.constructor));
+    }
     /**
      * Serializes this `Mod` to a `SerializedMod`.
      */
@@ -1884,7 +1904,7 @@ class Slider extends HitObject {
             .length;
     }
     get stackHeight() {
-        return this._stackHeight;
+        return super.stackHeight;
     }
     set stackHeight(value) {
         super.stackHeight = value;
@@ -1893,7 +1913,7 @@ class Slider extends HitObject {
         }
     }
     get scale() {
-        return this._scale;
+        return super.scale;
     }
     set scale(value) {
         super.scale = value;
@@ -1901,6 +1921,15 @@ class Slider extends HitObject {
             nestedObject.scale = value;
         }
     }
+    get stackOffsetMultiplier() {
+        return super.stackOffsetMultiplier;
+    }
+    set stackOffsetMultiplier(value) {
+        super.stackOffsetMultiplier = value;
+        for (const nestedObject of this.nestedHitObjects) {
+            nestedObject.stackOffsetMultiplier = value;
+        }
+    }
     constructor(values) {
         super(values);
         /**
@@ -2751,1716 +2780,1849 @@ class Circle extends HitObject {
     }
 }
 
+var _a$1;
 /**
- * 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.
+ * 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);
+
+/**
+ * Represents a spinner in a beatmap.
  *
- * 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.
+ * All we need from spinners is their duration. The
+ * position of a spinner is always at 256x192.
  */
-class ModReplayV6 extends Mod {
-    constructor() {
-        super(...arguments);
-        this.name = "Replay V6";
-        this.acronym = "RV6";
-        this.userPlayable = false;
-        this.droidRanked = false;
-        this.facilitateAdjustment = true;
+class Spinner extends HitObject {
+    get endTime() {
+        return this._endTime;
     }
-    get isDroidRelevant() {
-        return true;
+    constructor(values) {
+        super(Object.assign(Object.assign({}, values), { position: Playfield.baseSize.divide(2) }));
+        this._endTime = values.endTime;
     }
-    calculateDroidScoreMultiplier() {
-        return 1;
+    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)))));
     }
-    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;
-            }
-        }
+    get stackedPosition() {
+        return this.position;
     }
-    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);
-        hitObject.stackOffsetMultiplier = 4;
+    get stackedEndPosition() {
+        return this.position;
+    }
+    createHitWindow() {
+        return new EmptyHitWindow();
+    }
+    toString() {
+        return `Position: [${this._position.x}, ${this._position.y}], duration: ${this.duration}`;
     }
 }
+Spinner.baseSpinnerSpinSample = new BankHitSampleInfo("spinnerspin");
+Spinner.baseSpinnerBonusSample = new BankHitSampleInfo("spinnerbonus");
 
 /**
- * Represents a `Mod` specific setting that is constrained to a number of values.
- *
- * The value can be `null`, which is treated as a special case.
+ * Represents a four-dimensional vector.
  */
-class NullableDecimalModSetting extends RangeConstrainedModSetting {
+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;
+    }
     /**
-     * The number of decimal places to round the value to.
-     *
-     * When set to `null`, the value will not be rounded.
+     * The X coordinate of the left edge of this vector.
      */
-    get precision() {
-        return this._precision;
+    get left() {
+        return this.x;
     }
-    set precision(value) {
-        if (value !== null && value < 0) {
-            throw new RangeError(`The precision (${value}) must be greater than or equal to 0.`);
-        }
-        this._precision = value;
-        if (value !== null) {
-            this.value = this.processValue(this.value);
-        }
+    /**
+     * The Y coordinate of the top edge of this vector.
+     */
+    get top() {
+        return this.y;
     }
-    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;
+    /**
+     * The X coordinate of the right edge of this vector.
+     */
+    get right() {
+        return this.z;
     }
-    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;
+    /**
+     * 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;
     }
 }
 
 /**
- * Represents the Difficulty Adjust mod.
+ * Contains infromation about the position of a {@link HitObject}.
  */
-class ModDifficultyAdjust extends Mod {
-    get isRelevant() {
-        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;
-        /**
-         * 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);
+class HitObjectPositionInfo {
+    constructor(hitObject) {
         /**
-         * The overall difficulty to enforce.
+         * 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.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, _e, _f, _g, _h;
-        super.copySettings(mod);
-        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;
-    }
-    calculateDroidScoreMultiplier(difficulty) {
-        // Graph: https://www.desmos.com/calculator/yrggkhrkzz
-        let multiplier = 1;
-        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.value !== null) {
-            const diff = this.od.value - difficulty.od;
-            multiplier *=
-                diff >= 0
-                    ? 1 + 0.005 * Math.pow(diff, 1.3)
-                    : 2 / (1 + Math.exp(-0.25 * diff));
-        }
-        return multiplier;
-    }
-    get isOsuRelevant() {
-        return this.isRelevant;
-    }
-    get osuScoreMultiplier() {
-        return 0.5;
-    }
-    applyToDifficultyWithMods(_, difficulty, mods) {
-        var _a, _b, _c, _d;
-        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 in replay version 6 and older, 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.value !== null && mods.has(ModReplayV6)) {
-            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);
-        }
-    }
-    applyToHitObjectWithMods(_, hitObject, mods) {
-        // Special case for force AR in replay version 6 and older, 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.value === null || !mods.has(ModReplayV6)) {
-            return;
-        }
-        this.applyFadeAdjustment(hitObject, mods);
-        if (hitObject instanceof Slider) {
-            for (const nested of hitObject.nestedHitObjects) {
-                this.applyFadeAdjustment(nested, mods);
-            }
-        }
+        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;
     }
-    serializeSettings() {
-        if (!this.isRelevant) {
-            return null;
-        }
-        const settings = {};
-        if (this.cs.value !== null) {
-            settings.cs = this.cs.value;
-        }
-        if (this.ar.value !== null) {
-            settings.ar = this.ar.value;
-        }
-        if (this.od.value !== null) {
-            settings.od = this.od.value;
-        }
-        if (this.hp.value !== null) {
-            settings.hp = this.hp.value;
-        }
-        return settings;
+}
+
+/**
+ * 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;
     }
-    applyFadeAdjustment(hitObject, mods) {
-        // IMPORTANT: These do not use `ModUtil.calculateRateWithMods` to avoid circular dependency.
-        const initialTrackRate = this.calculateTrackRate(mods.values());
-        const currentTrackRate = this.calculateTrackRate(mods.values(), hitObject.startTime);
-        // Cancel the rate that was initially applied to timePreempt (via applyToDifficulty above and
-        // HitObject.applyDefaults) and apply the current one.
-        hitObject.timePreempt *= currentTrackRate / initialTrackRate;
-        hitObject.timeFadeIn *= currentTrackRate;
+    /**
+     * 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));
     }
-    calculateTrackRate(mods, time = 0) {
-        // IMPORTANT: This does not use `ModUtil.calculateRateWithMods` to avoid circular dependency.
-        let rate = 1;
-        for (const mod of mods) {
-            if (mod.isApplicableToTrackRate()) {
-                rate = mod.applyToRate(time, rate);
-            }
-        }
-        return rate;
+    /**
+     * 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);
     }
-    toString() {
-        if (!this.isRelevant) {
-            return super.toString();
-        }
-        const settings = [];
-        if (this.cs.value !== null) {
-            settings.push(`CS${this.cs.toDisplayString()}`);
+    /**
+     * 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.
+     * @returns Whether both numbers are almost equal up to the specified maximum error.
+     */
+    static almostEqualNormRelative(a, b, diff, maximumError) {
+        // If A or B are infinity (positive or negative) then
+        // only return true if they are exactly equal to each other -
+        // that is, if they are both infinities of the same sign.
+        if (!Number.isFinite(a) || !Number.isFinite(b)) {
+            return a === b;
         }
-        if (this.ar.value !== null) {
-            settings.push(`AR${this.ar.toDisplayString()}`);
+        // If A or B are a NAN, return false. NANs are equal to nothing,
+        // not even themselves.
+        if (Number.isNaN(a) || Number.isNaN(b)) {
+            return false;
         }
-        if (this.od.value !== null) {
-            settings.push(`OD${this.od.toDisplayString()}`);
+        // If one is almost zero, fall back to absolute equality.
+        const doublePrecision = Math.pow(2, -53);
+        if (Math.abs(a) < doublePrecision || Math.abs(b) < doublePrecision) {
+            return Math.abs(diff) < maximumError;
         }
-        if (this.hp.value !== null) {
-            settings.push(`HP${this.hp.toDisplayString()}`);
+        if ((a === 0 && Math.abs(b) < maximumError) ||
+            (b === 0 && Math.abs(a) < maximumError)) {
+            return true;
         }
-        return `${super.toString()} (${settings.join(", ")})`;
+        return (Math.abs(diff) < maximumError * Math.max(Math.abs(a), Math.abs(b)));
     }
 }
+Precision.FLOAT_EPSILON = 1e-3;
 
 /**
- * Represents the NightCore mod.
+ * Types of slider paths.
  */
-class ModNightCore extends ModRateAdjust {
-    constructor() {
-        super(1.5);
-        this.acronym = "NC";
-        this.name = "NightCore";
-        this.droidRanked = true;
-        this.osuRanked = true;
-        this.bitwise = 1 << 9;
-        this.incompatibleMods.add(ModDoubleTime).add(ModHalfTime);
-    }
-    get isDroidRelevant() {
-        return this.isRelevant;
-    }
-    calculateDroidScoreMultiplier() {
-        return this.droidScoreMultiplier;
-    }
-    get isOsuRelevant() {
-        return this.isRelevant;
-    }
-    get osuScoreMultiplier() {
-        return 1.12;
-    }
-}
+exports.PathType = void 0;
+(function (PathType) {
+    PathType["Catmull"] = "C";
+    PathType["Bezier"] = "B";
+    PathType["Linear"] = "L";
+    PathType["PerfectCurve"] = "P";
+})(exports.PathType || (exports.PathType = {}));
 
 /**
- * Represents the HalfTime mod.
+ * Path approximator for sliders.
  */
-class ModHalfTime extends ModRateAdjust {
-    constructor() {
-        super(0.75);
-        this.acronym = "HT";
-        this.name = "HalfTime";
-        this.droidRanked = true;
-        this.osuRanked = true;
-        this.bitwise = 1 << 8;
-        this.incompatibleMods.add(ModDoubleTime).add(ModNightCore);
-    }
-    get isDroidRelevant() {
-        return this.isRelevant;
-    }
-    calculateDroidScoreMultiplier() {
-        return this.droidScoreMultiplier;
+class PathApproximator {
+    /**
+     * Approximates a bezier slider's path.
+     *
+     * Creates a piecewise-linear approximation of a bezier curve by adaptively repeatedly subdividing
+     * the control points until their approximation error vanishes below a given threshold.
+     *
+     * @param controlPoints The anchor points of the slider.
+     */
+    static approximateBezier(controlPoints) {
+        const output = [];
+        const count = controlPoints.length - 1;
+        if (count < 0) {
+            return output;
+        }
+        const subdivisionBuffer1 = new Array(count + 1);
+        const subdivisionBuffer2 = new Array(count * 2 + 1);
+        // "toFlatten" contains all the curves which are not yet approximated well enough.
+        // We use a stack to emulate recursion without the risk of running into a stack overflow.
+        // (More specifically, we iteratively and adaptively refine our curve with a
+        // depth-first search (https://en.wikipedia.org/wiki/Depth-first_search)
+        // over the tree resulting from the subdivisions we make.)
+        const toFlatten = [controlPoints.slice()];
+        const freeBuffers = [];
+        const leftChild = subdivisionBuffer2;
+        while (toFlatten.length > 0) {
+            const parent = toFlatten.pop();
+            if (this.bezierIsFlatEnough(parent)) {
+                // If the control points we currently operate on are sufficiently "flat", we use
+                // an extension to De Casteljau's algorithm to obtain a piecewise-linear approximation
+                // of the bezier curve represented by our control points, consisting of the same amount
+                // of points as there are control points.
+                this.bezierApproximate(parent, output, subdivisionBuffer1, subdivisionBuffer2, count + 1);
+                freeBuffers.push(parent);
+                continue;
+            }
+            // If we do not yet have a sufficiently "flat" (in other words, detailed) approximation we keep
+            // subdividing the curve we are currently operating on.
+            const rightChild = freeBuffers.length > 0
+                ? freeBuffers.pop()
+                : new Array(count + 1);
+            this.bezierSubdivide(parent, leftChild, rightChild, subdivisionBuffer1, count + 1);
+            // We re-use the buffer of the parent for one of the children, so that we save one allocation per iteration.
+            for (let i = 0; i < count + 1; ++i) {
+                parent[i] = leftChild[i];
+            }
+            toFlatten.push(rightChild);
+            toFlatten.push(parent);
+        }
+        output.push(controlPoints[count]);
+        return output;
     }
-    get isOsuRelevant() {
-        return this.isRelevant;
+    /**
+     * Approximates a catmull slider's path.
+     *
+     * Creates a piecewise-linear approximation of a Catmull-Rom spline.
+     *
+     * @param controlPoints The anchor points of the slider.
+     */
+    static approximateCatmull(controlPoints) {
+        const result = [];
+        for (let i = 0; i < controlPoints.length - 1; ++i) {
+            const v1 = i > 0 ? controlPoints[i - 1] : controlPoints[i];
+            const v2 = controlPoints[i];
+            const v3 = controlPoints[i + 1];
+            const v4 = i < controlPoints.length - 2
+                ? controlPoints[i + 2]
+                : v3.add(v3).subtract(v2);
+            for (let c = 0; c < this.catmullDetail; ++c) {
+                result.push(this.catmullFindPoint(v1, v2, v3, v4, c / this.catmullDetail));
+                result.push(this.catmullFindPoint(v1, v2, v3, v4, (c + 1) / this.catmullDetail));
+            }
+        }
+        return result;
     }
-    get osuScoreMultiplier() {
-        return 0.3;
+    /**
+     * Approximates a slider's circular arc.
+     *
+     * Creates a piecewise-linear approximation of a circular arc curve.
+     *
+     * @param controlPoints The anchor points of the slider.
+     */
+    static approximateCircularArc(controlPoints) {
+        const a = controlPoints[0];
+        const b = controlPoints[1];
+        const c = controlPoints[2];
+        // If we have a degenerate triangle where a side-length is almost zero, then give up and fall
+        // back to a more numerically stable method.
+        if (Precision.almostEqualsNumber(0, (b.y - a.y) * (c.x - a.x) - (b.x - a.x) * (c.y - a.y))) {
+            return this.approximateBezier(controlPoints);
+        }
+        // See: https://en.wikipedia.org/wiki/Circumscribed_circle#Cartesian_coordinates_2
+        const d = 2 *
+            (a.x * b.subtract(c).y +
+                b.x * c.subtract(a).y +
+                c.x * a.subtract(b).y);
+        const aSq = Math.pow(a.length, 2);
+        const bSq = Math.pow(b.length, 2);
+        const cSq = Math.pow(c.length, 2);
+        const center = new Vector2(aSq * b.subtract(c).y +
+            bSq * c.subtract(a).y +
+            cSq * a.subtract(b).y, aSq * c.subtract(b).x +
+            bSq * a.subtract(c).x +
+            cSq * b.subtract(a).x).divide(d);
+        const dA = a.subtract(center);
+        const dC = c.subtract(center);
+        const r = dA.length;
+        const thetaStart = Math.atan2(dA.y, dA.x);
+        let thetaEnd = Math.atan2(dC.y, dC.x);
+        while (thetaEnd < thetaStart) {
+            thetaEnd += 2 * Math.PI;
+        }
+        let dir = 1;
+        let thetaRange = thetaEnd - thetaStart;
+        // Decide in which direction to draw the circle, depending on which side of
+        // AC B lies.
+        let orthoAtoC = c.subtract(a);
+        orthoAtoC = new Vector2(orthoAtoC.y, -orthoAtoC.x);
+        if (orthoAtoC.dot(b.subtract(a)) < 0) {
+            dir = -dir;
+            thetaRange = 2 * Math.PI - thetaRange;
+        }
+        // We select the amount of points for the approximation by requiring the discrete curvature
+        // to be smaller than the provided tolerance. The exact angle required to meet the tolerance
+        // is: 2 * Math.Acos(1 - TOLERANCE / r)
+        // The special case is required for extremely short sliders where the radius is smaller than
+        // the tolerance. This is a pathological rather than a realistic case.
+        const amountPoints = 2 * r <= this.circularArcTolerance
+            ? 2
+            : Math.max(2, Math.ceil(thetaRange /
+                (2 *
+                    Math.acos(1 - this.circularArcTolerance / r))));
+        const output = [];
+        for (let i = 0; i < amountPoints; ++i) {
+            const fract = i / (amountPoints - 1);
+            const theta = thetaStart + dir * fract * thetaRange;
+            const o = new Vector2(Math.cos(theta), Math.sin(theta)).scale(r);
+            output.push(center.add(o));
+        }
+        return output;
     }
-}
-
-/**
- * Represents the DoubleTime mod.
- */
-class ModDoubleTime extends ModRateAdjust {
-    constructor() {
-        super(1.5);
-        this.acronym = "DT";
-        this.name = "DoubleTime";
-        this.droidRanked = true;
-        this.osuRanked = true;
-        this.bitwise = 1 << 6;
-        this.incompatibleMods.add(ModHalfTime).add(ModNightCore);
+    /**
+     * Approximates a linear slider's path.
+     *
+     * Creates a piecewise-linear approximation of a linear curve.
+     * Basically, returns the input.
+     *
+     * @param controlPoints The anchor points of the slider.
+     */
+    static approximateLinear(controlPoints) {
+        return controlPoints;
     }
-    get isDroidRelevant() {
-        return this.isRelevant;
+    /**
+     * Checks if a bezier slider is flat enough to be approximated.
+     *
+     * Make sure the 2nd order derivative (approximated using finite elements) is within tolerable bounds.
+     *
+     * NOTE: The 2nd order derivative of a 2D curve represents its curvature, so intuitively this function
+     * checks (as the name suggests) whether our approximation is _locally_ "flat". More curvy parts
+     * need to have a denser approximation to be more "flat".
+     *
+     * @param controlPoints The anchor points of the slider.
+     */
+    static bezierIsFlatEnough(controlPoints) {
+        for (let i = 1; i < controlPoints.length - 1; ++i) {
+            const prev = controlPoints[i - 1];
+            const current = controlPoints[i];
+            const next = controlPoints[i + 1];
+            const final = prev.subtract(current.scale(2)).add(next);
+            if (Math.pow(final.length, 2) >
+                Math.pow(this.bezierTolerance, 2) * 4) {
+                return false;
+            }
+        }
+        return true;
     }
-    calculateDroidScoreMultiplier() {
-        return this.droidScoreMultiplier;
+    /**
+     * Approximates a bezier slider's path.
+     *
+     * This uses {@link https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm De Casteljau's algorithm} to obtain an optimal
+     * piecewise-linear approximation of the bezier curve with the same amount of points as there are control points.
+     *
+     * @param controlPoints The control points describing the bezier curve to be approximated.
+     * @param output The points representing the resulting piecewise-linear approximation.
+     * @param subdivisionBuffer1 The first buffer containing the current subdivision state.
+     * @param subdivisionBuffer2 The second buffer containing the current subdivision state.
+     * @param count The number of control points in the original array.
+     */
+    static bezierApproximate(controlPoints, output, subdivisionBuffer1, subdivisionBuffer2, count) {
+        const l = subdivisionBuffer2;
+        const r = subdivisionBuffer1;
+        this.bezierSubdivide(controlPoints, l, r, subdivisionBuffer1, count);
+        for (let i = 0; i < count - 1; ++i) {
+            l[count + i] = r[i + 1];
+        }
+        output.push(controlPoints[0]);
+        for (let i = 1; i < count - 1; ++i) {
+            const index = 2 * i;
+            const p = l[index - 1]
+                .add(l[index].scale(2))
+                .add(l[index + 1])
+                .scale(0.25);
+            output.push(p);
+        }
     }
-    get isOsuRelevant() {
-        return this.isRelevant;
+    /**
+     * Subdivides `n` control points representing a bezier curve into 2 sets of `n` control points, each
+     * describing a bezier curve equivalent to a half of the original curve. Effectively this splits
+     * the original curve into 2 curves which result in the original curve when pieced back together.
+     *
+     * @param controlPoints The anchor points of the slider.
+     * @param l Parts of the slider for approximation.
+     * @param r Parts of the slider for approximation.
+     * @param subdivisionBuffer Parts of the slider for approximation.
+     * @param count The amount of anchor points in the slider.
+     */
+    static bezierSubdivide(controlPoints, l, r, subdivisionBuffer, count) {
+        const midpoints = subdivisionBuffer;
+        for (let i = 0; i < count; ++i) {
+            midpoints[i] = controlPoints[i];
+        }
+        for (let i = 0; i < count; ++i) {
+            l[i] = midpoints[0];
+            r[count - i - 1] = midpoints[count - i - 1];
+            for (let j = 0; j < count - i - 1; ++j) {
+                midpoints[j] = midpoints[j].add(midpoints[j + 1]).divide(2);
+            }
+        }
     }
-    get osuScoreMultiplier() {
-        return 1.12;
+    /**
+     * Finds a point on the spline at the position of a parameter.
+     *
+     * @param vec1 The first vector.
+     * @param vec2 The second vector.
+     * @param vec3 The third vector.
+     * @param vec4 The fourth vector.
+     * @param t The parameter at which to find the point on the spline, in the range [0, 1].
+     */
+    static catmullFindPoint(vec1, vec2, vec3, vec4, t) {
+        const t2 = Math.pow(t, 2);
+        const t3 = Math.pow(t, 3);
+        return new Vector2(0.5 *
+            (2 * vec2.x +
+                (-vec1.x + vec3.x) * t +
+                (2 * vec1.x - 5 * vec2.x + 4 * vec3.x - vec4.x) * t2 +
+                (-vec1.x + 3 * vec2.x - 3 * vec3.x + vec4.x) * t3), 0.5 *
+            (2 * vec2.y +
+                (-vec1.y + vec3.y) * t +
+                (2 * vec1.y - 5 * vec2.y + 4 * vec3.y - vec4.y) * t2 +
+                (-vec1.y + 3 * vec2.y - 3 * vec3.y + vec4.y) * t3));
     }
 }
-
-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);
+PathApproximator.bezierTolerance = 0.25;
 /**
- * The center of the playfield, which is at (256, 192).
+ * The amount of pieces to calculate for each control point quadruplet.
  */
-Playfield.center = _a$1.baseSize.scale(0.5);
+PathApproximator.catmullDetail = 50;
+PathApproximator.circularArcTolerance = 0.1;
 
 /**
- * Represents a spinner in a beatmap.
- *
- * All we need from spinners is their duration. The
- * position of a spinner is always at 256x192.
- */
-class Spinner extends HitObject {
-    get endTime() {
-        return this._endTime;
-    }
+ * Represents a slider's path.
+ */
+class SliderPath {
     constructor(values) {
-        super(Object.assign(Object.assign({}, values), { position: Playfield.baseSize.divide(2) }));
-        this._endTime = values.endTime;
+        /**
+         * Whether or not the instance has been initialized.
+         */
+        this.isInitialized = false;
+        /**
+         * The calculated path of the slider.
+         */
+        this.calculatedPath = [];
+        /**
+         * The cumulative length of the slider.
+         */
+        this.cumulativeLength = [];
+        this.pathType = values.pathType;
+        this.controlPoints = values.controlPoints;
+        this.expectedDistance = values.expectedDistance;
+        this.ensureInitialized();
     }
-    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)))));
+    /**
+     * Initializes the instance.
+     */
+    ensureInitialized() {
+        if (this.isInitialized) {
+            return;
+        }
+        this.isInitialized = true;
+        this.calculatedPath.length = 0;
+        this.cumulativeLength.length = 0;
+        this.calculatePath();
+        this.calculateCumulativeLength();
     }
-    get stackedPosition() {
-        return this.position;
+    /**
+     * Calculates the slider's path.
+     */
+    calculatePath() {
+        this.calculatedPath.length = 0;
+        let spanStart = 0;
+        for (let i = 0; i < this.controlPoints.length; i++) {
+            if (i === this.controlPoints.length - 1 ||
+                this.controlPoints[i].equals(this.controlPoints[i + 1])) {
+                const spanEnd = i + 1;
+                const cpSpan = this.controlPoints.slice(spanStart, spanEnd);
+                this.calculateSubPath(cpSpan).forEach((t) => {
+                    if (this.calculatedPath.length === 0 ||
+                        !this.calculatedPath.at(-1).equals(t)) {
+                        this.calculatedPath.push(t);
+                    }
+                });
+                spanStart = spanEnd;
+            }
+        }
     }
-    get stackedEndPosition() {
-        return this.position;
+    /**
+     * Calculates the slider's subpath.
+     */
+    calculateSubPath(subControlPoints) {
+        switch (this.pathType) {
+            case exports.PathType.Linear:
+                return PathApproximator.approximateLinear(subControlPoints);
+            case exports.PathType.PerfectCurve: {
+                if (subControlPoints.length !== 3) {
+                    break;
+                }
+                const subPath = PathApproximator.approximateCircularArc(subControlPoints);
+                // If for some reason a circular arc could not be fit to the 3 given points, fall back to a numerically stable Bézier approximation.
+                if (subPath.length === 0) {
+                    break;
+                }
+                return subPath;
+            }
+            case exports.PathType.Catmull:
+                return PathApproximator.approximateCatmull(subControlPoints);
+        }
+        return PathApproximator.approximateBezier(subControlPoints);
     }
-    createHitWindow() {
-        return new EmptyHitWindow();
+    /**
+     * Calculates the slider's cumulative length.
+     */
+    calculateCumulativeLength() {
+        let calculatedLength = 0;
+        this.cumulativeLength.length = 0;
+        this.cumulativeLength.push(0);
+        for (let i = 0; i < this.calculatedPath.length - 1; ++i) {
+            const diff = this.calculatedPath[i + 1].subtract(this.calculatedPath[i]);
+            calculatedLength += diff.length;
+            this.cumulativeLength.push(calculatedLength);
+        }
+        if (calculatedLength !== this.expectedDistance) {
+            // In osu-stable, if the last two path points of a slider are equal, extension is not performed.
+            if (this.calculatedPath.length >= 2 &&
+                this.calculatedPath
+                    .at(-1)
+                    .equals(this.calculatedPath.at(-2)) &&
+                this.expectedDistance > calculatedLength) {
+                this.cumulativeLength.push(calculatedLength);
+                return;
+            }
+            // The last length is always incorrect
+            this.cumulativeLength.pop();
+            let pathEndIndex = this.calculatedPath.length - 1;
+            if (calculatedLength > this.expectedDistance) {
+                // The path will be shortened further, in which case we should trim any more unnecessary lengths and their associated path segments
+                while (this.cumulativeLength.length > 0 &&
+                    this.cumulativeLength.at(-1) >= this.expectedDistance) {
+                    this.cumulativeLength.pop();
+                    this.calculatedPath.splice(pathEndIndex--, 1);
+                }
+            }
+            if (pathEndIndex <= 0) {
+                // The expected distance is negative or zero
+                this.cumulativeLength.push(0);
+                return;
+            }
+            // The direction of the segment to shorten or lengthen
+            const dir = this.calculatedPath[pathEndIndex].subtract(this.calculatedPath[pathEndIndex - 1]);
+            dir.normalize();
+            this.calculatedPath[pathEndIndex] = this.calculatedPath[pathEndIndex - 1].add(dir.scale(this.expectedDistance - this.cumulativeLength.at(-1)));
+            this.cumulativeLength.push(this.expectedDistance);
+        }
     }
-    toString() {
-        return `Position: [${this._position.x}, ${this._position.y}], duration: ${this.duration}`;
+    /**
+     * Computes the position on the slider at a given progress that ranges from 0 (beginning of the path)
+     * to 1 (end of the path).
+     *
+     * @param progress Ranges from 0 (beginning of the path) to 1 (end of the path).
+     */
+    positionAt(progress) {
+        this.ensureInitialized();
+        const d = this.progressToDistance(progress);
+        return this.interpolateVerticles(this.indexOfDistance(d), d);
     }
-}
-Spinner.baseSpinnerSpinSample = new BankHitSampleInfo("spinnerspin");
-Spinner.baseSpinnerBonusSample = new BankHitSampleInfo("spinnerbonus");
-
-/**
- * Represents a four-dimensional vector.
- */
-class Vector4 {
-    constructor(xOrValueOrXZ, yOrYW, z, w) {
-        if (yOrYW === undefined) {
-            this.x = xOrValueOrXZ;
-            this.y = xOrValueOrXZ;
-            this.z = xOrValueOrXZ;
-            this.w = xOrValueOrXZ;
-            return;
+    /**
+     * 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;
         }
-        if (typeof z === "undefined") {
-            this.x = xOrValueOrXZ;
-            this.y = yOrYW;
-            this.z = xOrValueOrXZ;
-            this.w = yOrYW;
-            return;
+        path.push(this.interpolateVerticles(i, d0));
+        while (i < this.calculatedPath.length &&
+            this.cumulativeLength[i] <= d1) {
+            path.push(this.calculatedPath[i++]);
         }
-        this.x = xOrValueOrXZ;
-        this.y = yOrYW;
-        this.z = z;
-        this.w = w;
+        path.push(this.interpolateVerticles(i, d1));
+        return path;
     }
     /**
-     * The X coordinate of the left edge of this vector.
+     * Returns the progress of reaching expected distance.
      */
-    get left() {
-        return this.x;
+    progressToDistance(progress) {
+        return Math.min(Math.max(progress, 0), 1) * this.expectedDistance;
+    }
+    /**
+     * Interpolates verticles of the slider.
+     */
+    interpolateVerticles(i, d) {
+        if (this.calculatedPath.length === 0) {
+            return new Vector2(0);
+        }
+        if (i <= 0) {
+            return this.calculatedPath[0];
+        }
+        if (i >= this.calculatedPath.length) {
+            return this.calculatedPath.at(-1);
+        }
+        const p0 = this.calculatedPath[i - 1];
+        const p1 = this.calculatedPath[i];
+        const d0 = this.cumulativeLength[i - 1];
+        const d1 = this.cumulativeLength[i];
+        // Avoid division by and almost-zero number in case two points are extremely close to each other.
+        if (Precision.almostEqualsNumber(d0, d1)) {
+            return p0;
+        }
+        const w = (d - d0) / (d1 - d0);
+        return p0.add(p1.subtract(p0).scale(w));
+    }
+    /**
+     * Binary searches the cumulative length array and returns the
+     * index at which `arr[index] >= d`.
+     *
+     * @param d The distance to search.
+     * @returns The index.
+     */
+    indexOfDistance(d) {
+        if (this.cumulativeLength.length === 0 ||
+            d < this.cumulativeLength[0]) {
+            return 0;
+        }
+        if (d >= this.cumulativeLength.at(-1)) {
+            return this.cumulativeLength.length;
+        }
+        let l = 0;
+        let r = this.cumulativeLength.length - 2;
+        while (l <= r) {
+            const pivot = l + ((r - l) >> 1);
+            if (this.cumulativeLength[pivot] < d) {
+                l = pivot + 1;
+            }
+            else if (this.cumulativeLength[pivot] > d) {
+                r = pivot - 1;
+            }
+            else {
+                return pivot;
+            }
+        }
+        return l;
     }
+}
+
+var _a;
+/**
+ * Utilities for {@link HitObject} generation.
+ */
+class HitObjectGenerationUtils {
+    //#region Rotation
     /**
-     * The Y coordinate of the top edge of this vector.
+     * 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}.
      */
-    get top() {
-        return this.y;
+    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));
     }
     /**
-     * The X coordinate of the right edge of this vector.
+     * 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}.
      */
-    get right() {
-        return this.z;
+    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));
     }
     /**
-     * The Y coordinate of the bottom edge of this vector.
+     * 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.
      */
-    get bottom() {
-        return this.w;
+    static getSliderRotation(slider) {
+        const pathEndPosition = slider.path.positionAt(1);
+        return Math.atan2(pathEndPosition.y, pathEndPosition.x);
     }
     /**
-     * The top left corner of this vector.
+     * 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}.
      */
-    get topLeft() {
-        return new Vector2(this.left, this.top);
+    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
     /**
-     * The top right corner of this vector.
+     * Reflects the position of a {@link HitObject} horizontally along the playfield.
+     *
+     * @param hitObject The {@link HitObject} to reflect.
      */
-    get topRight() {
-        return new Vector2(this.right, this.top);
+    static reflectHorizontallyAlongPlayfield(hitObject) {
+        hitObject.position = this.reflectVectorHorizontallyAlongPlayfield(hitObject.position);
+        if (hitObject instanceof Slider) {
+            this.modifySlider(hitObject, (v) => new Vector2(-v.x, v.y));
+        }
     }
     /**
-     * The bottom left corner of this vector.
+     * Reflects the position of a {@link HitObject} vertically along the playfield.
+     *
+     * @param hitObject The {@link HitObject} to reflect.
      */
-    get bottomLeft() {
-        return new Vector2(this.left, this.bottom);
+    static reflectVerticallyAlongPlayfield(hitObject) {
+        // Reflect the position of the hit object.
+        hitObject.position = this.reflectVectorVerticallyAlongPlayfield(hitObject.position);
+        if (hitObject instanceof Slider) {
+            this.modifySlider(hitObject, (v) => new Vector2(v.x, -v.y));
+        }
     }
     /**
-     * The bottom right corner of this vector.
+     * Flips the position of a {@link Slider} around its start position horizontally.
+     *
+     * @param slider The {@link Slider} to be flipped.
      */
-    get bottomRight() {
-        return new Vector2(this.right, this.bottom);
+    static flipSliderInPlaceHorizontally(slider) {
+        this.modifySlider(slider, (v) => new Vector2(-v.x, v.y));
     }
     /**
-     * The width of the rectangle defined by this vector.
+     * 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.
      */
-    get width() {
-        return this.right - this.left;
+    static rotateSlider(slider, rotation) {
+        this.modifySlider(slider, (v) => this.rotateVector(v, rotation));
     }
-    /**
-     * The height of the rectangle defined by this vector.
-     */
-    get height() {
-        return this.bottom - this.top;
+    static modifySlider(slider, modifyControlPoint) {
+        slider.path = new SliderPath({
+            pathType: slider.path.pathType,
+            controlPoints: slider.path.controlPoints.map(modifyControlPoint),
+            expectedDistance: slider.path.expectedDistance,
+        });
     }
-}
-
-/**
- * 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;
+    static reflectVectorHorizontallyAlongPlayfield(vector) {
+        return new Vector2(Playfield.baseSize.x - vector.x, vector.y);
     }
-}
-
-/**
- * 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;
+    static reflectVectorVerticallyAlongPlayfield(vector) {
+        return new Vector2(vector.x, Playfield.baseSize.y - vector.y);
     }
+    //#endregion
+    //#region Reposition
     /**
-     * Checks if two vectors are equal with a given tolerance.
+     * Generates a list of {@link HitObjectPositionInfo}s containing information for how the given list of
+     * {@link HitObject}s are positioned.
      *
-     * @param vec1 The first vector.
-     * @param vec2 The second vector.
-     * @param acceptableDifference The acceptable difference as threshold. Default is `Precision.FLOAT_EPSILON = 1e-3`.
+     * @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 almostEqualsVector(vec1, vec2, acceptableDifference = this.FLOAT_EPSILON) {
-        return (this.almostEqualsNumber(vec1.x, vec2.x, acceptableDifference) &&
-            this.almostEqualsNumber(vec1.y, vec2.y, acceptableDifference));
+    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;
     }
-    /**
-     * 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);
+    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);
     }
     /**
-     * Compares two numbers and determines if they are equal within the specified maximum error.
+     * Determines whether a {@link HitObject} is on a beat.
      *
-     * @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.
-     * @returns Whether both numbers are almost equal up to the specified maximum error.
+     * @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 almostEqualNormRelative(a, b, diff, maximumError) {
-        // If A or B are infinity (positive or negative) then
-        // only return true if they are exactly equal to each other -
-        // that is, if they are both infinities of the same sign.
-        if (!Number.isFinite(a) || !Number.isFinite(b)) {
-            return a === b;
-        }
-        // If A or B are a NAN, return false. NANs are equal to nothing,
-        // not even themselves.
-        if (Number.isNaN(a) || Number.isNaN(b)) {
-            return false;
-        }
-        // If one is almost zero, fall back to absolute equality.
-        const doublePrecision = Math.pow(2, -53);
-        if (Math.abs(a) < doublePrecision || Math.abs(b) < doublePrecision) {
-            return Math.abs(diff) < maximumError;
-        }
-        if ((a === 0 && Math.abs(b) < maximumError) ||
-            (b === 0 && Math.abs(a) < maximumError)) {
-            return true;
+    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;
         }
-        return (Math.abs(diff) < maximumError * Math.max(Math.abs(a), Math.abs(b)));
+        // Ensure within 1ms of expected location.
+        return Math.abs(timeSinceTimingPoint + 1) % beatLength < 2;
     }
-}
-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.
- */
-class PathApproximator {
     /**
-     * Approximates a bezier slider's path.
-     *
-     * Creates a piecewise-linear approximation of a bezier curve by adaptively repeatedly subdividing
-     * the control points until their approximation error vanishes below a given threshold.
+     * Generates a random number from a Normal distribution using the Box-Muller transform.
      *
-     * @param controlPoints The anchor points of the slider.
+     * @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 approximateBezier(controlPoints) {
-        const output = [];
-        const count = controlPoints.length - 1;
-        if (count < 0) {
-            return output;
-        }
-        const subdivisionBuffer1 = new Array(count + 1);
-        const subdivisionBuffer2 = new Array(count * 2 + 1);
-        // "toFlatten" contains all the curves which are not yet approximated well enough.
-        // We use a stack to emulate recursion without the risk of running into a stack overflow.
-        // (More specifically, we iteratively and adaptively refine our curve with a
-        // depth-first search (https://en.wikipedia.org/wiki/Depth-first_search)
-        // over the tree resulting from the subdivisions we make.)
-        const toFlatten = [controlPoints.slice()];
-        const freeBuffers = [];
-        const leftChild = subdivisionBuffer2;
-        while (toFlatten.length > 0) {
-            const parent = toFlatten.pop();
-            if (this.bezierIsFlatEnough(parent)) {
-                // If the control points we currently operate on are sufficiently "flat", we use
-                // an extension to De Casteljau's algorithm to obtain a piecewise-linear approximation
-                // of the bezier curve represented by our control points, consisting of the same amount
-                // of points as there are control points.
-                this.bezierApproximate(parent, output, subdivisionBuffer1, subdivisionBuffer2, count + 1);
-                freeBuffers.push(parent);
-                continue;
-            }
-            // If we do not yet have a sufficiently "flat" (in other words, detailed) approximation we keep
-            // subdividing the curve we are currently operating on.
-            const rightChild = freeBuffers.length > 0
-                ? freeBuffers.pop()
-                : new Array(count + 1);
-            this.bezierSubdivide(parent, leftChild, rightChild, subdivisionBuffer1, count + 1);
-            // We re-use the buffer of the parent for one of the children, so that we save one allocation per iteration.
-            for (let i = 0; i < count + 1; ++i) {
-                parent[i] = leftChild[i];
-            }
-            toFlatten.push(rightChild);
-            toFlatten.push(parent);
-        }
-        output.push(controlPoints[count]);
-        return output;
+    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;
     }
     /**
-     * Approximates a catmull slider's path.
+     * 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.
      *
-     * Creates a piecewise-linear approximation of a Catmull-Rom spline.
+     * 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 controlPoints The anchor points of the slider.
+     * @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 approximateCatmull(controlPoints) {
-        const result = [];
-        for (let i = 0; i < controlPoints.length - 1; ++i) {
-            const v1 = i > 0 ? controlPoints[i - 1] : controlPoints[i];
-            const v2 = controlPoints[i];
-            const v3 = controlPoints[i + 1];
-            const v4 = i < controlPoints.length - 2
-                ? controlPoints[i + 2]
-                : v3.add(v3).subtract(v2);
-            for (let c = 0; c < this.catmullDetail; ++c) {
-                result.push(this.catmullFindPoint(v1, v2, v3, v4, c / this.catmullDetail));
-                result.push(this.catmullFindPoint(v1, v2, v3, v4, (c + 1) / this.catmullDetail));
-            }
+    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);
         }
-        return result;
+        // 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);
     }
     /**
-     * Approximates a slider's circular arc.
-     *
-     * Creates a piecewise-linear approximation of a circular arc curve.
+     * Computes the modified position of a {@link HitObject} while attempting to keep it inside the playfield.
      *
-     * @param controlPoints The anchor points of the slider.
+     * @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 approximateCircularArc(controlPoints) {
-        const a = controlPoints[0];
-        const b = controlPoints[1];
-        const c = controlPoints[2];
-        // If we have a degenerate triangle where a side-length is almost zero, then give up and fall
-        // back to a more numerically stable method.
-        if (Precision.almostEqualsNumber(0, (b.y - a.y) * (c.x - a.x) - (b.x - a.x) * (c.y - a.y))) {
-            return this.approximateBezier(controlPoints);
-        }
-        // See: https://en.wikipedia.org/wiki/Circumscribed_circle#Cartesian_coordinates_2
-        const d = 2 *
-            (a.x * b.subtract(c).y +
-                b.x * c.subtract(a).y +
-                c.x * a.subtract(b).y);
-        const aSq = Math.pow(a.length, 2);
-        const bSq = Math.pow(b.length, 2);
-        const cSq = Math.pow(c.length, 2);
-        const center = new Vector2(aSq * b.subtract(c).y +
-            bSq * c.subtract(a).y +
-            cSq * a.subtract(b).y, aSq * c.subtract(b).x +
-            bSq * a.subtract(c).x +
-            cSq * b.subtract(a).x).divide(d);
-        const dA = a.subtract(center);
-        const dC = c.subtract(center);
-        const r = dA.length;
-        const thetaStart = Math.atan2(dA.y, dA.x);
-        let thetaEnd = Math.atan2(dC.y, dC.x);
-        while (thetaEnd < thetaStart) {
-            thetaEnd += 2 * Math.PI;
+    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 dir = 1;
-        let thetaRange = thetaEnd - thetaStart;
-        // Decide in which direction to draw the circle, depending on which side of
-        // AC B lies.
-        let orthoAtoC = c.subtract(a);
-        orthoAtoC = new Vector2(orthoAtoC.y, -orthoAtoC.x);
-        if (orthoAtoC.dot(b.subtract(a)) < 0) {
-            dir = -dir;
-            thetaRange = 2 * Math.PI - thetaRange;
+        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;
         }
-        // We select the amount of points for the approximation by requiring the discrete curvature
-        // to be smaller than the provided tolerance. The exact angle required to meet the tolerance
-        // is: 2 * Math.Acos(1 - TOLERANCE / r)
-        // The special case is required for extremely short sliders where the radius is smaller than
-        // the tolerance. This is a pathological rather than a realistic case.
-        const amountPoints = 2 * r <= this.circularArcTolerance
-            ? 2
-            : Math.max(2, Math.ceil(thetaRange /
-                (2 *
-                    Math.acos(1 - this.circularArcTolerance / r))));
-        const output = [];
-        for (let i = 0; i < amountPoints; ++i) {
-            const fract = i / (amountPoints - 1);
-            const theta = thetaStart + dir * fract * thetaRange;
-            const o = new Vector2(Math.cos(theta), Math.sin(theta)).scale(r);
-            output.push(center.add(o));
+        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);
         }
-        return output;
     }
     /**
-     * Approximates a linear slider's path.
+     * Moves the modified position of a {@link Circle} so that it fits inside the playfield.
      *
-     * Creates a piecewise-linear approximation of a linear curve.
-     * Basically, returns the input.
+     * @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 controlPoints The anchor points of the slider.
+     * @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 approximateLinear(controlPoints) {
-        return controlPoints;
+    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);
     }
     /**
-     * Checks if a bezier slider is flat enough to be approximated.
+     * Clamps a {@link Vector2} into the playfield, keeping a specified distance from the edge of the playfield.
      *
-     * Make sure the 2nd order derivative (approximated using finite elements) is within tolerable bounds.
+     * @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.
      *
-     * NOTE: The 2nd order derivative of a 2D curve represents its curvature, so intuitively this function
-     * checks (as the name suggests) whether our approximation is _locally_ "flat". More curvy parts
-     * need to have a denser approximation to be more "flat".
+     * The first item in the list is shifted by the largest amount, while the last item is shifted by the
+     * smallest amount.
      *
-     * @param controlPoints The anchor points of the slider.
+     * @param hitObjects The list of {@link HitObject}s to be shifted.
+     * @param shift The amount to shift the {@link HitObject}s by.
      */
-    static bezierIsFlatEnough(controlPoints) {
-        for (let i = 1; i < controlPoints.length - 1; ++i) {
-            const prev = controlPoints[i - 1];
-            const current = controlPoints[i];
-            const next = controlPoints[i + 1];
-            const final = prev.subtract(current.scale(2)).add(next);
-            if (Math.pow(final.length, 2) >
-                Math.pow(this.bezierTolerance, 2) * 4) {
-                return false;
-            }
+    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);
         }
-        return true;
     }
     /**
-     * Approximates a bezier slider's path.
-     *
-     * This uses {@link https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm De Casteljau's algorithm} to obtain an optimal
-     * piecewise-linear approximation of the bezier curve with the same amount of points as there are control points.
+     * Estimates the center of mass of a {@link Slider} relative to its start position.
      *
-     * @param controlPoints The control points describing the bezier curve to be approximated.
-     * @param output The points representing the resulting piecewise-linear approximation.
-     * @param subdivisionBuffer1 The first buffer containing the current subdivision state.
-     * @param subdivisionBuffer2 The second buffer containing the current subdivision state.
-     * @param count The number of control points in the original array.
+     * @param slider The {@link Slider} whose center mass is to be estimated.
+     * @return The estimated center of mass of `slider`.
      */
-    static bezierApproximate(controlPoints, output, subdivisionBuffer1, subdivisionBuffer2, count) {
-        const l = subdivisionBuffer2;
-        const r = subdivisionBuffer1;
-        this.bezierSubdivide(controlPoints, l, r, subdivisionBuffer1, count);
-        for (let i = 0; i < count - 1; ++i) {
-            l[count + i] = r[i + 1];
+    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);
         }
-        output.push(controlPoints[0]);
-        for (let i = 1; i < count - 1; ++i) {
-            const index = 2 * i;
-            const p = l[index - 1]
-                .add(l[index].scale(2))
-                .add(l[index + 1])
-                .scale(0.25);
-            output.push(p);
+        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);
     }
     /**
-     * Subdivides `n` control points representing a bezier curve into 2 sets of `n` control points, each
-     * describing a bezier curve equivalent to a half of the original curve. Effectively this splits
-     * the original curve into 2 curves which result in the original curve when pieced back together.
+     * Calculates the absolute difference between two angles in radians.
      *
-     * @param controlPoints The anchor points of the slider.
-     * @param l Parts of the slider for approximation.
-     * @param r Parts of the slider for approximation.
-     * @param subdivisionBuffer Parts of the slider for approximation.
-     * @param count The amount of anchor points in the slider.
+     * @param angle1 The first angle.
+     * @param angle2 The second angle.
+     * @return THe absolute difference within interval `[0, Math.PI]`.
      */
-    static bezierSubdivide(controlPoints, l, r, subdivisionBuffer, count) {
-        const midpoints = subdivisionBuffer;
-        for (let i = 0; i < count; ++i) {
-            midpoints[i] = controlPoints[i];
+    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;
+    }
+}
+
+/**
+ * Represents the Mirror mod.
+ */
+class ModMirror extends Mod {
+    constructor() {
+        super();
+        this.name = "Mirror";
+        this.acronym = "MR";
+        this.droidRanked = false;
+        this.osuRanked = false;
+        /**
+         * The axes to reflect the `HitObject`s along.
+         */
+        this.flippedAxes = new ModSetting("Flipped axes", "The axes to reflect the hit objects along.", exports.Axes.x);
+        this.incompatibleMods.add(ModHardRock);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1;
+    }
+    copySettings(mod) {
+        var _a;
+        super.copySettings(mod);
+        switch ((_a = mod.settings) === null || _a === void 0 ? void 0 : _a.flippedAxes) {
+            case 0:
+                this.flippedAxes.value = exports.Axes.x;
+                break;
+            case 1:
+                this.flippedAxes.value = exports.Axes.y;
+                break;
+            case 2:
+                this.flippedAxes.value = exports.Axes.both;
+                break;
         }
-        for (let i = 0; i < count; ++i) {
-            l[i] = midpoints[0];
-            r[count - i - 1] = midpoints[count - i - 1];
-            for (let j = 0; j < count - i - 1; ++j) {
-                midpoints[j] = midpoints[j].add(midpoints[j + 1]).divide(2);
-            }
+    }
+    applyToHitObject(_, hitObject) {
+        switch (this.flippedAxes.value) {
+            case exports.Axes.x:
+                HitObjectGenerationUtils.reflectHorizontallyAlongPlayfield(hitObject);
+                break;
+            case exports.Axes.y:
+                HitObjectGenerationUtils.reflectVerticallyAlongPlayfield(hitObject);
+                break;
+            case exports.Axes.both:
+                HitObjectGenerationUtils.reflectHorizontallyAlongPlayfield(hitObject);
+                HitObjectGenerationUtils.reflectVerticallyAlongPlayfield(hitObject);
+                break;
+        }
+    }
+    serializeSettings() {
+        return { flippedAxes: this.flippedAxes.value - 1 };
+    }
+    toString() {
+        const settings = [];
+        if (this.flippedAxes.value === exports.Axes.x ||
+            this.flippedAxes.value === exports.Axes.both) {
+            settings.push("↔");
         }
-    }
-    /**
-     * Finds a point on the spline at the position of a parameter.
-     *
-     * @param vec1 The first vector.
-     * @param vec2 The second vector.
-     * @param vec3 The third vector.
-     * @param vec4 The fourth vector.
-     * @param t The parameter at which to find the point on the spline, in the range [0, 1].
-     */
-    static catmullFindPoint(vec1, vec2, vec3, vec4, t) {
-        const t2 = Math.pow(t, 2);
-        const t3 = Math.pow(t, 3);
-        return new Vector2(0.5 *
-            (2 * vec2.x +
-                (-vec1.x + vec3.x) * t +
-                (2 * vec1.x - 5 * vec2.x + 4 * vec3.x - vec4.x) * t2 +
-                (-vec1.x + 3 * vec2.x - 3 * vec3.x + vec4.x) * t3), 0.5 *
-            (2 * vec2.y +
-                (-vec1.y + vec3.y) * t +
-                (2 * vec1.y - 5 * vec2.y + 4 * vec3.y - vec4.y) * t2 +
-                (-vec1.y + 3 * vec2.y - 3 * vec3.y + vec4.y) * t3));
+        if (this.flippedAxes.value === exports.Axes.y ||
+            this.flippedAxes.value === exports.Axes.both) {
+            settings.push("↕");
+        }
+        return `${super.toString()} (${settings.join(", ")})`;
     }
 }
-PathApproximator.bezierTolerance = 0.25;
-/**
- * The amount of pieces to calculate for each control point quadruplet.
- */
-PathApproximator.catmullDetail = 50;
-PathApproximator.circularArcTolerance = 0.1;
 
 /**
- * Represents a slider's path.
+ * 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 SliderPath {
-    constructor(values) {
-        /**
-         * Whether or not the instance has been initialized.
-         */
-        this.isInitialized = false;
-        /**
-         * The calculated path of the slider.
-         */
-        this.calculatedPath = [];
-        /**
-         * The cumulative length of the slider.
-         */
-        this.cumulativeLength = [];
-        this.pathType = values.pathType;
-        this.controlPoints = values.controlPoints;
-        this.expectedDistance = values.expectedDistance;
-        this.ensureInitialized();
+class ModReplayV6 extends Mod {
+    constructor() {
+        super(...arguments);
+        this.name = "Replay V6";
+        this.acronym = "RV6";
+        this.userPlayable = false;
+        this.droidRanked = false;
+        this.facilitateAdjustment = true;
     }
-    /**
-     * Initializes the instance.
-     */
-    ensureInitialized() {
-        if (this.isInitialized) {
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1;
+    }
+    applyToBeatmap(beatmap) {
+        const { objects } = beatmap.hitObjects;
+        if (objects.length === 0) {
             return;
         }
-        this.isInitialized = true;
-        this.calculatedPath.length = 0;
-        this.cumulativeLength.length = 0;
-        this.calculatePath();
-        this.calculateCumulativeLength();
-    }
-    /**
-     * Calculates the slider's path.
-     */
-    calculatePath() {
-        this.calculatedPath.length = 0;
-        let spanStart = 0;
-        for (let i = 0; i < this.controlPoints.length; i++) {
-            if (i === this.controlPoints.length - 1 ||
-                this.controlPoints[i].equals(this.controlPoints[i + 1])) {
-                const spanEnd = i + 1;
-                const cpSpan = this.controlPoints.slice(spanStart, spanEnd);
-                this.calculateSubPath(cpSpan).forEach((t) => {
-                    if (this.calculatedPath.length === 0 ||
-                        !this.calculatedPath.at(-1).equals(t)) {
-                        this.calculatedPath.push(t);
-                    }
-                });
-                spanStart = spanEnd;
+        // 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;
             }
         }
     }
-    /**
-     * Calculates the slider's subpath.
-     */
-    calculateSubPath(subControlPoints) {
-        switch (this.pathType) {
-            case exports.PathType.Linear:
-                return PathApproximator.approximateLinear(subControlPoints);
-            case exports.PathType.PerfectCurve: {
-                if (subControlPoints.length !== 3) {
-                    break;
-                }
-                const subPath = PathApproximator.approximateCircularArc(subControlPoints);
-                // If for some reason a circular arc could not be fit to the 3 given points, fall back to a numerically stable Bézier approximation.
-                if (subPath.length === 0) {
-                    break;
-                }
-                return subPath;
-            }
-            case exports.PathType.Catmull:
-                return PathApproximator.approximateCatmull(subControlPoints);
-        }
-        return PathApproximator.approximateBezier(subControlPoints);
+    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);
+        hitObject.stackOffsetMultiplier = 4;
     }
-    /**
-     * Calculates the slider's cumulative length.
-     */
-    calculateCumulativeLength() {
-        let calculatedLength = 0;
-        this.cumulativeLength.length = 0;
-        this.cumulativeLength.push(0);
-        for (let i = 0; i < this.calculatedPath.length - 1; ++i) {
-            const diff = this.calculatedPath[i + 1].subtract(this.calculatedPath[i]);
-            calculatedLength += diff.length;
-            this.cumulativeLength.push(calculatedLength);
-        }
-        if (calculatedLength !== this.expectedDistance) {
-            // In osu-stable, if the last two path points of a slider are equal, extension is not performed.
-            if (this.calculatedPath.length >= 2 &&
-                this.calculatedPath
-                    .at(-1)
-                    .equals(this.calculatedPath.at(-2)) &&
-                this.expectedDistance > calculatedLength) {
-                this.cumulativeLength.push(calculatedLength);
-                return;
-            }
-            // The last length is always incorrect
-            this.cumulativeLength.pop();
-            let pathEndIndex = this.calculatedPath.length - 1;
-            if (calculatedLength > this.expectedDistance) {
-                // The path will be shortened further, in which case we should trim any more unnecessary lengths and their associated path segments
-                while (this.cumulativeLength.length > 0 &&
-                    this.cumulativeLength.at(-1) >= this.expectedDistance) {
-                    this.cumulativeLength.pop();
-                    this.calculatedPath.splice(pathEndIndex--, 1);
-                }
-            }
-            if (pathEndIndex <= 0) {
-                // The expected distance is negative or zero
-                this.cumulativeLength.push(0);
-                return;
-            }
-            // The direction of the segment to shorten or lengthen
-            const dir = this.calculatedPath[pathEndIndex].subtract(this.calculatedPath[pathEndIndex - 1]);
-            dir.normalize();
-            this.calculatedPath[pathEndIndex] = this.calculatedPath[pathEndIndex - 1].add(dir.scale(this.expectedDistance - this.cumulativeLength.at(-1)));
-            this.cumulativeLength.push(this.expectedDistance);
-        }
+}
+
+/**
+ * Represents the HardRock mod.
+ */
+class ModHardRock extends Mod {
+    constructor() {
+        super();
+        this.acronym = "HR";
+        this.name = "HardRock";
+        this.droidRanked = true;
+        this.osuRanked = true;
+        this.bitwise = 1 << 4;
+        this.incompatibleMods.add(ModEasy);
+        this.incompatibleMods.add(ModMirror);
     }
-    /**
-     * Computes the position on the slider at a given progress that ranges from 0 (beginning of the path)
-     * to 1 (end of the path).
-     *
-     * @param progress Ranges from 0 (beginning of the path) to 1 (end of the path).
-     */
-    positionAt(progress) {
-        this.ensureInitialized();
-        const d = this.progressToDistance(progress);
-        return this.interpolateVerticles(this.indexOfDistance(d), d);
+    get isDroidRelevant() {
+        return true;
     }
-    /**
-     * 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;
+    calculateDroidScoreMultiplier() {
+        return 1.06;
     }
-    /**
-     * Returns the progress of reaching expected distance.
-     */
-    progressToDistance(progress) {
-        return Math.min(Math.max(progress, 0), 1) * this.expectedDistance;
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1.06;
     }
-    /**
-     * Interpolates verticles of the slider.
-     */
-    interpolateVerticles(i, d) {
-        if (this.calculatedPath.length === 0) {
-            return new Vector2(0);
-        }
-        if (i <= 0) {
-            return this.calculatedPath[0];
-        }
-        if (i >= this.calculatedPath.length) {
-            return this.calculatedPath.at(-1);
+    applyToDifficulty(mode, difficulty, adjustmentMods) {
+        if (mode === exports.Modes.osu || !adjustmentMods.has(ModReplayV6)) {
+            difficulty.cs = this.applySetting(difficulty.cs, 1.3);
         }
-        const p0 = this.calculatedPath[i - 1];
-        const p1 = this.calculatedPath[i];
-        const d0 = this.cumulativeLength[i - 1];
-        const d1 = this.cumulativeLength[i];
-        // Avoid division by and almost-zero number in case two points are extremely close to each other.
-        if (Precision.almostEqualsNumber(d0, d1)) {
-            return p0;
+        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));
         }
-        const w = (d - d0) / (d1 - d0);
-        return p0.add(p1.subtract(p0).scale(w));
+        difficulty.ar = this.applySetting(difficulty.ar);
+        difficulty.od = this.applySetting(difficulty.od);
+        difficulty.hp = this.applySetting(difficulty.hp);
     }
-    /**
-     * Binary searches the cumulative length array and returns the
-     * index at which `arr[index] >= d`.
-     *
-     * @param d The distance to search.
-     * @returns The index.
-     */
-    indexOfDistance(d) {
-        if (this.cumulativeLength.length === 0 ||
-            d < this.cumulativeLength[0]) {
-            return 0;
-        }
-        if (d >= this.cumulativeLength.at(-1)) {
-            return this.cumulativeLength.length;
-        }
-        let l = 0;
-        let r = this.cumulativeLength.length - 2;
-        while (l <= r) {
-            const pivot = l + ((r - l) >> 1);
-            if (this.cumulativeLength[pivot] < d) {
-                l = pivot + 1;
-            }
-            else if (this.cumulativeLength[pivot] > d) {
-                r = pivot - 1;
-            }
-            else {
-                return pivot;
-            }
+    applyToHitObject(_, hitObject) {
+        HitObjectGenerationUtils.reflectVerticallyAlongPlayfield(hitObject);
+    }
+    isCompatibleWith(other) {
+        if (other instanceof ModDifficultyAdjust) {
+            return (other.cs.value === null ||
+                other.ar.value === null ||
+                other.od.value === null ||
+                other.hp.value === null);
         }
-        return l;
+        return super.isCompatibleWith(other);
+    }
+    applySetting(value, ratio = 1.4) {
+        return Math.min(value * ratio, 10);
     }
 }
 
-var _a;
 /**
- * Utilities for {@link HitObject} generation.
+ * Represents the Easy mod.
  */
-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));
+class ModEasy extends Mod {
+    constructor() {
+        super();
+        this.acronym = "EZ";
+        this.name = "Easy";
+        this.droidRanked = true;
+        this.osuRanked = true;
+        this.bitwise = 1 << 1;
+        this.incompatibleMods.add(ModHardRock);
     }
-    /**
-     * 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;
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 0.5;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 0.5;
+    }
+    applyToDifficulty(mode, difficulty, adjustmentMods) {
+        if (mode === exports.Modes.osu || !adjustmentMods.has(ModReplayV6)) {
+            difficulty.cs /= 2;
         }
-        while (diff > Math.PI) {
-            diff -= 2 * Math.PI;
+        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));
         }
-        const finalAngle = initialAngle + diff * rotationRatio;
-        return new Vector2(initial.x * Math.cos(finalAngle), initial.y * Math.sin(finalAngle));
+        difficulty.ar /= 2;
+        difficulty.od /= 2;
+        difficulty.hp /= 2;
     }
-    /**
-     * 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);
+    isCompatibleWith(other) {
+        if (other instanceof ModDifficultyAdjust) {
+            return (other.cs.value === null ||
+                other.ar.value === null ||
+                other.od.value === null ||
+                other.hp.value === null);
+        }
+        return super.isCompatibleWith(other);
     }
-    /**
-     * 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));
+}
+
+/**
+ * Represents the ReallyEasy mod.
+ */
+class ModReallyEasy extends Mod {
+    constructor() {
+        super(...arguments);
+        this.acronym = "RE";
+        this.name = "Really Easy";
+        this.droidRanked = false;
     }
-    //#endregion
-    //#region Reflection
-    /**
-     * Reflects the position of a {@link HitObject} horizontally along the playfield.
-     *
-     * @param hitObject The {@link HitObject} to reflect.
-     */
-    static reflectHorizontallyAlongPlayfield(hitObject) {
-        hitObject.position = this.reflectVectorHorizontallyAlongPlayfield(hitObject.position);
-        if (hitObject instanceof Slider) {
-            this.modifySlider(hitObject, (v) => new Vector2(-v.x, v.y));
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 0.4;
+    }
+    applyToDifficultyWithMods(mode, difficulty, mods) {
+        var _a;
+        if (mode !== exports.Modes.droid) {
+            return;
+        }
+        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.value) !== null && _a !== void 0 ? _a : 1) - 1;
+        }
+        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 (typeof (difficultyAdjust === null || difficultyAdjust === void 0 ? void 0 : difficultyAdjust.od.value) !== "number") {
+            difficulty.od /= 2;
+        }
+        if (typeof (difficultyAdjust === null || difficultyAdjust === void 0 ? void 0 : difficultyAdjust.hp.value) !== "number") {
+            difficulty.hp /= 2;
         }
     }
-    /**
-     * Reflects the position of a {@link HitObject} vertically along the playfield.
-     *
-     * @param hitObject The {@link HitObject} to reflect.
-     */
-    static reflectVerticallyAlongPlayfield(hitObject) {
-        // Reflect the position of the hit object.
-        hitObject.position = this.reflectVectorVerticallyAlongPlayfield(hitObject.position);
-        if (hitObject instanceof Slider) {
-            this.modifySlider(hitObject, (v) => new Vector2(v.x, -v.y));
+    isCompatibleWith(other) {
+        if (other instanceof ModDifficultyAdjust) {
+            return (other.cs.value === null ||
+                other.ar.value === null ||
+                other.od.value === null ||
+                other.hp.value === null);
         }
+        return super.isCompatibleWith(other);
     }
-    /**
-     * 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));
+}
+
+/**
+ * Represents the SmallCircle mod.
+ *
+ * This is a legacy osu!droid mod that may still be exist when parsing replays.
+ */
+class ModSmallCircle extends Mod {
+    constructor() {
+        super(...arguments);
+        this.acronym = "SC";
+        this.name = "SmallCircle";
+        this.droidRanked = false;
     }
-    /**
-     * 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));
+    get isDroidRelevant() {
+        return true;
     }
-    static modifySlider(slider, modifyControlPoint) {
-        slider.path = new SliderPath({
-            pathType: slider.path.pathType,
-            controlPoints: slider.path.controlPoints.map(modifyControlPoint),
-            expectedDistance: slider.path.expectedDistance,
-        });
+    calculateDroidScoreMultiplier() {
+        return 1.06;
     }
-    static reflectVectorHorizontallyAlongPlayfield(vector) {
-        return new Vector2(Playfield.baseSize.x - vector.x, vector.y);
+    migrateDroidMod(difficulty) {
+        return new ModDifficultyAdjust({ cs: difficulty.cs + 4 });
     }
-    static reflectVectorVerticallyAlongPlayfield(vector) {
-        return new Vector2(vector.x, Playfield.baseSize.y - vector.y);
+    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));
+        }
     }
-    //#endregion
-    //#region Reposition
+    isCompatibleWith(other) {
+        if (other instanceof ModDifficultyAdjust) {
+            return other.cs.value === null;
+        }
+        return super.isCompatibleWith(other);
+    }
+}
+
+/**
+ * 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 {
     /**
-     * Generates a list of {@link HitObjectPositionInfo}s containing information for how the given list of
-     * {@link HitObject}s are positioned.
+     * The number of decimal places to round the value to.
      *
-     * @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.
+     * When set to `null`, the value will not be rounded.
      */
-    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);
+    get precision() {
+        return this._precision;
+    }
+    set precision(value) {
+        if (value !== null && value < 0) {
+            throw new RangeError(`The precision (${value}) must be greater than or equal to 0.`);
+        }
+        this._precision = value;
+        if (value !== null) {
+            this.value = this.processValue(this.value);
         }
-        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);
+    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 (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);
+            if (this.precision !== null) {
+                return v.toFixed(this.precision);
             }
-            previous = current;
+            return super.toDisplayString();
+        };
+        if (min > max) {
+            throw new RangeError(`The minimum value (${min}) must be less than or equal to the maximum value (${max}).`);
         }
-        return workingObjects.map((w) => w.hitObject);
+        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;
     }
-    /**
-     * 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;
+    processValue(value) {
+        if (value === null) {
+            return null;
         }
-        // Ensure within 1ms of expected location.
-        return Math.abs(timeSinceTimingPoint + 1) % beatLength < 2;
+        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;
     }
-    /**
-     * 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;
+}
+
+/**
+ * Represents the Difficulty Adjust mod.
+ */
+class ModDifficultyAdjust extends Mod {
+    get isRelevant() {
+        return (this.cs.value !== null ||
+            this.ar.value !== null ||
+            this.od.value !== null ||
+            this.hp.value !== null);
     }
-    /**
-     * 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);
+    constructor(values) {
+        var _a, _b, _c, _d;
+        super();
+        this.acronym = "DA";
+        this.name = "Difficulty Adjust";
+        this.droidRanked = false;
+        this.osuRanked = false;
+        /**
+         * 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);
+        /**
+         * The health drain rate to enforce.
+         */
+        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, _e, _f, _g, _h;
+        super.copySettings(mod);
+        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);
     }
-    /**
-     * 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;
+    get isDroidRelevant() {
+        return this.isRelevant;
+    }
+    calculateDroidScoreMultiplier(difficulty) {
+        // Graph: https://www.desmos.com/calculator/yrggkhrkzz
+        let multiplier = 1;
+        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));
         }
-        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);
+        if (this.od.value !== null) {
+            const diff = this.od.value - difficulty.od;
+            multiplier *=
+                diff >= 0
+                    ? 1 + 0.005 * Math.pow(diff, 1.3)
+                    : 2 / (1 + Math.exp(-0.25 * diff));
         }
+        return multiplier;
     }
-    /**
-     * 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);
+    get isOsuRelevant() {
+        return this.isRelevant;
     }
-    /**
-     * 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);
+    get osuScoreMultiplier() {
+        return 0.5;
+    }
+    applyToDifficultyWithMods(_, difficulty, mods) {
+        var _a, _b, _c, _d;
+        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 in replay version 6 and older, 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.value !== null && mods.has(ModReplayV6)) {
+            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);
         }
-        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));
+    applyToHitObjectWithMods(_, hitObject, mods) {
+        // Special case for force AR in replay version 6 and older, 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.value === null || !mods.has(ModReplayV6)) {
+            return;
+        }
+        this.applyFadeAdjustment(hitObject, mods);
+        if (hitObject instanceof Slider) {
+            for (const nested of hitObject.nestedHitObjects) {
+                this.applyFadeAdjustment(nested, mods);
+            }
+        }
     }
-    /**
-     * 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);
+    isCompatibleWith(other) {
+        if (this.cs.value !== null && other instanceof ModSmallCircle) {
+            return false;
         }
+        if (this.cs.value !== null &&
+            this.ar.value !== null &&
+            this.od.value !== null &&
+            this.hp.value !== null) {
+            return !(other instanceof ModEasy ||
+                other instanceof ModHardRock ||
+                other instanceof ModReallyEasy);
+        }
+        return super.isCompatibleWith(other);
     }
-    /**
-     * 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);
+    serializeSettings() {
+        if (!this.isRelevant) {
+            return null;
         }
-        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;
+        const settings = {};
+        if (this.cs.value !== null) {
+            settings.cs = this.cs.value;
         }
-        return sum.divide(count);
+        if (this.ar.value !== null) {
+            settings.ar = this.ar.value;
+        }
+        if (this.od.value !== null) {
+            settings.od = this.od.value;
+        }
+        if (this.hp.value !== null) {
+            settings.hp = this.hp.value;
+        }
+        return settings;
     }
-    /**
-     * 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);
+    applyFadeAdjustment(hitObject, mods) {
+        // IMPORTANT: These do not use `ModUtil.calculateRateWithMods` to avoid circular dependency.
+        const initialTrackRate = this.calculateTrackRate(mods.values());
+        const currentTrackRate = this.calculateTrackRate(mods.values(), hitObject.startTime);
+        // Cancel the rate that was initially applied to timePreempt (via applyToDifficulty above and
+        // HitObject.applyDefaults) and apply the current one.
+        hitObject.timePreempt *= currentTrackRate / initialTrackRate;
+        hitObject.timeFadeIn *= currentTrackRate;
     }
-}
-_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;
+    calculateTrackRate(mods, time = 0) {
+        // IMPORTANT: This does not use `ModUtil.calculateRateWithMods` to avoid circular dependency.
+        let rate = 1;
+        for (const mod of mods) {
+            if (mod.isApplicableToTrackRate()) {
+                rate = mod.applyToRate(time, rate);
+            }
+        }
+        return rate;
     }
-    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;
+    toString() {
+        if (!this.isRelevant) {
+            return super.toString();
+        }
+        const settings = [];
+        if (this.cs.value !== null) {
+            settings.push(`CS${this.cs.toDisplayString()}`);
+        }
+        if (this.ar.value !== null) {
+            settings.push(`AR${this.ar.toDisplayString()}`);
+        }
+        if (this.od.value !== null) {
+            settings.push(`OD${this.od.toDisplayString()}`);
+        }
+        if (this.hp.value !== null) {
+            settings.push(`HP${this.hp.toDisplayString()}`);
+        }
+        return `${super.toString()} (${settings.join(", ")})`;
     }
 }
 
 /**
- * Represents the Mirror mod.
+ * Represents the NightCore mod.
  */
-class ModMirror extends Mod {
+class ModNightCore extends ModRateAdjust {
     constructor() {
-        super();
-        this.name = "Mirror";
-        this.acronym = "MR";
-        this.droidRanked = false;
-        this.osuRanked = false;
-        /**
-         * The axes to reflect the `HitObject`s along.
-         */
-        this.flippedAxes = new ModSetting("Flipped axes", "The axes to reflect the hit objects along.", exports.Axes.x);
-        this.incompatibleMods.add(ModHardRock);
+        super(1.5);
+        this.acronym = "NC";
+        this.name = "NightCore";
+        this.droidRanked = true;
+        this.osuRanked = true;
+        this.bitwise = 1 << 9;
+        this.incompatibleMods.add(ModDoubleTime).add(ModHalfTime);
     }
     get isDroidRelevant() {
-        return true;
+        return this.isRelevant;
     }
     calculateDroidScoreMultiplier() {
-        return 1;
+        return this.droidScoreMultiplier;
     }
     get isOsuRelevant() {
-        return true;
+        return this.isRelevant;
     }
     get osuScoreMultiplier() {
-        return 1;
-    }
-    copySettings(mod) {
-        var _a;
-        super.copySettings(mod);
-        switch ((_a = mod.settings) === null || _a === void 0 ? void 0 : _a.flippedAxes) {
-            case 0:
-                this.flippedAxes.value = exports.Axes.x;
-                break;
-            case 1:
-                this.flippedAxes.value = exports.Axes.y;
-                break;
-            case 2:
-                this.flippedAxes.value = exports.Axes.both;
-                break;
-        }
-    }
-    applyToHitObject(_, hitObject) {
-        switch (this.flippedAxes.value) {
-            case exports.Axes.x:
-                HitObjectGenerationUtils.reflectHorizontallyAlongPlayfield(hitObject);
-                break;
-            case exports.Axes.y:
-                HitObjectGenerationUtils.reflectVerticallyAlongPlayfield(hitObject);
-                break;
-            case exports.Axes.both:
-                HitObjectGenerationUtils.reflectHorizontallyAlongPlayfield(hitObject);
-                HitObjectGenerationUtils.reflectVerticallyAlongPlayfield(hitObject);
-                break;
-        }
-    }
-    serializeSettings() {
-        return { flippedAxes: this.flippedAxes.value - 1 };
-    }
-    toString() {
-        const settings = [];
-        if (this.flippedAxes.value === exports.Axes.x ||
-            this.flippedAxes.value === exports.Axes.both) {
-            settings.push("↔");
-        }
-        if (this.flippedAxes.value === exports.Axes.y ||
-            this.flippedAxes.value === exports.Axes.both) {
-            settings.push("↕");
-        }
-        return `${super.toString()} (${settings.join(", ")})`;
+        return 1.12;
     }
 }
 
 /**
- * Represents the HardRock mod.
+ * Represents the HalfTime mod.
  */
-class ModHardRock extends Mod {
+class ModHalfTime extends ModRateAdjust {
     constructor() {
-        super();
-        this.acronym = "HR";
-        this.name = "HardRock";
+        super(0.75);
+        this.acronym = "HT";
+        this.name = "HalfTime";
         this.droidRanked = true;
         this.osuRanked = true;
-        this.bitwise = 1 << 4;
-        this.incompatibleMods.add(ModEasy);
-        this.incompatibleMods.add(ModMirror);
+        this.bitwise = 1 << 8;
+        this.incompatibleMods.add(ModDoubleTime).add(ModNightCore);
     }
     get isDroidRelevant() {
-        return true;
+        return this.isRelevant;
     }
     calculateDroidScoreMultiplier() {
-        return 1.06;
+        return this.droidScoreMultiplier;
     }
     get isOsuRelevant() {
-        return true;
+        return this.isRelevant;
     }
     get osuScoreMultiplier() {
-        return 1.06;
-    }
-    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);
-        difficulty.hp = this.applySetting(difficulty.hp);
-    }
-    applyToHitObject(_, hitObject) {
-        HitObjectGenerationUtils.reflectVerticallyAlongPlayfield(hitObject);
-    }
-    applySetting(value, ratio = 1.4) {
-        return Math.min(value * ratio, 10);
+        return 0.3;
     }
 }
 
 /**
- * Represents the Easy mod.
+ * Represents the DoubleTime mod.
  */
-class ModEasy extends Mod {
+class ModDoubleTime extends ModRateAdjust {
     constructor() {
-        super();
-        this.acronym = "EZ";
-        this.name = "Easy";
+        super(1.5);
+        this.acronym = "DT";
+        this.name = "DoubleTime";
         this.droidRanked = true;
         this.osuRanked = true;
-        this.bitwise = 1 << 1;
-        this.incompatibleMods.add(ModHardRock);
+        this.bitwise = 1 << 6;
+        this.incompatibleMods.add(ModHalfTime).add(ModNightCore);
     }
     get isDroidRelevant() {
-        return true;
+        return this.isRelevant;
     }
     calculateDroidScoreMultiplier() {
-        return 0.5;
+        return this.droidScoreMultiplier;
     }
     get isOsuRelevant() {
-        return true;
+        return this.isRelevant;
     }
     get osuScoreMultiplier() {
-        return 0.5;
-    }
-    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;
-        difficulty.hp /= 2;
+        return 1.12;
     }
 }
 
@@ -4594,8 +4756,8 @@ class ModMuted extends Mod {
          * Hit sounds are also muted alongside the track.
          */
         this.affectsHitSounds = new BooleanModSetting("Mute hit sounds", "Hit sounds are also muted alongside the track.", true);
-        this.inverseMuting.bindValueChanged((_, newValue) => {
-            this.muteComboCount.min = newValue ? 1 : 0;
+        this.inverseMuting.bindValueChanged((value) => {
+            this.muteComboCount.min = value.newValue ? 1 : 0;
         }, true);
     }
     /**
@@ -5049,57 +5211,6 @@ class ModRandom extends Mod {
 }
 ModRandom.playfieldDiagonal = Playfield.baseSize.length;
 
-/**
- * Represents the ReallyEasy mod.
- */
-class ModReallyEasy extends Mod {
-    constructor() {
-        super(...arguments);
-        this.acronym = "RE";
-        this.name = "ReallyEasy";
-        this.droidRanked = false;
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 0.4;
-    }
-    applyToDifficultyWithMods(mode, difficulty, mods) {
-        var _a;
-        if (mode !== exports.Modes.droid) {
-            return;
-        }
-        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.value) !== null && _a !== void 0 ? _a : 1) - 1;
-        }
-        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 (typeof (difficultyAdjust === null || difficultyAdjust === void 0 ? void 0 : difficultyAdjust.od.value) !== "number") {
-            difficulty.od /= 2;
-        }
-        if (typeof (difficultyAdjust === null || difficultyAdjust === void 0 ? void 0 : difficultyAdjust.hp.value) !== "number") {
-            difficulty.hp /= 2;
-        }
-    }
-}
-
 /**
  * Represents the ScoreV2 mod.
  */
@@ -5126,38 +5237,6 @@ class ModScoreV2 extends Mod {
     }
 }
 
-/**
- * Represents the SmallCircle mod.
- *
- * This is a legacy osu!droid mod that may still be exist when parsing replays.
- */
-class ModSmallCircle extends Mod {
-    constructor() {
-        super(...arguments);
-        this.acronym = "SC";
-        this.name = "SmallCircle";
-        this.droidRanked = false;
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 1.06;
-    }
-    migrateDroidMod(difficulty) {
-        return new ModDifficultyAdjust({ cs: difficulty.cs + 4 });
-    }
-    applyToDifficulty(mode, difficulty, 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));
-        }
-    }
-}
-
 /**
  * Represents the SpunOut mod.
  */
@@ -5453,14 +5532,14 @@ class ModWindDown extends ModTimeRamp {
         this.osuRanked = false;
         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.initialRate.bindValueChanged((value) => {
+            if (value.newValue <= this.finalRate.value) {
+                this.finalRate.value = value.newValue - this.finalRate.step;
             }
         });
-        this.finalRate.bindValueChanged((_, value) => {
-            if (value >= this.initialRate.value) {
-                this.initialRate.value = value + this.initialRate.step;
+        this.finalRate.bindValueChanged((value) => {
+            if (value.newValue >= this.initialRate.value) {
+                this.initialRate.value = value.newValue + this.initialRate.step;
             }
         });
     }
@@ -5490,14 +5569,14 @@ class ModWindUp extends ModTimeRamp {
         this.osuRanked = false;
         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.initialRate.bindValueChanged((value) => {
+            if (value.newValue >= this.finalRate.value) {
+                this.finalRate.value = value.newValue + this.finalRate.step;
             }
         });
-        this.finalRate.bindValueChanged((_, value) => {
-            if (value <= this.initialRate.value) {
-                this.initialRate.value = value - this.initialRate.step;
+        this.finalRate.bindValueChanged((value) => {
+            if (value.newValue <= this.initialRate.value) {
+                this.initialRate.value = value.newValue - this.initialRate.step;
             }
         });
     }
@@ -5777,15 +5856,17 @@ class ModMap extends Map {
         return this.size === 0;
     }
     constructor(iterable) {
+        // We are not passing `iterable` here to preserve mod-specific settings.
+        super();
         if (Array.isArray(iterable)) {
             for (const [key, value] of iterable) {
                 // Ensure the mod type corresponds to the mod instance.
                 if (key !== value.constructor) {
                     throw new TypeError(`Key ${key.name} does not match value ${value.constructor.name}`);
                 }
+                this.set(value);
             }
         }
-        super(iterable);
     }
     has(keyOrValue) {
         const key = keyOrValue instanceof Mod
@@ -5804,27 +5885,11 @@ class ModMap extends Map {
             throw new TypeError(`Key ${key.name} does not match value ${value.constructor.name}`);
         }
         const existing = this.get(key);
-        // If all difficulty statistics are set, all other difficulty adjusting mods are irrelevant, so we remove them.
-        // This prevents potential abuse cases where score multipliers from non-affecting mods stack (i.e., forcing
-        // all difficulty statistics while using the Hard Rock mod).
-        const removeDifficultyAdjustmentMods = value instanceof ModDifficultyAdjust &&
-            value.cs !== undefined &&
-            value.ar !== undefined &&
-            value.od !== undefined &&
-            value.hp !== undefined;
-        if (removeDifficultyAdjustmentMods) {
-            this.delete(ModEasy);
-            this.delete(ModHardRock);
-            this.delete(ModReallyEasy);
-            this.delete(ModSmallCircle);
-        }
         // Check if there are any mods that are incompatible with the new mod.
         // If so, remove them.
-        for (const incompatibleMod of value.incompatibleMods) {
-            for (const mod of this.values()) {
-                if (mod instanceof incompatibleMod) {
-                    this.delete(mod.constructor);
-                }
+        for (const mod of this.values()) {
+            if (!value.isCompatibleWith(mod)) {
+                this.delete(mod.constructor);
             }
         }
         super.set(key, value);
@@ -6329,7 +6394,10 @@ class PlayableBeatmap {
         this.hitObjects = baseBeatmap.hitObjects;
         this.maxCombo = baseBeatmap.maxCombo;
         this.mods = mods;
-        this.speedMultiplier = ModUtil.calculateRateWithMods(this.mods.values());
+        this.speedMultiplier = ModUtil.calculateRateWithMods(this.mods.values(), Number.POSITIVE_INFINITY);
+    }
+    getOffsetTime(time) {
+        return time + (this.formatVersion < 5 ? 24 : 0);
     }
 }
 
@@ -7079,13 +7147,6 @@ class Beatmap {
             .sort((a, b) => b.duration - a.duration)[0];
         return (_e = mostCommon === null || mostCommon === void 0 ? void 0 : mostCommon.beatLength) !== null && _e !== void 0 ? _e : 0;
     }
-    /**
-     * Returns a time combined with beatmap-wide time offset.
-     *
-     * BeatmapVersion 4 and lower had an incorrect offset. Stable has this set as 24ms off.
-     *
-     * @param time The time.
-     */
     getOffsetTime(time) {
         return time + (this.formatVersion < 5 ? 24 : 0);
     }