@rian8337/osu-base 3.0.0 → 3.3.0

package/dist/index.js

@@ -1,17 +1,10 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var request = require('request');
 var cloneDeep = require('lodash.clonedeep');
-var path = require('path');
+var node_path = require('node:path');
 var dotenv = require('dotenv');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var request__default = /*#__PURE__*/_interopDefaultLegacy(request);
-var cloneDeep__default = /*#__PURE__*/_interopDefaultLegacy(cloneDeep);
-
 /**
  * Some math utility functions.
  */
@@ -211,7 +204,7 @@ class Utils {
      * @param obj The object to deep copy.
      */
     static deepCopy(obj) {
-        return cloneDeep__default["default"](obj);
+        return cloneDeep(obj);
     }
     /**
      * Creates an array with specific length that's prefilled with an initial value.
@@ -305,7 +298,7 @@ class APIRequestBuilder {
         return new Promise((resolve) => {
             const url = this.buildURL();
             const dataArray = [];
-            request__default["default"](url)
+            request(url)
                 .on("data", (chunk) => {
                 dataArray.push(Buffer.from(chunk));
             })
@@ -514,6 +507,10 @@ class Vector2 {
  * Represents a hitobject in a beatmap.
  */
 class HitObject {
+    /**
+     * The base radius of all hitobjects.
+     */
+    static baseRadius = 64;
     /**
      * The start time of the hitobject in milliseconds.
      */
@@ -558,15 +555,51 @@ class HitObject {
     /**
      * The stack height of the hitobject.
      */
-    stackHeight = 0;
+    _stackHeight = 0;
+    /**
+     * The stack height of the hitobject.
+     */
+    get stackHeight() {
+        return this._stackHeight;
+    }
+    /**
+     * The stack height of the hitobject.
+     */
+    set stackHeight(value) {
+        this._stackHeight = value;
+    }
+    /**
+     * The osu!droid scale used to calculate stacked position and radius.
+     */
+    _droidScale = 1;
+    /**
+     * The osu!droid scale used to calculate stacked position and radius.
+     */
+    get droidScale() {
+        return this._droidScale;
+    }
     /**
      * The osu!droid scale used to calculate stacked position and radius.
      */
-    droidScale = 1;
+    set droidScale(value) {
+        this._droidScale = value;
+    }
     /**
      * The osu!standard scale used to calculate stacked position and radius.
      */
-    osuScale = 1;
+    _osuScale = 1;
+    /**
+     * The osu!standard scale used to calculate stacked position and radius.
+     */
+    get osuScale() {
+        return this._osuScale;
+    }
+    /**
+     * The osu!standard scale used to calculate stacked position and radius.
+     */
+    set osuScale(value) {
+        this._osuScale = value;
+    }
     /**
      * The hitobject type (circle, slider, or spinner).
      */
@@ -599,16 +632,12 @@ class HitObject {
      * @returns The radius of the hitobject with respect to the gamemode.
      */
     getRadius(mode) {
-        let radius = 64;
         switch (mode) {
             case exports.Modes.droid:
-                radius *= this.droidScale;
-                break;
+                return HitObject.baseRadius * this._droidScale;
             case exports.Modes.osu:
-                radius *= this.osuScale;
-                break;
+                return HitObject.baseRadius * this._osuScale;
         }
-        return radius;
     }
     /**
      * Evaluates the stack offset vector of the hitobject.
@@ -619,13 +648,13 @@ class HitObject {
      * @returns The stack offset with respect to the gamemode.
      */
     getStackOffset(mode) {
-        let coordinate = this.stackHeight;
+        let coordinate = this._stackHeight;
         switch (mode) {
             case exports.Modes.droid:
-                coordinate *= this.droidScale * -4;
+                coordinate *= this._droidScale * 4;
                 break;
             case exports.Modes.osu:
-                coordinate *= this.osuScale * -6.4;
+                coordinate *= this._osuScale * -6.4;
                 break;
         }
         return new Vector2(coordinate, coordinate);
@@ -799,6 +828,33 @@ class Slider extends HitObject {
     get repeats() {
         return this.repetitions - 1;
     }
+    get stackHeight() {
+        return this._stackHeight;
+    }
+    set stackHeight(value) {
+        super.stackHeight = value;
+        for (const nestedObject of this.nestedHitObjects) {
+            nestedObject.stackHeight = value;
+        }
+    }
+    get droidScale() {
+        return this._droidScale;
+    }
+    set droidScale(value) {
+        super.droidScale = value;
+        for (const nestedObject of this.nestedHitObjects) {
+            nestedObject.droidScale = value;
+        }
+    }
+    get osuScale() {
+        return this._osuScale;
+    }
+    set osuScale(value) {
+        super.osuScale = value;
+        for (const nestedObject of this.nestedHitObjects) {
+            nestedObject.osuScale = value;
+        }
+    }
     /**
      * The repetition amount of the slider. Note that 1 repetition means no repeats (1 loop).
      */
@@ -2248,17 +2304,6 @@ class ModPrecise extends Mod {
     droidString = "s";
 }
 
-/**
- * Represents the SmallCircle mod.
- */
-class ModSmallCircle extends Mod {
-    acronym = "SC";
-    name = "SmallCircle";
-    droidRanked = false;
-    droidScoreMultiplier = 1.06;
-    droidString = "m";
-}
-
 /**
  * Represents the ReallyEasy mod.
  */
@@ -2384,6 +2429,17 @@ class ModScoreV2 extends Mod {
     droidString = "v";
 }
 
+/**
+ * Represents the SmallCircle mod.
+ */
+class ModSmallCircle extends Mod {
+    acronym = "SC";
+    name = "SmallCircle";
+    droidRanked = false;
+    droidScoreMultiplier = 1.06;
+    droidString = "m";
+}
+
 /**
  * Represents the SpunOut mod.
  */
@@ -2542,6 +2598,17 @@ class ModUtil {
         }
         return mods;
     }
+    /**
+     * Removes speed-changing mods from an array of mods.
+     *
+     * @param mods The array of mods.
+     * @returns A new array with speed changing mods filtered out.
+     */
+    static removeSpeedChangingMods(mods) {
+        return mods
+            .slice()
+            .filter((m) => !this.speedChangingMods.some((v) => m.acronym === v.acronym));
+    }
     /**
      * Processes parsing options.
      *
@@ -2560,6 +2627,93 @@ class ModUtil {
     }
 }
 
+/**
+ * A utility class for calculating circle sizes across all modes (rimu! and osu!standard).
+ */
+class CircleSizeCalculator {
+    static assumedDroidHeight = 681;
+    /**
+     * Converts osu!droid CS to osu!droid scale.
+     *
+     * @param cs The CS to convert.
+     * @param mods The mods to apply.
+     * @returns The calculated osu!droid scale.
+     */
+    static droidCSToDroidScale(cs, mods = []) {
+        let scale = ((this.assumedDroidHeight / 480) * (54.42 - cs * 4.48) * 2) / 128 +
+            (0.5 * (11 - 5.2450170716245195)) / 5;
+        if (mods.some((m) => m instanceof ModHardRock)) {
+            scale -= 0.125;
+        }
+        if (mods.some((m) => m instanceof ModEasy)) {
+            scale += 0.125;
+        }
+        if (mods.some((m) => m instanceof ModReallyEasy)) {
+            scale += 0.125;
+        }
+        if (mods.some((m) => m instanceof ModSmallCircle)) {
+            scale -= ((this.assumedDroidHeight / 480) * (4 * 4.48) * 2) / 128;
+        }
+        return Math.max(scale, 1e-3);
+    }
+    /**
+     * Converts osu!droid scale to osu!standard radius.
+     *
+     * @param scale The osu!droid scale to convert.
+     * @returns The osu!standard radius of the given osu!droid scale.
+     */
+    static droidScaleToStandardRadius(scale) {
+        return ((64 * Math.max(1e-3, scale)) /
+            ((this.assumedDroidHeight * 0.85) / 384));
+    }
+    /**
+     * Converts osu!standard radius to osu!droid scale.
+     *
+     * @param radius The osu!standard radius to convert.
+     * @returns The osu!droid scale of the given osu!standard radius.
+     */
+    static standardRadiusToDroidScale(radius) {
+        return ((radius * ((this.assumedDroidHeight * 0.85) / 384)) /
+            HitObject.baseRadius);
+    }
+    /**
+     * Converts osu!standard radius to osu!standard circle size.
+     *
+     * @param radius The osu!standard radius to convert.
+     * @returns The osu!standard circle size of the given radius.
+     */
+    static standardRadiusToStandardCS(radius) {
+        return 5 + ((1 - radius / (HitObject.baseRadius / 2)) * 5) / 0.7;
+    }
+    /**
+     * Converts osu!standard circle size to osu!standard scale.
+     *
+     * @param cs The osu!standard circle size to convert.
+     * @returns The osu!standard scale of the given circle size.
+     */
+    static standardCSToStandardScale(cs) {
+        return (1 - (0.7 * (cs - 5)) / 5) / 2;
+    }
+    /**
+     * Converts osu!standard scale to osu!droid scale.
+     *
+     * @param scale The osu!standard scale to convert.
+     * @returns The osu!droid scale of the given osu!standard scale.
+     */
+    static standardScaleToDroidScale(scale) {
+        return this.standardRadiusToDroidScale(HitObject.baseRadius * scale);
+    }
+    /**
+     * Converts osu!standard circle size to osu!droid scale.
+     *
+     * @param cs The osu!standard circle size to convert.
+     * @returns The osu!droid scale of the given osu!droid scale.
+     */
+    static standardCSToDroidScale(cs) {
+        return this.standardScaleToDroidScale(this.standardCSToStandardScale(cs));
+    }
+}
+
 /**
  * Holds general beatmap statistics for further modifications.
  */
@@ -2664,13 +2818,26 @@ class MapStats {
                 // needs to be computed regardless of map-changing mods
                 // and statistics multiplier.
                 if (this.od !== undefined) {
-                    // Apply EZ or HR to OD.
-                    this.od = Math.min(this.od * statisticsMultiplier, 10);
+                    // Apply non-speed changing mods to OD.
+                    this.od *= statisticsMultiplier;
+                    if (this.mods.some((m) => m instanceof ModReallyEasy)) {
+                        this.od /= 2;
+                    }
+                    this.od = Math.min(this.od, 10);
                     // Convert original OD to droid hit window to take
                     // droid hit window and the PR mod in mind.
-                    const droidToMS = new DroidHitWindow(this.od).hitWindowFor300(this.mods.some((m) => m instanceof ModPrecise)) / this.speedMultiplier;
-                    // Convert droid hit window back to original OD.
-                    this.od = OsuHitWindow.hitWindow300ToOD(droidToMS);
+                    // Consider speed multiplier as well.
+                    const isPrecise = this.mods.some((m) => m instanceof ModPrecise);
+                    const droidToMS = new DroidHitWindow(this.od).hitWindowFor300(isPrecise) /
+                        this.speedMultiplier;
+                    if (params?.convertDroidOD !== false) {
+                        // Convert droid hit window to osu!standard OD.
+                        this.od = OsuHitWindow.hitWindow300ToOD(droidToMS);
+                    }
+                    else {
+                        // Convert droid hit window back to original OD.
+                        this.od = DroidHitWindow.hitWindow300ToOD(droidToMS, isPrecise);
+                    }
                 }
                 // HR and EZ works differently in droid in terms of
                 // CS modification (even CS in itself as well).
@@ -2679,26 +2846,9 @@ class MapStats {
                 // from the bitwise enum of mods to prevent double
                 // calculation.
                 if (this.cs !== undefined) {
-                    // Assume 681 is height.
-                    const assumedHeight = 681;
-                    let scale = ((assumedHeight / 480) * (54.42 - this.cs * 4.48) * 2) /
-                        128 +
-                        (0.5 * (11 - 5.2450170716245195)) / 5;
-                    if (this.mods.some((m) => m instanceof ModHardRock)) {
-                        scale -= 0.125;
-                    }
-                    if (this.mods.some((m) => m instanceof ModEasy)) {
-                        scale += 0.125;
-                    }
-                    if (this.mods.some((m) => m instanceof ModReallyEasy)) {
-                        scale += 0.125;
-                    }
-                    if (this.mods.some((m) => m instanceof ModSmallCircle)) {
-                        scale -= ((assumedHeight / 480) * (4 * 4.48) * 2) / 128;
-                    }
-                    const radius = (64 * Math.max(1e-3, scale)) /
-                        ((assumedHeight * 0.85) / 384);
-                    this.cs = Math.min(5 + ((1 - radius / 32) * 5) / 0.7, 10);
+                    const scale = CircleSizeCalculator.droidCSToDroidScale(this.cs, this.mods);
+                    const radius = CircleSizeCalculator.droidScaleToStandardRadius(scale);
+                    this.cs = Math.min(CircleSizeCalculator.standardRadiusToStandardCS(radius), 10);
                 }
                 if (this.hp !== undefined) {
                     if (this.mods.some((m) => m instanceof ModReallyEasy)) {
@@ -3862,10 +4012,13 @@ class BeatmapHitObjectsDecoder extends SectionDecoder {
         this.target.hitObjects.add(object);
     }
     /**
-     * Applies stacking to hitobjects for this.map version 6 or above.
+     * Applies stacking to hitobjects for beatmap version 6 or above.
+     *
+     * @deprecated Use `HitObjectStackEvaluator.applyStandardStacking` instead.
      */
     applyStacking(startIndex, endIndex) {
         if (this.target.formatVersion < 6) {
+            this.applyStackingOld();
             return;
         }
         const stackDistance = 3;
@@ -3982,10 +4135,13 @@ class BeatmapHitObjectsDecoder extends SectionDecoder {
         }
     }
     /**
-     * Applies stacking to hitobjects for this.map version 5 or below.
+     * Applies stacking to hitobjects for beatmap version 5 or below.
+     *
+     * @deprecated Use `HitObjectStackEvaluator.applyStandardStacking` instead.
      */
     applyStackingOld() {
         if (this.target.formatVersion > 5) {
+            this.applyStacking(0, this.target.hitObjects.objects.length - 1);
             return;
         }
         const stackDistance = 3;
@@ -5378,7 +5534,7 @@ class StoryboardEventsDecoder extends SectionDecoder {
         while (end > start && name.charAt(end - 1) === '"') {
             --end;
         }
-        return path.normalize(start > 0 || end < name.length ? name.substring(start, end) : name);
+        return node_path.normalize(start > 0 || end < name.length ? name.substring(start, end) : name);
     }
 }
 
@@ -5520,6 +5676,217 @@ class StoryboardDecoder extends Decoder {
     }
 }
 
+/**
+ * An evaluator for evaluating stack heights of hitobjects.
+ */
+class HitObjectStackEvaluator {
+    static stackDistance = 3;
+    /**
+     * Applies note stacking to hit objects using osu!standard algorithm.
+     *
+     * @param formatVersion The format version of the beatmap containing the hit objects.
+     * @param objects The hit objects to apply stacking to.
+     * @param ar The calculated approach rate of the beatmap.
+     * @param stackLeniency The multiplier for the threshold in time where hit objects placed close together stack, ranging from 0 to 1.
+     * @param startIndex The minimum index bound of the hit object to apply stacking to. Defaults to 0.
+     * @param endIndex The maximum index bound of the hit object to apply stacking to. Defaults to the last index of the array of hit objects.
+     */
+    static applyStandardStacking(formatVersion, hitObjects, ar, stackLeniency, startIndex = 0, endIndex = hitObjects.length - 1) {
+        if (formatVersion < 6) {
+            // Use the old version of stacking algorithm for beatmap version 5 or lower.
+            this.applyStandardOldStacking(hitObjects, ar, stackLeniency);
+            return;
+        }
+        const timePreempt = MapStats.arToMS(ar);
+        let extendedEndIndex = endIndex;
+        const stackThreshold = timePreempt * stackLeniency;
+        if (endIndex < hitObjects.length - 1) {
+            for (let i = endIndex; i >= startIndex; --i) {
+                let stackBaseIndex = i;
+                for (let n = stackBaseIndex + 1; n < hitObjects.length; ++n) {
+                    const stackBaseObject = hitObjects[stackBaseIndex];
+                    if (stackBaseObject instanceof Spinner) {
+                        break;
+                    }
+                    const objectN = hitObjects[n];
+                    if (objectN instanceof Spinner) {
+                        break;
+                    }
+                    if (objectN.startTime - stackBaseObject.endTime >
+                        stackThreshold) {
+                        // We are no longer within stacking range of the next object.
+                        break;
+                    }
+                    const endPositionDistanceCheck = stackBaseObject instanceof Slider
+                        ? stackBaseObject.endPosition.getDistance(objectN.position) < this.stackDistance
+                        : false;
+                    if (stackBaseObject.position.getDistance(objectN.position) <
+                        this.stackDistance ||
+                        endPositionDistanceCheck) {
+                        stackBaseIndex = n;
+                        // Hit objects after the specified update range haven't been reset yet
+                        objectN.stackHeight = 0;
+                    }
+                }
+                if (stackBaseIndex > extendedEndIndex) {
+                    extendedEndIndex = stackBaseIndex;
+                    if (extendedEndIndex === hitObjects.length - 1) {
+                        break;
+                    }
+                }
+            }
+        }
+        // Reverse pass for stack calculation.
+        let extendedStartIndex = startIndex;
+        for (let i = extendedEndIndex; i > startIndex; --i) {
+            let n = i;
+            // We should check every note which has not yet got a stack.
+            // Consider the case we have two inter-wound stacks and this will make sense.
+            //
+            // o <-1      o <-2
+            //  o <-3      o <-4
+            //
+            // We first process starting from 4 and handle 2,
+            // then we come backwards on the i loop iteration until we reach 3 and handle 1.
+            // 2 and 1 will be ignored in the i loop because they already have a stack value.
+            let objectI = hitObjects[i];
+            if (objectI.stackHeight !== 0 || objectI instanceof Spinner) {
+                continue;
+            }
+            // If this object is a hit circle, then we enter this "special" case.
+            // It either ends with a stack of hit circles only, or a stack of hit circles that are underneath a slider.
+            // Any other case is handled by the "instanceof Slider" code below this.
+            if (objectI instanceof Circle) {
+                while (--n >= 0) {
+                    const objectN = hitObjects[n];
+                    if (objectN instanceof Spinner) {
+                        continue;
+                    }
+                    if (objectI.startTime - objectN.endTime > stackThreshold) {
+                        // We are no longer within stacking range of the previous object.
+                        break;
+                    }
+                    // Hit objects before the specified update range haven't been reset yet
+                    if (n < extendedStartIndex) {
+                        objectN.stackHeight = 0;
+                        extendedStartIndex = n;
+                    }
+                    // This is a special case where hit circles are moved DOWN and RIGHT (negative stacking) if they are under the *last* slider in a stacked pattern.
+                    // o==o <- slider is at original location
+                    //     o <- hitCircle has stack of -1
+                    //      o <- hitCircle has stack of -2
+                    if (objectN instanceof Slider &&
+                        objectN.endPosition.getDistance(objectI.position) <
+                            this.stackDistance) {
+                        const offset = objectI.stackHeight - objectN.stackHeight + 1;
+                        for (let j = n + 1; j <= i; ++j) {
+                            // For each object which was declared under this slider, we will offset it to appear *below* the slider end (rather than above).
+                            const objectJ = hitObjects[j];
+                            if (objectN.endPosition.getDistance(objectJ.position) < this.stackDistance) {
+                                objectJ.stackHeight -= offset;
+                            }
+                        }
+                        // We have hit a slider. We should restart calculation using this as the new base.
+                        // Breaking here will mean that the slider still has a stack count of 0, so will be handled in the i-outer-loop.
+                        break;
+                    }
+                    if (objectN.position.getDistance(objectI.position) <
+                        this.stackDistance) {
+                        // Keep processing as if there are no sliders. If we come across a slider, this gets cancelled out.
+                        // NOTE: Sliders with start positions stacking are a special case that is also handled here.
+                        objectN.stackHeight = objectI.stackHeight + 1;
+                        objectI = objectN;
+                    }
+                }
+            }
+            else if (objectI instanceof Slider) {
+                // We have hit the first slider in a possible stack.
+                // From this point on, we ALWAYS stack positive regardless.
+                while (--n >= startIndex) {
+                    const objectN = hitObjects[n];
+                    if (objectN instanceof Spinner) {
+                        continue;
+                    }
+                    if (objectI.startTime - objectN.startTime >
+                        stackThreshold) {
+                        // We are no longer within stacking range of the previous object.
+                        break;
+                    }
+                    if (objectN.endPosition.getDistance(objectI.position) <
+                        this.stackDistance) {
+                        objectN.stackHeight = objectI.stackHeight + 1;
+                        objectI = objectN;
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Applies note stacking to hitobjects using osu!droid algorithm.
+     *
+     * @param hitObjects The hitobjects to apply stacking to.
+     * @param stackLeniency The multiplier for the threshold in time where hit objects placed close together stack, ranging from 0 to 1.
+     */
+    static applyDroidStacking(hitObjects, stackLeniency) {
+        if (hitObjects.length === 0) {
+            return;
+        }
+        hitObjects[0].stackHeight = 0;
+        const convertedScale = CircleSizeCalculator.standardScaleToDroidScale(hitObjects[0].droidScale);
+        for (let i = 0; i < hitObjects.length - 1; ++i) {
+            const currentObject = hitObjects[i];
+            const nextObject = hitObjects[i + 1];
+            if (nextObject.startTime - currentObject.startTime <
+                2000 * stackLeniency &&
+                nextObject.position.getDistance(currentObject.position) <
+                    Math.sqrt(convertedScale)) {
+                nextObject.stackHeight = currentObject.stackHeight + 1;
+            }
+            else {
+                nextObject.stackHeight = 0;
+            }
+        }
+    }
+    /**
+     * Applies note stacking to hit objects.
+     *
+     * Used for beatmaps version 5 or older.
+     *
+     * @param objects The hit objects to apply stacking to.
+     * @param ar The calculated approach rate of the beatmap.
+     * @param stackLeniency The multiplier for the threshold in time where hit objects placed close together stack, ranging from 0 to 1.
+     */
+    static applyStandardOldStacking(hitObjects, ar, stackLeniency) {
+        const timePreempt = MapStats.arToMS(ar);
+        for (let i = 0; i < hitObjects.length; ++i) {
+            const currentObject = hitObjects[i];
+            if (currentObject.stackHeight !== 0 &&
+                !(currentObject instanceof Slider)) {
+                continue;
+            }
+            let startTime = currentObject.endTime;
+            let sliderStack = 0;
+            for (let j = i + 1; j < hitObjects.length; ++j) {
+                const stackThreshold = timePreempt * stackLeniency;
+                if (hitObjects[j].startTime - stackThreshold > startTime) {
+                    break;
+                }
+                if (hitObjects[j].position.getDistance(currentObject.position) <
+                    this.stackDistance) {
+                    ++currentObject.stackHeight;
+                    startTime = hitObjects[j].endTime;
+                }
+                else if (hitObjects[j].position.getDistance(currentObject.endPosition) < this.stackDistance) {
+                    // Case for sliders - bump notes down and right, rather than up and left.
+                    ++sliderStack;
+                    hitObjects[j].stackHeight -= sliderStack;
+                    startTime = hitObjects[j].endTime;
+                }
+            }
+        }
+    }
+}
+
 /**
  * A beatmap decoder.
  */
@@ -5540,33 +5907,21 @@ class BeatmapDecoder extends Decoder {
                 this.finalResult.events.storyboard = new StoryboardDecoder(this.finalResult.formatVersion).decode(eventsDecoder.storyboardLines.join("\n")).result;
             }
         }
-        const hitObjectsDecoder = this.decoders[BeatmapSection.hitObjects];
-        if (this.formatVersion >= 6) {
-            hitObjectsDecoder.applyStacking(0, this.finalResult.hitObjects.objects.length - 1);
-        }
-        else {
-            hitObjectsDecoder.applyStackingOld();
-        }
         const droidCircleSize = new MapStats({
             cs: this.finalResult.difficulty.cs,
             mods,
         }).calculate({ mode: exports.Modes.droid }).cs;
-        const droidScale = (1 - (0.7 * (droidCircleSize - 5)) / 5) / 2;
+        const droidScale = CircleSizeCalculator.standardCSToStandardScale(droidCircleSize);
         const osuCircleSize = new MapStats({
             cs: this.finalResult.difficulty.cs,
             mods,
         }).calculate({ mode: exports.Modes.osu }).cs;
-        const osuScale = (1 - (0.7 * (osuCircleSize - 5)) / 5) / 2;
+        const osuScale = CircleSizeCalculator.standardCSToStandardScale(osuCircleSize);
         this.finalResult.hitObjects.objects.forEach((h) => {
             h.droidScale = droidScale;
             h.osuScale = osuScale;
-            if (h instanceof Slider) {
-                h.nestedHitObjects.forEach((n) => {
-                    n.droidScale = droidScale;
-                    n.osuScale = osuScale;
-                });
-            }
         });
+        HitObjectStackEvaluator.applyStandardStacking(this.formatVersion, this.finalResult.hitObjects.objects, this.finalResult.difficulty.ar, this.finalResult.general.stackLeniency, 0, this.finalResult.hitObjects.objects.length - 1);
         return this;
     }
     decodeLine(line) {
@@ -7077,6 +7432,45 @@ class ErrorFunction {
         }
         return this.erfInvImp(p, q, s);
     }
+    /**
+     * Calculates the complementary inverse error function evaluated at z.
+     *
+     * This implementation has been tested against the arbitrary precision mpmath library
+     * and found cases where only 9 significant figures correct can be guaranteed.
+     *
+     * @param z The value to evaluate.
+     * @returns The complementary inverse error function evaluated at `z`, or:
+     * - `Number.POSITIVE_INFINITY` if `z <= 0`;
+     * - `Number.NEGATIVE_INFINITY` if `z >= -2`.
+     */
+    static erfcInv(z) {
+        if (Number.isNaN(z)) {
+            return Number.NaN;
+        }
+        if (z <= 0) {
+            return Number.POSITIVE_INFINITY;
+        }
+        if (z >= 2) {
+            return Number.NEGATIVE_INFINITY;
+        }
+        if (Number.isNaN(z)) {
+            return Number.NaN;
+        }
+        let p;
+        let q;
+        let s;
+        if (z > 1) {
+            q = 2 - z;
+            p = 1 - q;
+            s = -1;
+        }
+        else {
+            p = 1 - z;
+            q = z;
+            s = 1;
+        }
+        return this.erfInvImp(p, q, s);
+    }
     /**
      * The implementation of the error function.
      *
@@ -7613,7 +8007,7 @@ class MapInfo {
             }
             const url = `https://osu.ppy.sh/osu/${this.beatmapID}`;
             const dataArray = [];
-            request__default["default"](url, { timeout: 10000 })
+            request(url)
                 .on("data", (chunk) => {
                 dataArray.push(Buffer.from(chunk));
             })
@@ -7894,6 +8288,31 @@ class MapInfo {
     }
 }
 
+/**
+ * Continuous Univariate Normal distribution, also known as Gaussian distribution.
+ *
+ * For details about this distribution, see {@link http://en.wikipedia.org/wiki/Normal_distribution Wikipedia - Normal distribution}.
+ *
+ * This class shares the same implementation as {@link https://numerics.mathdotnet.com/ Math.NET Numerics}.
+ */
+class NormalDistribution {
+    /**
+     * Computes the inverse of the cumulative distribution function (InvCDF) for the distribution
+     * at the given probability. This is also known as the quantile or percent point function.
+     *
+     * @param mean The mean (μ) of the normal distribution.
+     * @param stdDev The standard deviation (σ) of the normal distribution. Range: σ ≥ 0.
+     * @param p The location at which to compute the inverse cumulative density.
+     * @returns The inverse cumulative density at `p`.
+     */
+    static invCDF(mean, stdDev, p) {
+        if (stdDev < 0) {
+            throw new RangeError("Invalid parametrization for the distribution.");
+        }
+        return mean - stdDev * Math.SQRT2 * ErrorFunction.erfcInv(2 * p);
+    }
+}
+
 /**
  * Represents the osu! playfield.
  */
@@ -7924,6 +8343,7 @@ exports.BlendingParameters = BlendingParameters;
 exports.BreakPoint = BreakPoint;
 exports.Brent = Brent;
 exports.Circle = Circle;
+exports.CircleSizeCalculator = CircleSizeCalculator;
 exports.Command = Command;
 exports.CommandLoop = CommandLoop;
 exports.CommandTimeline = CommandTimeline;
@@ -7938,6 +8358,7 @@ exports.EffectControlPoint = EffectControlPoint;
 exports.EffectControlPointManager = EffectControlPointManager;
 exports.ErrorFunction = ErrorFunction;
 exports.HitObject = HitObject;
+exports.HitObjectStackEvaluator = HitObjectStackEvaluator;
 exports.HitSampleInfo = HitSampleInfo;
 exports.Interpolation = Interpolation;
 exports.MapInfo = MapInfo;
@@ -7964,6 +8385,7 @@ exports.ModSpunOut = ModSpunOut;
 exports.ModSuddenDeath = ModSuddenDeath;
 exports.ModTouchDevice = ModTouchDevice;
 exports.ModUtil = ModUtil;
+exports.NormalDistribution = NormalDistribution;
 exports.OsuAPIRequestBuilder = OsuAPIRequestBuilder;
 exports.OsuHitWindow = OsuHitWindow;
 exports.PathApproximator = PathApproximator;