@rian8337/osu-difficulty-calculator 4.0.0-beta.93 → 4.0.0-beta.95

package/dist/index.js

@@ -223,17 +223,8 @@ class Skill {
     get objectDifficulties() {
         return this._objectDifficulties;
     }
-    /**
-     * The start times of {@link DifficultyHitObject}s, populated by {@link Skill.process}.
-     *
-     * Indices correspond to {@link objectDifficulties}.
-     */
-    get objectTimes() {
-        return this._objectTimes;
-    }
     constructor(mods) {
         this._objectDifficulties = [];
-        this._objectTimes = [];
         this.mods = mods;
     }
     /**
@@ -249,7 +240,6 @@ class Skill {
         const difficultyValue = this.processInternal(current);
         this.saveToHitObject(current, difficultyValue);
         this._objectDifficulties.push(difficultyValue);
-        this._objectTimes.push(current.startTime);
     }
     /**
      * Saves the calculated difficulty to a {@link DifficultyHitObject}.
@@ -1015,6 +1005,7 @@ class DroidFlashlightEvaluator {
      * @param mods The mods used.
      */
     static evaluateDifficultyOf(current, mods) {
+        var _a;
         if (current.object instanceof osuBase.Spinner ||
             // Exclude overlapping objects that can be tapped at once.
             current.isOverlapping(true)) {
@@ -1026,6 +1017,10 @@ class DroidFlashlightEvaluator {
         let result = 0;
         let last = current;
         let angleRepeatCount = 0;
+        // Hidden's fade-out only affects opacity when the "only fade approach circles" setting is off.
+        const opacityMods = ((_a = mods.get(osuBase.ModHidden)) === null || _a === void 0 ? void 0 : _a.onlyFadeApproachCircles.value)
+            ? undefined
+            : mods;
         for (let i = 0; i < Math.min(current.index, 10); ++i) {
             const currentObject = current.previous(i);
             cumulativeStrainTime += last.strainTime;
@@ -1043,7 +1038,7 @@ class DroidFlashlightEvaluator {
                 const opacityBonus = 1 +
                     this.maxOpacityBonus *
                         (1 -
-                            current.opacityAt(currentObject.object.startTime, mods));
+                            current.opacityAt(currentObject.object.startTime, opacityMods));
                 result +=
                     (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
                         cumulativeStrainTime;
@@ -1133,7 +1128,10 @@ class StrainSkill extends Skill {
     get peaks() {
         return this.strainPeaks
             .map((value, i) => ({ time: this.strainPeakTimes[i], value }))
-            .concat({ time: this.currentSectionEnd, value: this.currentSectionPeak });
+            .concat({
+            time: this.currentSectionEnd,
+            value: this.currentSectionPeak,
+        });
     }
     /**
      * Converts a difficulty value to a performance value.
@@ -1180,9 +1178,7 @@ class StrainSkill extends Skill {
             this.startNewSectionFrom(this.currentSectionEnd, current);
             this.currentSectionEnd += this.sectionLength;
         }
-        // Ignore the first hitobject.
         this.currentStrain = this.strainValueAt(current);
-        this.saveToHitObject(current, this.currentStrain);
         this.currentSectionPeak = Math.max(this.currentStrain, this.currentSectionPeak);
         return this.currentStrain;
     }
@@ -1268,8 +1264,8 @@ class DroidFlashlight extends DroidSkill {
         this.totalObjects = totalObjects;
         this.reducedSectionCount = 0;
         this.reducedSectionBaseline = 1;
-        this.starsPerDouble = 1.06;
-        this.skillMultiplier = 0.024;
+        this.starsPerDouble = 1;
+        this.skillMultiplier = 0.058;
         this.currentFlashlightStrain = 0;
     }
     strainValueAt(current) {
@@ -1326,6 +1322,7 @@ class HarmonicSkill extends Skill {
     constructor() {
         super(...arguments);
         this._noteWeightSum = 0;
+        this._objectTimes = [];
         /**
          * Scaling factor applied as `x / (i + 1)`, where `x` is the skill's {@link harmonicScale} and `i`
          * is the index of the {@link DifficultyHitObject} being processed.
@@ -1348,6 +1345,14 @@ class HarmonicSkill extends Skill {
     get noteWeightSum() {
         return this._noteWeightSum;
     }
+    /**
+     * The start times of {@link DifficultyHitObject}s, populated by {@link HarmonicSkill.process}.
+     *
+     * Indices correspond to {@link objectDifficulties}.
+     */
+    get objectTimes() {
+        return this._objectTimes;
+    }
     get peaks() {
         return this.objectDifficulties.map((value, i) => ({
             time: this.objectTimes[i],
@@ -1413,6 +1418,13 @@ class HarmonicSkill extends Skill {
     applyDifficultyTransformation(difficulties) {
         // Do nothing by default.
     }
+    process(current) {
+        const previousLength = this.objectDifficulties.length;
+        super.process(current);
+        if (this.objectDifficulties.length > previousLength) {
+            this._objectTimes.push(current.startTime);
+        }
+    }
     processInternal(current) {
         return this.objectDifficultyOf(current);
     }
@@ -2527,6 +2539,10 @@ class DifficultyHitObject {
          * The flashlight strain generated by the hitobject.
          */
         this.flashlightStrain = 0;
+        /**
+         * The reading difficulty generated by the hitobject.
+         */
+        this.readingDifficulty = 0;
         /**
          * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
          */
@@ -2685,16 +2701,9 @@ class DifficultyHitObject {
         const nextDeltaTime = Math.max(1, nextObj.deltaTime);
         const deltaDifference = Math.abs(nextDeltaTime - currentDeltaTime);
         const speedRatio = currentDeltaTime / Math.max(currentDeltaTime, deltaDifference);
-        if (this.mode === osuBase.Modes.Droid) {
-            const windowRatio = Math.pow(Math.min(1, currentDeltaTime / this.hitWindowFor(osuBase.HitResult.Great)), 5);
-            const distanceFactor = Math.pow(osuBase.Interpolation.reverseLerp(this.lazyJumpDistance, this.normalizedDiameter, this.normalizedRadius), 2);
-            return 1 - Math.pow(speedRatio, distanceFactor * (1 - windowRatio));
-        }
-        else {
-            // TODO: unported osu!standard change
-            const windowRatio = Math.pow(Math.min(1, currentDeltaTime / this.hitWindowFor(osuBase.HitResult.Great)), 2);
-            return 1 - Math.pow(speedRatio, 1 - windowRatio);
-        }
+        const windowRatio = Math.pow(Math.min(1, currentDeltaTime / this.hitWindowFor(osuBase.HitResult.Great)), 5);
+        const distanceFactor = Math.pow(osuBase.Interpolation.reverseLerp(this.lazyJumpDistance, this.normalizedDiameter, this.normalizedRadius), 2);
+        return 1 - Math.pow(speedRatio, distanceFactor * (1 - windowRatio));
     }
     /**
      * Retrieves the full rate-adjusted hit window for a {@link HitResult}.
@@ -2715,17 +2724,9 @@ class DifficultyHitObject {
         var _a;
         if (this.object instanceof osuBase.Slider) {
             // Bonus for repeat sliders until a better per nested object strain system can be achieved.
-            if (this.mode === osuBase.Modes.Droid) {
-                this.travelDistance =
-                    this.lazyTravelDistance *
-                        Math.max(1, Math.pow(this.object.repeatCount, 0.3));
-            }
-            else {
-                // TODO: unported osu!standard change
-                this.travelDistance =
-                    this.lazyTravelDistance *
-                        Math.pow(1 + this.object.repeatCount / 2.5, 1 / 2.5);
-            }
+            this.travelDistance =
+                this.lazyTravelDistance *
+                    Math.max(1, Math.pow(this.object.repeatCount, 0.3));
             this.travelTime = Math.max(this.lazyTravelTime / clockRate, DifficultyHitObject.minDeltaTime);
         }
         this.minimumJumpTime = this.strainTime;
@@ -2776,29 +2777,17 @@ class DifficultyHitObject {
         if (this.lastLastDifficultyObject &&
             !(this.lastLastDifficultyObject.object instanceof osuBase.Spinner)) {
             const lastLastCursorPosition = this.getEndCursorPosition(this.lastLastDifficultyObject);
-            if (this.mode === osuBase.Modes.Droid) {
-                if (((_a = this.lastDifficultyObject) === null || _a === void 0 ? void 0 : _a.object) instanceof osuBase.Slider &&
-                    this.lastDifficultyObject.travelDistance > 0) {
-                    lastCursorPosition =
-                        this.lastDifficultyObject.object.stackedPosition;
-                }
-                const angle = this.calculateAngle(this.object.stackedPosition, lastCursorPosition, lastLastCursorPosition);
-                const sliderAngle = this.calculateSliderAngle(this.lastDifficultyObject, lastLastCursorPosition);
-                const v = this.object.stackedPosition.subtract(lastCursorPosition);
-                this.normalizedVectorAngle = Math.atan2(Math.abs(v.y), Math.abs(v.x));
-                this.angleSigned =
-                    Math.abs(angle) <= Math.abs(sliderAngle)
-                        ? angle
-                        : sliderAngle;
-            }
-            else {
-                // TODO: unported osu!standard change
-                const v1 = lastLastCursorPosition.subtract(this.lastObject.stackedPosition);
-                const v2 = this.object.stackedPosition.subtract(lastCursorPosition);
-                const dot = v1.dot(v2);
-                const det = v1.x * v2.y - v1.y * v2.x;
-                this.angleSigned = Math.atan2(det, dot);
+            if (((_a = this.lastDifficultyObject) === null || _a === void 0 ? void 0 : _a.object) instanceof osuBase.Slider &&
+                this.lastDifficultyObject.travelDistance > 0) {
+                lastCursorPosition =
+                    this.lastDifficultyObject.object.stackedPosition;
             }
+            const angle = this.calculateAngle(this.object.stackedPosition, lastCursorPosition, lastLastCursorPosition);
+            const sliderAngle = this.calculateSliderAngle(this.lastDifficultyObject, lastLastCursorPosition);
+            const v = this.object.stackedPosition.subtract(lastCursorPosition);
+            this.normalizedVectorAngle = Math.atan2(Math.abs(v.y), Math.abs(v.x));
+            this.angleSigned =
+                Math.abs(angle) <= Math.abs(sliderAngle) ? angle : sliderAngle;
         }
     }
     calculateAngle(currentPosition, lastPosition, lastLastPosition) {
@@ -2931,10 +2920,6 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
          * The rhythm difficulty generated by the hitobject.
          */
         this.rhythmDifficulty = 0;
-        /**
-         * The reading difficulty generated by the hitobject.
-         */
-        this.readingDifficulty = 0;
         this.normalizedRadius = 50;
         this.mode = osuBase.Modes.Droid;
     }
@@ -3022,17 +3007,24 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
     }
 }
 
-class DroidIsland {
-    constructor(delta, deltaDifferenceEpsilon) {
+/**
+ * Represents a group of consecutive objects with the same delta time.
+ */
+class Island {
+    constructor(delta) {
+        /**
+         * Delta time of every object in this island.
+         */
         this.delta = Number.MAX_SAFE_INTEGER;
-        this.deltaCount = 0;
-        if (deltaDifferenceEpsilon === undefined) {
-            this.deltaDifferenceEpsilon = delta;
-        }
-        else {
-            this.deltaDifferenceEpsilon = deltaDifferenceEpsilon;
-            this.addDelta(delta);
-        }
+        /**
+         * How long the island is.
+         */
+        this.deltaCount = 1;
+        /**
+         * How many times the island already occured.
+         */
+        this.occurrences = 1;
+        this.delta = Math.max(Math.trunc(delta), DifficultyHitObject.minDeltaTime);
     }
     addDelta(delta) {
         if (this.delta === Number.MAX_SAFE_INTEGER) {
@@ -3040,27 +3032,20 @@ class DroidIsland {
         }
         ++this.deltaCount;
     }
-    isSimilarPolarity(other) {
+    isSimilarPolarity(other, epsilon) {
         // Single delta islands should not be compared.
         if (this.deltaCount <= 1 || other.deltaCount <= 1) {
             return false;
         }
-        return (Math.abs(this.delta - other.delta) < this.deltaDifferenceEpsilon &&
+        return (Math.abs(this.delta - other.delta) < epsilon &&
             this.deltaCount % 2 === other.deltaCount % 2);
     }
-    equals(other) {
-        return (Math.abs(this.delta - other.delta) < this.deltaDifferenceEpsilon &&
+    almostEquals(other, epsilon) {
+        return (Math.abs(this.delta - other.delta) < epsilon &&
             this.deltaCount === other.deltaCount);
     }
 }
 
-class DroidIslandCounter {
-    constructor(island, count) {
-        this.island = island;
-        this.count = count;
-    }
-}
-
 /**
  * An evaluator for calculating osu!droid Rhythm skill.
  */
@@ -3078,9 +3063,9 @@ class DroidRhythmEvaluator {
         }
         const deltaDifferenceEpsilon = current.hitWindowFor(osuBase.HitResult.Great) * 0.3;
         let rhythmComplexitySum = 0;
-        let island = new DroidIsland(deltaDifferenceEpsilon);
-        let previousIsland = new DroidIsland(deltaDifferenceEpsilon);
-        const islandCounts = [];
+        let island = new Island(Number.MAX_SAFE_INTEGER);
+        let previousIsland = new Island(Number.MAX_SAFE_INTEGER);
+        const islands = [];
         // Store the ratio of the current start of an island to buff for tighter rhythms.
         let startRatio = 0;
         let firstDeltaSwitch = false;
@@ -3121,7 +3106,7 @@ class DroidRhythmEvaluator {
             const prevDelta = Math.max(prevObject.deltaTime, 1e-7);
             const lastDelta = Math.max(lastObject.deltaTime, 1e-7);
             if (island.delta == Number.MAX_SAFE_INTEGER) {
-                island = new DroidIsland(currentDelta, deltaDifferenceEpsilon);
+                island = new Island(currentDelta);
             }
             // Calculate how much current delta difference deserves a rhythm bonus.
             // This function is meant to reduce rhythm bonus for deltas that are multiples of each other (i.e. 100 and 200).
@@ -3158,7 +3143,7 @@ class DroidRhythmEvaluator {
                         effectiveRatio /= 2;
                     }
                     // Repeated island polarity (2 -> 4, 3 -> 5).
-                    if (island.isSimilarPolarity(previousIsland)) {
+                    if (island.isSimilarPolarity(previousIsland, deltaDifferenceEpsilon)) {
                         effectiveRatio /= 2;
                     }
                     // Previous increase happened a note ago.
@@ -3175,18 +3160,24 @@ class DroidRhythmEvaluator {
                     if (isSpeedingUp) {
                         effectiveRatio *= 0.65;
                     }
-                    const islandCount = islandCounts.find((x) => x.island.equals(island));
-                    if (islandCount) {
+                    let found = false;
+                    for (const existingIsland of islands) {
+                        if (!existingIsland.almostEquals(island, deltaDifferenceEpsilon)) {
+                            continue;
+                        }
                         // Only add island to island counts if they're going one after another.
-                        if (previousIsland.equals(island)) {
-                            ++islandCount.count;
+                        if (previousIsland.almostEquals(island, deltaDifferenceEpsilon)) {
+                            ++existingIsland.occurrences;
                         }
+                        const power = osuBase.MathUtils.offsetLogistic(island.delta, 58.33, 0.24, 2.75);
                         // Repeated island (ex: triplet -> triplet).
                         // Graph: https://www.desmos.com/calculator/pj7an56zwf
-                        effectiveRatio *= Math.min(3 / islandCount.count, Math.pow(1 / islandCount.count, osuBase.MathUtils.offsetLogistic(island.delta, 58.33, 0.24, 2.75)));
+                        effectiveRatio *= Math.min(3 / existingIsland.occurrences, Math.pow(1 / existingIsland.occurrences, power));
+                        found = true;
+                        break;
                     }
-                    else if (island.deltaCount > 0) {
-                        islandCounts.push(new DroidIslandCounter(island, 1));
+                    if (!found && island.deltaCount > 0) {
+                        islands.push(island);
                     }
                     // Scale down the difficulty if the object is doubletappable.
                     effectiveRatio *=
@@ -3207,7 +3198,7 @@ class DroidRhythmEvaluator {
                         // If we're speeding up, this stays as is and we keep counting island size.
                         firstDeltaSwitch = false;
                     }
-                    island = new DroidIsland(currentDelta, deltaDifferenceEpsilon);
+                    island = new Island(currentDelta);
                 }
             }
             else if (prevDelta > currentDelta + deltaDifferenceEpsilon) {
@@ -3225,7 +3216,7 @@ class DroidRhythmEvaluator {
                     effectiveRatio *= 0.6;
                 }
                 startRatio = effectiveRatio;
-                island = new DroidIsland(currentDelta, deltaDifferenceEpsilon);
+                island = new Island(currentDelta);
             }
             lastObject = prevObject;
             prevObject = currentObject;
@@ -3289,6 +3280,7 @@ class DifficultyAttributes {
         this.maxCombo = 0;
         this.aimDifficulty = 0;
         this.flashlightDifficulty = 0;
+        this.readingDifficulty = 0;
         this.speedNoteCount = 0;
         this.sliderFactor = 1;
         this.clockRate = 1;
@@ -3298,6 +3290,8 @@ class DifficultyAttributes {
         this.spinnerCount = 0;
         this.aimDifficultSliderCount = 0;
         this.aimDifficultStrainCount = 0;
+        this.aimTopWeightedSliderFactor = 0;
+        this.readingDifficultNoteCount = 0;
         if (!cacheableAttributes) {
             return;
         }
@@ -3306,6 +3300,7 @@ class DifficultyAttributes {
         this.maxCombo = cacheableAttributes.maxCombo;
         this.aimDifficulty = cacheableAttributes.aimDifficulty;
         this.flashlightDifficulty = cacheableAttributes.flashlightDifficulty;
+        this.readingDifficulty = cacheableAttributes.readingDifficulty;
         this.speedNoteCount = cacheableAttributes.speedNoteCount;
         this.sliderFactor = cacheableAttributes.sliderFactor;
         this.clockRate = cacheableAttributes.clockRate;
@@ -3317,6 +3312,10 @@ class DifficultyAttributes {
             cacheableAttributes.aimDifficultSliderCount;
         this.aimDifficultStrainCount =
             cacheableAttributes.aimDifficultStrainCount;
+        this.aimTopWeightedSliderFactor =
+            cacheableAttributes.aimTopWeightedSliderFactor;
+        this.readingDifficultNoteCount =
+            cacheableAttributes.readingDifficultNoteCount;
     }
     /**
      * Converts this `DifficultyAttributes` instance to an attribute structure that can be cached.
@@ -3341,10 +3340,7 @@ class DroidDifficultyAttributes extends DifficultyAttributes {
     constructor(cacheableAttributes) {
         super(cacheableAttributes);
         this.tapDifficulty = 0;
-        this.readingDifficulty = 0;
-        this.aimTopWeightedSliderFactor = 0;
         this.tapTopWeightedSliderFactor = 0;
-        this.readingDifficultNoteCount = 0;
         this.rhythmDifficulty = 0;
         this.tapDifficultStrainCount = 0;
         this.maximumScore = 0;
@@ -3356,10 +3352,6 @@ class DroidDifficultyAttributes extends DifficultyAttributes {
         this.readingDifficulty = cacheableAttributes.readingDifficulty;
         this.tapDifficultStrainCount =
             cacheableAttributes.tapDifficultStrainCount;
-        this.readingDifficultNoteCount =
-            cacheableAttributes.readingDifficultNoteCount;
-        this.aimTopWeightedSliderFactor =
-            cacheableAttributes.aimTopWeightedSliderFactor;
         this.tapTopWeightedSliderFactor =
             cacheableAttributes.tapTopWeightedSliderFactor;
         this.maximumScore = cacheableAttributes.maximumScore;
@@ -3640,13 +3632,9 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         attributes.rhythmDifficulty = this.calculateDifficultyRating((_a = rhythm === null || rhythm === void 0 ? void 0 : rhythm.difficultyValue()) !== null && _a !== void 0 ? _a : 0);
     }
     populateFlashlightAttributes(attributes, skills) {
+        var _a;
         const flashlight = skills.find((s) => s instanceof DroidFlashlight);
-        if (!flashlight) {
-            attributes.flashlightDifficulty = 0;
-            return;
-        }
-        attributes.flashlightDifficulty =
-            Math.sqrt(flashlight.difficultyValue()) * 0.18;
+        attributes.flashlightDifficulty = this.calculateDifficultyRating((_a = flashlight === null || flashlight === void 0 ? void 0 : flashlight.difficultyValue()) !== null && _a !== void 0 ? _a : 0);
     }
     populateReadingAttributes(attributes, skills) {
         const reading = skills.find((s) => s instanceof DroidReading);
@@ -3678,154 +3666,33 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
 }
 
 /**
- * An evaluator for calculating osu!standard Aim skill.
+ * An evaluator for calculating osu!standard agility aim difficulty.
  */
-class OsuAimEvaluator {
+class OsuAgilityEvaluator {
     /**
-     * Evaluates the difficulty of aiming the current object, based on:
-     *
-     * - cursor velocity to the current object,
-     * - angle difficulty,
-     * - sharp velocity increases,
-     * - and slider difficulty.
+     * Evaluates the difficulty of fast aiming the current object.
      *
      * @param current The current object.
-     * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current, withSliders) {
-        const last = current.previous(0);
-        if (current.object instanceof osuBase.Spinner ||
-            current.index <= 1 ||
-            last.object instanceof osuBase.Spinner) {
+    static evaluateDifficultyOf(current) {
+        var _a;
+        if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
-        const lastLast = current.previous(1);
-        const last2 = current.previous(2);
-        const radius = current.normalizedRadius;
-        const diameter = current.normalizedDiameter;
-        // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
-        let currentVelocity = current.lazyJumpDistance / current.strainTime;
-        // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
-        if (last.object instanceof osuBase.Slider && withSliders) {
-            // Calculate the slider velocity from slider head to slider end.
-            const travelVelocity = last.travelDistance / last.travelTime;
-            // Calculate the movement velocity from slider end to current object.
-            const movementVelocity = current.minimumJumpDistance / current.minimumJumpTime;
-            // Take the larger total combined velocity.
-            currentVelocity = Math.max(currentVelocity, movementVelocity + travelVelocity);
-        }
-        // As above, do the same for the previous hitobject.
-        let prevVelocity = last.lazyJumpDistance / last.strainTime;
-        if (lastLast.object instanceof osuBase.Slider && withSliders) {
-            const travelVelocity = lastLast.travelDistance / lastLast.travelTime;
-            const movementVelocity = last.minimumJumpDistance / last.minimumJumpTime;
-            prevVelocity = Math.max(prevVelocity, movementVelocity + travelVelocity);
-        }
-        let wideAngleBonus = 0;
-        let acuteAngleBonus = 0;
-        let sliderBonus = 0;
-        let velocityChangeBonus = 0;
-        let wiggleBonus = 0;
-        // Start strain with regular velocity.
-        let strain = currentVelocity;
-        if (current.angle !== null && last.angle !== null) {
-            const currentAngle = current.angle;
-            const lastAngle = last.angle;
-            // Rewarding angles, take the smaller velocity as base.
-            const angleBonus = Math.min(currentVelocity, prevVelocity);
-            if (
-            // If rhythms are the same.
-            Math.max(current.strainTime, last.strainTime) <
-                1.25 * Math.min(current.strainTime, last.strainTime)) {
-                acuteAngleBonus = this.calculateAcuteAngleBonus(currentAngle);
-                // Penalize angle repetition.
-                acuteAngleBonus *=
-                    0.08 +
-                        0.92 *
-                            (1 -
-                                Math.min(acuteAngleBonus, Math.pow(this.calculateAcuteAngleBonus(lastAngle), 3)));
-                // Apply acute angle bonus for BPM above 300 1/2 and distance more than one diameter
-                acuteAngleBonus *=
-                    angleBonus *
-                        osuBase.MathUtils.smootherstep(osuBase.MathUtils.millisecondsToBPM(current.strainTime, 2), 300, 400) *
-                        osuBase.MathUtils.smootherstep(current.lazyJumpDistance, diameter, diameter * 2);
-            }
-            wideAngleBonus = this.calculateWideAngleBonus(currentAngle);
-            // Penalize angle repetition.
-            wideAngleBonus *=
-                1 -
-                    Math.min(wideAngleBonus, Math.pow(this.calculateWideAngleBonus(lastAngle), 3));
-            // Apply full wide angle bonus for distance more than one diameter
-            wideAngleBonus *=
-                angleBonus *
-                    osuBase.MathUtils.smootherstep(current.lazyJumpDistance, 0, diameter);
-            // Apply wiggle bonus for jumps that are [radius, 3*diameter] in distance, with < 110 angle
-            // https://www.desmos.com/calculator/dp0v0nvowc
-            wiggleBonus =
-                angleBonus *
-                    osuBase.MathUtils.smootherstep(current.lazyJumpDistance, radius, diameter) *
-                    Math.pow(osuBase.MathUtils.reverseLerp(current.lazyJumpDistance, diameter * 3, diameter), 1.8) *
-                    osuBase.MathUtils.smootherstep(currentAngle, osuBase.MathUtils.degreesToRadians(110), osuBase.MathUtils.degreesToRadians(60)) *
-                    osuBase.MathUtils.smootherstep(last.lazyJumpDistance, radius, diameter) *
-                    Math.pow(osuBase.MathUtils.reverseLerp(last.lazyJumpDistance, diameter * 3, diameter), 1.8) *
-                    osuBase.MathUtils.smootherstep(lastAngle, osuBase.MathUtils.degreesToRadians(110), osuBase.MathUtils.degreesToRadians(60));
-            if (last2 !== null) {
-                // If objects just go back and forth through a middle point - don't give as much wide bonus.
-                // Use previous(2) and previous(0) because angles calculation is done prevprev-prev-curr, so any
-                // object's angle's center point is always the previous object.
-                const distance = last2.object.stackedPosition.getDistance(last.object.stackedPosition);
-                if (distance < 1) {
-                    wideAngleBonus *= 1 - 0.35 * (1 - distance);
-                }
-            }
-        }
-        if (Math.max(prevVelocity, currentVelocity)) {
-            // We want to use the average velocity over the whole object when awarding differences, not the individual jump and slider path velocities.
-            prevVelocity =
-                (last.lazyJumpDistance + lastLast.travelDistance) /
-                    last.strainTime;
-            currentVelocity =
-                (current.lazyJumpDistance + last.travelDistance) /
-                    current.strainTime;
-            // Scale with ratio of difference compared to half the max distance.
-            const distanceRatio = osuBase.MathUtils.smoothstep(Math.abs(prevVelocity - currentVelocity) /
-                Math.max(prevVelocity, currentVelocity), 0, 1);
-            // Reward for % distance up to 125 / strainTime for overlaps where velocity is still changing.
-            const overlapVelocityBuff = Math.min((diameter * 1.25) /
-                Math.min(current.strainTime, last.strainTime), Math.abs(prevVelocity - currentVelocity));
-            velocityChangeBonus = overlapVelocityBuff * distanceRatio;
-            // Penalize for rhythm changes.
-            velocityChangeBonus *= Math.pow(Math.min(current.strainTime, last.strainTime) /
-                Math.max(current.strainTime, last.strainTime), 2);
-        }
-        if (last.travelTime) {
-            // Reward sliders based on velocity.
-            sliderBonus = last.travelDistance / last.travelTime;
-        }
-        strain += wiggleBonus * this.wiggleMultiplier;
-        strain += velocityChangeBonus * this.velocityChangeMultiplier;
-        // Add in acute angle bonus or wide angle bonus, whichever is larger.
-        strain += Math.max(acuteAngleBonus * this.acuteAngleMultiplier, wideAngleBonus * this.wideAngleMultiplier);
-        // Apply high circle size bonus
-        strain *= current.smallCircleBonus;
-        // Add in additional slider velocity bonus.
-        if (withSliders) {
-            strain += sliderBonus * this.sliderMultiplier;
-        }
+        const prev = current.previous(0);
+        const travelDistance = (_a = prev === null || prev === void 0 ? void 0 : prev.lazyTravelDistance) !== null && _a !== void 0 ? _a : 0;
+        const distance = travelDistance + current.lazyJumpDistance;
+        const distanceCap = current.normalizedDiameter * 1.2;
+        const distanceScaled = Math.min(distance, distanceCap) / distanceCap;
+        let strain = (distanceScaled * 1000) / current.strainTime;
+        strain *= Math.pow(current.smallCircleBonus, 1.5);
+        strain *= this.highBpmBonus(current.strainTime);
         return strain;
     }
-    static calculateWideAngleBonus(angle) {
-        return osuBase.MathUtils.smoothstep(angle, osuBase.MathUtils.degreesToRadians(40), osuBase.MathUtils.degreesToRadians(140));
-    }
-    static calculateAcuteAngleBonus(angle) {
-        return osuBase.MathUtils.smoothstep(angle, osuBase.MathUtils.degreesToRadians(140), osuBase.MathUtils.degreesToRadians(40));
+    static highBpmBonus(ms) {
+        return 1 / (1 - Math.pow(0.2, ms / 1000));
     }
 }
-OsuAimEvaluator.wideAngleMultiplier = 1.5;
-OsuAimEvaluator.acuteAngleMultiplier = 2.55;
-OsuAimEvaluator.sliderMultiplier = 1.35;
-OsuAimEvaluator.velocityChangeMultiplier = 0.75;
-OsuAimEvaluator.wiggleMultiplier = 1.02;
 
 /**
  * An evaluator for calculating osu!standard Flashlight skill.
@@ -3844,6 +3711,7 @@ class OsuFlashlightEvaluator {
      * @param mods The mods used.
      */
     static evaluateDifficultyOf(current, mods) {
+        var _a;
         if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
@@ -3853,6 +3721,10 @@ class OsuFlashlightEvaluator {
         let result = 0;
         let last = current;
         let angleRepeatCount = 0;
+        // Hidden's fade-out only affects opacity when the "only fade approach circles" setting is off.
+        const opacityMods = ((_a = mods.get(osuBase.ModHidden)) === null || _a === void 0 ? void 0 : _a.onlyFadeApproachCircles.value)
+            ? undefined
+            : mods;
         for (let i = 0; i < Math.min(current.index, 10); ++i) {
             const currentObject = current.previous(i);
             cumulativeStrainTime += last.strainTime;
@@ -3868,7 +3740,7 @@ class OsuFlashlightEvaluator {
                 const opacityBonus = 1 +
                     this.maxOpacityBonus *
                         (1 -
-                            current.opacityAt(currentObject.object.startTime, mods));
+                            current.opacityAt(currentObject.object.startTime, opacityMods));
                 result +=
                     (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
                         cumulativeStrainTime;
@@ -3912,149 +3784,660 @@ OsuFlashlightEvaluator.minVelocity = 0.5;
 OsuFlashlightEvaluator.sliderMultiplier = 1.3;
 OsuFlashlightEvaluator.minAngleMultiplier = 0.2;
 
-class OsuIsland {
-    constructor(delta, deltaDifferenceEpsilon) {
-        this.delta = Number.MAX_SAFE_INTEGER;
-        this.deltaCount = 0;
-        if (deltaDifferenceEpsilon === undefined) {
-            this.deltaDifferenceEpsilon = delta;
-        }
-        else {
-            this.deltaDifferenceEpsilon = deltaDifferenceEpsilon;
-            this.addDelta(delta);
-        }
-    }
-    addDelta(delta) {
-        if (this.delta === Number.MAX_SAFE_INTEGER) {
-            this.delta = Math.max(Math.trunc(delta), DifficultyHitObject.minDeltaTime);
-        }
-        ++this.deltaCount;
-    }
-    isSimilarPolarity(other) {
-        // TODO: consider islands to be of similar polarity only if they're having the same average delta (we don't want to consider 3 singletaps similar to a triple)
-        // naively adding delta check here breaks _a lot_ of maps because of the flawed ratio calculation
-        return this.deltaCount % 2 == other.deltaCount % 2;
-    }
-    equals(other) {
-        return (Math.abs(this.delta - other.delta) < this.deltaDifferenceEpsilon &&
-            this.deltaCount === other.deltaCount);
-    }
-}
-
 /**
- * An evaluator for calculating osu!standard Rhythm skill.
+ * An evaluator for calculating osu!standard snap aim difficulty.
  */
-class OsuRhythmEvaluator {
+class OsuSnapAimEvaluator {
     /**
-     * Calculates a rhythm multiplier for the difficulty of the tap associated
-     * with historic data of the current object.
+     * Evaluates the difficulty of aiming the current object, based on:
+     *
+     * - cursor velocity to the current object,
+     * - angle difficulty,
+     * - sharp velocity increases,
+     * - and slider difficulty.
      *
      * @param current The current object.
+     * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current) {
-        if (current.object instanceof osuBase.Spinner) {
+    static evaluateDifficultyOf(current, withSliders) {
+        const last = current.previous(0);
+        if (current.object instanceof osuBase.Spinner ||
+            current.index <= 1 ||
+            last.object instanceof osuBase.Spinner) {
             return 0;
         }
-        const deltaDifferenceEpsilon = current.hitWindowFor(osuBase.HitResult.Great) * 0.3;
-        let rhythmComplexitySum = 0;
-        let island = new OsuIsland(deltaDifferenceEpsilon);
-        let previousIsland = new OsuIsland(deltaDifferenceEpsilon);
-        const islandCounts = new Map();
-        // Store the ratio of the current start of an island to buff for tighter rhythms.
-        let startRatio = 0;
-        let firstDeltaSwitch = false;
-        let rhythmStart = 0;
-        const historicalNoteCount = Math.min(current.index, this.historyObjectsMax);
-        while (rhythmStart < historicalNoteCount - 2 &&
-            current.startTime - current.previous(rhythmStart).startTime <
-                this.historyTimeMax) {
-            ++rhythmStart;
+        const last2 = current.previous(2);
+        const radius = current.normalizedRadius;
+        const diameter = current.normalizedDiameter;
+        // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
+        const currentDistance = withSliders
+            ? current.lazyJumpDistance
+            : current.jumpDistance;
+        let currentVelocity = currentDistance / current.strainTime;
+        // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
+        if (last.object instanceof osuBase.Slider && withSliders) {
+            const sliderDistance = last.lazyTravelDistance + current.lazyJumpDistance;
+            currentVelocity = Math.max(currentVelocity, sliderDistance / current.strainTime);
         }
-        let prevObject = current.previous(rhythmStart);
-        let lastObject = current.previous(rhythmStart + 1);
-        for (let i = rhythmStart; i > 0; --i) {
-            const currentObject = current.previous(i - 1);
-            // Scale note 0 to 1 from history to now.
-            const timeDecay = (this.historyTimeMax -
-                (current.startTime - currentObject.startTime)) /
-                this.historyTimeMax;
-            const noteDecay = (historicalNoteCount - i) / historicalNoteCount;
-            // Either we're limited by time or limited by object count.
-            const currentHistoricalDecay = Math.min(timeDecay, noteDecay);
-            // Use custom cap value to ensure that that at this point delta time is actually zero.
-            const currentDelta = Math.max(currentObject.deltaTime, 1e-7);
-            const prevDelta = Math.max(prevObject.deltaTime, 1e-7);
-            const lastDelta = Math.max(lastObject.deltaTime, 1e-7);
-            // Calculate how much current delta difference deserves a rhythm bonus
-            // This function is meant to reduce rhythm bonus for deltas that are multiples of each other (i.e. 100 and 200)
-            const deltaDifference = Math.max(prevDelta, currentDelta) /
-                Math.min(prevDelta, currentDelta);
-            // Take only the fractional part of the value since we are only interested in punishing multiples.
-            const deltaDifferenceFraction = deltaDifference - Math.trunc(deltaDifference);
-            const currentRatio = 1 +
-                this.rhythmRatioMultiplier *
-                    Math.min(0.5, osuBase.MathUtils.smoothstepBellCurve(deltaDifferenceFraction));
-            // Reduce ratio bonus if delta difference is too big
-            const differenceMultiplier = osuBase.MathUtils.clamp(2 - deltaDifference / 8, 0, 1);
-            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - deltaDifferenceEpsilon) / deltaDifferenceEpsilon);
-            let effectiveRatio = windowPenalty * currentRatio * differenceMultiplier;
-            if (firstDeltaSwitch) {
-                if (Math.abs(prevDelta - currentDelta) < deltaDifferenceEpsilon) {
-                    // Island is still progressing, count size.
-                    island.addDelta(currentDelta);
-                }
-                else {
-                    // BPM change is into slider, this is easy acc window.
-                    if (currentObject.object instanceof osuBase.Slider) {
-                        effectiveRatio /= 8;
-                    }
-                    // BPM change was from a slider, this is easier typically than circle -> circle.
-                    // Unintentional side effect is that bursts with kicksliders at the ends might have lower difficulty
-                    // than bursts without sliders.
-                    if (prevObject.object instanceof osuBase.Slider) {
-                        effectiveRatio *= 0.3;
-                    }
-                    // Repeated island polarity (2 -> 4, 3 -> 5).
-                    if (island.isSimilarPolarity(previousIsland)) {
-                        effectiveRatio /= 2;
-                    }
-                    // Previous increase happened a note ago.
-                    // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
-                    if (lastDelta > prevDelta + deltaDifferenceEpsilon &&
-                        prevDelta > currentDelta + deltaDifferenceEpsilon) {
-                        effectiveRatio /= 8;
-                    }
+        const prevDistance = withSliders
+            ? last.lazyJumpDistance
+            : last.jumpDistance;
+        const prevVelocity = prevDistance / last.strainTime;
+        // Start strain with regular velocity.
+        let strain = currentVelocity;
+        strain *= this.calculateVectorAngleRepetition(current, last);
+        if (current.angle !== null && last.angle !== null) {
+            const currentAngle = current.angle;
+            const lastAngle = last.angle;
+            // Rewarding angles, take the smaller velocity as base.
+            const velocityInfluence = Math.min(currentVelocity, prevVelocity);
+            let acuteAngleBonus = 0;
+            if (
+            // If rhythms are the same.
+            Math.max(current.strainTime, last.strainTime) <
+                1.25 * Math.min(current.strainTime, last.strainTime)) {
+                acuteAngleBonus =
+                    this.calculateAcuteAngleAcuteness(currentAngle);
+                // Penalize angle repetition. It is important to do it _before_ multiplying by anything because we compare raw acuteness here.
+                acuteAngleBonus *=
+                    0.08 +
+                        0.92 *
+                            (1 -
+                                Math.min(acuteAngleBonus, Math.pow(this.calculateAcuteAngleAcuteness(lastAngle), 3)));
+                // Apply acute angle bonus for BPM above 300 1/2.
+                acuteAngleBonus *=
+                    velocityInfluence *
+                        osuBase.MathUtils.smootherstep(osuBase.MathUtils.millisecondsToBPM(current.strainTime, 2), 300, 400) *
+                        osuBase.MathUtils.smootherstep(currentDistance, 0, diameter * 2);
+            }
+            let wideAngleBonus = this.calculateWideAngleAcuteness(currentAngle);
+            // Penalize angle repetition. It is important to do it _before_ multiplying by velocity because we compare raw wideness here.
+            wideAngleBonus *=
+                0.25 +
+                    0.75 *
+                        (1 -
+                            Math.min(wideAngleBonus, Math.pow(this.calculateWideAngleAcuteness(lastAngle), 3)));
+            // Rescale velocity for wide angle bonus.
+            const wideAngleTimeScale = 1.45;
+            let wideAngleCurrentVelocity = currentDistance /
+                Math.pow(current.strainTime, wideAngleTimeScale);
+            const wideAnglePrevVelocity = prevDistance / Math.pow(last.strainTime, wideAngleTimeScale);
+            if (last.object instanceof osuBase.Slider && withSliders) {
+                const sliderDistance = last.lazyTravelDistance + current.lazyJumpDistance;
+                wideAngleCurrentVelocity = Math.max(wideAngleCurrentVelocity, sliderDistance /
+                    Math.pow(current.strainTime, wideAngleTimeScale));
+            }
+            wideAngleBonus *= Math.min(wideAngleCurrentVelocity, wideAnglePrevVelocity);
+            if (last2 !== null) {
+                // If objects just go back and forth through a middle point - don't give as much wide bonus.
+                // Use previous(2) and previous(0) because angles calculation is done prevprev-prev-curr, so any
+                // object's angle's center point is always the previous object.
+                const distance = last2.object.stackedPosition.getDistance(last.object.stackedPosition);
+                if (distance < 1) {
+                    wideAngleBonus *= 1 - 0.55 * (1 - distance);
+                }
+            }
+            // Add in acute angle bonus or wide angle bonus, whichever is larger.
+            strain += Math.max(acuteAngleBonus * this.acuteAngleMultiplier, wideAngleBonus * this.wideAngleMultiplier);
+            // Apply wiggle bonus for jumps that are [radius, 3*diameter] in distance, with < 110 angle
+            // https://www.desmos.com/calculator/dp0v0nvowc
+            strain +=
+                velocityInfluence *
+                    osuBase.MathUtils.smootherstep(currentDistance, radius, diameter) *
+                    Math.pow(osuBase.MathUtils.reverseLerp(currentDistance, diameter * 3, diameter), 1.8) *
+                    osuBase.MathUtils.smootherstep(currentAngle, osuBase.MathUtils.degreesToRadians(110), osuBase.MathUtils.degreesToRadians(60)) *
+                    osuBase.MathUtils.smootherstep(prevDistance, radius, diameter) *
+                    Math.pow(osuBase.MathUtils.reverseLerp(prevDistance, diameter * 3, diameter), 1.8) *
+                    osuBase.MathUtils.smootherstep(lastAngle, osuBase.MathUtils.degreesToRadians(110), osuBase.MathUtils.degreesToRadians(60)) *
+                    this.wiggleMultiplier;
+        }
+        if (Math.max(prevVelocity, currentVelocity)) {
+            if (withSliders) {
+                // We want to use the average velocity over the whole object when awarding differences, not the individual jump and slider path velocities.
+                currentVelocity = currentDistance / current.strainTime;
+            }
+            // Scale with ratio of difference compared to half the max distance.
+            const distanceRatio = osuBase.MathUtils.smoothstep(Math.abs(prevVelocity - currentVelocity) /
+                Math.max(prevVelocity, currentVelocity), 0, 1);
+            // Reward for % distance up to 125 / strainTime for overlaps where velocity is still changing.
+            const overlapVelocityBuff = Math.min((diameter * 1.25) /
+                Math.min(current.strainTime, last.strainTime), Math.abs(prevVelocity - currentVelocity));
+            let velocityChangeBonus = overlapVelocityBuff * distanceRatio;
+            // Penalize for rhythm changes.
+            velocityChangeBonus *= Math.pow(Math.min(current.strainTime, last.strainTime) /
+                Math.max(current.strainTime, last.strainTime), 2);
+            strain += velocityChangeBonus * this.velocityChangeMultiplier;
+        }
+        if (current.object instanceof osuBase.Slider && withSliders) {
+            // Reward sliders based on velocity.
+            const sliderBonus = current.travelDistance / current.travelTime;
+            strain +=
+                (sliderBonus < 1 ? sliderBonus : Math.pow(sliderBonus, 0.75)) *
+                    this.sliderMultiplier;
+        }
+        // Apply high circle size bonus
+        strain *= current.smallCircleBonus;
+        strain *= this.highBpmBonus(current.strainTime);
+        return strain;
+    }
+    static calculateWideAngleAcuteness(angle) {
+        return osuBase.MathUtils.smoothstep(angle, osuBase.MathUtils.degreesToRadians(40), osuBase.MathUtils.degreesToRadians(140));
+    }
+    static calculateAcuteAngleAcuteness(angle) {
+        return osuBase.MathUtils.smoothstep(angle, osuBase.MathUtils.degreesToRadians(140), osuBase.MathUtils.degreesToRadians(40));
+    }
+    static highBpmBonus(ms) {
+        return 1 / (1 - Math.pow(0.03, Math.pow(ms / 1000, 0.65)));
+    }
+    static calculateVectorAngleRepetition(current, prev) {
+        if (current.angle === null || prev.angle === null) {
+            return 1;
+        }
+        let constantAngleCount = 0;
+        for (let i = 0; i < this.angleRepetitionNoteLimit; ++i) {
+            const loopObj = current.previous(i);
+            if (!loopObj) {
+                break;
+            }
+            // Only consider vectors in the same jump section, as stopping to change rhythm ruins momentum.
+            if (Math.max(current.strainTime, loopObj.strainTime) >
+                1.1 * Math.min(current.strainTime, loopObj.strainTime)) {
+                break;
+            }
+            if (loopObj.normalizedVectorAngle !== null &&
+                current.normalizedVectorAngle !== null) {
+                const angleDifference = Math.abs(current.normalizedVectorAngle -
+                    loopObj.normalizedVectorAngle);
+                // Refer to this Desmos for tuning.
+                // Constants need to be precise so that values stay within the range of 0 and 1.
+                // https://www.desmos.com/calculator/a8jesv5sv2
+                constantAngleCount += Math.cos(8 *
+                    Math.min(osuBase.MathUtils.degreesToRadians(11.25), angleDifference));
+            }
+        }
+        const vectorRepetition = Math.pow(Math.min(0.5 / constantAngleCount, 1), 2);
+        const stackFactor = osuBase.MathUtils.smootherstep(current.lazyJumpDistance, 0, current.normalizedDiameter);
+        const angleDifferenceAdjusted = Math.cos(2 *
+            Math.min(osuBase.MathUtils.degreesToRadians(45), Math.abs(current.angle - prev.angle) * stackFactor));
+        const baseNerf = 1 -
+            this.maximumRepetitionNerf *
+                this.calculateAcuteAngleAcuteness(prev.angle) *
+                angleDifferenceAdjusted;
+        return Math.pow(baseNerf +
+            (1 - baseNerf) *
+                vectorRepetition *
+                this.maximumVectorInfluence *
+                stackFactor, 2);
+    }
+}
+OsuSnapAimEvaluator.wideAngleMultiplier = 9.67;
+OsuSnapAimEvaluator.acuteAngleMultiplier = 2.41;
+OsuSnapAimEvaluator.sliderMultiplier = 1.5;
+OsuSnapAimEvaluator.velocityChangeMultiplier = 0.9;
+// Increasing this multiplier beyond 1.02 reduces difficulty as distance increases.
+// Refer to the desmos link above the wiggle bonus calculation.
+OsuSnapAimEvaluator.wiggleMultiplier = 1.02;
+OsuSnapAimEvaluator.angleRepetitionNoteLimit = 6;
+OsuSnapAimEvaluator.maximumRepetitionNerf = 0.15;
+OsuSnapAimEvaluator.maximumVectorInfluence = 0.5;
+
+/**
+ * An evaluator for calculating osu!standard flow aim difficulty.
+ */
+class OsuFlowAimEvaluator {
+    static evaluateDifficultyOf(current, withSliders) {
+        var _a;
+        if (current.object instanceof osuBase.Spinner ||
+            current.index <= 1 ||
+            ((_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.object) instanceof osuBase.Spinner) {
+            return 0;
+        }
+        const last = current.previous(0);
+        const lastLast = current.previous(1);
+        const currentDistance = withSliders
+            ? current.lazyJumpDistance
+            : current.jumpDistance;
+        const prevDistance = withSliders
+            ? last.lazyJumpDistance
+            : last.jumpDistance;
+        let currentVelocity = currentDistance / current.strainTime;
+        if (last.object instanceof osuBase.Slider && withSliders) {
+            // If the last object is a slider, then we extend the travel velocity through the slider into the current object.
+            const sliderDistance = last.lazyTravelDistance + current.lazyJumpDistance;
+            currentVelocity = Math.max(currentVelocity, sliderDistance / current.strainTime);
+        }
+        const prevVelocity = prevDistance / last.strainTime;
+        let flowDifficulty = currentVelocity;
+        // Apply high circle size bonus to the base velocity.
+        // We use reduced CS bonus here because the bonus was made for an evaluator with a different d/t scaling.
+        flowDifficulty *= Math.sqrt(current.smallCircleBonus);
+        // Rhythm changes are harder to flow.
+        flowDifficulty *=
+            1 +
+                Math.min(0.25, Math.pow((Math.max(current.strainTime, last.strainTime) -
+                    Math.min(current.strainTime, last.strainTime)) /
+                    50, 4));
+        if (current.angle !== null && last.angle !== null) {
+            // Low angular velocity (consistent angles) is easier to follow than erratic flow.
+            const angleDifference = Math.abs(current.angle - last.angle);
+            const angleDifferenceAdjusted = Math.sin(angleDifference / 2) * 180;
+            const angularVelocity = angleDifferenceAdjusted / (current.strainTime * 0.1);
+            flowDifficulty *= 0.8 + Math.sqrt(angularVelocity / 270);
+        }
+        // If all three notes overlap, do not reward bonuses as there is no required additional movement.
+        let overlappedNotesWeight = 1;
+        if (current.index > 2) {
+            const o1 = this.calculateOverlapFactor(current, last);
+            const o2 = this.calculateOverlapFactor(current, lastLast);
+            const o3 = this.calculateOverlapFactor(last, lastLast);
+            overlappedNotesWeight = 1 - o1 * o2 * o3;
+        }
+        if (current.angle !== null) {
+            // Acute angles are hard to flow.
+            flowDifficulty +=
+                currentVelocity *
+                    OsuSnapAimEvaluator.calculateAcuteAngleAcuteness(current.angle) *
+                    overlappedNotesWeight;
+        }
+        if (Math.max(prevVelocity, currentVelocity)) {
+            if (withSliders) {
+                currentVelocity = currentDistance / current.strainTime;
+            }
+            // Scale with ratio of difference compared to 0.5 * max distance.
+            const distanceRatio = osuBase.MathUtils.smoothstep(Math.abs(prevVelocity - currentVelocity) /
+                Math.max(prevVelocity, currentVelocity), 0, 1);
+            // Reward for % distance up to 125 / strainTime for overlaps where velocity is still changing.
+            const overlapVelocityBuff = Math.min((current.normalizedDiameter * 1.25) /
+                Math.min(current.strainTime, last.strainTime), Math.abs(prevVelocity - currentVelocity));
+            flowDifficulty +=
+                overlapVelocityBuff *
+                    distanceRatio *
+                    overlappedNotesWeight *
+                    this.velocityChangeMultiplier;
+        }
+        if (current.object instanceof osuBase.Slider && withSliders) {
+            // Include slider velocity to make velocity more consistent with snap.
+            flowDifficulty += current.travelDistance / current.travelTime;
+        }
+        // The final velocity is being raised to a power because flow difficulty scales harder with both high
+        // distance and time, and we want to account for that.
+        flowDifficulty = Math.pow(flowDifficulty, 1.45);
+        // Reduce difficulty for low spacing since spacing below radius is always to be flowed.
+        return (flowDifficulty *
+            osuBase.MathUtils.smootherstep(currentDistance, 0, current.normalizedRadius));
+    }
+    static calculateOverlapFactor(o1, o2) {
+        const distance = o1.object.stackedPosition.getDistance(o2.object.stackedPosition);
+        const { radius } = o1.object;
+        return osuBase.MathUtils.clamp(1 - Math.pow(Math.max(distance - radius, 0) / radius, 2), 0, 1);
+    }
+}
+OsuFlowAimEvaluator.velocityChangeMultiplier = 0.52;
+
+/**
+ * Evaluator for reading difficulty in osu!standard.
+ */
+class OsuReadingEvaluator {
+    /**
+     * Evaluates the difficulty of reading the object.
+     */
+    static evaluateDifficultyOf(current, mods) {
+        if (current.object instanceof osuBase.Spinner || current.index === 0) {
+            return 0;
+        }
+        // 1.5 circles distance between centers
+        const distanceInfluenceThreshold = current.normalizedDiameter * 1.5;
+        const next = current.next(0);
+        // Only allow velocity to buff
+        const velocity = Math.max(1, current.lazyJumpDistance / current.strainTime);
+        const currentVisibleObjectDensity = this.retrieveCurrentVisibleObjectDensity(current);
+        const pastObjectDifficultyInfluence = this.getPastObjectDifficultyInfluence(current, distanceInfluenceThreshold);
+        const constantAngleNerfFactor = this.getConstantAngleNerfFactor(current);
+        const noteDensityDifficulty = this.calculateDensityDifficulty(next, distanceInfluenceThreshold, velocity, constantAngleNerfFactor, pastObjectDifficultyInfluence, currentVisibleObjectDensity);
+        const hiddenDifficulty = this.calculateHiddenDifficulty(current, mods, pastObjectDifficultyInfluence, currentVisibleObjectDensity, velocity, constantAngleNerfFactor);
+        const preemptDifficulty = this.calculatePreemptDifficulty(velocity, constantAngleNerfFactor, current.timePreempt);
+        let difficulty = osuBase.MathUtils.norm(1.5, preemptDifficulty, hiddenDifficulty, noteDensityDifficulty);
+        // Having less time to process information is harder.
+        difficulty *= this.highBpmBonus(current.strainTime);
+        return difficulty;
+    }
+    /**
+     * Calculates the density difficulty of the current object and how hard it is to aim it because of it based on:
+     *
+     * - cursor velocity to the current object,
+     * - how many times the current object's angle was repeated,
+     * - density of objects visible when the current object appears, and
+     * - density of objects visible when the current object needs to be clicked.
+     */
+    static calculateDensityDifficulty(next, distanceInfluenceThreshold, velocity, constantAngleNerfFactor, pastObjectDifficultyInfluence, currentVisibleObjectDensity) {
+        // Consider future densities too because it can make the path the cursor takes less clear.
+        let futureObjectDifficultyInfluence = Math.sqrt(currentVisibleObjectDensity);
+        if (next !== null) {
+            // Reduce difficulty if movement to next object is small.
+            futureObjectDifficultyInfluence *= osuBase.MathUtils.smootherstep(next.lazyJumpDistance, 15, distanceInfluenceThreshold);
+        }
+        // Value higher note densities exponentially.
+        let noteDensityDifficulty = Math.pow(pastObjectDifficultyInfluence + futureObjectDifficultyInfluence, 1.7) *
+            0.4 *
+            constantAngleNerfFactor *
+            velocity;
+        // Award only denser than average maps.
+        noteDensityDifficulty = Math.max(0, noteDensityDifficulty - this.densityDifficultyBase);
+        // Apply a soft cap to general density reading to account for partial memorization
+        noteDensityDifficulty =
+            Math.pow(noteDensityDifficulty, 0.45) * this.densityMultiplier;
+        return noteDensityDifficulty;
+    }
+    /**
+     * Calculates the difficulty of aiming the current object when the approach rate is very high based on:
+     *
+     * - cursor velocity to the current object,
+     * - how many times the current object's angle was repeated, and
+     * - how many milliseconds elapse between the approach circle appearing and touching the inner circle.
+     */
+    static calculatePreemptDifficulty(velocity, constantAngleNerfFactor, preempt) {
+        // Arbitrary curve for the base value preempt difficulty should have as approach rate increases.
+        // https://www.desmos.com/calculator/c175335a71
+        let preemptDifficulty = Math.pow((this.preemptStartingPoint -
+            preempt +
+            Math.abs(preempt - this.preemptStartingPoint)) /
+            2, 2.5) / this.preemptBalancingFactor;
+        preemptDifficulty *= constantAngleNerfFactor * velocity;
+        return preemptDifficulty;
+    }
+    /**
+     * Calculates the difficulty of aiming the current object when the Hidden mod is active based on:
+     *
+     * - cursor velocity to the current object,
+     * - time the current object spends invisible,
+     * - density of objects visible when the current object appears,
+     * - density of objects visible when the current object needs to be clicked,
+     * - how many times the current object's angle was repeated, and
+     * - if the current object is perfectly stacked to the previous one.
+     */
+    static calculateHiddenDifficulty(current, mods, pastObjectDifficultyInfluence, currentVisibleObjectDensity, velocity, constantAngleNerfFactor) {
+        var _a;
+        if (!mods.has(osuBase.ModHidden) ||
+            ((_a = mods.get(osuBase.ModHidden)) === null || _a === void 0 ? void 0 : _a.onlyFadeApproachCircles.value)) {
+            return 0;
+        }
+        // Higher preempt means that time spent invisible is higher too, we want to reward that.
+        const preemptFactor = Math.pow(current.timePreempt, 2.2) * 0.01;
+        // Account for both past and current densities.
+        const densityFactor = Math.pow(currentVisibleObjectDensity + pastObjectDifficultyInfluence, 3.3) * 3;
+        let hiddenDifficulty = (preemptFactor + densityFactor) *
+            constantAngleNerfFactor *
+            velocity *
+            0.01;
+        // Apply a soft cap to general HD reading to account for partial memorization.
+        hiddenDifficulty =
+            Math.pow(hiddenDifficulty, 0.4) * this.hiddenMultiplier;
+        const prev = current.previous(0);
+        // Buff perfect stacks only if current note is completely invisible at the time you click the previous note.
+        if (current.lazyJumpDistance === 0 &&
+            current.opacityAt(prev.object.startTime, mods) === 0 &&
+            // At the same time, we only want to buff them if the current note is already
+            // animating at the time the previous note was clicked.
+            prev.startTime > current.startTime - current.timePreempt) {
+            // Perfect stacks are harder the less time between notes.
+            hiddenDifficulty +=
+                (this.hiddenMultiplier * 2500) /
+                    Math.pow(current.strainTime, 1.5);
+        }
+        return hiddenDifficulty;
+    }
+    static getPastObjectDifficultyInfluence(current, distanceInfluenceThreshold) {
+        let pastObjectDifficultyInfluence = 0;
+        for (const loopObj of this.retrievePastVisibleObjects(current)) {
+            let loopDifficulty = current.opacityAt(loopObj.object.startTime);
+            // When aiming an object small distances mean previous objects may be cheesed,
+            // so it doesn't matter whether they were arranged confusingly.
+            loopDifficulty *= osuBase.MathUtils.smootherstep(loopObj.lazyJumpDistance, 15, distanceInfluenceThreshold);
+            // Account less for objects close to the max reading window.
+            const timeBetweenCurrAndLoopObj = current.startTime - loopObj.startTime;
+            const timeNerfFactor = this.getTimeNerfFactor(timeBetweenCurrAndLoopObj);
+            loopDifficulty *= timeNerfFactor;
+            pastObjectDifficultyInfluence += loopDifficulty;
+        }
+        return pastObjectDifficultyInfluence;
+    }
+    /**
+     * Returns a list of objects that are visible on screen at the point in time the current object becomes visible.
+     */
+    static *retrievePastVisibleObjects(current) {
+        for (let i = 0; i < current.index; ++i) {
+            const hitObject = current.previous(i);
+            if (!hitObject ||
+                current.startTime - hitObject.startTime >
+                    this.readingWindowSize ||
+                // Current object not visible at the time object needs to be clicked
+                hitObject.startTime < current.startTime - current.timePreempt) {
+                break;
+            }
+            yield hitObject;
+        }
+    }
+    /**
+     * Returns the density of objects visible at the point in time the current object needs to be clicked capped by the reading window.
+     */
+    static retrieveCurrentVisibleObjectDensity(current) {
+        let visibleObjectCount = 0;
+        let hitObject = current.next(0);
+        while (hitObject !== null) {
+            if (hitObject.startTime - current.startTime >
+                this.readingWindowSize ||
+                // Object not visible at the time current object needs to be clicked.
+                current.startTime + hitObject.timePreempt < hitObject.startTime) {
+                break;
+            }
+            const timeBetweenCurrAndLoopObj = hitObject.startTime - current.startTime;
+            const timeNerfFactor = this.getTimeNerfFactor(timeBetweenCurrAndLoopObj);
+            visibleObjectCount +=
+                hitObject.opacityAt(current.object.startTime) * timeNerfFactor;
+            hitObject = hitObject.next(0);
+        }
+        return visibleObjectCount;
+    }
+    /**
+     * Returns a factor of how often the current object's angle has been repeated in a certain time frame.
+     * It does this by checking the difference in angle between current and past objects and sums them based on a range of similarity.
+     * https://www.desmos.com/calculator/eb057a4822
+     */
+    static getConstantAngleNerfFactor(current) {
+        let constantAngleCount = 0;
+        let index = 0;
+        let currentTimeGap = 0;
+        let loopObjPrev0 = current;
+        let loopObjPrev1 = null;
+        let loopObjPrev2 = null;
+        while (currentTimeGap < this.minimumAngleRelevancyTime) {
+            const loopObj = current.previous(index);
+            if (!loopObj) {
+                break;
+            }
+            // Account less for objects that are close to the time limit.
+            const longIntervalFactor = 1 -
+                osuBase.Interpolation.reverseLerp(loopObj.strainTime, this.maximumAngleRelevancyTime, this.minimumAngleRelevancyTime);
+            if (loopObj.angle !== null && current.angle !== null) {
+                const angleDifference = Math.abs(current.angle - loopObj.angle);
+                let angleDifferenceAlternating = Math.PI;
+                if (loopObjPrev0.angle !== null &&
+                    typeof (loopObjPrev1 === null || loopObjPrev1 === void 0 ? void 0 : loopObjPrev1.angle) === "number" &&
+                    typeof (loopObjPrev2 === null || loopObjPrev2 === void 0 ? void 0 : loopObjPrev2.angle) === "number") {
+                    angleDifferenceAlternating = Math.abs(loopObjPrev1.angle - loopObj.angle);
+                    angleDifferenceAlternating += Math.abs(loopObjPrev2.angle - loopObjPrev0.angle);
+                    let weight = 1;
+                    // Be sure that one of the angles is very sharp, when other is wide.
+                    weight *= osuBase.Interpolation.reverseLerp(osuBase.MathUtils.radiansToDegrees(Math.min(loopObj.angle, loopObjPrev0.angle)), 20, 5);
+                    weight *= osuBase.Interpolation.reverseLerp(osuBase.MathUtils.radiansToDegrees(Math.max(loopObj.angle, loopObjPrev0.angle)), 60, 120);
+                    // Interpolate between max angle difference and rescaled alternating difference, with
+                    // harsher scaling compared to normal difference.
+                    angleDifferenceAlternating = osuBase.Interpolation.lerp(Math.PI, 0.1 * angleDifferenceAlternating, weight);
+                }
+                const stackFactor = osuBase.MathUtils.smootherstep(loopObj.lazyJumpDistance, 0, current.normalizedRadius);
+                constantAngleCount +=
+                    Math.cos(3 *
+                        Math.min(osuBase.MathUtils.degreesToRadians(30), Math.min(angleDifference, angleDifferenceAlternating) * stackFactor)) * longIntervalFactor;
+            }
+            currentTimeGap = current.startTime - loopObj.startTime;
+            index++;
+            loopObjPrev2 = loopObjPrev1;
+            loopObjPrev1 = loopObjPrev0;
+            loopObjPrev0 = loopObj;
+        }
+        return osuBase.MathUtils.clamp(2 / constantAngleCount, 0.2, 1);
+    }
+    /**
+     * Returns a nerfing factor for when objects are very distant in time, affecting reading less.
+     */
+    static getTimeNerfFactor(deltaTime) {
+        return osuBase.MathUtils.clamp(2 - deltaTime / (this.readingWindowSize / 2), 0, 1);
+    }
+    static highBpmBonus(ms) {
+        return 1 / (1 - Math.pow(0.8, ms / 1000));
+    }
+}
+OsuReadingEvaluator.readingWindowSize = 3000; // 3 seconds
+OsuReadingEvaluator.hiddenMultiplier = 0.28;
+OsuReadingEvaluator.densityMultiplier = 2.4;
+OsuReadingEvaluator.densityDifficultyBase = 2.5;
+OsuReadingEvaluator.preemptBalancingFactor = 140000;
+OsuReadingEvaluator.preemptStartingPoint = 500; // AR 9.66 in milliseconds
+OsuReadingEvaluator.minimumAngleRelevancyTime = 2000; // 2 seconds
+OsuReadingEvaluator.maximumAngleRelevancyTime = 200;
+
+/**
+ * An evaluator for calculating osu!standard Rhythm skill.
+ */
+class OsuRhythmEvaluator {
+    /**
+     * Calculates a rhythm multiplier for the difficulty of the tap associated
+     * with historic data of the current object.
+     *
+     * @param current The current object.
+     */
+    static evaluateDifficultyOf(current) {
+        if (current.object instanceof osuBase.Spinner) {
+            return 0;
+        }
+        const deltaDifferenceEpsilon = current.hitWindowFor(osuBase.HitResult.Great) * 0.3;
+        let rhythmComplexitySum = 0;
+        let island = new Island(Number.MAX_SAFE_INTEGER);
+        let previousIsland = new Island(Number.MAX_SAFE_INTEGER);
+        const islands = [];
+        // Store the ratio of the current start of an island to buff for tighter rhythms.
+        let startRatio = 0;
+        let firstDeltaSwitch = false;
+        let rhythmStart = 0;
+        const historicalNoteCount = Math.min(current.index, this.historyObjectsMax);
+        while (rhythmStart < historicalNoteCount - 2 &&
+            current.startTime - current.previous(rhythmStart).startTime <
+                this.historyTimeMax) {
+            ++rhythmStart;
+        }
+        let prevObject = current.previous(rhythmStart);
+        let lastObject = current.previous(rhythmStart + 1);
+        for (let i = rhythmStart; i > 0; --i) {
+            const currentObject = current.previous(i - 1);
+            if (currentObject.object instanceof osuBase.Spinner) {
+                continue;
+            }
+            // Scale note 0 to 1 from history to now.
+            const timeDecay = (this.historyTimeMax -
+                (current.startTime - currentObject.startTime)) /
+                this.historyTimeMax;
+            const noteDecay = (historicalNoteCount - i) / historicalNoteCount;
+            // Either we're limited by time or limited by object count.
+            const currentHistoricalDecay = Math.min(timeDecay, noteDecay);
+            // Use custom cap value to ensure that at this point delta time is actually zero.
+            const currentDelta = Math.max(currentObject.deltaTime, 1e-7);
+            const prevDelta = Math.max(prevObject.deltaTime, 1e-7);
+            const lastDelta = Math.max(lastObject.deltaTime, 1e-7);
+            if (island.delta == Number.MAX_SAFE_INTEGER) {
+                island = new Island(currentDelta);
+            }
+            // Calculate how much current delta difference deserves a rhythm bonus
+            // This function is meant to reduce rhythm bonus for deltas that are multiples of each other (i.e. 100 and 200)
+            const deltaDifference = Math.max(prevDelta, currentDelta) /
+                Math.min(prevDelta, currentDelta);
+            // Reduce ratio bonus if delta difference is too big
+            const differenceMultiplier = osuBase.MathUtils.clamp(2 - deltaDifference / 8, 0, 1);
+            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - deltaDifferenceEpsilon) / deltaDifferenceEpsilon);
+            let effectiveRatio = windowPenalty *
+                this.getEffectiveRatio(deltaDifference) *
+                differenceMultiplier;
+            // If the previous object is a slider, it might be easier to tap since you do not have to do a whole tapping motion.
+            // While a full deltatime might end up some weird ratio, the "unpress->tap" motion might be simple.
+            // For example, a slider-circle-circle pattern should be evaluated as a regular triple and not as a single->double.
+            if (prevObject.object instanceof osuBase.Slider) {
+                const sliderLazyEndDelta = currentObject.minimumJumpTime;
+                const sliderLazyEndDeltaDifference = Math.max(sliderLazyEndDelta, currentDelta) /
+                    Math.min(sliderLazyEndDelta, currentDelta);
+                const sliderRealEndDelta = currentObject.lastObjectEndDeltaTime;
+                const sliderRealEndDeltaDifference = Math.max(sliderRealEndDelta, currentDelta) /
+                    Math.min(sliderRealEndDelta, currentDelta);
+                const sliderEffectiveRatio = Math.min(this.getEffectiveRatio(sliderLazyEndDeltaDifference), this.getEffectiveRatio(sliderRealEndDeltaDifference));
+                effectiveRatio = Math.min(sliderEffectiveRatio, effectiveRatio);
+            }
+            const isSpeedingUp = prevDelta > currentDelta + deltaDifferenceEpsilon;
+            if (Math.abs(prevDelta - currentDelta) < deltaDifferenceEpsilon) {
+                island.addDelta(currentDelta);
+            }
+            if (firstDeltaSwitch) {
+                if (Math.abs(prevDelta - currentDelta) > deltaDifferenceEpsilon) {
+                    // BPM change is into slider, this is easy acc window.
+                    if (currentObject.object instanceof osuBase.Slider) {
+                        effectiveRatio /= 2;
+                    }
+                    // Repeated island polarity (2 -> 4, 3 -> 5).
+                    if (island.isSimilarPolarity(previousIsland, deltaDifferenceEpsilon)) {
+                        effectiveRatio /= 2;
+                    }
+                    // Previous increase happened a note ago.
+                    // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                    if (lastDelta > prevDelta + deltaDifferenceEpsilon &&
+                        prevDelta > currentDelta + deltaDifferenceEpsilon) {
+                        effectiveRatio /= 8;
+                    }
                     // Repeated island size (ex: triplet -> triplet).
                     // TODO: remove this nerf since its staying here only for balancing purposes because of the flawed ratio calculation
                     if (previousIsland.deltaCount == island.deltaCount) {
                         effectiveRatio /= 2;
                     }
-                    let islandFound = false;
-                    for (const [currentIsland, count] of islandCounts) {
-                        if (!island.equals(currentIsland)) {
+                    if (isSpeedingUp) {
+                        effectiveRatio *= 0.65;
+                    }
+                    let found = false;
+                    for (const existingIsland of islands) {
+                        if (!existingIsland.almostEquals(island, deltaDifferenceEpsilon)) {
                             continue;
                         }
-                        islandFound = true;
-                        let islandCount = count;
-                        if (previousIsland.equals(island)) {
-                            // Only add island to island counts if they're going one after another.
-                            ++islandCount;
-                            islandCounts.set(currentIsland, islandCount);
+                        // Only add island to island counts if they're going one after another.
+                        if (previousIsland.almostEquals(island, deltaDifferenceEpsilon)) {
+                            ++existingIsland.occurrences;
                         }
+                        const power = osuBase.MathUtils.offsetLogistic(island.delta, 58.33, 0.24, 2.75);
                         // Repeated island (ex: triplet -> triplet).
                         // Graph: https://www.desmos.com/calculator/pj7an56zwf
-                        effectiveRatio *= Math.min(3 / islandCount, Math.pow(1 / islandCount, osuBase.MathUtils.offsetLogistic(island.delta, 58.33, 0.24, 2.75)));
+                        effectiveRatio *= Math.min(3 / existingIsland.occurrences, Math.pow(1 / existingIsland.occurrences, power));
+                        found = true;
                         break;
                     }
-                    if (!islandFound) {
-                        islandCounts.set(island, 1);
+                    if (!found && island.deltaCount > 0) {
+                        islands.push(island);
                     }
                     // Scale down the difficulty if the object is doubletappable.
                     effectiveRatio *=
                         1 - prevObject.getDoubletapness(currentObject) * 0.75;
-                    rhythmComplexitySum +=
-                        Math.sqrt(effectiveRatio * startRatio) *
-                            currentHistoricalDecay;
+                    if (island.deltaCount > 1) {
+                        rhythmComplexitySum +=
+                            Math.sqrt(effectiveRatio * startRatio) *
+                                currentHistoricalDecay;
+                    }
+                    else {
+                        // Constant difficulty for single-note islands.
+                        rhythmComplexitySum += 0.7 * currentHistoricalDecay;
+                    }
                     startRatio = effectiveRatio;
                     previousIsland = island;
                     if (prevDelta + deltaDifferenceEpsilon < currentDelta) {
@@ -4062,7 +4445,7 @@ class OsuRhythmEvaluator {
                         // If we're speeding up, this stays as is and we keep counting island size.
                         firstDeltaSwitch = false;
                     }
-                    island = new OsuIsland(currentDelta, deltaDifferenceEpsilon);
+                    island = new Island(currentDelta);
                 }
             }
             else if (prevDelta > currentDelta + deltaDifferenceEpsilon) {
@@ -4080,20 +4463,28 @@ class OsuRhythmEvaluator {
                     effectiveRatio *= 0.6;
                 }
                 startRatio = effectiveRatio;
-                island = new OsuIsland(currentDelta, deltaDifferenceEpsilon);
+                island = new Island(currentDelta);
             }
             lastObject = prevObject;
             prevObject = currentObject;
         }
-        return ((Math.sqrt(4 + rhythmComplexitySum * this.rhythmOverallMultiplier) *
-            (1 - current.getDoubletapness(current.next(0)))) /
+        // If the current island is long we don't want the sum to have as big of an effect.
+        rhythmComplexitySum *= osuBase.Interpolation.reverseLerp(island.deltaCount, 22, 3);
+        return (Math.sqrt(4 + rhythmComplexitySum * this.rhythmOverallMultiplier) /
             2);
     }
+    static getEffectiveRatio(deltaDifference) {
+        // Take only the fractional part of the value since we are only interested in punishing multiples.
+        const deltaDifferenceFraction = deltaDifference - Math.trunc(deltaDifference);
+        return (1 +
+            this.rhythmRatioMultiplier *
+                Math.min(0.5, osuBase.MathUtils.smoothstepBellCurve(deltaDifferenceFraction)));
+    }
 }
 OsuRhythmEvaluator.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
 OsuRhythmEvaluator.historyObjectsMax = 32;
-OsuRhythmEvaluator.rhythmOverallMultiplier = 1;
-OsuRhythmEvaluator.rhythmRatioMultiplier = 15;
+OsuRhythmEvaluator.rhythmOverallMultiplier = 0.95;
+OsuRhythmEvaluator.rhythmRatioMultiplier = 26;
 
 /**
  * An evaluator for calculating osu!standard speed skill.
@@ -4103,18 +4494,14 @@ class OsuSpeedEvaluator {
      * Evaluates the difficulty of tapping the current object, based on:
      *
      * - time between pressing the previous and current object,
-     * - distance between those objects,
      * - and how easily they can be cheesed.
      *
      * @param current The current object.
-     * @param mods The mods applied.
      */
-    static evaluateDifficultyOf(current, mods) {
-        var _a;
+    static evaluateDifficultyOf(current) {
         if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
-        const prev = current.previous(0);
         let strainTime = current.strainTime;
         // Nerf doubletappable doubles.
         const doubletapness = 1 - current.getDoubletapness(current.next(0));
@@ -4124,389 +4511,389 @@ class OsuSpeedEvaluator {
         // speedBonus will be 0.0 for BPM < 200
         let speedBonus = 0;
         // Add additional scaling bonus for streams/bursts higher than 200bpm
-        if (strainTime < this.minSpeedBonus) {
+        if (osuBase.MathUtils.millisecondsToBPM(strainTime) > this.minSpeedBonus) {
             speedBonus =
-                0.75 * Math.pow((this.minSpeedBonus - strainTime) / 40, 2);
-        }
-        const travelDistance = (_a = prev === null || prev === void 0 ? void 0 : prev.travelDistance) !== null && _a !== void 0 ? _a : 0;
-        const singleSpacingThreshold = current.normalizedDiameter * 1.25;
-        // Cap distance at spacing threshold
-        const distance = Math.min(singleSpacingThreshold, travelDistance + current.minimumJumpDistance);
-        // Max distance bonus is 1 * `distance_multiplier` at single_spacing_threshold
-        let distanceBonus = Math.pow(distance / singleSpacingThreshold, 3.95) *
-            this.DISTANCE_MULTIPLIER;
-        // Apply reduced small circle bonus because flow aim difficulty on small circles does not scale as hard as jumps.
-        distanceBonus *= Math.sqrt(current.smallCircleBonus);
-        if (mods.has(osuBase.ModAutopilot)) {
-            distanceBonus = 0;
+                0.75 *
+                    Math.pow((osuBase.MathUtils.bpmToMilliseconds(this.minSpeedBonus) -
+                        strainTime) /
+                        40, 2);
         }
         // Base difficulty with all bonuses
-        const difficulty = ((1 + speedBonus + distanceBonus) * 1000) / strainTime;
+        let difficulty = ((1 + speedBonus) * 1000) / strainTime;
+        difficulty *= this.highBpmBonus(current.strainTime);
         // Apply penalty if there's doubletappable doubles
         return difficulty * doubletapness;
     }
+    static highBpmBonus(ms) {
+        return 1 / (1 - Math.pow(0.3, ms / 1000));
+    }
 }
 // ~200 1/4 BPM streams
-OsuSpeedEvaluator.minSpeedBonus = 75;
-OsuSpeedEvaluator.DISTANCE_MULTIPLIER = 0.8;
+OsuSpeedEvaluator.minSpeedBonus = 200;
 
-class OsuRatingCalculator {
-    constructor(mods, totalHits, approachRate, overallDifficulty, mechanicalDifficultyRating, sliderFactor) {
-        this.mods = mods;
-        this.totalHits = totalHits;
-        this.approachRate = approachRate;
-        this.overallDifficulty = overallDifficulty;
-        this.mechanicalDifficultyRating = mechanicalDifficultyRating;
-        this.sliderFactor = sliderFactor;
+/**
+ * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
+ */
+class OsuAim extends VariableLengthStrainSkill {
+    constructor(mods, withSliders) {
+        super(mods);
+        this.currentStrain = 0;
+        this.skillMultiplierSnap = 70.9;
+        this.skillMultiplierAgility = 2.35;
+        this.skillMultiplierFlow = 242;
+        this.skillMultiplierTotal = 1.12;
+        this.combinedSnapNormExponent = 1.2;
+        /**
+         * The number of sections with the highest strains, which the peak strain reductions will apply to.
+         * This is done in order to decrease their impact on the overall difficulty of the beatmap.
+         */
+        this.reducedSectionTime = 4000;
+        /**
+         * The baseline multiplier applied to the section with the biggest strain.
+         */
+        this.reducedStrainBaseline = 0.727;
+        this.sliderStrains = [];
+        this.maxSliderStrain = 0;
+        this.withSliders = withSliders;
     }
-    computeAimRating(aimDifficultyValue) {
-        if (this.mods.has(osuBase.ModAutopilot)) {
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
+     */
+    countDifficultSliders() {
+        if (this.sliderStrains.length === 0 || this.maxSliderStrain === 0) {
             return 0;
         }
-        let aimRating = OsuRatingCalculator.calculateDifficultyRating(aimDifficultyValue);
-        if (this.mods.has(osuBase.ModTouchDevice)) {
-            aimRating = Math.pow(aimRating, 0.8);
-        }
-        if (this.mods.has(osuBase.ModRelax)) {
-            aimRating *= 0.9;
-        }
-        if (this.mods.has(osuBase.ModMagnetised)) {
-            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
-            aimRating *= 1 - magnetisedStrength;
-        }
-        let ratingMultiplier = 1;
-        const approachRateLengthBonus = 0.95 +
-            0.4 * Math.min(1, this.totalHits / 2000) +
-            (this.totalHits > 2000
-                ? Math.log10(this.totalHits / 2000) * 0.5
-                : 0);
-        let approachRateFactor = 0;
-        if (this.approachRate > 10.33) {
-            approachRateFactor = 0.3 * (this.approachRate - 10.33);
-        }
-        else if (this.approachRate < 8) {
-            approachRateFactor = 0.05 * (8 - this.approachRate);
-        }
-        if (this.mods.has(osuBase.ModRelax)) {
-            approachRateFactor = 0;
-        }
-        // Buff for longer beatmaps with high AR.
-        ratingMultiplier += approachRateFactor * approachRateLengthBonus;
-        if (this.mods.has(osuBase.ModHidden)) {
-            const visibilityFactor = this.calculateAimVisibilityFactor();
-            ratingMultiplier += OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.approachRate, visibilityFactor, this.sliderFactor);
+        return this.sliderStrains.reduce((total, strain) => total +
+            1 / (1 + Math.exp(-((strain / this.maxSliderStrain) * 12 - 6))), 0);
+    }
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain, weighted by consistency.
+     *
+     * @param difficultyValue The final difficulty value.
+     */
+    countTopWeightedSliders(difficultyValue) {
+        if (this.sliderStrains.length === 0) {
+            return 0;
         }
-        // It is important to consider accuracy difficulty when scaling with accuracy.
-        ratingMultiplier *=
-            0.98 + Math.pow(Math.max(0, this.overallDifficulty), 2) / 2500;
-        return aimRating * Math.cbrt(ratingMultiplier);
-    }
-    computeSpeedRating(speedDifficultyValue) {
-        if (this.mods.has(osuBase.ModRelax)) {
+        const consistentTopStrain = difficultyValue * (1 - this.decayWeight);
+        if (consistentTopStrain === 0) {
             return 0;
         }
-        let speedRating = OsuRatingCalculator.calculateDifficultyRating(speedDifficultyValue);
+        // Use a weighted sum of all strains. Constants are arbitrary and give nice values
+        return this.sliderStrains.reduce((total, next) => total +
+            osuBase.MathUtils.offsetLogistic(next / consistentTopStrain, 0.88, 10, 1.1), 0);
+    }
+    strainValueAt(current) {
         if (this.mods.has(osuBase.ModAutopilot)) {
-            speedRating *= 0.5;
+            return 0;
         }
-        if (this.mods.has(osuBase.ModMagnetised)) {
-            // Reduce speed rating because of the distance scaling, with maximum reduction being 0.7.
-            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
-            speedRating *= 1 - magnetisedStrength * 0.3;
-        }
-        let ratingMultiplier = 1;
-        const approachRateLengthBonus = 0.95 +
-            0.4 * Math.min(1, this.totalHits / 2000) +
-            (this.totalHits > 2000
-                ? Math.log10(this.totalHits / 2000) * 0.5
-                : 0);
-        let approachRateFactor = 0;
-        if (this.approachRate > 10.33) {
-            approachRateFactor = 0.3 * (this.approachRate - 10.33);
+        const decay = this.strainDecay(current.strainTime);
+        this.currentStrain *= decay;
+        this.currentStrain +=
+            this.calculateAdjustedDifficulty(current) * (1 - decay);
+        if (current.object instanceof osuBase.Slider) {
+            this.sliderStrains.push(this.currentStrain);
+            this.maxSliderStrain = Math.max(this.maxSliderStrain, this.currentStrain);
         }
-        if (this.mods.has(osuBase.ModAutopilot)) {
-            approachRateFactor = 0;
+        return this.currentStrain;
+    }
+    calculateInitialStrain(time, current) {
+        var _a, _b;
+        return (this.currentStrain *
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
+    }
+    saveToHitObject(current) {
+        if (this.withSliders) {
+            current.aimStrainWithSliders = this.currentStrain;
         }
-        // Buff for longer beatmaps with high AR.
-        ratingMultiplier += approachRateFactor * approachRateLengthBonus;
-        if (this.mods.has(osuBase.ModHidden)) {
-            const visibilityFactor = this.calculateSpeedVisibilityFactor();
-            ratingMultiplier += OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.approachRate, visibilityFactor, this.sliderFactor);
+        else {
+            current.aimStrainWithoutSliders = this.currentStrain;
         }
-        ratingMultiplier *=
-            0.95 + Math.pow(Math.max(0, this.overallDifficulty), 2) / 750;
-        return speedRating * Math.cbrt(ratingMultiplier);
     }
-    computeFlashlightRating(flashlightDifficultyValue) {
-        if (!this.mods.has(osuBase.ModFlashlight)) {
-            return 0;
+    calculateAdjustedDifficulty(current) {
+        const snapDifficulty = OsuSnapAimEvaluator.evaluateDifficultyOf(current, this.withSliders) * this.skillMultiplierSnap;
+        const agilityDifficulty = OsuAgilityEvaluator.evaluateDifficultyOf(current) *
+            this.skillMultiplierAgility;
+        const flowDifficulty = OsuFlowAimEvaluator.evaluateDifficultyOf(current, this.withSliders) * this.skillMultiplierFlow;
+        let totalDifficulty = this.calculateTotalValue(snapDifficulty, agilityDifficulty, flowDifficulty);
+        if (this.mods.has(osuBase.ModMagnetised)) {
+            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
+            totalDifficulty *= 1 - magnetisedStrength;
         }
-        let flashlightRating = OsuRatingCalculator.calculateDifficultyRating(flashlightDifficultyValue);
+        totalDifficulty *=
+            0.985 + Math.pow(Math.max(0, current.overallDifficulty), 2) / 4000;
+        return totalDifficulty;
+    }
+    calculateTotalValue(snapDifficulty, agilityDifficulty, flowDifficulty) {
+        // We compare flow to combined snap and agility because snap by itself does not have enough difficulty
+        // to be above flow on streams. Agility, on the other hand, is supposed to measure the rate of cursor
+        // velocity changes while snapping. This means snapping every circle on a stream requires an enormous
+        // amount of agility at which point it is easier to flow.
+        let combinedSnapDifficulty = osuBase.MathUtils.norm(this.combinedSnapNormExponent, snapDifficulty, agilityDifficulty);
+        const pSnap = this.calculateSnapFlowProbability(flowDifficulty / combinedSnapDifficulty);
+        const pFlow = 1 - pSnap;
         if (this.mods.has(osuBase.ModTouchDevice)) {
-            flashlightRating = Math.pow(flashlightRating, 0.8);
+            // We do not adjust agility here since agility represents TD difficulty in a decent enough way.
+            snapDifficulty = Math.pow(snapDifficulty, 0.89);
+            combinedSnapDifficulty = osuBase.MathUtils.norm(this.combinedSnapNormExponent, snapDifficulty, agilityDifficulty);
         }
         if (this.mods.has(osuBase.ModRelax)) {
-            flashlightRating *= 0.7;
-        }
-        else if (this.mods.has(osuBase.ModAutopilot)) {
-            flashlightRating *= 0.4;
-        }
-        if (this.mods.has(osuBase.ModMagnetised)) {
-            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
-            flashlightRating *= 1 - magnetisedStrength;
-        }
-        if (this.mods.has(osuBase.ModDeflate)) {
-            const deflateInitialScale = this.mods.get(osuBase.ModDeflate).startScale.value;
-            flashlightRating *= osuBase.MathUtils.clamp(osuBase.Interpolation.reverseLerp(deflateInitialScale, 11, 1), 0.1, 1);
+            combinedSnapDifficulty *= 0.75;
+            flowDifficulty *= 0.6;
         }
-        let ratingMultiplier = 1;
-        // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
-        ratingMultiplier *=
-            0.7 +
-                0.1 * Math.min(1, this.totalHits / 200) +
-                (this.totalHits > 200
-                    ? 0.2 * Math.min(1, (this.totalHits - 200) / 200)
-                    : 0);
-        // It is important to consider accuracy difficulty when scaling with accuracy.
-        ratingMultiplier *=
-            0.98 + Math.pow(Math.max(0, this.overallDifficulty), 2) / 2500;
-        return flashlightRating * Math.sqrt(ratingMultiplier);
-    }
-    calculateAimVisibilityFactor() {
-        const approachRateFactorEndpoint = 11.5;
-        const mechanicalDifficultyFactor = osuBase.Interpolation.reverseLerp(this.mechanicalDifficultyRating, 5, 10);
-        const approachRateFactorStartingPoint = osuBase.Interpolation.lerp(9, 10.33, mechanicalDifficultyFactor);
-        return osuBase.Interpolation.reverseLerp(this.approachRate, approachRateFactorEndpoint, approachRateFactorStartingPoint);
-    }
-    calculateSpeedVisibilityFactor() {
-        const approachRateFactorEndpoint = 11.5;
-        const mechanicalDifficultyFactor = osuBase.Interpolation.reverseLerp(this.mechanicalDifficultyRating, 5, 10);
-        const approachRateFactorStartingPoint = osuBase.Interpolation.lerp(10, 10.33, mechanicalDifficultyFactor);
-        return osuBase.Interpolation.reverseLerp(this.approachRate, approachRateFactorEndpoint, approachRateFactorStartingPoint);
+        const totalDifficulty = combinedSnapDifficulty * pSnap + flowDifficulty * pFlow;
+        return totalDifficulty * this.skillMultiplierTotal;
     }
     /**
-     * Calculates a visibility bonus that is applicable to Hidden and Traceable.
+     * Converts the ratio of snap to flow into the probability of snapping or flowing.
+     *
+     * Constraints:
+     * - `P(snap) + P(flow) = 1` (the object is always either snapped or flowed)
+     * - `P(snap) = f(snap / flow)` and `P(flow) = f(flow/snap)` (i.e., snap and flow are symmetric and
+     * reversible). This means `f(x) + f(1/x) = 1`
+     * - `0 <= f(x) <= 1` (cannot have negative or greater than 100% probability of snapping or flowing)
+     *
+     * This logistic function is a solution, which fits nicely with the general idea of interpolation and
+     * provides a tuneable constant.
      *
-     * @param mods The mods applied to the calculation.
-     * @param approachRate The approach rate of the beatmap.
-     * @param visibilityFactor The visibility factor to apply.
-     * @param sliderFactor The slider factor to apply.
-     * @returns The visibility bonus multiplier.
+     * @param ratio The ratio.
+     * @returns The probability.
      */
-    static calculateVisibilityBonus(mods, approachRate, visibilityFactor = 1, sliderFactor = 1) {
-        var _a, _b;
-        const isAlwaysPartiallyVisible = (_b = (_a = mods.get(osuBase.ModHidden)) === null || _a === void 0 ? void 0 : _a.onlyFadeApproachCircles.value) !== null && _b !== void 0 ? _b : mods.has(osuBase.ModTraceable);
-        // Start from normal curve, rewarding lower AR up to AR 7.
-        // Traceable forcefully requires a lower reading bonus for now as it is post-applied in pp, which make
-        // it multiplicative with the regular AR bonuses.
-        // This means it has an advantage over Hidden, so we decrease the multiplier to compensate.
-        // This should be removed once we are able to apply Traceable bonuses in star rating (requires real-time
-        // difficulty calculations being possible).
-        let readingBonus = (isAlwaysPartiallyVisible ? 0.025 : 0.04) *
-            (12 - Math.max(approachRate, 7));
-        readingBonus *= visibilityFactor;
-        // We want to reward slideraim on low AR less.
-        const sliderVisibilityFactor = Math.pow(sliderFactor, 3);
-        // For AR up to 0, reduce reward for very low ARs when object is visible.
-        if (approachRate < 7) {
-            readingBonus +=
-                (isAlwaysPartiallyVisible ? 0.02 : 0.045) *
-                    (7 - Math.max(approachRate, 0)) *
-                    sliderVisibilityFactor;
+    calculateSnapFlowProbability(ratio) {
+        if (ratio === 0) {
+            return 0;
         }
-        // Starting from AR 0, cap values so they won't grow to infinity.
-        if (approachRate < 0) {
-            readingBonus +=
-                (isAlwaysPartiallyVisible ? 0.01 : 0.1) *
-                    (1 - Math.pow(1.5, approachRate)) *
-                    sliderVisibilityFactor;
+        if (Number.isNaN(ratio)) {
+            return 1;
         }
-        return readingBonus;
-    }
-    static calculateDifficultyRating(difficultyValue) {
-        return Math.sqrt(difficultyValue) * this.difficultyMultiplier;
-    }
-}
-OsuRatingCalculator.difficultyMultiplier = 0.0675;
-
-/**
- * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
- * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
- */
-class OsuSkill extends StrainSkill {
-    constructor() {
-        super(...arguments);
-        this.difficulty = 0;
+        return osuBase.MathUtils.logistic(-7.27 * Math.log(ratio));
     }
     difficultyValue() {
-        const strains = this.currentStrainPeaks.slice().sort((a, b) => b - a);
-        if (this.reducedSectionCount > 0) {
-            // We are reducing the highest strains first to account for extreme difficulty spikes.
-            for (let i = 0; i < Math.min(strains.length, this.reducedSectionCount); ++i) {
-                const scale = Math.log10(osuBase.Interpolation.lerp(1, 10, osuBase.MathUtils.clamp(i / this.reducedSectionCount, 0, 1)));
-                strains[i] *= osuBase.Interpolation.lerp(this.reducedSectionBaseline, 1, scale);
-            }
-            strains.sort((a, b) => b - a);
+        let time = 0;
+        let difficulty = 0;
+        for (const strain of this.getReducedStrainPeaks()) {
+            /* Weighting function can be thought of as:
+                    b
+                    ∫ decayWeight^x dx
+                    a
+                where a = startTime and b = endTime
+
+                Technically, the function below has been slightly modified from the equation above.
+                The real function would be
+                    double weight = Math.pow(this.decayWeight, startTime) - Math.pow(this.decayWeight, endTime))
+                    ...
+                    return difficulty / Math.log(1 / this.decayWeight)
+                E.g. for a decayWeight of 0.9, we're multiplying by 10 instead of 9.49122...
+
+                This change makes it so that a beatmap composed solely of maxSectionLength chunks will have the exact same value
+                when summed in this class and StrainSkill.
+                Doing this ensures the relationship between strain values and difficulty values remains the same between the two
+                classes.
+            */
+            const startTime = time;
+            const endTime = time + strain.sectionLength / this.maxSectionLength;
+            const weight = Math.pow(this.decayWeight, startTime) -
+                Math.pow(this.decayWeight, endTime);
+            difficulty += strain.value * weight;
+            time = endTime;
         }
-        // Difficulty is the weighted sum of the highest strains from every section.
-        // We're sorting from highest to lowest strain.
-        this.difficulty = 0;
-        let weight = 1;
-        for (const strain of strains) {
-            const addition = strain * weight;
-            if (this.difficulty + addition === this.difficulty) {
-                break;
+        return difficulty / (1 - this.decayWeight);
+    }
+    getReducedStrainPeaks() {
+        // Sections with 0 strain are excluded to avoid worst-case time complexity of the following sort (e.g. /b/2351871).
+        // These sections will not contribute to the difficulty.
+        const strains = this.currentStrainPeaks
+            .filter((s) => s.value > 0)
+            .sort((a, b) => b.value - a.value);
+        let time = 0;
+        // All strains are removed at the end for optimization.
+        let strainsToRemove = 0;
+        // We are reducing the highest strains first to account for extreme difficulty spikes.
+        // Strains are split into 20ms chunks to try to mitigate inconsistencies caused by reducing strains.
+        const chunkSize = 20;
+        while (strains.length > strainsToRemove &&
+            time < this.reducedSectionTime) {
+            const strain = strains[strainsToRemove];
+            for (let addedTime = 0; addedTime < strain.sectionLength; addedTime += chunkSize) {
+                const scale = Math.log10(osuBase.Interpolation.lerp(1, 10, osuBase.MathUtils.clamp((time + addedTime) / this.reducedSectionTime, 0, 1)));
+                strains.push(new StrainPeak(strain.value *
+                    osuBase.Interpolation.lerp(this.reducedStrainBaseline, 1, scale), Math.min(chunkSize, strain.sectionLength - addedTime)));
             }
-            this.difficulty += addition;
-            weight *= this.decayWeight;
+            time += strain.sectionLength;
+            ++strainsToRemove;
         }
-        return this.difficulty;
+        strains.splice(0, strainsToRemove);
+        return strains.sort((a, b) => b.value - a.value);
     }
-}
-
-class StrainUtils {
-    static countTopWeightedSliders(sliderStrains, difficultyValue) {
-        if (sliderStrains.length === 0) {
-            return 0;
-        }
-        const consistentTopStrain = difficultyValue / 10;
-        if (consistentTopStrain === 0) {
-            return 0;
-        }
-        // Use a weighted sum of all strains. Constants are arbitrary and give nice values
-        return sliderStrains.reduce((total, next) => total +
-            osuBase.MathUtils.offsetLogistic(next / consistentTopStrain, 0.88, 10, 1.1));
+    strainDecay(ms) {
+        return Math.pow(0.2, ms / 1000);
     }
 }
 
 /**
- * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
+ * Represents the skill required to read every object in the beatmap.
  */
-class OsuAim extends OsuSkill {
-    constructor(mods, withSliders) {
+class OsuReading extends HarmonicSkill {
+    constructor(mods, clockRate, hitObjects) {
         super(mods);
-        this.strainDecayBase = 0.15;
-        this.reducedSectionCount = 10;
-        this.reducedSectionBaseline = 0.75;
-        this.decayWeight = 0.9;
-        this.currentAimStrain = 0;
-        this.skillMultiplier = 26;
-        this.sliderStrains = [];
-        this.withSliders = withSliders;
+        this.clockRate = clockRate;
+        this.hitObjects = hitObjects;
+        this.currentDifficulty = 0;
+        this.skillMultiplier = 2.5;
+        this.difficultyDecayBase = 0.8;
     }
-    /**
-     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
-     */
-    countDifficultSliders() {
-        if (this.sliderStrains.length === 0) {
+    countTopWeightedObjectDifficulties(difficultyValue) {
+        if (difficultyValue === 0) {
             return 0;
         }
-        const maxSliderStrain = osuBase.MathUtils.max(this.sliderStrains);
-        if (maxSliderStrain === 0) {
+        if (this.noteWeightSum === 0) {
             return 0;
         }
-        return this.sliderStrains.reduce((total, strain) => total +
-            1 / (1 + Math.exp(-((strain / maxSliderStrain) * 12 - 6))), 0);
-    }
-    /**
-     * Obtains the amount of sliders that are considered difficult in terms of relative strain, weighted by consistency.
-     */
-    countTopWeightedSliders() {
-        return StrainUtils.countTopWeightedSliders(this.sliderStrains, this.difficulty);
+        // This is what the top object difficulty is if all object difficulties were identical.
+        const consistentTopNote = difficultyValue / this.noteWeightSum;
+        if (consistentTopNote === 0) {
+            return 0;
+        }
+        return this.objectDifficulties.reduce((total, next) => total +
+            osuBase.MathUtils.offsetLogistic(next / consistentTopNote, 1.15, 5, 1.1), 0);
     }
-    strainValueAt(current) {
-        this.currentAimStrain *= this.strainDecay(current.deltaTime);
-        this.currentAimStrain +=
-            OsuAimEvaluator.evaluateDifficultyOf(current, this.withSliders) *
+    objectDifficultyOf(current) {
+        const decay = this.difficultyDecay(current.deltaTime);
+        this.currentDifficulty *= decay;
+        this.currentDifficulty +=
+            this.calculateAdjustedDifficulty(current) *
+                (1 - decay) *
                 this.skillMultiplier;
-        this._objectStrains.push(this.currentAimStrain);
-        if (current.object instanceof osuBase.Slider) {
-            this.sliderStrains.push(this.currentAimStrain);
-        }
-        return this.currentAimStrain;
+        return this.currentDifficulty;
     }
-    calculateInitialStrain(time, current) {
-        var _a, _b;
-        return (this.currentAimStrain *
-            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
+    applyDifficultyTransformation(difficulties) {
+        // Assume the first few seconds are completely memorized.
+        const reducedNoteCount = this.calculateReducedNoteCount();
+        for (let i = 0; i < Math.min(difficulties.length, reducedNoteCount); ++i) {
+            difficulties[i] *= Math.log10(osuBase.Interpolation.lerp(1, 10, osuBase.MathUtils.clamp(i / reducedNoteCount, 0, 1)));
+        }
     }
-    /**
-     * @param current The hitobject to save to.
-     */
     saveToHitObject(current, difficulty) {
-        if (this.withSliders) {
-            current.aimStrainWithSliders = difficulty;
+        current.readingDifficulty = difficulty;
+    }
+    calculateAdjustedDifficulty(current) {
+        let difficulty = OsuReadingEvaluator.evaluateDifficultyOf(current, this.mods);
+        if (this.mods.has(osuBase.ModTouchDevice)) {
+            difficulty = Math.pow(difficulty, 0.89);
         }
-        else {
-            current.aimStrainWithoutSliders = difficulty;
+        if (this.mods.has(osuBase.ModMagnetised)) {
+            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
+            difficulty *= 1 - magnetisedStrength;
+        }
+        if (this.mods.has(osuBase.ModRelax)) {
+            difficulty *= 0.4;
+        }
+        else if (this.mods.has(osuBase.ModAutopilot)) {
+            difficulty *= 0.1;
+        }
+        difficulty *=
+            0.825 +
+                Math.pow(Math.max(0, current.overallDifficulty), 2.2) / 1125;
+        return difficulty;
+    }
+    calculateReducedNoteCount() {
+        if (this.hitObjects.length < 2) {
+            return 0;
+        }
+        const reducedDifficultyDuration = 60 * 1000;
+        // We take the 2nd note to match `createDifficultyHitObjects`
+        const firstDifficultyObject = this.hitObjects[1];
+        const reducedDuration = firstDifficultyObject.startTime / this.clockRate +
+            reducedDifficultyDuration;
+        let reducedNoteCount = 0;
+        for (let i = 1; i < this.hitObjects.length; ++i) {
+            const object = this.hitObjects[i];
+            if (object.startTime / this.clockRate > reducedDuration) {
+                break;
+            }
+            ++reducedNoteCount;
         }
+        return reducedNoteCount;
     }
-    strainDecay(ms) {
-        return Math.pow(this.strainDecayBase, ms / 1000);
+    difficultyDecay(ms) {
+        return Math.pow(this.difficultyDecayBase, ms / 1000);
     }
 }
 
 /**
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
-class OsuSpeed extends OsuSkill {
+class OsuSpeed extends HarmonicSkill {
     constructor() {
         super(...arguments);
-        this.strainDecayBase = 0.3;
-        this.reducedSectionCount = 5;
-        this.reducedSectionBaseline = 0.75;
-        this.decayWeight = 0.9;
-        this.currentSpeedStrain = 0;
+        this.harmonicScale = 20;
+        this.currentDifficulty = 0;
         this.currentRhythm = 0;
-        this.skillMultiplier = 1.47;
-        this.sliderStrains = [];
-        this.maxStrain = 0;
+        this.skillMultiplier = 1.16;
+        this.strainDecayBase = 0.3;
+        this.sliderDifficulties = [];
+        this.maxDifficulty = 0;
     }
     /**
      * The amount of notes that are relevant to the difficulty.
      */
     relevantNoteCount() {
-        if (this._objectStrains.length === 0 || this.maxStrain === 0) {
+        if (this.objectDifficulties.length === 0 || this.maxDifficulty === 0) {
             return 0;
         }
-        return this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / this.maxStrain) * 12 - 6))), 0);
+        return this.objectDifficulties.reduce((total, next) => total +
+            1 / (1 + Math.exp(-((next / this.maxDifficulty) * 12 - 6))), 0);
     }
     /**
-     * Obtains the amount of sliders that are considered difficult in terms of relative strain, weighted by consistency.
+     * Obtains the amount of sliders that are considered difficult in terms of relative difficulty, weighted by consistency.
+     *
+     * @param difficultyValue The final difficulty value.
      */
-    countTopWeightedSliders() {
-        return StrainUtils.countTopWeightedSliders(this.sliderStrains, this.difficulty);
+    countTopWeightedSliders(difficultyValue) {
+        if (this.sliderDifficulties.length === 0) {
+            return 0;
+        }
+        if (this.noteWeightSum === 0) {
+            return 0;
+        }
+        // What would the top note be if all note values were identical
+        const consistentTopNote = difficultyValue / this.noteWeightSum;
+        if (consistentTopNote === 0) {
+            return 0;
+        }
+        // Use a weighted sum of all notes. Constants are arbitrary and give nice values
+        return this.sliderDifficulties.reduce((total, next) => total +
+            osuBase.MathUtils.offsetLogistic(next / consistentTopNote, 0.88, 10, 1.1), 0);
     }
-    /**
-     * @param current The hitobject to calculate.
-     */
-    strainValueAt(current) {
-        this.currentSpeedStrain *= this.strainDecay(current.strainTime);
-        this.currentSpeedStrain +=
-            OsuSpeedEvaluator.evaluateDifficultyOf(current, this.mods) *
+    objectDifficultyOf(current) {
+        if (this.mods.has(osuBase.ModRelax)) {
+            return 0;
+        }
+        const decay = this.strainDecay(current.strainTime);
+        this.currentDifficulty *= decay;
+        this.currentDifficulty +=
+            this.calculateAdjustedDifficulty(current) *
+                (1 - decay) *
                 this.skillMultiplier;
         this.currentRhythm = OsuRhythmEvaluator.evaluateDifficultyOf(current);
-        const strain = this.currentSpeedStrain * this.currentRhythm;
-        this._objectStrains.push(strain);
-        this.maxStrain = Math.max(this.maxStrain, strain);
+        const difficulty = this.currentDifficulty * this.currentRhythm;
+        this.maxDifficulty = Math.max(this.maxDifficulty, difficulty);
         if (current.object instanceof osuBase.Slider) {
-            this.sliderStrains.push(strain);
+            this.sliderDifficulties.push(difficulty);
         }
-        return strain;
-    }
-    calculateInitialStrain(time, current) {
-        var _a, _b;
-        return (this.currentSpeedStrain *
-            this.currentRhythm *
-            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
+        return difficulty;
     }
-    /**
-     * @param current The hitobject to save to.
-     */
-    saveToHitObject(current, difficulty) {
-        current.speedStrain = difficulty;
+    saveToHitObject(current) {
+        current.speedStrain = this.currentDifficulty * this.currentRhythm;
         current.rhythmMultiplier = this.currentRhythm;
     }
+    calculateAdjustedDifficulty(current) {
+        let difficulty = OsuSpeedEvaluator.evaluateDifficultyOf(current);
+        if (this.mods.has(osuBase.ModAutopilot)) {
+            difficulty *= 0.5;
+        }
+        return difficulty;
+    }
     strainDecay(ms) {
         return Math.pow(this.strainDecayBase, ms / 1000);
     }
@@ -4534,6 +4921,10 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
          * The flashlight performance value.
          */
         this.flashlight = 0;
+        /**
+         * The reading performance value.
+         */
+        this.reading = 0;
         this.greatWindow = 0;
         this.okWindow = 0;
         this.mehWindow = 0;
@@ -4574,20 +4965,17 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         this.greatWindow = hitWindow.greatWindow / clockRate;
         this.okWindow = hitWindow.okWindow / clockRate;
         this.mehWindow = hitWindow.mehWindow / clockRate;
-        this.approachRate =
-            OsuDifficultyCalculator.calculateRateAdjustedApproachRate(ar, clockRate);
-        this.overallDifficulty =
-            OsuDifficultyCalculator.calculateRateAdjustedOverallDifficulty(od, clockRate);
+        this.approachRate = this.calculateRateAdjustedApproachRate(ar, clockRate);
+        this.overallDifficulty = (79.5 - this.greatWindow) / 6;
         this.speedDeviation = this.calculateSpeedDeviation();
         this.aim = this.calculateAimValue();
         this.speed = this.calculateSpeedValue();
         this.accuracy = this.calculateAccuracyValue();
         this.flashlight = this.calculateFlashlightValue();
+        this.reading = this.calculateReadingValue();
+        const cognitionValue = OsuDifficultyCalculator.sumCognitionDifficulty(this.reading, this.flashlight);
         this.total =
-            Math.pow(Math.pow(this.aim, 1.1) +
-                Math.pow(this.speed, 1.1) +
-                Math.pow(this.accuracy, 1.1) +
-                Math.pow(this.flashlight, 1.1), 1 / 1.1) * finalMultiplier;
+            osuBase.MathUtils.norm(OsuPerformanceCalculator.normExponent, this.aim, this.speed, this.accuracy, cognitionValue) * finalMultiplier;
     }
     /**
      * Calculates the aim performance value of the beatmap.
@@ -4620,7 +5008,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         }
         let aimValue = OsuAim.difficultyToPerformance(aimDifficulty);
         // Longer maps are worth more
-        let lengthBonus = 0.95 + 0.4 * Math.min(1, this.totalHits / 2000);
+        let lengthBonus = 0.95 + 0.35 * Math.min(1, this.totalHits / 2000);
         if (this.totalHits > 2000) {
             lengthBonus += Math.log10(this.totalHits / 2000) * 0.5;
         }
@@ -4645,7 +5033,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         else if (this.mods.has(osuBase.ModTraceable)) {
             aimValue *=
                 1 +
-                    OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.approachRate, undefined, this.difficultyAttributes.sliderFactor);
+                    this.calculateTraceableBonus(this.difficultyAttributes.sliderFactor);
         }
         // Scale the aim value with accuracy.
         aimValue *= this.computedAccuracy.value();
@@ -4660,45 +5048,23 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             return 0;
         }
         let speedValue = OsuSpeed.difficultyToPerformance(this.difficultyAttributes.speedDifficulty);
-        // Longer maps are worth more
-        let lengthBonus = 0.95 + 0.4 * Math.min(1, this.totalHits / 2000);
-        if (this.totalHits > 2000) {
-            lengthBonus += Math.log10(this.totalHits / 2000) * 0.5;
-        }
-        speedValue *= lengthBonus;
         if (this._effectiveMissCount > 0) {
             const speedEstimatedSliderBreaks = this.calculateEstimatedSliderBreaks(this.difficultyAttributes.speedTopWeightedSliderFactor);
             const relevantMissCount = Math.min(this._effectiveMissCount + speedEstimatedSliderBreaks, this.totalImperfectHits + this.sliderTicksMissed);
             speedValue *= this.calculateMissPenalty(relevantMissCount, this.difficultyAttributes.speedDifficultStrainCount);
         }
-        // Traceable bonuses are excluded when Blinds is present, as the increased visual difficulty is
-        // redundant when notes cannot be seen.
         if (this.mods.has(osuBase.ModBlinds)) {
             // Increasing the speed value by object count for Blinds is not ideal, so the minimum buff is given.
             speedValue *= 1.12;
         }
-        else if (this.mods.has(osuBase.ModTraceable)) {
-            speedValue *=
-                1 +
-                    OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.approachRate, undefined, this.difficultyAttributes.sliderFactor);
-        }
-        // Calculate accuracy assuming the worst case scenario.
-        const countGreat = this.computedAccuracy.n300;
-        const countOk = this.computedAccuracy.n100;
-        const countMeh = this.computedAccuracy.n50;
-        const relevantTotalDiff = this.totalHits - this.difficultyAttributes.speedNoteCount;
-        const relevantAccuracy = new osuBase.Accuracy(this.difficultyAttributes.speedNoteCount > 0
-            ? {
-                n300: Math.max(0, countGreat - relevantTotalDiff),
-                n100: Math.max(0, countOk - Math.max(0, relevantTotalDiff - countGreat)),
-                n50: Math.max(0, countMeh -
-                    Math.max(0, relevantTotalDiff - countGreat - countOk)),
-            }
-            : // Set accuracy to 0.
-                { n300: 0, nobjects: 1 });
         speedValue *= this.calculateSpeedHighDeviationNerf();
-        // Scale the speed value with accuracy and OD.
-        speedValue *= Math.pow((this.computedAccuracy.value() + relevantAccuracy.value()) / 2, (14.5 - this.overallDifficulty) / 2);
+        // An effective hit window is created based on the speed SR. The higher the speed difficulty, the shorter the hit window.
+        // For example, a speed SR of 4 leads to an effective hit window of 20ms, which is OD 10.
+        const effectiveHitWindow = 20 * Math.pow(4 / this.difficultyAttributes.speedDifficulty, 0.35);
+        // Find the proportion of 300s on speed notes assuming the hit window was the effective hit window.
+        const effectiveAccuracy = osuBase.ErrorFunction.erf(effectiveHitWindow / this.speedDeviation);
+        // Scale speed value by normalized accuracy.
+        speedValue *= Math.pow(effectiveAccuracy, 2);
         return speedValue;
     }
     /**
@@ -4708,7 +5074,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         if (this.mods.has(osuBase.ModRelax)) {
             return 0;
         }
-        const ncircles = this.mods.has(osuBase.ModScoreV2)
+        const ncircles = !this.usingClassicSliderAccuracy || this.mods.has(osuBase.ModScoreV2)
             ? this.totalHits - this.difficultyAttributes.spinnerCount
             : this.difficultyAttributes.hitCircleCount;
         if (ncircles === 0) {
@@ -4721,21 +5087,18 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             // It is possible to reach a negative accuracy with this formula. Cap it at zero - zero points.
             Math.pow(realAccuracy.n300 < 0 ? 0 : realAccuracy.value(), 24) *
             2.83;
-        // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
-        accuracyValue *= Math.min(1.15, Math.pow(ncircles / 1000, 0.3));
+        // Bonus for many hitcircles - it's harder to keep good accuracy up for longer.
+        accuracyValue *= Math.pow(ncircles / 1000, ncircles < 1000 ? 0.3 : 0.1);
         // Increasing the accuracy value by object count for Blinds isn't ideal, so the minimum buff is given.
         if (this.mods.has(osuBase.ModBlinds)) {
             accuracyValue *= 1.14;
         }
-        else if (this.mods.has(osuBase.ModHidden) || this.mods.has(osuBase.ModTraceable)) {
+        else if (this.mods.has(osuBase.ModTraceable)) {
             // Decrease bonus for AR > 10.
             accuracyValue *=
                 1 +
                     0.08 * osuBase.Interpolation.reverseLerp(this.approachRate, 11.5, 10);
         }
-        if (this.mods.has(osuBase.ModFlashlight)) {
-            accuracyValue *= 1.02;
-        }
         return accuracyValue;
     }
     /**
@@ -4755,17 +5118,23 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                     Math.pow(1 -
                         Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
         }
-        // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
-        flashlightValue *=
-            0.7 +
-                0.1 * Math.min(1, this.totalHits / 200) +
-                (this.totalHits > 200
-                    ? 0.2 * Math.min(1, (this.totalHits - 200) / 200)
-                    : 0);
         // Scale the flashlight value with accuracy slightly.
         flashlightValue *= 0.5 + this.computedAccuracy.value() / 2;
         return flashlightValue;
     }
+    /**
+     * Calculates the reading performance value of the beatmap.
+     */
+    calculateReadingValue() {
+        let readingValue = OsuReading.difficultyToPerformance(this.difficultyAttributes.readingDifficulty);
+        if (this.effectiveMissCount > 0) {
+            const aimEstimatedSliderBreaks = this.calculateEstimatedSliderBreaks(this.difficultyAttributes.aimTopWeightedSliderFactor);
+            readingValue *= this.calculateMissPenalty(this.effectiveMissCount + aimEstimatedSliderBreaks, this.difficultyAttributes.readingDifficultNoteCount);
+        }
+        // Scale the reading value with accuracy _harshly_.
+        readingValue *= Math.pow(this.computedAccuracy.value(), 3);
+        return readingValue;
+    }
     /**
      * Calculates a strain-based miss penalty.
      *
@@ -4777,9 +5146,8 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         if (missCount === 0) {
             return 1;
         }
-        return (0.96 /
-            (missCount / (4 * Math.pow(Math.log(difficultStrainCount), 0.94)) +
-                1));
+        // https://www.desmos.com/calculator/naggvbcz0a
+        return 0.93 / (missCount / (4 * Math.log(difficultStrainCount)) + 1);
     }
     /**
      * Estimates a player's deviation on speed notes using {@link calculateDeviation}, assuming worst-case.
@@ -4881,19 +5249,21 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         return (osuBase.Interpolation.lerp(adjustedSpeedValue, speedValue, t) / speedValue);
     }
     calculateEstimatedSliderBreaks(topWeightedSliderFactor) {
-        const { n100 } = this.computedAccuracy;
-        if (!this.usingClassicSliderAccuracy || n100 === 0) {
+        const nonMissMistakes = this.computedAccuracy.n100 + this.computedAccuracy.n50;
+        if (!this.usingClassicSliderAccuracy || nonMissMistakes === 0) {
             return 0;
         }
         const missedComboPercent = 1 - this.combo / this.difficultyAttributes.maxCombo;
-        let estimatedSliderBreaks = Math.min(n100, this._effectiveMissCount * topWeightedSliderFactor);
-        // Scores with more Oks are more likely to have slider breaks.
-        const okAdjustment = (n100 - estimatedSliderBreaks + 0.5) / n100;
+        let estimatedSliderBreaks = Math.min(nonMissMistakes, this._effectiveMissCount * topWeightedSliderFactor);
+        // Scores with more Oks and Mehs are more likely to have slider breaks.
+        // We add an arbitrary value to both sides of the division to make it more stable on extreme ends.
+        const nonMissMistakeAdjustment = (nonMissMistakes - estimatedSliderBreaks + 4.5) /
+            (nonMissMistakes + 4);
         // There is a low probability of extra slider breaks on effective miss counts close to 1, as
         // score based calculations are good at indicating if only a single break occurred.
         estimatedSliderBreaks *= osuBase.MathUtils.smoothstep(this._effectiveMissCount, 1, 2);
         return (estimatedSliderBreaks *
-            okAdjustment *
+            nonMissMistakeAdjustment *
             osuBase.MathUtils.offsetLogistic(missedComboPercent, 0.33, 15));
     }
     /**
@@ -4902,16 +5272,27 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
     calculateComboBasedEstimatedMissCount() {
         let missCount = this.computedAccuracy.nmiss;
         const { combo } = this;
-        const { sliderCount, maxCombo } = this.difficultyAttributes;
+        const { aimTopWeightedSliderFactor, sliderCount, maxCombo } = this.difficultyAttributes;
         if (sliderCount <= 0) {
             return missCount;
         }
         if (this.usingClassicSliderAccuracy) {
+            // If sliders in the beatmap are hard, it's likely for player to drop sliderends.
+            // However, if the beatmap has easy sliders, it's more likely for player to sliderbreak.
+            const likelyMissedSliderendPortion = 0.04 +
+                0.06 * Math.pow(Math.min(aimTopWeightedSliderFactor, 1), 2);
             // Consider that full combo is maximum combo minus dropped slider tails since
             // they don't contribute to combo but also don't break it.
             // In classic scores, we can't know the amount of dropped sliders so we estimate
             // to 10% of all sliders in the beatmap.
-            const fullComboThreshold = maxCombo - 0.1 * sliderCount;
+            const fullComboThreshold = maxCombo -
+                Math.min(
+                // 4 is the minimum leniency baseline to ensure that dropping one (for few) sliderends will
+                // not instantly be treated as a sliderbreak even in cases where the slider count is low.
+                // 4 was picked because in a lot of short stream beatmaps with small amount of sliders, there
+                // are 2-3 sliders on which sliderends are often dropped. This is a kind of optimization to
+                // achieve the most accurate result on average.
+                4 + likelyMissedSliderendPortion * sliderCount, sliderCount);
             if (combo < fullComboThreshold) {
                 missCount = fullComboThreshold / Math.max(1, combo);
             }
@@ -4938,6 +5319,36 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         }
         return missCount;
     }
+    calculateTraceableBonus(sliderFactor = 1) {
+        // We want to reward slider aim less, more so at lower AR.
+        const highApproachRateSliderVisibilityFactor = 0.5 + Math.pow(sliderFactor, 6) / 2;
+        const lowApproachRateSliderVisibilityFactor = Math.pow(sliderFactor, 6);
+        let traceableBonus = 0.0275;
+        // Start from normal curve, rewarding lower AR up to AR7.
+        traceableBonus +=
+            0.025 *
+                (12.0 - Math.max(this.approachRate, 7)) *
+                highApproachRateSliderVisibilityFactor;
+        // For AR up to 0 - reduce reward for very low ARs when object is visible.
+        if (this.approachRate < 7) {
+            traceableBonus +=
+                0.025 *
+                    (7 - Math.max(this.approachRate, 0)) *
+                    lowApproachRateSliderVisibilityFactor;
+        }
+        // Starting from AR0 - cap values so they won't grow to infinity.
+        if (this.approachRate < 0) {
+            traceableBonus +=
+                0.025 *
+                    (1 - Math.pow(1.5, this.approachRate)) *
+                    lowApproachRateSliderVisibilityFactor;
+        }
+        return traceableBonus;
+    }
+    calculateRateAdjustedApproachRate(approachRate, clockRate) {
+        const preempt = osuBase.BeatmapDifficulty.difficultyRange(approachRate, osuBase.HitObject.preemptMax, osuBase.HitObject.preemptMid, osuBase.HitObject.preemptMin) / clockRate;
+        return osuBase.BeatmapDifficulty.inverseDifficultyRange(preempt, osuBase.HitObject.preemptMax, osuBase.HitObject.preemptMid, osuBase.HitObject.preemptMin);
+    }
     toString() {
         return (this.total.toFixed(2) +
             " pp (" +
@@ -4948,10 +5359,13 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             this.accuracy.toFixed(2) +
             " accuracy, " +
             this.flashlight.toFixed(2) +
-            " flashlight)");
+            " flashlight, " +
+            this.reading.toFixed(2) +
+            " reading)");
     }
 }
-OsuPerformanceCalculator.finalMultiplier = 1.14;
+OsuPerformanceCalculator.finalMultiplier = 1.12;
+OsuPerformanceCalculator.normExponent = 1.1;
 
 /**
  * Represents an osu!standard hit object with difficulty calculation values.
@@ -4967,34 +5381,83 @@ class OsuDifficultyHitObject extends DifficultyHitObject {
         this.mode = osuBase.Modes.Osu;
     }
     get smallCircleBonus() {
-        return Math.max(1, 1 + (30 - this.object.radius) / 40);
+        return Math.max(1, 1 + (30 - this.object.radius) / 70);
+    }
+    get overallDifficulty() {
+        const hitWindowGreat = this.hitWindowFor(osuBase.HitResult.Great) / 2;
+        return (79.5 - hitWindowGreat) / 6;
     }
 }
 
 /**
- * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
+ * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
  */
-class OsuFlashlight extends OsuSkill {
+class OsuSkill extends StrainSkill {
     constructor() {
         super(...arguments);
-        this.strainDecayBase = 0.15;
+        this.difficulty = 0;
+    }
+    difficultyValue() {
+        const strains = this.currentStrainPeaks.slice().sort((a, b) => b - a);
+        if (this.reducedSectionCount > 0) {
+            // We are reducing the highest strains first to account for extreme difficulty spikes.
+            for (let i = 0; i < Math.min(strains.length, this.reducedSectionCount); ++i) {
+                const scale = Math.log10(osuBase.Interpolation.lerp(1, 10, osuBase.MathUtils.clamp(i / this.reducedSectionCount, 0, 1)));
+                strains[i] *= osuBase.Interpolation.lerp(this.reducedSectionBaseline, 1, scale);
+            }
+            strains.sort((a, b) => b - a);
+        }
+        // Difficulty is the weighted sum of the highest strains from every section.
+        // We're sorting from highest to lowest strain.
+        this.difficulty = 0;
+        let weight = 1;
+        for (const strain of strains) {
+            const addition = strain * weight;
+            if (this.difficulty + addition === this.difficulty) {
+                break;
+            }
+            this.difficulty += addition;
+            weight *= this.decayWeight;
+        }
+        return this.difficulty;
+    }
+}
+
+/**
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ */
+class OsuFlashlight extends OsuSkill {
+    static difficultyToPerformance(difficulty) {
+        return Math.pow(difficulty, 2) * 25;
+    }
+    constructor(mods, totalObjects) {
+        super(mods);
+        this.totalObjects = totalObjects;
         this.reducedSectionCount = 0;
         this.reducedSectionBaseline = 1;
         this.decayWeight = 1;
         this.currentFlashlightStrain = 0;
-        this.skillMultiplier = 0.05512;
-    }
-    static difficultyToPerformance(difficulty) {
-        return Math.pow(difficulty, 2) * 25;
+        this.skillMultiplier = 0.058;
     }
     difficultyValue() {
-        return this.currentStrainPeaks.reduce((a, b) => a + b, 0);
+        let sum = this.currentStrainPeaks.reduce((a, b) => a + b, 0);
+        // Account for shorter beatmaps having a higher ratio of 0 combo/100 combo flashlight radius.
+        sum *=
+            0.7 +
+                0.1 * Math.min(1, this.totalObjects / 200) +
+                (this.totalObjects > 200
+                    ? 0.2 * Math.min(1, (this.totalObjects - 200) / 200)
+                    : 0);
+        return sum;
     }
     strainValueAt(current) {
+        if (!this.mods.has(osuBase.ModFlashlight)) {
+            return 0;
+        }
         this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
         this.currentFlashlightStrain +=
-            OsuFlashlightEvaluator.evaluateDifficultyOf(current, this.mods) *
-                this.skillMultiplier;
+            this.calculateAdjustedDifficulty(current) * this.skillMultiplier;
         return this.currentFlashlightStrain;
     }
     calculateInitialStrain(time, current) {
@@ -5002,11 +5465,34 @@ class OsuFlashlight extends OsuSkill {
         return (this.currentFlashlightStrain *
             this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
-    saveToHitObject(current, difficulty) {
-        current.flashlightStrain = difficulty;
+    saveToHitObject(current) {
+        current.flashlightStrain = this.currentFlashlightStrain;
+    }
+    calculateAdjustedDifficulty(current) {
+        let difficulty = OsuFlashlightEvaluator.evaluateDifficultyOf(current, this.mods);
+        if (this.mods.has(osuBase.ModTouchDevice)) {
+            difficulty = Math.pow(difficulty, 0.9);
+        }
+        if (this.mods.has(osuBase.ModMagnetised)) {
+            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
+            difficulty *= 1 - magnetisedStrength;
+        }
+        if (this.mods.has(osuBase.ModDeflate)) {
+            const deflateInitialScale = this.mods.get(osuBase.ModDeflate).startScale.value;
+            difficulty *= osuBase.MathUtils.clamp(osuBase.Interpolation.reverseLerp(deflateInitialScale, 11, 1), 0.1, 1);
+        }
+        if (this.mods.has(osuBase.ModRelax)) {
+            difficulty *= 0.7;
+        }
+        else if (this.mods.has(osuBase.ModAutopilot)) {
+            difficulty *= 0.4;
+        }
+        difficulty *=
+            0.985 + Math.pow(Math.max(0, current.overallDifficulty), 2) / 4000;
+        return difficulty;
     }
     strainDecay(ms) {
-        return Math.pow(this.strainDecayBase, ms / 1000);
+        return Math.pow(0.15, ms / 1000);
     }
 }
 
@@ -5020,7 +5506,6 @@ class OsuDifficultyAttributes extends DifficultyAttributes {
         this.drainRate = 0;
         this.speedDifficulty = 0;
         this.speedDifficultStrainCount = 0;
-        this.aimTopWeightedSliderFactor = 0;
         this.speedTopWeightedSliderFactor = 0;
         if (!cacheableAttributes) {
             return;
@@ -5030,8 +5515,6 @@ class OsuDifficultyAttributes extends DifficultyAttributes {
         this.speedDifficulty = cacheableAttributes.speedDifficulty;
         this.speedDifficultStrainCount =
             cacheableAttributes.speedDifficultStrainCount;
-        this.aimTopWeightedSliderFactor =
-            cacheableAttributes.aimTopWeightedSliderFactor;
         this.speedTopWeightedSliderFactor =
             cacheableAttributes.speedTopWeightedSliderFactor;
     }
@@ -5039,7 +5522,8 @@ class OsuDifficultyAttributes extends DifficultyAttributes {
         return (super.toString() +
             ` (${this.aimDifficulty.toFixed(2)} aim, ` +
             `${this.speedDifficulty.toFixed(2)} speed, ` +
-            `${this.flashlightDifficulty.toFixed(2)} flashlight)`);
+            `${this.flashlightDifficulty.toFixed(2)} flashlight, ` +
+            `${this.readingDifficulty.toFixed(2)} reading)`);
     }
 }
 
@@ -5049,7 +5533,6 @@ class OsuDifficultyAttributes extends DifficultyAttributes {
 class OsuDifficultyCalculator extends DifficultyCalculator {
     constructor() {
         super();
-        this.starRatingMultiplier = 0.0265;
         this.difficultyAdjustmentMods.push(osuBase.ModTouchDevice, osuBase.ModBlinds);
     }
     retainDifficultyAdjustmentMods(mods) {
@@ -5057,8 +5540,8 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             mod.isOsuRelevant &&
             this.difficultyAdjustmentMods.some((m) => mod instanceof m));
     }
-    createDifficultyAttributes(_beatmap, playableBeatmap, skills) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    createDifficultyAttributes(beatmap, playableBeatmap, skills) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         const attributes = new OsuDifficultyAttributes();
         if (playableBeatmap.hitObjects.objects.length === 0) {
             return attributes;
@@ -5069,27 +5552,26 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         attributes.hitCircleCount = playableBeatmap.hitObjects.circles;
         attributes.sliderCount = playableBeatmap.hitObjects.sliders;
         attributes.spinnerCount = playableBeatmap.hitObjects.spinners;
+        attributes.approachRate = playableBeatmap.difficulty.ar;
+        attributes.overallDifficulty = playableBeatmap.difficulty.od;
         attributes.drainRate = playableBeatmap.difficulty.hp;
-        attributes.approachRate =
-            OsuDifficultyCalculator.calculateRateAdjustedApproachRate(playableBeatmap.difficulty.ar, attributes.clockRate);
-        attributes.overallDifficulty =
-            OsuDifficultyCalculator.calculateRateAdjustedOverallDifficulty(playableBeatmap.difficulty.od, attributes.clockRate);
         const aim = skills.find((s) => s instanceof OsuAim && s.withSliders);
         const aimNoSlider = skills.find((s) => s instanceof OsuAim && !s.withSliders);
         const speed = skills.find((s) => s instanceof OsuSpeed);
         const flashlight = skills.find((s) => s instanceof OsuFlashlight);
+        const reading = skills.find((s) => s instanceof OsuReading);
         // Aim attributes
         const aimDifficultyValue = (_a = aim === null || aim === void 0 ? void 0 : aim.difficultyValue()) !== null && _a !== void 0 ? _a : 0;
-        attributes.aimDifficultSliderCount = (_b = aim === null || aim === void 0 ? void 0 : aim.countDifficultSliders()) !== null && _b !== void 0 ? _b : 0;
+        const aimNoSliderDifficultyValue = (_b = aimNoSlider === null || aimNoSlider === void 0 ? void 0 : aimNoSlider.difficultyValue()) !== null && _b !== void 0 ? _b : 0;
+        attributes.aimDifficultSliderCount = (_c = aim === null || aim === void 0 ? void 0 : aim.countDifficultSliders()) !== null && _c !== void 0 ? _c : 0;
         attributes.aimDifficultStrainCount =
-            (_c = aim === null || aim === void 0 ? void 0 : aim.countTopWeightedStrains(aimDifficultyValue)) !== null && _c !== void 0 ? _c : 0;
+            (_d = aim === null || aim === void 0 ? void 0 : aim.countTopWeightedStrains(aimDifficultyValue)) !== null && _d !== void 0 ? _d : 0;
         attributes.sliderFactor =
             aimDifficultyValue > 0
-                ? OsuRatingCalculator.calculateDifficultyRating((_d = aimNoSlider === null || aimNoSlider === void 0 ? void 0 : aimNoSlider.difficultyValue()) !== null && _d !== void 0 ? _d : 0) /
-                    OsuRatingCalculator.calculateDifficultyRating(aimDifficultyValue)
+                ? this.calculateAimDifficultyRating(aimNoSliderDifficultyValue) / this.calculateAimDifficultyRating(aimDifficultyValue)
                 : 1;
-        const aimNoSliderTopWeightedSliderCount = (_e = aimNoSlider === null || aimNoSlider === void 0 ? void 0 : aimNoSlider.countTopWeightedSliders()) !== null && _e !== void 0 ? _e : 0;
-        const aimNoSliderDifficultStrainCount = (_f = aimNoSlider === null || aimNoSlider === void 0 ? void 0 : aimNoSlider.countTopWeightedStrains(aimNoSlider.difficultyValue())) !== null && _f !== void 0 ? _f : 0;
+        const aimNoSliderTopWeightedSliderCount = (_e = aimNoSlider === null || aimNoSlider === void 0 ? void 0 : aimNoSlider.countTopWeightedSliders(aimNoSliderDifficultyValue)) !== null && _e !== void 0 ? _e : 0;
+        const aimNoSliderDifficultStrainCount = (_f = aimNoSlider === null || aimNoSlider === void 0 ? void 0 : aimNoSlider.countTopWeightedStrains(aimNoSliderDifficultyValue)) !== null && _f !== void 0 ? _f : 0;
         attributes.aimTopWeightedSliderFactor =
             aimNoSliderTopWeightedSliderCount /
                 Math.max(1, aimNoSliderDifficultStrainCount -
@@ -5098,27 +5580,29 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         const speedDifficultyValue = (_g = speed === null || speed === void 0 ? void 0 : speed.difficultyValue()) !== null && _g !== void 0 ? _g : 0;
         attributes.speedNoteCount = (_h = speed === null || speed === void 0 ? void 0 : speed.relevantNoteCount()) !== null && _h !== void 0 ? _h : 0;
         attributes.speedDifficultStrainCount =
-            (_j = speed === null || speed === void 0 ? void 0 : speed.countTopWeightedStrains(speedDifficultyValue)) !== null && _j !== void 0 ? _j : 0;
-        const speedTopWeightedSliderCount = (_k = speed === null || speed === void 0 ? void 0 : speed.countTopWeightedSliders()) !== null && _k !== void 0 ? _k : 0;
+            (_j = speed === null || speed === void 0 ? void 0 : speed.countTopWeightedObjectDifficulties(speedDifficultyValue)) !== null && _j !== void 0 ? _j : 0;
+        const speedTopWeightedSliderCount = (_k = speed === null || speed === void 0 ? void 0 : speed.countTopWeightedSliders(speedDifficultyValue)) !== null && _k !== void 0 ? _k : 0;
         attributes.speedTopWeightedSliderFactor =
             speedTopWeightedSliderCount /
                 Math.max(1, attributes.speedDifficultStrainCount -
                     speedTopWeightedSliderCount);
+        // Reading attributes
+        const readingDifficultyValue = (_l = reading === null || reading === void 0 ? void 0 : reading.difficultyValue()) !== null && _l !== void 0 ? _l : 0;
+        attributes.readingDifficultNoteCount =
+            (_m = reading === null || reading === void 0 ? void 0 : reading.countTopWeightedObjectDifficulties(readingDifficultyValue)) !== null && _m !== void 0 ? _m : 0;
         // Final rating
-        const mechanicalDifficultyRating = this.calculateMechanicalDifficultyRating(aimDifficultyValue, speedDifficultyValue);
-        const ratingCalculator = new OsuRatingCalculator(attributes.mods, playableBeatmap.hitObjects.objects.length, attributes.approachRate, attributes.overallDifficulty, mechanicalDifficultyRating, attributes.sliderFactor);
         attributes.aimDifficulty =
-            ratingCalculator.computeAimRating(aimDifficultyValue);
+            this.calculateAimDifficultyRating(aimDifficultyValue);
         attributes.speedDifficulty =
-            ratingCalculator.computeSpeedRating(speedDifficultyValue);
-        attributes.flashlightDifficulty =
-            ratingCalculator.computeFlashlightRating((_l = flashlight === null || flashlight === void 0 ? void 0 : flashlight.difficultyValue()) !== null && _l !== void 0 ? _l : 0);
+            this.calculateDifficultyRating(speedDifficultyValue);
+        attributes.flashlightDifficulty = this.calculateDifficultyRating((_o = flashlight === null || flashlight === void 0 ? void 0 : flashlight.difficultyValue()) !== null && _o !== void 0 ? _o : 0);
+        attributes.readingDifficulty = this.calculateDifficultyRating(readingDifficultyValue);
         const baseAimPerformance = OsuAim.difficultyToPerformance(attributes.aimDifficulty);
         const baseSpeedPerformance = OsuSpeed.difficultyToPerformance(attributes.speedDifficulty);
         const baseFlashlightPerformance = OsuFlashlight.difficultyToPerformance(attributes.flashlightDifficulty);
-        const basePerformance = Math.pow(Math.pow(baseAimPerformance, 1.1) +
-            Math.pow(baseSpeedPerformance, 1.1) +
-            Math.pow(baseFlashlightPerformance, 1.1), 1 / 1.1);
+        const baseReadingPerformance = OsuReading.difficultyToPerformance(attributes.readingDifficulty);
+        const baseCognitionPerformance = OsuDifficultyCalculator.sumCognitionDifficulty(baseReadingPerformance, baseFlashlightPerformance);
+        const basePerformance = osuBase.MathUtils.norm(OsuPerformanceCalculator.normExponent, baseAimPerformance, baseSpeedPerformance, baseCognitionPerformance);
         attributes.starRating = this.calculateStarRating(basePerformance);
         return attributes;
     }
@@ -5126,12 +5610,11 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         return beatmap.createOsuPlayableBeatmap(mods);
     }
     createDifficultyHitObjects(beatmap) {
-        var _a;
         const clockRate = beatmap.speedMultiplier;
         const difficultyObjects = [];
         const { objects } = beatmap.hitObjects;
         for (let i = 1; i < objects.length; ++i) {
-            const difficultyObject = new OsuDifficultyHitObject(objects[i], (_a = objects[i - 1]) !== null && _a !== void 0 ? _a : null, difficultyObjects, clockRate, i - 1);
+            const difficultyObject = new OsuDifficultyHitObject(objects[i], objects[i - 1], difficultyObjects, clockRate, i - 1);
             difficultyObject.computeProperties(clockRate);
             difficultyObjects.push(difficultyObject);
         }
@@ -5147,8 +5630,9 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         if (!mods.has(osuBase.ModRelax)) {
             skills.push(new OsuSpeed(mods));
         }
+        skills.push(new OsuReading(mods, beatmap.speedMultiplier, beatmap.hitObjects.objects));
         if (mods.has(osuBase.ModFlashlight)) {
-            skills.push(new OsuFlashlight(mods));
+            skills.push(new OsuFlashlight(mods, beatmap.hitObjects.objects.length));
         }
         return skills;
     }
@@ -5158,30 +5642,26 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             new OsuAim(mods, true),
             new OsuAim(mods, false),
             new OsuSpeed(mods),
-            new OsuFlashlight(mods),
+            new OsuFlashlight(mods, beatmap.hitObjects.objects.length),
         ];
     }
-    calculateMechanicalDifficultyRating(aimDifficultyValue, speedDifficultyValue) {
-        const aimValue = OsuSkill.difficultyToPerformance(OsuRatingCalculator.calculateDifficultyRating(aimDifficultyValue));
-        const speedValue = OsuSkill.difficultyToPerformance(OsuRatingCalculator.calculateDifficultyRating(speedDifficultyValue));
-        const totalValue = Math.pow(Math.pow(aimValue, 1.1) + Math.pow(speedValue, 1.1), 1 / 1.1);
-        return this.calculateStarRating(totalValue);
+    calculateAimDifficultyRating(difficultyValue) {
+        return Math.pow(difficultyValue, 0.63) * 0.02275;
+    }
+    calculateDifficultyRating(difficultyValue) {
+        return Math.sqrt(difficultyValue) * 0.0675;
     }
     calculateStarRating(basePerformance) {
-        if (basePerformance <= 1e-5) {
-            return 0;
-        }
-        return (Math.cbrt(OsuPerformanceCalculator.finalMultiplier) *
-            this.starRatingMultiplier *
-            (Math.cbrt((100000 / Math.pow(2, 1 / 1.1)) * basePerformance) + 4));
-    }
-    static calculateRateAdjustedApproachRate(approachRate, clockRate) {
-        const preempt = osuBase.BeatmapDifficulty.difficultyRange(approachRate, osuBase.HitObject.preemptMax, osuBase.HitObject.preemptMid, osuBase.HitObject.preemptMin) / clockRate;
-        return osuBase.BeatmapDifficulty.inverseDifficultyRange(preempt, osuBase.HitObject.preemptMax, osuBase.HitObject.preemptMid, osuBase.HitObject.preemptMin);
+        return Math.cbrt(basePerformance * OsuPerformanceCalculator.finalMultiplier);
     }
-    static calculateRateAdjustedOverallDifficulty(overallDifficulty, clockRate) {
-        const greatWindow = new osuBase.OsuHitWindow(overallDifficulty).greatWindow / clockRate;
-        return (79.5 - greatWindow) / 6;
+    static sumCognitionDifficulty(reading, flashlight) {
+        if (reading <= 0) {
+            return flashlight;
+        }
+        if (flashlight <= 0) {
+            return reading;
+        }
+        return osuBase.MathUtils.norm(OsuPerformanceCalculator.normExponent, reading, flashlight * osuBase.MathUtils.clamp(flashlight / reading, 0.25, 1));
     }
 }
 
@@ -5205,15 +5685,19 @@ exports.DroidSnapAimEvaluator = DroidSnapAimEvaluator;
 exports.DroidTap = DroidTap;
 exports.DroidTapEvaluator = DroidTapEvaluator;
 exports.ExtendedDroidDifficultyAttributes = ExtendedDroidDifficultyAttributes;
+exports.OsuAgilityEvaluator = OsuAgilityEvaluator;
 exports.OsuAim = OsuAim;
-exports.OsuAimEvaluator = OsuAimEvaluator;
 exports.OsuDifficultyAttributes = OsuDifficultyAttributes;
 exports.OsuDifficultyCalculator = OsuDifficultyCalculator;
 exports.OsuDifficultyHitObject = OsuDifficultyHitObject;
 exports.OsuFlashlight = OsuFlashlight;
 exports.OsuFlashlightEvaluator = OsuFlashlightEvaluator;
+exports.OsuFlowAimEvaluator = OsuFlowAimEvaluator;
 exports.OsuPerformanceCalculator = OsuPerformanceCalculator;
+exports.OsuReading = OsuReading;
+exports.OsuReadingEvaluator = OsuReadingEvaluator;
 exports.OsuRhythmEvaluator = OsuRhythmEvaluator;
+exports.OsuSnapAimEvaluator = OsuSnapAimEvaluator;
 exports.OsuSpeed = OsuSpeed;
 exports.OsuSpeedEvaluator = OsuSpeedEvaluator;
 exports.PerformanceCalculator = PerformanceCalculator;