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

package/dist/index.js

@@ -1040,6 +1040,35 @@ class HitObject {
     set scale(value) {
         this._scale = value;
     }
+    /**
+     * The multiplier for the stack offset of this hitobject.
+     *
+     * This determines how much hitobjects are stacked - and to which direction.
+     */
+    get stackOffsetMultiplier() {
+        return this._stackOffsetMultiplier;
+    }
+    set stackOffsetMultiplier(value) {
+        this._stackOffsetMultiplier = value;
+    }
+    /**
+     * The stack offset vector of this hitobject.
+     */
+    get stackOffset() {
+        return new Vector2(this.stackHeight * this.scale * this.stackOffsetMultiplier);
+    }
+    /**
+     * The stacked position of this hitobject.
+     */
+    get stackedPosition() {
+        return this.evaluateStackedPosition(this.position);
+    }
+    /**
+     * The stacked end position of this hitobject.
+     */
+    get stackedEndPosition() {
+        return this.evaluateStackedPosition(this.endPosition);
+    }
     /**
      * The hitobject type (circle, slider, or spinner).
      */
@@ -1089,6 +1118,7 @@ class HitObject {
         this.hitWindow = null;
         this._stackHeight = 0;
         this._scale = 1;
+        this._stackOffsetMultiplier = 0;
         /**
          * The time at which the approach circle of this hitobject should appear before this hitobject starts.
          */
@@ -1127,9 +1157,11 @@ class HitObject {
         switch (mode) {
             case exports.Modes.droid:
                 this.scale = CircleSizeCalculator.droidCSToDroidScale(difficulty.cs);
+                this.stackOffsetMultiplier = -4;
                 break;
             case exports.Modes.osu:
                 this.scale = CircleSizeCalculator.standardCSToStandardScale(difficulty.cs, true);
+                this.stackOffsetMultiplier = -6.4;
                 break;
         }
     }
@@ -1164,35 +1196,6 @@ class HitObject {
             }
         }
     }
-    /**
-     * Evaluates the stack offset vector of the hitobject.
-     *
-     * This is used to calculate offset for stacked positions.
-     *
-     * @param mode The gamemode to evaluate for.
-     * @returns The stack offset with respect to the gamemode.
-     */
-    getStackOffset(mode) {
-        return new Vector2(this.stackHeight * this.scale * (mode === exports.Modes.droid ? -4 : -6.4));
-    }
-    /**
-     * Evaluates the stacked position of the hitobject.
-     *
-     * @param mode The gamemode to evaluate for.
-     * @returns The stacked position with respect to the gamemode.
-     */
-    getStackedPosition(mode) {
-        return this.evaluateStackedPosition(this.position, mode);
-    }
-    /**
-     * Evaluates the stacked end position of the hitobject.
-     *
-     * @param mode The gamemode to evaluate for.
-     * @returns The stacked end position with respect to the gamemode.
-     */
-    getStackedEndPosition(mode) {
-        return this.evaluateStackedPosition(this.endPosition, mode);
-    }
     /**
      * Creates a hit sample info based on the sample setting of the first `BankHitSampleInfo.HIT_NORMAL` sample in the `samples` array.
      * If no sample is available, sane default settings will be used instead.
@@ -1232,14 +1235,13 @@ class HitObject {
      * Evaluates the stacked position of the specified position.
      *
      * @param position The position to evaluate.
-     * @param mode The gamemode to evaluate for.
      * @returns The stacked position.
      */
-    evaluateStackedPosition(position, mode) {
-        if (this.type & exports.ObjectTypes.spinner) {
+    evaluateStackedPosition(position) {
+        if ((this.type & exports.ObjectTypes.spinner) > 0 || this.stackHeight === 0) {
             return position;
         }
-        return position.add(this.getStackOffset(mode));
+        return position.add(this.stackOffset);
     }
 }
 /**
@@ -1263,10 +1265,64 @@ HitObject.preemptMin = 450;
  */
 HitObject.controlPointLeniency = 1;
 
+/**
+ * Types of easing.
+ *
+ * See {@link http://easings.net/ this} page for more samples.
+ */
+exports.Easing = void 0;
+(function (Easing) {
+    Easing[Easing["none"] = 0] = "none";
+    Easing[Easing["out"] = 1] = "out";
+    Easing[Easing["in"] = 2] = "in";
+    Easing[Easing["inQuad"] = 3] = "inQuad";
+    Easing[Easing["outQuad"] = 4] = "outQuad";
+    Easing[Easing["inOutQuad"] = 5] = "inOutQuad";
+    Easing[Easing["inCubic"] = 6] = "inCubic";
+    Easing[Easing["outCubic"] = 7] = "outCubic";
+    Easing[Easing["inOutCubic"] = 8] = "inOutCubic";
+    Easing[Easing["inQuart"] = 9] = "inQuart";
+    Easing[Easing["outQuart"] = 10] = "outQuart";
+    Easing[Easing["inOutQuart"] = 11] = "inOutQuart";
+    Easing[Easing["inQuint"] = 12] = "inQuint";
+    Easing[Easing["outQuint"] = 13] = "outQuint";
+    Easing[Easing["inOutQuint"] = 14] = "inOutQuint";
+    Easing[Easing["inSine"] = 15] = "inSine";
+    Easing[Easing["outSine"] = 16] = "outSine";
+    Easing[Easing["inOutSine"] = 17] = "inOutSine";
+    Easing[Easing["inExpo"] = 18] = "inExpo";
+    Easing[Easing["outExpo"] = 19] = "outExpo";
+    Easing[Easing["inOutExpo"] = 20] = "inOutExpo";
+    Easing[Easing["inCirc"] = 21] = "inCirc";
+    Easing[Easing["outCirc"] = 22] = "outCirc";
+    Easing[Easing["inOutCirc"] = 23] = "inOutCirc";
+    Easing[Easing["inElastic"] = 24] = "inElastic";
+    Easing[Easing["outElastic"] = 25] = "outElastic";
+    Easing[Easing["outElasticHalf"] = 26] = "outElasticHalf";
+    Easing[Easing["outElasticQuarter"] = 27] = "outElasticQuarter";
+    Easing[Easing["inOutElastic"] = 28] = "inOutElastic";
+    Easing[Easing["inBack"] = 29] = "inBack";
+    Easing[Easing["outBack"] = 30] = "outBack";
+    Easing[Easing["inOutBack"] = 31] = "inOutBack";
+    Easing[Easing["inBounce"] = 32] = "inBounce";
+    Easing[Easing["outBounce"] = 33] = "outBounce";
+    Easing[Easing["inOutBounce"] = 34] = "inOutBounce";
+    Easing[Easing["outPow10"] = 35] = "outPow10";
+})(exports.Easing || (exports.Easing = {}));
+
 /**
  * Represents a `Mod` specific setting.
  */
 class ModSetting {
+    /**
+     * The default value of this `ModSetting`.
+     */
+    get defaultValue() {
+        return this._value;
+    }
+    set defaultValue(value) {
+        this._defaultValue = value;
+    }
     /**
      * The value of this `ModSetting`.
      */
@@ -1296,7 +1352,7 @@ class ModSetting {
         this.valueChangedListeners = new Set();
         this.name = name;
         this.description = description;
-        this.defaultValue = defaultValue;
+        this._defaultValue = defaultValue;
         this._value = defaultValue;
     }
     /**
@@ -1344,19 +1400,29 @@ class Mod {
          * `Mod`s that are incompatible with this `Mod`.
          */
         this.incompatibleMods = new Set();
+        this.settingsBacking = null;
     }
     /**
      * `ModSetting`s that are specific to this `Mod`.
      */
     get settings() {
-        const settings = [];
+        if (this.settingsBacking !== null) {
+            return this.settingsBacking;
+        }
+        this.settingsBacking = [];
         for (const prop in this) {
             const value = this[prop];
             if (value instanceof ModSetting) {
-                settings.push(value);
+                this.settingsBacking.push(value);
             }
         }
-        return settings;
+        return this.settingsBacking;
+    }
+    /**
+     * Whether all `ModSetting`s of this `Mod` are set to their default values.
+     */
+    get usesDefaultSettings() {
+        return this.settings.every((s) => s.isDefault);
     }
     /**
      * Serializes this `Mod` to a `SerializedMod`.
@@ -1464,7 +1530,27 @@ class Mod {
      * @returns `true` if the object is the same `Mod`, `false` otherwise.
      */
     equals(other) {
-        return this === other || this.acronym === other.acronym;
+        if (this === other) {
+            return true;
+        }
+        if (this.acronym !== other.acronym) {
+            return false;
+        }
+        const settings = this.settings;
+        const otherSettings = other.settings;
+        if (settings.length !== otherSettings.length) {
+            return false;
+        }
+        for (const setting of settings) {
+            const otherSetting = otherSettings.find((s) => s.name === setting.name);
+            if (!otherSetting) {
+                return false;
+            }
+            if (setting.value !== otherSetting.value) {
+                return false;
+            }
+        }
+        return true;
     }
     /**
      * Returns the string representation of this `Mod`.
@@ -1475,329 +1561,105 @@ class Mod {
 }
 
 /**
- * Represents the Relax mod.
+ * Represents a hitobject that can be nested within a slider.
  */
-class ModRelax extends Mod {
-    constructor() {
-        super();
-        this.acronym = "RX";
-        this.name = "Relax";
-        this.droidRanked = false;
-        this.osuRanked = false;
-        this.bitwise = 1 << 7;
-        this.incompatibleMods.add(ModAuto).add(ModAutopilot);
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 0.001;
+class SliderNestedHitObject extends HitObject {
+    constructor(values) {
+        super(values);
+        this.spanIndex = values.spanIndex;
+        this.spanStartTime = values.spanStartTime;
     }
-    get isOsuRelevant() {
-        return true;
+    toString() {
+        return `Position: [${this._position.x}, ${this._position.y}], span index: ${this.spanIndex}, span start time: ${this.spanStartTime}`;
     }
-    get osuScoreMultiplier() {
-        return 0;
+}
+
+/**
+ * Represents the head of a slider.
+ */
+class SliderHead extends SliderNestedHitObject {
+    constructor(values) {
+        super(Object.assign(Object.assign({}, values), { spanIndex: 0, spanStartTime: values.startTime }));
     }
 }
 
 /**
- * Represents the Autopilot mod.
+ * An empty `HitWindow` that does not have any hit windows.
+ *
+ * No time values are provided (meaning instantaneous hit or miss).
  */
-class ModAutopilot extends Mod {
+class EmptyHitWindow extends HitWindow {
     constructor() {
-        super();
-        this.acronym = "AP";
-        this.name = "Autopilot";
-        this.droidRanked = false;
-        this.osuRanked = false;
-        this.bitwise = 1 << 13;
-        this.incompatibleMods.add(ModRelax).add(ModAuto);
-    }
-    get isDroidRelevant() {
-        return true;
+        super(0);
     }
-    calculateDroidScoreMultiplier() {
-        return 0.001;
+    get greatWindow() {
+        return 0;
     }
-    get isOsuRelevant() {
-        return true;
+    get okWindow() {
+        return 0;
     }
-    get osuScoreMultiplier() {
+    get mehWindow() {
         return 0;
     }
 }
 
 /**
- * Represents the Auto mod.
+ * Represents a nested hit object that is at the end of a slider path (either repeat or tail).
  */
-class ModAuto extends Mod {
-    constructor() {
-        super();
-        this.acronym = "AT";
-        this.name = "Autoplay";
-        this.droidRanked = false;
-        this.osuRanked = false;
-        this.bitwise = 1 << 11;
-        this.incompatibleMods.add(ModAutopilot).add(ModRelax);
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 1;
+class SliderEndCircle extends SliderNestedHitObject {
+    constructor(values) {
+        super(values);
+        this.sliderSpanDuration = values.sliderSpanDuration;
+        this.sliderStartTime = values.sliderStartTime;
     }
-    get isOsuRelevant() {
-        return true;
+    applyDefaults(controlPoints, difficulty, mode) {
+        super.applyDefaults(controlPoints, difficulty, mode);
+        if (this.spanIndex > 0) {
+            // Repeat points after the first span should appear behind the still-visible one.
+            this.timeFadeIn = 0;
+            // The next end circle should appear exactly after the previous circle (on the same end) is hit.
+            this.timePreempt = this.sliderSpanDuration * 2;
+        }
+        else {
+            // The first end circle should fade in with the slider.
+            this.timePreempt += this.startTime - this.sliderStartTime;
+        }
     }
-    get osuScoreMultiplier() {
-        return 1;
+    createHitWindow() {
+        return new EmptyHitWindow();
     }
 }
 
 /**
- * Represents a `Mod` specific setting that is constrained to a range of values.
+ * Represents a slider repeat.
  */
-class RangeConstrainedModSetting extends ModSetting {
-    get value() {
-        return super.value;
-    }
-    set value(value) {
-        super.value = this.processValue(value);
-    }
-    constructor(name, description, defaultValue, min, max, step) {
-        super(name, description, defaultValue);
-        this.min = min;
-        this.max = max;
-        this.step = step;
-    }
+class SliderRepeat extends SliderEndCircle {
 }
 
 /**
- * Represents a `Mod` specific setting that is constrained to a number of values.
+ * Represents a slider tick in a slider.
  */
-class NumberModSetting extends RangeConstrainedModSetting {
-    constructor(name, description, defaultValue, min, max, step) {
-        super(name, description, defaultValue, min, max, step);
-        this.displayFormatter = (v) => v.toString();
-        if (min > max) {
-            throw new RangeError(`The minimum value (${min}) must be less than or equal to the maximum value (${max}).`);
-        }
-        if (step < 0) {
-            throw new RangeError(`The step size (${step}) must be greater than or equal to 0.`);
+class SliderTick extends SliderNestedHitObject {
+    applyDefaults(controlPoints, difficulty, mode) {
+        super.applyDefaults(controlPoints, difficulty, mode);
+        let offset;
+        if (this.spanIndex > 0) {
+            // Adding 200 to include the offset stable used.
+            // This is so on repeats ticks don't appear too late to be visually processed by the player.
+            offset = 200;
         }
-        if (defaultValue < min || defaultValue > max) {
-            throw new RangeError(`The default value (${defaultValue}) must be between the minimum (${min}) and maximum (${max}) values.`);
+        else {
+            offset = this.timePreempt * 0.66;
         }
+        this.timePreempt = (this.startTime - this.spanStartTime) / 2 + offset;
     }
-    processValue(value) {
-        return MathUtils.clamp(Math.round(value / this.step) * this.step, this.min, this.max);
+    createHitWindow() {
+        return new EmptyHitWindow();
     }
 }
 
 /**
- * Represents a `Mod` specific setting that is constrained to a range of decimal values.
- */
-class DecimalModSetting extends NumberModSetting {
-    constructor(name, description, defaultValue, min = -Number.MAX_VALUE, max = Number.MAX_VALUE, step = 0, precision = null) {
-        super(name, description, defaultValue, min, max, step);
-        this.displayFormatter = (v) => {
-            if (this.precision !== null) {
-                return v.toFixed(this.precision);
-            }
-            return super.toDisplayString();
-        };
-        if (precision !== null && precision < 0) {
-            throw new RangeError(`The precision (${precision}) must be greater than or equal to 0.`);
-        }
-        this.precision = precision;
-    }
-    processValue(value) {
-        const processedValue = super.processValue(value);
-        if (this.precision !== null) {
-            return parseFloat(processedValue.toFixed(this.precision));
-        }
-        return processedValue;
-    }
-}
-
-/**
- * Represents a `Mod` that adjusts the playback rate of a track.
- */
-class ModRateAdjust extends Mod {
-    /**
-     * The generic osu!droid score multiplier of this `Mod`.
-     */
-    get droidScoreMultiplier() {
-        return this.trackRateMultiplier.value >= 1
-            ? 1 + (this.trackRateMultiplier.value - 1) * 0.24
-            : Math.pow(0.3, (1 - this.trackRateMultiplier.value) * 4);
-    }
-    /**
-     * Generic getter to determine if this `ModRateAdjust` is relevant.
-     */
-    get isRelevant() {
-        return this.trackRateMultiplier.value !== 1;
-    }
-    constructor(trackRateMultiplier = 1) {
-        super();
-        this.trackRateMultiplier = new DecimalModSetting("Track rate multiplier", "The multiplier for the track's playback rate after applying this mod.", trackRateMultiplier, 0.5, 2, 0.05, 2);
-    }
-    applyToRate(_, rate) {
-        return rate * this.trackRateMultiplier.value;
-    }
-    equals(other) {
-        return (super.equals(other) &&
-            other instanceof ModRateAdjust &&
-            this.trackRateMultiplier.value === other.trackRateMultiplier.value);
-    }
-}
-
-/**
- * Represents the Custom Speed mod.
- *
- * This is a replacement `Mod` for speed modify in osu!droid and custom rates in osu!lazer.
- */
-class ModCustomSpeed extends ModRateAdjust {
-    constructor() {
-        super(...arguments);
-        this.acronym = "CS";
-        this.name = "Custom Speed";
-        this.droidRanked = true;
-        this.osuRanked = false;
-    }
-    copySettings(mod) {
-        var _a, _b;
-        super.copySettings(mod);
-        this.trackRateMultiplier.value =
-            (_b = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.rateMultiplier) !== null && _b !== void 0 ? _b : this.trackRateMultiplier.value;
-    }
-    get isDroidRelevant() {
-        return this.isRelevant;
-    }
-    calculateDroidScoreMultiplier() {
-        return this.droidScoreMultiplier;
-    }
-    get isOsuRelevant() {
-        return this.isRelevant;
-    }
-    get osuScoreMultiplier() {
-        // Round to the nearest multiple of 0.1.
-        let value = Math.trunc(this.trackRateMultiplier.value * 10) / 10;
-        // Offset back to 0.
-        --value;
-        return this.trackRateMultiplier.value >= 1
-            ? 1 + value / 5
-            : 0.6 + value;
-    }
-    serializeSettings() {
-        return { rateMultiplier: this.trackRateMultiplier.value };
-    }
-    toString() {
-        return `${super.toString()} (${this.trackRateMultiplier.toDisplayString()}x)`;
-    }
-}
-
-/**
- * Represents a hitobject that can be nested within a slider.
- */
-class SliderNestedHitObject extends HitObject {
-    constructor(values) {
-        super(values);
-        this.spanIndex = values.spanIndex;
-        this.spanStartTime = values.spanStartTime;
-    }
-    toString() {
-        return `Position: [${this._position.x}, ${this._position.y}], span index: ${this.spanIndex}, span start time: ${this.spanStartTime}`;
-    }
-}
-
-/**
- * Represents the head of a slider.
- */
-class SliderHead extends SliderNestedHitObject {
-    constructor(values) {
-        super(Object.assign(Object.assign({}, values), { spanIndex: 0, spanStartTime: values.startTime }));
-    }
-}
-
-/**
- * An empty `HitWindow` that does not have any hit windows.
- *
- * No time values are provided (meaning instantaneous hit or miss).
- */
-class EmptyHitWindow extends HitWindow {
-    constructor() {
-        super(0);
-    }
-    get greatWindow() {
-        return 0;
-    }
-    get okWindow() {
-        return 0;
-    }
-    get mehWindow() {
-        return 0;
-    }
-}
-
-/**
- * Represents a nested hit object that is at the end of a slider path (either repeat or tail).
- */
-class SliderEndCircle extends SliderNestedHitObject {
-    constructor(values) {
-        super(values);
-        this.sliderSpanDuration = values.sliderSpanDuration;
-        this.sliderStartTime = values.sliderStartTime;
-    }
-    applyDefaults(controlPoints, difficulty, mode) {
-        super.applyDefaults(controlPoints, difficulty, mode);
-        if (this.spanIndex > 0) {
-            // Repeat points after the first span should appear behind the still-visible one.
-            this.timeFadeIn = 0;
-            // The next end circle should appear exactly after the previous circle (on the same end) is hit.
-            this.timePreempt = this.sliderSpanDuration * 2;
-        }
-        else {
-            // The first end circle should fade in with the slider.
-            this.timePreempt += this.startTime - this.sliderStartTime;
-        }
-    }
-    createHitWindow() {
-        return new EmptyHitWindow();
-    }
-}
-
-/**
- * Represents a slider repeat.
- */
-class SliderRepeat extends SliderEndCircle {
-}
-
-/**
- * Represents a slider tick in a slider.
- */
-class SliderTick extends SliderNestedHitObject {
-    applyDefaults(controlPoints, difficulty, mode) {
-        super.applyDefaults(controlPoints, difficulty, mode);
-        let offset;
-        if (this.spanIndex > 0) {
-            // Adding 200 to include the offset stable used.
-            // This is so on repeats ticks don't appear too late to be visually processed by the player.
-            offset = 200;
-        }
-        else {
-            offset = this.timePreempt * 0.66;
-        }
-        this.timePreempt = (this.startTime - this.spanStartTime) / 2 + offset;
-    }
-    createHitWindow() {
-        return new EmptyHitWindow();
-    }
-}
-
-/**
- * Represents the tail of a slider.
+ * Represents the tail of a slider.
  */
 class SliderTail extends SliderEndCircle {
 }
@@ -2297,16 +2159,654 @@ class Slider extends HitObject {
                 default:
                     v.samples.push(...sampleList);
             }
-        });
+        });
+    }
+    toString() {
+        return `Position: [${this.position.x}, ${this.position.y}], distance: ${this.path.expectedDistance}, repeat count: ${this.repeatCount}, slider ticks: ${this.nestedHitObjects.filter((v) => v instanceof SliderTick).length}`;
+    }
+}
+Slider.baseNormalSlideSample = new BankHitSampleInfo("sliderslide");
+Slider.baseWhistleSlideSample = new BankHitSampleInfo("sliderwhistle");
+Slider.baseTickSample = new BankHitSampleInfo("slidertick");
+Slider.legacyLastTickOffset = 36;
+
+/**
+ * Represents the Freeze Frame mod.
+ */
+class ModFreezeFrame extends Mod {
+    constructor() {
+        super();
+        this.name = "Freeze Frame";
+        this.acronym = "FR";
+        this.lastNewComboTime = 0;
+        this.incompatibleMods.add(ModApproachDifferent);
+    }
+    get droidRanked() {
+        return false;
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1;
+    }
+    get osuRanked() {
+        return false;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1;
+    }
+    applyToBeatmap(beatmap) {
+        this.lastNewComboTime = 0;
+        for (const hitObject of beatmap.hitObjects) {
+            if (hitObject.isNewCombo) {
+                this.lastNewComboTime = hitObject.startTime;
+            }
+            this.applyFadeInAdjustment(hitObject);
+        }
+    }
+    applyFadeInAdjustment(hitObject) {
+        hitObject.timePreempt += hitObject.startTime - this.lastNewComboTime;
+        if (hitObject instanceof Slider) {
+            // Freezing slider ticks doesn't play well with snaking sliders, and slider repeats will not
+            // layer correctly if its preempt is changed.
+            this.applyFadeInAdjustment(hitObject.head);
+            this.applyFadeInAdjustment(hitObject.tail);
+        }
+    }
+}
+
+/**
+ * Represents the Traceable mod.
+ */
+class ModTraceable extends Mod {
+    constructor() {
+        super();
+        this.acronym = "TC";
+        this.name = "Traceable";
+        this.droidRanked = false;
+        this.osuRanked = false;
+        this.incompatibleMods.add(ModHidden);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1.06;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1;
+    }
+}
+
+/**
+ * Represents a `Mod` specific setting that is constrained to a boolean value.
+ */
+class BooleanModSetting extends ModSetting {
+    constructor() {
+        super(...arguments);
+        this.displayFormatter = (v) => v ? "Enabled" : "Disabled";
+    }
+}
+
+/**
+ * Represents the Hidden mod.
+ */
+class ModHidden extends Mod {
+    get droidRanked() {
+        return this.usesDefaultSettings;
+    }
+    get osuRanked() {
+        return this.usesDefaultSettings;
+    }
+    constructor() {
+        super();
+        this.acronym = "HD";
+        this.name = "Hidden";
+        this.bitwise = 1 << 3;
+        /**
+         * Whether to only fade approach circles.
+         *
+         * The main object body will not fade when enabled.
+         */
+        this.onlyFadeApproachCircles = new BooleanModSetting("Only fade approach circles", "The main object body will not fade when enabled.", false);
+        this.incompatibleMods.add(ModTraceable).add(ModApproachDifferent);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1.06;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1.06;
+    }
+    copySettings(mod) {
+        var _a, _b;
+        super.copySettings(mod);
+        this.onlyFadeApproachCircles.value =
+            (_b = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.onlyFadeApproachCircles) !== null && _b !== void 0 ? _b : this.onlyFadeApproachCircles.value;
+    }
+    applyToBeatmap(beatmap) {
+        const applyFadeInAdjustment = (hitObject) => {
+            hitObject.timeFadeIn =
+                hitObject.timePreempt * ModHidden.fadeInDurationMultiplier;
+            if (hitObject instanceof Slider) {
+                hitObject.nestedHitObjects.forEach(applyFadeInAdjustment);
+            }
+        };
+        beatmap.hitObjects.objects.forEach(applyFadeInAdjustment);
+    }
+    serializeSettings() {
+        return this.onlyFadeApproachCircles.value
+            ? { onlyFadeApproachCircles: this.onlyFadeApproachCircles.value }
+            : null;
+    }
+    toString() {
+        if (!this.onlyFadeApproachCircles.value) {
+            return super.toString();
+        }
+        return `${super.toString()} (approach circles only)`;
+    }
+}
+ModHidden.fadeInDurationMultiplier = 0.4;
+ModHidden.fadeOutDurationMultiplier = 0.3;
+
+/**
+ * Represents a `Mod` specific setting that is constrained to a range of values.
+ */
+class RangeConstrainedModSetting extends ModSetting {
+    /**
+     * The minimum value of this `RangeConstrainedModSetting`.
+     */
+    get min() {
+        return this._min;
+    }
+    set min(value) {
+        this._min = value;
+        this.value = this.processValue(this.value);
+    }
+    /**
+     * The maximum value of this `RangeConstrainedModSetting`.
+     */
+    get max() {
+        return this._max;
+    }
+    set max(value) {
+        this._max = value;
+        this.value = this.processValue(this.value);
+    }
+    /**
+     * The step size of this `RangeConstrainedModSetting`.
+     */
+    get step() {
+        return this._step;
+    }
+    set step(value) {
+        this._step = value;
+        this.value = this.processValue(this.value);
+    }
+    get value() {
+        return super.value;
+    }
+    set value(value) {
+        super.value = this.processValue(value);
+    }
+    constructor(name, description, defaultValue, min, max, step) {
+        super(name, description, defaultValue);
+        this._min = min;
+        this._max = max;
+        this._step = step;
+    }
+}
+
+/**
+ * Represents a `Mod` specific setting that is constrained to a number of values.
+ */
+class NumberModSetting extends RangeConstrainedModSetting {
+    constructor(name, description, defaultValue, min, max, step) {
+        super(name, description, defaultValue, min, max, step);
+        this.displayFormatter = (v) => v.toString();
+        if (min > max) {
+            throw new RangeError(`The minimum value (${min}) must be less than or equal to the maximum value (${max}).`);
+        }
+        if (step < 0) {
+            throw new RangeError(`The step size (${step}) must be greater than or equal to 0.`);
+        }
+        if (defaultValue < min || defaultValue > max) {
+            throw new RangeError(`The default value (${defaultValue}) must be between the minimum (${min}) and maximum (${max}) values.`);
+        }
+    }
+    processValue(value) {
+        return MathUtils.clamp(Math.round(value / this.step) * this.step, this.min, this.max);
+    }
+}
+
+/**
+ * Represents a `Mod` specific setting that is constrained to a range of decimal values.
+ */
+class DecimalModSetting extends NumberModSetting {
+    /**
+     * The number of decimal places to round the value to.
+     *
+     * When set to `null`, the value will not be rounded.
+     */
+    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);
+        }
+    }
+    constructor(name, description, defaultValue, min = -Number.MAX_VALUE, max = Number.MAX_VALUE, step = 0, precision = null) {
+        super(name, description, defaultValue, min, max, step);
+        this.displayFormatter = (v) => {
+            if (this.precision !== null) {
+                return v.toFixed(this.precision);
+            }
+            return super.toDisplayString();
+        };
+        if (precision !== null && precision < 0) {
+            throw new RangeError(`The precision (${precision}) must be greater than or equal to 0.`);
+        }
+        this._precision = precision;
+    }
+    processValue(value) {
+        const processedValue = super.processValue(value);
+        if (this.precision !== null) {
+            return parseFloat(processedValue.toFixed(this.precision));
+        }
+        return processedValue;
+    }
+}
+
+/**
+ * Represents the Approach Different mod.
+ */
+class ModApproachDifferent extends Mod {
+    /**
+     * The {@link Easing} to apply to the approach circle animation.
+     */
+    get easing() {
+        switch (this.style.value) {
+            case exports.AnimationStyle.linear:
+                return exports.Easing.none;
+            case exports.AnimationStyle.gravity:
+                return exports.Easing.inBack;
+            case exports.AnimationStyle.inOut1:
+                return exports.Easing.inOutCubic;
+            case exports.AnimationStyle.inOut2:
+                return exports.Easing.inOutQuint;
+            case exports.AnimationStyle.accelerate1:
+                return exports.Easing.in;
+            case exports.AnimationStyle.accelerate2:
+                return exports.Easing.inCubic;
+            case exports.AnimationStyle.accelerate3:
+                return exports.Easing.inQuint;
+            case exports.AnimationStyle.decelerate1:
+                return exports.Easing.out;
+            case exports.AnimationStyle.decelerate2:
+                return exports.Easing.outCubic;
+            case exports.AnimationStyle.decelerate3:
+                return exports.Easing.outQuint;
+        }
+    }
+    constructor() {
+        super();
+        this.name = "Approach Different";
+        this.acronym = "AD";
+        /**
+         * The initial size of the approach circle, relative to hit circles.
+         */
+        this.scale = new DecimalModSetting("Initial size", "The initial size of the approach circle, relative to hit circles.", 3, 1.5, 10, 0.1, 1);
+        /**
+         * The animation style of the approach circles.
+         */
+        this.style = new ModSetting("Style", "The animation style of the approach circles.", exports.AnimationStyle.gravity);
+        this.incompatibleMods.add(ModHidden).add(ModFreezeFrame);
+    }
+    get droidRanked() {
+        return false;
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1;
+    }
+    get osuRanked() {
+        return false;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1;
+    }
+    copySettings(mod) {
+        super.copySettings(mod);
+        const { settings } = mod;
+        if (typeof (settings === null || settings === void 0 ? void 0 : settings.scale) === "number") {
+            this.scale.value = settings.scale;
+        }
+        if (typeof (settings === null || settings === void 0 ? void 0 : settings.style) === "number") {
+            this.style.value = settings.style;
+        }
+    }
+    serializeSettings() {
+        return {
+            scale: this.scale.value,
+            style: this.style.value,
+        };
+    }
+}
+exports.AnimationStyle = void 0;
+(function (AnimationStyle) {
+    AnimationStyle[AnimationStyle["linear"] = 0] = "linear";
+    AnimationStyle[AnimationStyle["gravity"] = 1] = "gravity";
+    AnimationStyle[AnimationStyle["inOut1"] = 2] = "inOut1";
+    AnimationStyle[AnimationStyle["inOut2"] = 3] = "inOut2";
+    AnimationStyle[AnimationStyle["accelerate1"] = 4] = "accelerate1";
+    AnimationStyle[AnimationStyle["accelerate2"] = 5] = "accelerate2";
+    AnimationStyle[AnimationStyle["accelerate3"] = 6] = "accelerate3";
+    AnimationStyle[AnimationStyle["decelerate1"] = 7] = "decelerate1";
+    AnimationStyle[AnimationStyle["decelerate2"] = 8] = "decelerate2";
+    AnimationStyle[AnimationStyle["decelerate3"] = 9] = "decelerate3";
+})(exports.AnimationStyle || (exports.AnimationStyle = {}));
+
+/**
+ * Represents the Relax mod.
+ */
+class ModRelax extends Mod {
+    constructor() {
+        super();
+        this.acronym = "RX";
+        this.name = "Relax";
+        this.droidRanked = false;
+        this.osuRanked = false;
+        this.bitwise = 1 << 7;
+        this.incompatibleMods.add(ModAuto).add(ModAutopilot);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 0.001;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 0;
+    }
+}
+
+/**
+ * Represents the Autopilot mod.
+ */
+class ModAutopilot extends Mod {
+    constructor() {
+        super();
+        this.acronym = "AP";
+        this.name = "Autopilot";
+        this.droidRanked = false;
+        this.osuRanked = false;
+        this.bitwise = 1 << 13;
+        this.incompatibleMods.add(ModRelax).add(ModAuto);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 0.001;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 0;
+    }
+}
+
+/**
+ * Represents the Auto mod.
+ */
+class ModAuto extends Mod {
+    constructor() {
+        super();
+        this.acronym = "AT";
+        this.name = "Autoplay";
+        this.droidRanked = false;
+        this.osuRanked = false;
+        this.bitwise = 1 << 11;
+        this.incompatibleMods.add(ModAutopilot).add(ModRelax);
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1;
+    }
+}
+
+/**
+ * Represents a `Mod` that adjusts the playback rate of a track.
+ */
+class ModRateAdjust extends Mod {
+    /**
+     * The generic osu!droid score multiplier of this `Mod`.
+     */
+    get droidScoreMultiplier() {
+        return this.trackRateMultiplier.value >= 1
+            ? 1 + (this.trackRateMultiplier.value - 1) * 0.24
+            : Math.pow(0.3, (1 - this.trackRateMultiplier.value) * 4);
+    }
+    /**
+     * Generic getter to determine if this `ModRateAdjust` is relevant.
+     */
+    get isRelevant() {
+        return this.trackRateMultiplier.value !== 1;
+    }
+    constructor(trackRateMultiplier = 1) {
+        super();
+        this.trackRateMultiplier = new DecimalModSetting("Track rate multiplier", "The multiplier for the track's playback rate after applying this mod.", trackRateMultiplier, 0.5, 2, 0.05, 2);
+    }
+    applyToRate(_, rate) {
+        return rate * this.trackRateMultiplier.value;
+    }
+}
+
+/**
+ * Represents the Custom Speed mod.
+ *
+ * This is a replacement `Mod` for speed modify in osu!droid and custom rates in osu!lazer.
+ */
+class ModCustomSpeed extends ModRateAdjust {
+    constructor() {
+        super(...arguments);
+        this.acronym = "CS";
+        this.name = "Custom Speed";
+        this.droidRanked = true;
+        this.osuRanked = false;
+    }
+    copySettings(mod) {
+        var _a, _b;
+        super.copySettings(mod);
+        this.trackRateMultiplier.value =
+            (_b = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.rateMultiplier) !== null && _b !== void 0 ? _b : this.trackRateMultiplier.value;
+    }
+    get isDroidRelevant() {
+        return this.isRelevant;
+    }
+    calculateDroidScoreMultiplier() {
+        return this.droidScoreMultiplier;
+    }
+    get isOsuRelevant() {
+        return this.isRelevant;
+    }
+    get osuScoreMultiplier() {
+        // Round to the nearest multiple of 0.1.
+        let value = Math.trunc(this.trackRateMultiplier.value * 10) / 10;
+        // Offset back to 0.
+        --value;
+        return this.trackRateMultiplier.value >= 1
+            ? 1 + value / 5
+            : 0.6 + value;
+    }
+    serializeSettings() {
+        return { rateMultiplier: this.trackRateMultiplier.value };
+    }
+    toString() {
+        return `${super.toString()} (${this.trackRateMultiplier.toDisplayString()}x)`;
+    }
+}
+
+/**
+ * Represents a `Mod` that adjusts the size of `HitObject`s during their fade in animation.
+ */
+class ModObjectScaleTween extends Mod {
+    constructor() {
+        super();
+        /**
+         * The final size multiplier applied to all [HitObject]s.
+         */
+        this.endScale = 1;
+        this.incompatibleMods.add(ModObjectScaleTween).add(ModTraceable);
+    }
+    copySettings(mod) {
+        var _a;
+        super.copySettings(mod);
+        const { settings } = mod;
+        this.startScale.value =
+            (_a = settings === null || settings === void 0 ? void 0 : settings.startScale) !== null && _a !== void 0 ? _a : this.startScale.value;
+    }
+    serializeSettings() {
+        return { startScale: this.startScale.value };
+    }
+}
+
+/**
+ * Represents the Deflate mod.
+ */
+class ModDeflate extends ModObjectScaleTween {
+    constructor() {
+        super(...arguments);
+        this.name = "Deflate";
+        this.acronym = "DF";
+        this.startScale = new DecimalModSetting("Start scale", "The initial size multiplier applied to all hit objects.", 2, 1, 25, 0.1, 1);
+    }
+    get droidRanked() {
+        return false;
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1;
+    }
+    get osuRanked() {
+        return false;
+    }
+    get isOsuRelevant() {
+        return true;
+    }
+    get osuScoreMultiplier() {
+        return 1;
+    }
+}
+
+/**
+ * Represents a circle in a beatmap.
+ *
+ * All we need from circles is their position. All positions
+ * stored in the objects are in playfield coordinates (512*384
+ * rectangle).
+ */
+class Circle extends HitObject {
+    constructor(values) {
+        super(values);
+    }
+    toString() {
+        return `Position: [${this._position.x}, ${this._position.y}]`;
+    }
+}
+
+/**
+ * Represents the Replay V6 mod.
+ *
+ * Some behavior of beatmap parsing was changed in replay version 7. More specifically, object stacking
+ * behavior now matches osu!stable and osu!lazer.
+ *
+ * This `Mod` is meant to reapply the stacking behavior prior to replay version 7 to a `Beatmap` that
+ * was played in replays recorded in version 6 and older for replayability and difficulty calculation.
+ */
+class ModReplayV6 extends Mod {
+    constructor() {
+        super(...arguments);
+        this.name = "Replay V6";
+        this.acronym = "RV6";
+        this.userPlayable = false;
+        this.droidRanked = false;
+        this.facilitateAdjustment = true;
+    }
+    get isDroidRelevant() {
+        return true;
+    }
+    calculateDroidScoreMultiplier() {
+        return 1;
+    }
+    applyToBeatmap(beatmap) {
+        const { objects } = beatmap.hitObjects;
+        if (objects.length === 0) {
+            return;
+        }
+        // Reset stacking
+        objects.forEach((h) => {
+            h.stackHeight = 0;
+        });
+        for (let i = 0; i < objects.length - 1; ++i) {
+            const current = objects[i];
+            const next = objects[i + 1];
+            this.revertObjectScale(current, beatmap.difficulty);
+            this.revertObjectScale(next, beatmap.difficulty);
+            const convertedScale = CircleSizeCalculator.standardScaleToOldDroidScale(objects[0].scale);
+            if (current instanceof Circle &&
+                next.startTime - current.startTime <
+                    2000 * beatmap.general.stackLeniency &&
+                next.position.getDistance(current.position) <
+                    Math.sqrt(convertedScale)) {
+                next.stackHeight = current.stackHeight + 1;
+            }
+        }
     }
-    toString() {
-        return `Position: [${this.position.x}, ${this.position.y}], distance: ${this.path.expectedDistance}, repeat count: ${this.repeatCount}, slider ticks: ${this.nestedHitObjects.filter((v) => v instanceof SliderTick).length}`;
+    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;
     }
 }
-Slider.baseNormalSlideSample = new BankHitSampleInfo("sliderslide");
-Slider.baseWhistleSlideSample = new BankHitSampleInfo("sliderwhistle");
-Slider.baseTickSample = new BankHitSampleInfo("slidertick");
-Slider.legacyLastTickOffset = 36;
 
 /**
  * Represents a `Mod` specific setting that is constrained to a number of values.
@@ -2314,6 +2814,23 @@ Slider.legacyLastTickOffset = 36;
  * The value can be `null`, which is treated as a special case.
  */
 class NullableDecimalModSetting extends RangeConstrainedModSetting {
+    /**
+     * The number of decimal places to round the value to.
+     *
+     * When set to `null`, the value will not be rounded.
+     */
+    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);
+        }
+    }
     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) => {
@@ -2335,7 +2852,7 @@ class NullableDecimalModSetting extends RangeConstrainedModSetting {
             (defaultValue < min || defaultValue > max)) {
             throw new RangeError(`The default value (${defaultValue}) must be between the minimum (${min}) and maximum (${max}) values.`);
         }
-        this.precision = precision;
+        this._precision = precision;
     }
     processValue(value) {
         if (value === null) {
@@ -2426,18 +2943,19 @@ class ModDifficultyAdjust extends Mod {
         difficulty.ar = (_b = this.ar.value) !== null && _b !== void 0 ? _b : difficulty.ar;
         difficulty.od = (_c = this.od.value) !== null && _c !== void 0 ? _c : difficulty.od;
         difficulty.hp = (_d = this.hp.value) !== null && _d !== void 0 ? _d : difficulty.hp;
-        // Special case for force AR, where the AR value is kept constant with respect to game time.
-        // This makes the player perceive the AR as is under all speed multipliers.
-        if (this.ar.value !== null) {
+        // 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, 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) {
+        // 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);
@@ -2485,14 +3003,6 @@ class ModDifficultyAdjust extends Mod {
         }
         return rate;
     }
-    equals(other) {
-        return (super.equals(other) &&
-            other instanceof ModDifficultyAdjust &&
-            this.cs.value === other.cs.value &&
-            this.ar.value === other.ar.value &&
-            this.od.value === other.od.value &&
-            this.hp.value === other.hp.value);
-    }
     toString() {
         if (!this.isRelevant) {
             return super.toString();
@@ -2595,22 +3105,6 @@ class ModDoubleTime extends ModRateAdjust {
     }
 }
 
-/**
- * Represents a circle in a beatmap.
- *
- * All we need from circles is their position. All positions
- * stored in the objects are in playfield coordinates (512*384
- * rectangle).
- */
-class Circle extends HitObject {
-    constructor(values) {
-        super(values);
-    }
-    toString() {
-        return `Position: [${this._position.x}, ${this._position.y}]`;
-    }
-}
-
 var _a$1;
 /**
  * Represents the osu! playfield.
@@ -2648,10 +3142,10 @@ class Spinner extends HitObject {
         this.auxiliarySamples.push(new SequenceHitSampleInfo(samplePoints.map((s) => new TimedHitSampleInfo(s.time, s.applyTo(Spinner.baseSpinnerSpinSample)))));
         this.auxiliarySamples.push(new SequenceHitSampleInfo(samplePoints.map((s) => new TimedHitSampleInfo(s.time, s.applyTo(Spinner.baseSpinnerBonusSample)))));
     }
-    getStackedPosition() {
+    get stackedPosition() {
         return this.position;
     }
-    getStackedEndPosition() {
+    get stackedEndPosition() {
         return this.position;
     }
     createHitWindow() {
@@ -3867,11 +4361,6 @@ class ModMirror extends Mod {
     serializeSettings() {
         return { flippedAxes: this.flippedAxes.value - 1 };
     }
-    equals(other) {
-        return (super.equals(other) &&
-            other instanceof ModMirror &&
-            other.flippedAxes.value === this.flippedAxes.value);
-    }
     toString() {
         const settings = [];
         if (this.flippedAxes.value === exports.Axes.x ||
@@ -3886,62 +4375,6 @@ class ModMirror extends Mod {
     }
 }
 
-/**
- * Represents the Replay V6 mod.
- *
- * Some behavior of beatmap parsing was changed in replay version 7. More specifically, object stacking
- * behavior now matches osu!stable and osu!lazer.
- *
- * This `Mod` is meant to reapply the stacking behavior prior to replay version 7 to a `Beatmap` that
- * was played in replays recorded in version 6 and older for replayability and difficulty calculation.
- */
-class ModReplayV6 extends Mod {
-    constructor() {
-        super(...arguments);
-        this.name = "Replay V6";
-        this.acronym = "RV6";
-        this.userPlayable = false;
-        this.droidRanked = false;
-        this.facilitateAdjustment = true;
-    }
-    get isDroidRelevant() {
-        return true;
-    }
-    calculateDroidScoreMultiplier() {
-        return 1;
-    }
-    applyToBeatmap(beatmap) {
-        const { objects } = beatmap.hitObjects;
-        if (objects.length === 0) {
-            return;
-        }
-        // Reset stacking
-        objects.forEach((h) => {
-            h.stackHeight = 0;
-        });
-        for (let i = 0; i < objects.length - 1; ++i) {
-            const current = objects[i];
-            const next = objects[i + 1];
-            this.revertObjectScale(current, beatmap.difficulty);
-            this.revertObjectScale(next, beatmap.difficulty);
-            const convertedScale = CircleSizeCalculator.standardScaleToOldDroidScale(objects[0].scale);
-            if (current instanceof Circle &&
-                next.startTime - current.startTime <
-                    2000 * beatmap.general.stackLeniency &&
-                next.position.getDistance(current.position) <
-                    Math.sqrt(convertedScale)) {
-                next.stackHeight = current.stackHeight + 1;
-            }
-        }
-    }
-    revertObjectScale(hitObject, difficulty) {
-        const droidScale = CircleSizeCalculator.droidCSToOldDroidScale(difficulty.cs);
-        const radius = CircleSizeCalculator.oldDroidScaleToStandardRadius(droidScale);
-        const standardCS = CircleSizeCalculator.standardRadiusToStandardCS(radius, true);
-        hitObject.scale = CircleSizeCalculator.standardCSToStandardScale(standardCS, true);
-    }
-}
-
 /**
  * Represents the HardRock mod.
  */
@@ -4068,11 +4501,6 @@ class ModFlashlight extends Mod {
     serializeSettings() {
         return { areaFollowDelay: this.followDelay.value };
     }
-    equals(other) {
-        return (super.equals(other) &&
-            other instanceof ModFlashlight &&
-            other.followDelay.value === this.followDelay.value);
-    }
     toString() {
         if (this.followDelay.value === ModFlashlight.defaultFollowDelay) {
             return super.toString();
@@ -4086,22 +4514,26 @@ class ModFlashlight extends Mod {
 ModFlashlight.defaultFollowDelay = 0.12;
 
 /**
- * Represents the Traceable mod.
+ * Represents the Grow mod.
  */
-class ModTraceable extends Mod {
+class ModGrow extends ModObjectScaleTween {
     constructor() {
-        super();
-        this.acronym = "TC";
-        this.name = "Traceable";
-        this.droidRanked = false;
-        this.osuRanked = false;
-        this.incompatibleMods.add(ModHidden);
+        super(...arguments);
+        this.name = "Grow";
+        this.acronym = "GR";
+        this.startScale = new DecimalModSetting("Start scale", "The initial size multiplier applied to all hit objects.", 0.5, 0, 0.99, 0.01, 2);
+    }
+    get droidRanked() {
+        return false;
     }
     get isDroidRelevant() {
         return true;
     }
     calculateDroidScoreMultiplier() {
-        return 1.06;
+        return 1;
+    }
+    get osuRanked() {
+        return false;
     }
     get isOsuRelevant() {
         return true;
@@ -4112,82 +4544,92 @@ class ModTraceable extends Mod {
 }
 
 /**
- * Represents a `Mod` specific setting that is constrained to a boolean value.
+ * Represents a `Mod` specific setting that is constrained to a range of integer values.
  */
-class BooleanModSetting extends ModSetting {
-    constructor() {
-        super(...arguments);
-        this.displayFormatter = (v) => v ? "Enabled" : "Disabled";
+class IntegerModSetting extends NumberModSetting {
+    constructor(name, description, defaultValue, min = -2147483648, max = 2147483647) {
+        super(name, description, defaultValue, min, max, 1);
     }
 }
 
 /**
- * Represents the Hidden mod.
+ * Represents the Muted mod.
  */
-class ModHidden extends Mod {
-    constructor() {
-        super();
-        this.acronym = "HD";
-        this.name = "Hidden";
-        this.droidRanked = true;
-        this.osuRanked = true;
-        this.bitwise = 1 << 3;
-        /**
-         * Whether to only fade approach circles.
-         *
-         * The main object body will not fade when enabled.
-         */
-        this.onlyFadeApproachCircles = new BooleanModSetting("Only fade approach circles", "The main object body will not fade when enabled.", false);
-        this.incompatibleMods.add(ModTraceable);
+class ModMuted extends Mod {
+    get droidRanked() {
+        return false;
     }
     get isDroidRelevant() {
         return true;
     }
     calculateDroidScoreMultiplier() {
-        return 1.06;
+        return 1;
+    }
+    get osuRanked() {
+        return true;
     }
     get isOsuRelevant() {
         return true;
     }
     get osuScoreMultiplier() {
-        return 1.06;
+        return 1;
+    }
+    constructor() {
+        super();
+        this.name = "Muted";
+        this.acronym = "MU";
+        /**
+         * Increase volume as combo builds.
+         */
+        this.inverseMuting = new BooleanModSetting("Start muted", "Increase volume as combo builds.", false);
+        /**
+         * Add a metronome beat to help the player keep track of the rhythm.
+         */
+        this.enableMetronome = new BooleanModSetting("Enable metronome", "Add a metronome beat to help you keep track of the rhythm.", true);
+        /**
+         * The combo count at which point the track reaches its final volume.
+         */
+        this.muteComboCount = new IntegerModSetting("Final volume at combo", "The combo count at which point the track reaches its final volume.", 100, 0, 500);
+        /**
+         * 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;
+        }, true);
+    }
+    /**
+     * Obtains the volume at a given combo.
+     *
+     * @param combo The combo.
+     * @return The volume at `combo`, where 0 is muted and 1 is full volume.
+     */
+    volumeAt(combo) {
+        const volume = MathUtils.clamp(combo / Math.max(1, this.muteComboCount.value), 0, 1);
+        return this.inverseMuting.value ? volume : 1 - volume;
     }
     copySettings(mod) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         super.copySettings(mod);
-        this.onlyFadeApproachCircles.value =
-            (_b = (_a = mod.settings) === null || _a === void 0 ? void 0 : _a.onlyFadeApproachCircles) !== null && _b !== void 0 ? _b : this.onlyFadeApproachCircles.value;
-    }
-    applyToBeatmap(beatmap) {
-        const applyFadeInAdjustment = (hitObject) => {
-            hitObject.timeFadeIn =
-                hitObject.timePreempt * ModHidden.fadeInDurationMultiplier;
-            if (hitObject instanceof Slider) {
-                hitObject.nestedHitObjects.forEach(applyFadeInAdjustment);
-            }
-        };
-        beatmap.hitObjects.objects.forEach(applyFadeInAdjustment);
+        const { settings } = mod;
+        this.inverseMuting.value =
+            (_a = settings === null || settings === void 0 ? void 0 : settings.inverseMuting) !== null && _a !== void 0 ? _a : this.inverseMuting.value;
+        this.enableMetronome.value =
+            (_b = settings === null || settings === void 0 ? void 0 : settings.enableMetronome) !== null && _b !== void 0 ? _b : this.enableMetronome.value;
+        this.muteComboCount.value =
+            (_c = settings === null || settings === void 0 ? void 0 : settings.muteComboCount) !== null && _c !== void 0 ? _c : this.muteComboCount.value;
+        this.affectsHitSounds.value =
+            (_d = settings === null || settings === void 0 ? void 0 : settings.affectsHitSounds) !== null && _d !== void 0 ? _d : this.affectsHitSounds.value;
     }
     serializeSettings() {
-        return this.onlyFadeApproachCircles.value
-            ? { onlyFadeApproachCircles: this.onlyFadeApproachCircles.value }
-            : null;
-    }
-    equals(other) {
-        return (super.equals(other) &&
-            other instanceof ModHidden &&
-            other.onlyFadeApproachCircles.value ===
-                this.onlyFadeApproachCircles.value);
-    }
-    toString() {
-        if (!this.onlyFadeApproachCircles.value) {
-            return super.toString();
-        }
-        return `${super.toString()} (approach circles only)`;
+        return {
+            inverseMuting: this.inverseMuting.value,
+            enableMetronome: this.enableMetronome.value,
+            muteComboCount: this.muteComboCount.value,
+            affectsHitSounds: this.affectsHitSounds.value,
+        };
     }
 }
-ModHidden.fadeInDurationMultiplier = 0.4;
-ModHidden.fadeOutDurationMultiplier = 0.3;
 
 /**
  * Represents the SuddenDeath mod.
@@ -4596,12 +5038,6 @@ class ModRandom extends Mod {
             1 && positionInfos[i - 1].hitObject.isNewCombo;
         return previousObjectStartedCombo && this.random.nextDouble() < 0.6;
     }
-    equals(other) {
-        return (super.equals(other) &&
-            other instanceof ModRandom &&
-            other.seed.value === this.seed.value &&
-            other.angleSharpness.value === this.angleSharpness.value);
-    }
     toString() {
         const settings = [];
         if (this.seed.value !== null) {
@@ -4785,51 +5221,6 @@ class ModTouchDevice extends Mod {
     }
 }
 
-/**
- * Types of easing.
- *
- * See {@link http://easings.net/ this} page for more samples.
- */
-exports.Easing = void 0;
-(function (Easing) {
-    Easing[Easing["none"] = 0] = "none";
-    Easing[Easing["out"] = 1] = "out";
-    Easing[Easing["in"] = 2] = "in";
-    Easing[Easing["inQuad"] = 3] = "inQuad";
-    Easing[Easing["outQuad"] = 4] = "outQuad";
-    Easing[Easing["inOutQuad"] = 5] = "inOutQuad";
-    Easing[Easing["inCubic"] = 6] = "inCubic";
-    Easing[Easing["outCubic"] = 7] = "outCubic";
-    Easing[Easing["inOutCubic"] = 8] = "inOutCubic";
-    Easing[Easing["inQuart"] = 9] = "inQuart";
-    Easing[Easing["outQuart"] = 10] = "outQuart";
-    Easing[Easing["inOutQuart"] = 11] = "inOutQuart";
-    Easing[Easing["inQuint"] = 12] = "inQuint";
-    Easing[Easing["outQuint"] = 13] = "outQuint";
-    Easing[Easing["inOutQuint"] = 14] = "inOutQuint";
-    Easing[Easing["inSine"] = 15] = "inSine";
-    Easing[Easing["outSine"] = 16] = "outSine";
-    Easing[Easing["inOutSine"] = 17] = "inOutSine";
-    Easing[Easing["inExpo"] = 18] = "inExpo";
-    Easing[Easing["outExpo"] = 19] = "outExpo";
-    Easing[Easing["inOutExpo"] = 20] = "inOutExpo";
-    Easing[Easing["inCirc"] = 21] = "inCirc";
-    Easing[Easing["outCirc"] = 22] = "outCirc";
-    Easing[Easing["inOutCirc"] = 23] = "inOutCirc";
-    Easing[Easing["inElastic"] = 24] = "inElastic";
-    Easing[Easing["outElastic"] = 25] = "outElastic";
-    Easing[Easing["outElasticHalf"] = 26] = "outElasticHalf";
-    Easing[Easing["outElasticQuarter"] = 27] = "outElasticQuarter";
-    Easing[Easing["inOutElastic"] = 28] = "inOutElastic";
-    Easing[Easing["inBack"] = 29] = "inBack";
-    Easing[Easing["outBack"] = 30] = "outBack";
-    Easing[Easing["inOutBack"] = 31] = "inOutBack";
-    Easing[Easing["inBounce"] = 32] = "inBounce";
-    Easing[Easing["outBounce"] = 33] = "outBounce";
-    Easing[Easing["inOutBounce"] = 34] = "inOutBounce";
-    Easing[Easing["outPow10"] = 35] = "outPow10";
-})(exports.Easing || (exports.Easing = {}));
-
 /**
  * Holds interpolation methods for numbers and vectors.
  */
@@ -5041,12 +5432,6 @@ class ModTimeRamp extends Mod {
             finalRate: this.finalRate.value,
         };
     }
-    equals(other) {
-        return (super.equals(other) &&
-            other instanceof ModTimeRamp &&
-            other.initialRate.value === this.initialRate.value &&
-            other.finalRate.value === this.finalRate.value);
-    }
     toString() {
         return `${super.toString()} (${this.initialRate.toDisplayString()}x - ${this.finalRate.toDisplayString()}x)`;
     }
@@ -5344,6 +5729,8 @@ ModUtil.allMods = (() => {
         ModEasy,
         ModNoFail,
         ModHidden,
+        ModApproachDifferent,
+        ModFreezeFrame,
         ModTraceable,
         ModDoubleTime,
         ModNightCore,
@@ -5353,6 +5740,8 @@ ModUtil.allMods = (() => {
         ModWindUp,
         ModHardRock,
         ModMirror,
+        ModGrow,
+        ModDeflate,
         ModDifficultyAdjust,
         ModFlashlight,
         ModSuddenDeath,
@@ -5360,6 +5749,7 @@ ModUtil.allMods = (() => {
         ModPrecise,
         ModRandom,
         ModReallyEasy,
+        ModMuted,
         ModSynesthesia,
         ModReplayV6,
         ModScoreV2,
@@ -5387,15 +5777,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
@@ -5586,6 +5978,9 @@ class BeatmapHitObjects {
         this._sliders = 0;
         this._spinners = 0;
     }
+    [Symbol.iterator]() {
+        return this.objects[Symbol.iterator]();
+    }
     /**
      * Finds the insertion index of a hitobject in a given time.
      *
@@ -5936,7 +6331,7 @@ 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);
     }
 }
 
@@ -6151,6 +6546,9 @@ class ControlPointManager {
         // l will be the first control point with time > this._points[l].time, but we want the one before it
         return this._points[l - 1];
     }
+    [Symbol.iterator]() {
+        return this._points[Symbol.iterator]();
+    }
     /**
      * Finds the insertion index of a control point in a given time.
      *
@@ -8844,8 +9242,8 @@ class BeatmapDecoder extends Decoder {
      * @param parseStoryboard Whether to parse the beatmap's storyboard.
      */
     decode(str, mode = exports.Modes.osu, parseStoryboard = true) {
-        this.finalResult.mode = mode;
         super.decode(str);
+        this.finalResult.mode = mode;
         if (parseStoryboard) {
             const eventsDecoder = (this.decoders[BeatmapSection.events]);
             if (eventsDecoder.storyboardLines.length > 0) {
@@ -10949,15 +11347,6 @@ ErrorFunction.ervInvImpGd = [
     0.3999688121938621e-6, 0.1618092908879045e-8, 0.2315586083102596e-11,
 ];
 
-/**
- * Represents a `Mod` specific setting that is constrained to a range of integer values.
- */
-class IntegerModSetting extends NumberModSetting {
-    constructor(name, description, defaultValue, min = -2147483648, max = 2147483647) {
-        super(name, description, defaultValue, min, max, 1);
-    }
-}
-
 /**
  * Ranking status of a beatmap.
  */
@@ -11475,20 +11864,26 @@ exports.Interpolation = Interpolation;
 exports.MapInfo = MapInfo;
 exports.MathUtils = MathUtils;
 exports.Mod = Mod;
+exports.ModApproachDifferent = ModApproachDifferent;
 exports.ModAuto = ModAuto;
 exports.ModAutopilot = ModAutopilot;
 exports.ModCustomSpeed = ModCustomSpeed;
+exports.ModDeflate = ModDeflate;
 exports.ModDifficultyAdjust = ModDifficultyAdjust;
 exports.ModDoubleTime = ModDoubleTime;
 exports.ModEasy = ModEasy;
 exports.ModFlashlight = ModFlashlight;
+exports.ModFreezeFrame = ModFreezeFrame;
+exports.ModGrow = ModGrow;
 exports.ModHalfTime = ModHalfTime;
 exports.ModHardRock = ModHardRock;
 exports.ModHidden = ModHidden;
 exports.ModMap = ModMap;
 exports.ModMirror = ModMirror;
+exports.ModMuted = ModMuted;
 exports.ModNightCore = ModNightCore;
 exports.ModNoFail = ModNoFail;
+exports.ModObjectScaleTween = ModObjectScaleTween;
 exports.ModOldNightCore = ModOldNightCore;
 exports.ModPerfect = ModPerfect;
 exports.ModPrecise = ModPrecise;
@@ -11510,6 +11905,7 @@ exports.ModWindDown = ModWindDown;
 exports.ModWindUp = ModWindUp;
 exports.NormalDistribution = NormalDistribution;
 exports.NullableDecimalModSetting = NullableDecimalModSetting;
+exports.NullableIntegerModSetting = NullableIntegerModSetting;
 exports.NumberModSetting = NumberModSetting;
 exports.OsuAPIRequestBuilder = OsuAPIRequestBuilder;
 exports.OsuHitWindow = OsuHitWindow;