@rian8337/osu-difficulty-calculator 4.0.0-beta.82 → 4.0.0-beta.85

package/dist/index.js

@@ -72,6 +72,7 @@ class DifficultyCalculator {
             osuBase.ModEasy,
             osuBase.ModHardRock,
             osuBase.ModFlashlight,
+            osuBase.ModTraceable,
             osuBase.ModHidden,
             osuBase.ModRelax,
             osuBase.ModAutopilot,
@@ -79,10 +80,15 @@ class DifficultyCalculator {
             osuBase.ModRandom,
         ];
     }
+    /**
+     * Calculates the difficulty of a `Beatmap` with specific `Mod`s.
+     *
+     * @param beatmap The `Beatmap` whose difficulty is to be calculated.
+     * @param mods The `Mod`s to apply to the beatmap. Defaults to No Mod.
+     * @returns A `DifficultyAttributes` object describing the difficulty of the `Beatmap`.
+     */
     calculate(beatmap, mods) {
-        const playableBeatmap = beatmap instanceof osuBase.PlayableBeatmap
-            ? beatmap
-            : this.createPlayableBeatmapWithDifficultyAdjustmentMods(beatmap, mods);
+        const playableBeatmap = this.createPlayableBeatmap(beatmap, mods);
         const skills = this.createSkills(playableBeatmap);
         const objects = this.createDifficultyHitObjects(playableBeatmap);
         for (const object of objects) {
@@ -95,7 +101,7 @@ class DifficultyCalculator {
     calculateStrainPeaks(beatmap, mods) {
         const playableBeatmap = beatmap instanceof osuBase.PlayableBeatmap
             ? beatmap
-            : this.createPlayableBeatmapWithDifficultyAdjustmentMods(beatmap, mods);
+            : this.createPlayableBeatmap(beatmap, mods);
         const skills = this.createStrainPeakSkills(playableBeatmap);
         const objects = this.createDifficultyHitObjects(playableBeatmap);
         for (const object of objects) {
@@ -110,30 +116,6 @@ class DifficultyCalculator {
             flashlight: skills[3].strainPeaks,
         };
     }
-    /**
-     * Calculates the base rating of a `Skill`.
-     *
-     * @param skill The `Skill` to calculate the rating of.
-     * @returns The rating of the `Skill`.
-     */
-    calculateRating(skill) {
-        return Math.sqrt(skill.difficultyValue()) * this.difficultyMultiplier;
-    }
-    /**
-     * Calculates the base performance value of a difficulty rating.
-     *
-     * @param rating The difficulty rating.
-     */
-    basePerformanceValue(rating) {
-        return Math.pow(5 * Math.max(1, rating / 0.0675) - 4, 3) / 100000;
-    }
-    createPlayableBeatmapWithDifficultyAdjustmentMods(beatmap, mods) {
-        const difficultyAdjustmentMods = this.retainDifficultyAdjustmentMods(mods ? Array.from(mods.values()) : []);
-        return this.createPlayableBeatmap(beatmap, new osuBase.ModMap(difficultyAdjustmentMods.map((m) => [
-            m.constructor,
-            m,
-        ])));
-    }
 }
 
 /**
@@ -312,13 +294,12 @@ class DifficultyHitObject {
      *
      * A value closer to 1 indicates a higher possibility.
      */
-    get doubletapness() {
-        const next = this.next(0);
-        if (!next) {
+    getDoubletapness(nextObj) {
+        if (!nextObj) {
             return 0;
         }
         const currentDeltaTime = Math.max(1, this.deltaTime);
-        const nextDeltaTime = Math.max(1, next.deltaTime);
+        const nextDeltaTime = Math.max(1, nextObj.deltaTime);
         const deltaDifference = Math.abs(nextDeltaTime - currentDeltaTime);
         const speedRatio = currentDeltaTime / Math.max(currentDeltaTime, deltaDifference);
         const windowRatio = Math.pow(Math.min(1, currentDeltaTime / this.fullGreatWindow), 2);
@@ -326,7 +307,6 @@ class DifficultyHitObject {
     }
     setDistances(clockRate) {
         if (this.object instanceof osuBase.Slider) {
-            this.calculateSliderCursorPosition();
             this.travelDistance = this.lazyTravelDistance;
             // Bonus for repeat sliders until a better per nested object strain system can be achieved.
             if (this.mode === osuBase.Modes.droid) {
@@ -343,12 +323,8 @@ class DifficultyHitObject {
             this.lastObject instanceof osuBase.Spinner) {
             return;
         }
-        // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
-        let scalingFactor = DifficultyHitObject.normalizedRadius / this.object.radius;
-        // High circle size (small CS) bonus
-        if (this.mode === osuBase.Modes.osu && this.object.radius < 30) {
-            scalingFactor *= 1 + Math.min(30 - this.object.radius, 5) / 50;
-        }
+        // We will scale distances by this factor, so we can assume a uniform circle size among beatmaps.
+        const scalingFactor = DifficultyHitObject.normalizedRadius / this.object.radius;
         const lastCursorPosition = this.lastDifficultyObject !== null
             ? this.getEndCursorPosition(this.lastDifficultyObject)
             : this.lastObject.stackedPosition;
@@ -860,6 +836,15 @@ class StrainSkill extends Skill {
     get objectStrains() {
         return this._objectStrains;
     }
+    /**
+     * Converts a difficulty value to a performance value.
+     *
+     * @param difficulty The difficulty value to convert.
+     * @returns The performance value.
+     */
+    static difficultyToPerformance(difficulty) {
+        return Math.pow(5 * Math.max(1, difficulty / 0.0675) - 4, 3) / 100000;
+    }
     process(current) {
         // The first object doesn't generate a strain, so we begin with an incremented section end
         if (current.index === 0) {
@@ -983,6 +968,9 @@ class DroidAim extends DroidSkill {
         this.maxSliderStrain = 0;
         this.withSliders = withSliders;
     }
+    static difficultyToPerformance(difficulty) {
+        return super.difficultyToPerformance(Math.pow(difficulty, 0.8));
+    }
     /**
      * Obtains the amount of sliders that are considered difficult in terms of relative strain.
      */
@@ -1181,6 +1169,9 @@ class DroidFlashlight extends DroidSkill {
         this.currentFlashlightStrain = 0;
         this.withSliders = withSliders;
     }
+    static difficultyToPerformance(difficulty) {
+        return Math.pow(difficulty, 1.6) * 25;
+    }
     strainValueAt(current) {
         this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
         this.currentFlashlightStrain +=
@@ -1445,6 +1436,15 @@ class DroidReading extends Skill {
         this.difficulty = 0;
         this.noteWeightSum = 0;
     }
+    /**
+     * Converts a difficulty value to a performance value.
+     *
+     * @param difficulty The difficulty value to convert.
+     * @returns The performance value.
+     */
+    static difficultyToPerformance(difficulty) {
+        return Math.pow(Math.pow(difficulty, 2) * 25, 0.8);
+    }
     process(current) {
         this.currentNoteDifficulty *= this.strainDecay(current.deltaTime);
         this.currentNoteDifficulty +=
@@ -1585,10 +1585,10 @@ class DroidRhythmEvaluator {
                 this.historyTimeMax) {
             ++rhythmStart;
         }
+        let prevObject = validPrevious[rhythmStart];
+        let lastObject = validPrevious[rhythmStart + 1];
         for (let i = rhythmStart; i > 0; --i) {
             const currentObject = validPrevious[i - 1];
-            const prevObject = validPrevious[i];
-            const lastObject = validPrevious[i + 1];
             // Scale note 0 to 1 from history to now.
             const timeDecay = (this.historyTimeMax -
                 (current.startTime - currentObject.startTime)) /
@@ -1667,7 +1667,9 @@ class DroidRhythmEvaluator {
                         islandCounts.set(island, 1);
                     }
                     // Scale down the difficulty if the object is doubletappable.
-                    effectiveRatio *= 1 - prevObject.doubletapness * 0.75;
+                    effectiveRatio *=
+                        1 -
+                            prevObject.getDoubletapness(prevObject.next(0)) * 0.75;
                     rhythmComplexitySum +=
                         Math.sqrt(effectiveRatio * startRatio) *
                             currentHistoricalDecay;
@@ -1698,6 +1700,8 @@ class DroidRhythmEvaluator {
                 startRatio = effectiveRatio;
                 island = new Island(currentDelta, deltaDifferenceEpsilon);
             }
+            lastObject = prevObject;
+            prevObject = currentObject;
         }
         return (Math.sqrt(4 + rhythmComplexitySum * this.rhythmOverallMultiplier) /
             2);
@@ -1724,7 +1728,7 @@ class DroidRhythm extends DroidSkill {
     }
     strainValueAt(current) {
         const rhythmMultiplier = DroidRhythmEvaluator.evaluateDifficultyOf(current, this.useSliderAccuracy);
-        const doubletapness = 1 - current.doubletapness;
+        const doubletapness = 1 - current.getDoubletapness(current.next(0));
         this.currentRhythmStrain *= this.strainDecay(current.deltaTime);
         this.currentRhythmStrain += (rhythmMultiplier - 1) * doubletapness;
         this.currentRhythmMultiplier = rhythmMultiplier * doubletapness;
@@ -1767,7 +1771,7 @@ class DroidTapEvaluator {
             return 0;
         }
         const doubletapness = considerCheesability
-            ? 1 - current.doubletapness
+            ? 1 - current.getDoubletapness(current.next(0))
             : 1;
         const strainTime = strainTimeCap !== undefined
             ? // We cap the strain time to 50 here as the chance of vibro is higher in any BPM higher than 300.
@@ -1929,10 +1933,10 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         this.populateRhythmAttributes(attributes, skills);
         this.populateFlashlightAttributes(attributes, skills);
         this.populateReadingAttributes(attributes, skills);
-        const aimPerformanceValue = this.basePerformanceValue(Math.pow(attributes.aimDifficulty, 0.8));
-        const tapPerformanceValue = this.basePerformanceValue(attributes.tapDifficulty);
-        const flashlightPerformanceValue = Math.pow(attributes.flashlightDifficulty, 1.6) * 25;
-        const readingPerformanceValue = Math.pow(Math.pow(attributes.readingDifficulty, 2) * 25, 0.8);
+        const aimPerformanceValue = DroidAim.difficultyToPerformance(attributes.aimDifficulty);
+        const tapPerformanceValue = DroidTap.difficultyToPerformance(attributes.tapDifficulty);
+        const flashlightPerformanceValue = DroidFlashlight.difficultyToPerformance(attributes.flashlightDifficulty);
+        const readingPerformanceValue = DroidReading.difficultyToPerformance(attributes.readingDifficulty);
         const basePerformanceValue = Math.pow(Math.pow(aimPerformanceValue, 1.1) +
             Math.pow(tapPerformanceValue, 1.1) +
             Math.pow(flashlightPerformanceValue, 1.1) +
@@ -2162,6 +2166,15 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             Math.pow(Math.max(0, attributes.overallDifficulty), 2.2) / 800;
         attributes.readingDifficulty *= Math.sqrt(ratingMultiplier);
     }
+    /**
+     * Calculates the base rating of a `Skill`.
+     *
+     * @param skill The `Skill` to calculate the rating of.
+     * @returns The rating of the `Skill`.
+     */
+    calculateRating(skill) {
+        return Math.sqrt(skill.difficultyValue()) * this.difficultyMultiplier;
+    }
 }
 /**
  * The strain threshold to start detecting for possible three-fingered section.
@@ -2174,6 +2187,20 @@ DroidDifficultyCalculator.threeFingerStrainThreshold = 175;
  * The base class of performance calculators.
  */
 class PerformanceCalculator {
+    /**
+     * The amount of slider ends dropped in the score.
+     */
+    get sliderEndsDropped() {
+        return this._sliderEndsDropped;
+    }
+    /**
+     * The amount of slider ticks missed in the score.
+     *
+     * This is used to calculate the slider accuracy.
+     */
+    get sliderTicksMissed() {
+        return this._sliderTicksMissed;
+    }
     /**
      * Whether this score uses classic slider accuracy.
      */
@@ -2193,24 +2220,12 @@ class PerformanceCalculator {
          */
         this.computedAccuracy = new osuBase.Accuracy({});
         /**
-         * The amount of misses that are filtered out from sliderbreaks.
-         */
-        this.effectiveMissCount = 0;
-        /**
-         * The amount of slider ends dropped in the score.
-         */
-        this.sliderEndsDropped = 0;
-        /**
-         * The amount of slider ticks missed in the score.
-         *
-         * This is used to calculate the slider accuracy.
+         * The calculated maximum combo.
          */
-        this.sliderTicksMissed = 0;
+        this.combo = 0;
+        this._sliderEndsDropped = 0;
+        this._sliderTicksMissed = 0;
         this._usingClassicSliderAccuracy = false;
-        /**
-         * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
-         */
-        this.sliderNerfFactor = 1;
         this.difficultyAttributes = difficultyAttributes;
         this.mods = this.isCacheableAttribute(difficultyAttributes)
             ? osuBase.ModUtil.deserializeMods(difficultyAttributes.mods)
@@ -2225,7 +2240,6 @@ class PerformanceCalculator {
     calculate(options) {
         this.handleOptions(options);
         this.calculateValues();
-        this.total = this.calculateTotalValue();
         return this;
     }
     /**
@@ -2252,12 +2266,6 @@ class PerformanceCalculator {
             this.computedAccuracy.n50 +
             this.computedAccuracy.nmiss);
     }
-    /**
-     * Calculates the base performance value of a star rating.
-     */
-    baseValue(stars) {
-        return Math.pow(5 * Math.max(1, stars / 0.0675) - 4, 3) / 100000;
-    }
     /**
      * Processes given options for usage in performance calculation.
      *
@@ -2287,115 +2295,20 @@ class PerformanceCalculator {
         }
         const maxCombo = this.difficultyAttributes.maxCombo;
         const miss = this.computedAccuracy.nmiss;
-        let combo = (_b = options === null || options === void 0 ? void 0 : options.combo) !== null && _b !== void 0 ? _b : maxCombo - miss;
+        this.combo = (_b = options === null || options === void 0 ? void 0 : options.combo) !== null && _b !== void 0 ? _b : maxCombo - miss;
         if ((options === null || options === void 0 ? void 0 : options.sliderEndsDropped) !== undefined &&
             (options === null || options === void 0 ? void 0 : options.sliderTicksMissed) !== undefined) {
             this._usingClassicSliderAccuracy = false;
-            this.sliderEndsDropped = options.sliderEndsDropped;
-            this.sliderTicksMissed = options.sliderTicksMissed;
+            this._sliderEndsDropped = options.sliderEndsDropped;
+            this._sliderTicksMissed = options.sliderTicksMissed;
         }
         else {
             this._usingClassicSliderAccuracy = true;
-            this.sliderEndsDropped = 0;
-            this.sliderTicksMissed = 0;
+            this._sliderEndsDropped = 0;
+            this._sliderTicksMissed = 0;
         }
         // Ensure that combo is within possible bounds.
-        combo = osuBase.MathUtils.clamp(combo, 0, maxCombo - miss - this.sliderEndsDropped - this.sliderTicksMissed);
-        this.effectiveMissCount = this.calculateEffectiveMissCount(combo, maxCombo);
-        if (this.mods.has(osuBase.ModNoFail)) {
-            this.finalMultiplier *= Math.max(0.9, 1 - 0.02 * this.effectiveMissCount);
-        }
-        if (this.mods.has(osuBase.ModSpunOut)) {
-            this.finalMultiplier *=
-                1 -
-                    Math.pow(this.difficultyAttributes.spinnerCount / this.totalHits, 0.85);
-        }
-        if (this.mods.has(osuBase.ModRelax)) {
-            // Graph: https://www.desmos.com/calculator/bc9eybdthb
-            // We use OD13.3 as maximum since it's the value at which great hit window becomes 0.
-            const n100Multiplier = Math.max(0, this.difficultyAttributes.overallDifficulty > 0
-                ? 1 -
-                    Math.pow(this.difficultyAttributes.overallDifficulty /
-                        13.33, 1.8)
-                : 1);
-            const n50Multiplier = Math.max(0, this.difficultyAttributes.overallDifficulty > 0
-                ? 1 -
-                    Math.pow(this.difficultyAttributes.overallDifficulty /
-                        13.33, 5)
-                : 1);
-            // As we're adding 100s and 50s to an approximated number of combo breaks, the result can be higher
-            // than total hits in specific scenarios (which breaks some calculations),  so we need to clamp it.
-            this.effectiveMissCount = Math.min(this.effectiveMissCount +
-                this.computedAccuracy.n100 * n100Multiplier +
-                this.computedAccuracy.n50 * n50Multiplier, this.totalHits);
-        }
-        const { aimDifficultSliderCount, sliderFactor } = this.difficultyAttributes;
-        if (aimDifficultSliderCount > 0) {
-            let estimateImproperlyFollowedDifficultSliders;
-            if (this.usingClassicSliderAccuracy) {
-                // When the score is considered classic (regardless if it was made on old client or not),
-                // we consider all missing combo to be dropped difficult sliders.
-                estimateImproperlyFollowedDifficultSliders = osuBase.MathUtils.clamp(Math.min(this.totalImperfectHits, maxCombo - combo), 0, aimDifficultSliderCount);
-            }
-            else {
-                // We add tick misses here since they too mean that the player didn't follow the slider
-                // properly. However aren't adding misses here because missing slider heads has a harsh
-                // penalty by itself and doesn't mean that the rest of the slider wasn't followed properly.
-                estimateImproperlyFollowedDifficultSliders = osuBase.MathUtils.clamp(this.sliderEndsDropped + this.sliderTicksMissed, 0, aimDifficultSliderCount);
-            }
-            this.sliderNerfFactor =
-                (1 - sliderFactor) *
-                    Math.pow(1 -
-                        estimateImproperlyFollowedDifficultSliders /
-                            aimDifficultSliderCount, 3) +
-                    sliderFactor;
-        }
-    }
-    /**
-     * Calculates a strain-based miss penalty.
-     *
-     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
-     * so we use the amount of relatively difficult sections to adjust miss penalty
-     * to make it more punishing on maps with lower amount of hard sections.
-     */
-    calculateStrainBasedMissPenalty(difficultStrainCount) {
-        if (this.effectiveMissCount === 0) {
-            return 1;
-        }
-        return (0.96 /
-            (this.effectiveMissCount /
-                (4 * Math.pow(Math.log(difficultStrainCount), 0.94)) +
-                1));
-    }
-    /**
-     * Calculates the amount of misses + sliderbreaks from combo.
-     */
-    calculateEffectiveMissCount(combo, maxCombo) {
-        let missCount = this.computedAccuracy.nmiss;
-        const { sliderCount } = this.difficultyAttributes;
-        if (sliderCount > 0) {
-            if (this.usingClassicSliderAccuracy || this.mode === osuBase.Modes.droid) {
-                // 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;
-                if (combo < fullComboThreshold) {
-                    missCount = fullComboThreshold / Math.max(1, combo);
-                }
-                // In classic scores, there can't be more misses than a sum of all non-perfect judgements.
-                missCount = Math.min(missCount, this.totalImperfectHits);
-            }
-            else {
-                const fullComboThreshold = maxCombo - this.sliderEndsDropped;
-                if (combo < fullComboThreshold) {
-                    missCount = fullComboThreshold / Math.max(1, combo);
-                }
-                // Combine regular misses with tick misses, since tick misses break combo as well.
-                missCount = Math.min(missCount, this.sliderTicksMissed + this.computedAccuracy.nmiss);
-            }
-        }
-        return osuBase.MathUtils.clamp(missCount, this.computedAccuracy.nmiss, this.totalHits);
+        this.combo = osuBase.MathUtils.clamp(this.combo, 0, maxCombo - miss - this._sliderEndsDropped - this._sliderTicksMissed);
     }
     /**
      * Determines whether an attribute is a cacheable attribute.
@@ -2434,11 +2347,10 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
          * The reading performance value.
          */
         this.reading = 0;
-        this.finalMultiplier = 1.24;
-        this.mode = osuBase.Modes.droid;
         this._aimSliderCheesePenalty = 1;
         this._flashlightSliderCheesePenalty = 1;
         this._tapPenalty = 1;
+        this._effectiveMissCount = 0;
         this._deviation = 0;
         this._tapDeviation = 0;
     }
@@ -2479,66 +2391,54 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         return this._flashlightSliderCheesePenalty;
     }
     /**
-     * Applies a tap penalty value to this calculator.
-     *
-     * The tap and total performance value will be recalculated afterwards.
-     *
-     * @param value The tap penalty value. Must be greater than or equal to 1.
-     */
-    applyTapPenalty(value) {
-        if (value < 1) {
-            throw new RangeError("New tap penalty must be greater than or equal to one.");
-        }
-        if (value === this._tapPenalty) {
-            return;
-        }
-        this._tapPenalty = value;
-        this.tap = this.calculateTapValue();
-        this.total = this.calculateTotalValue();
-    }
-    /**
-     * Applies an aim slider cheese penalty value to this calculator.
-     *
-     * The aim and total performance value will be recalculated afterwards.
-     *
-     * @param value The slider cheese penalty value. Must be between than 0 and 1.
+     * The amount of misses, including slider breaks.
      */
-    applyAimSliderCheesePenalty(value) {
-        if (value < 0) {
-            throw new RangeError("New aim slider cheese penalty must be greater than or equal to zero.");
-        }
-        if (value > 1) {
-            throw new RangeError("New aim slider cheese penalty must be less than or equal to one.");
-        }
-        if (value === this._aimSliderCheesePenalty) {
-            return;
-        }
-        this._aimSliderCheesePenalty = value;
-        this.aim = this.calculateAimValue();
-        this.total = this.calculateTotalValue();
+    get effectiveMissCount() {
+        return this._effectiveMissCount;
     }
-    /**
-     * Applies a flashlight slider cheese penalty value to this calculator.
-     *
-     * The flashlight and total performance value will be recalculated afterwards.
-     *
-     * @param value The slider cheese penalty value. Must be between 0 and 1.
-     */
-    applyFlashlightSliderCheesePenalty(value) {
-        if (value < 0) {
-            throw new RangeError("New flashlight slider cheese penalty must be greater than or equal to zero.");
+    calculateValues() {
+        const { sliderCount, maxCombo } = this.difficultyAttributes;
+        if (sliderCount > 0) {
+            if (this.usingClassicSliderAccuracy) {
+                // 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;
+                if (this.combo < fullComboThreshold) {
+                    this._effectiveMissCount =
+                        fullComboThreshold / Math.max(1, this.combo);
+                }
+                // In classic scores, there can't be more misses than a sum of all non-perfect judgements.
+                this._effectiveMissCount = Math.min(this._effectiveMissCount, this.totalImperfectHits);
+            }
+            else {
+                const fullComboThreshold = maxCombo - this.sliderEndsDropped;
+                if (this.combo < fullComboThreshold) {
+                    this._effectiveMissCount =
+                        fullComboThreshold / Math.max(1, this.combo);
+                }
+                // Combine regular misses with tick misses, since tick misses break combo as well.
+                this._effectiveMissCount = Math.min(this._effectiveMissCount, this.sliderTicksMissed + this.computedAccuracy.nmiss);
+            }
         }
-        if (value > 1) {
-            throw new RangeError("New flashlight slider cheese penalty must be less than or equal to one.");
+        this._effectiveMissCount = osuBase.MathUtils.clamp(this._effectiveMissCount, this.computedAccuracy.nmiss, this.totalHits);
+        let { finalMultiplier } = DroidPerformanceCalculator;
+        if (this.mods.has(osuBase.ModNoFail)) {
+            finalMultiplier *= Math.max(0.9, 1 - 0.02 * this._effectiveMissCount);
         }
-        if (value === this._flashlightSliderCheesePenalty) {
-            return;
+        if (this.mods.has(osuBase.ModRelax)) {
+            const { overallDifficulty: od } = this.difficultyAttributes;
+            // Graph: https://www.desmos.com/calculator/vspzsop6td
+            // We use OD13.3 as maximum since it's the value at which great hit window becomes 0.
+            const n100Multiplier = 0.75 * Math.max(0, od > 0 ? 1 - od / 13.33 : 1);
+            const n50Multiplier = Math.max(0, od > 0 ? 1 - Math.pow(od / 13.33, 5) : 1);
+            // As we're adding 100s and 50s to an approximated number of combo breaks, the result can be higher
+            // than total hits in specific scenarios (which breaks some calculations),  so we need to clamp it.
+            this._effectiveMissCount = Math.min(this._effectiveMissCount +
+                this.computedAccuracy.n100 * n100Multiplier +
+                this.computedAccuracy.n50 * n50Multiplier, this.totalHits);
         }
-        this._flashlightSliderCheesePenalty = value;
-        this.flashlight = this.calculateFlashlightValue();
-        this.total = this.calculateTotalValue();
-    }
-    calculateValues() {
         this._deviation = this.calculateDeviation();
         this._tapDeviation = this.calculateTapDeviation();
         this.aim = this.calculateAimValue();
@@ -2546,13 +2446,12 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         this.accuracy = this.calculateAccuracyValue();
         this.flashlight = this.calculateFlashlightValue();
         this.reading = this.calculateReadingValue();
-    }
-    calculateTotalValue() {
-        return (Math.pow(Math.pow(this.aim, 1.1) +
-            Math.pow(this.tap, 1.1) +
-            Math.pow(this.accuracy, 1.1) +
-            Math.pow(this.flashlight, 1.1) +
-            Math.pow(this.reading, 1.1), 1 / 1.1) * this.finalMultiplier);
+        this.total =
+            Math.pow(Math.pow(this.aim, 1.1) +
+                Math.pow(this.tap, 1.1) +
+                Math.pow(this.accuracy, 1.1) +
+                Math.pow(this.flashlight, 1.1) +
+                Math.pow(this.reading, 1.1), 1 / 1.1) * finalMultiplier;
     }
     handleOptions(options) {
         var _a, _b, _c;
@@ -2566,12 +2465,31 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      * Calculates the aim performance value of the beatmap.
      */
     calculateAimValue() {
-        let aimValue = this.baseValue(Math.pow(this.difficultyAttributes.aimDifficulty, 0.8));
+        let aimValue = DroidAim.difficultyToPerformance(this.difficultyAttributes.aimDifficulty);
         aimValue *= Math.min(this.calculateStrainBasedMissPenalty(this.difficultyAttributes.aimDifficultStrainCount), this.proportionalMissPenalty);
         // Scale the aim value with estimated full combo deviation.
         aimValue *= this.calculateDeviationBasedLengthScaling();
-        // Scale the aim value with slider factor to nerf very likely dropped sliderends.
-        aimValue *= this.sliderNerfFactor;
+        const { aimDifficultSliderCount, sliderFactor, maxCombo } = this.difficultyAttributes;
+        if (aimDifficultSliderCount > 0) {
+            let estimateImproperlyFollowedDifficultSliders;
+            if (this.usingClassicSliderAccuracy) {
+                // When the score is considered classic (regardless if it was made on old client or not),
+                // we consider all missing combo to be dropped difficult sliders.
+                estimateImproperlyFollowedDifficultSliders = osuBase.MathUtils.clamp(Math.min(this.totalImperfectHits, maxCombo - this.combo), 0, aimDifficultSliderCount);
+            }
+            else {
+                // We add tick misses here since they too mean that the player didn't follow the slider
+                // properly. However aren't adding misses here because missing slider heads has a harsh
+                // penalty by itself and doesn't mean that the rest of the slider wasn't followed properly.
+                estimateImproperlyFollowedDifficultSliders = osuBase.MathUtils.clamp(this.sliderEndsDropped + this.sliderTicksMissed, 0, aimDifficultSliderCount);
+            }
+            aimValue *=
+                (1 - sliderFactor) *
+                    Math.pow(1 -
+                        estimateImproperlyFollowedDifficultSliders /
+                            aimDifficultSliderCount, 3) +
+                    sliderFactor;
+        }
         // Scale the aim value with slider cheese penalty.
         aimValue *= this._aimSliderCheesePenalty;
         // Scale the aim value with deviation.
@@ -2586,7 +2504,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      * Calculates the tap performance value of the beatmap.
      */
     calculateTapValue() {
-        let tapValue = this.baseValue(this.difficultyAttributes.tapDifficulty);
+        let tapValue = DroidTap.difficultyToPerformance(this.difficultyAttributes.tapDifficulty);
         tapValue *= this.calculateStrainBasedMissPenalty(this.difficultyAttributes.tapDifficultStrainCount);
         // Scale the tap value with estimated full combo deviation.
         // Consider notes that are difficult to tap with respect to other notes, but
@@ -2644,7 +2562,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
                 (1 +
                     Math.exp(-(this.difficultyAttributes.rhythmDifficulty - 1) / 2));
         // Penalize accuracy pp after the first miss.
-        accuracyValue *= Math.pow(0.97, Math.max(0, this.effectiveMissCount - 1));
+        accuracyValue *= Math.pow(0.97, Math.max(0, this._effectiveMissCount - 1));
         if (this.mods.has(osuBase.ModFlashlight)) {
             accuracyValue *= 1.02;
         }
@@ -2688,14 +2606,30 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         readingValue *= 0.98 + Math.pow(5, 2) / 2500;
         return readingValue;
     }
+    /**
+     * Calculates a strain-based miss penalty.
+     *
+     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
+     * so we use the amount of relatively difficult sections to adjust miss penalty
+     * to make it more punishing on maps with lower amount of hard sections.
+     */
+    calculateStrainBasedMissPenalty(difficultStrainCount) {
+        if (this.effectiveMissCount === 0) {
+            return 1;
+        }
+        return (0.96 /
+            (this.effectiveMissCount /
+                (4 * Math.pow(Math.log(difficultStrainCount), 0.94)) +
+                1));
+    }
     /**
      * The object-based proportional miss penalty.
      */
     get proportionalMissPenalty() {
-        if (this.effectiveMissCount === 0) {
+        if (this._effectiveMissCount === 0) {
             return 1;
         }
-        const missProportion = (this.totalHits - this.effectiveMissCount) / (this.totalHits + 1);
+        const missProportion = (this.totalHits - this._effectiveMissCount) / (this.totalHits + 1);
         const noMissProportion = this.totalHits / (this.totalHits + 1);
         return (
         // Aim deviation-based scale.
@@ -2892,7 +2826,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         if (this.tapDeviation == Number.POSITIVE_INFINITY) {
             return 0;
         }
-        const tapValue = this.baseValue(this.difficultyAttributes.tapDifficulty);
+        const tapValue = DroidTap.difficultyToPerformance(this.difficultyAttributes.tapDifficulty);
         // Decide a point where the PP value achieved compared to the tap deviation is assumed to be tapped
         // improperly. Any PP above this point is considered "excess" tap difficulty. This is used to cause
         // PP above the cutoff to scale logarithmically towards the original tap value thus nerfing the value.
@@ -2925,13 +2859,14 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             this.tap.toFixed(2) +
             " tap, " +
             this.accuracy.toFixed(2) +
-            " acc, " +
+            " accuracy, " +
             this.flashlight.toFixed(2) +
             " flashlight, " +
             this.reading.toFixed(2) +
             " reading)");
     }
 }
+DroidPerformanceCalculator.finalMultiplier = 1.24;
 
 /**
  * Represents an osu!standard hit object with difficulty calculation values.
@@ -2977,6 +2912,7 @@ class OsuAimEvaluator {
             return 0;
         }
         const lastLast = current.previous(1);
+        const last2 = current.previous(2);
         const radius = OsuDifficultyHitObject.normalizedRadius;
         const diameter = OsuDifficultyHitObject.normalizedDiameter;
         // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
@@ -3004,36 +2940,37 @@ class OsuAimEvaluator {
         let wiggleBonus = 0;
         // Start strain with regular velocity.
         let strain = currentVelocity;
-        if (
-        // If rhythms are the same.
-        Math.max(current.strainTime, last.strainTime) <
-            1.25 * Math.min(current.strainTime, last.strainTime) &&
-            current.angle !== null &&
-            last.angle !== null) {
+        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);
-            wideAngleBonus = this.calculateWideAngleBonus(current.angle);
-            acuteAngleBonus = this.calculateAcuteAngleBonus(current.angle);
+            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));
-            acuteAngleBonus *=
-                0.08 +
-                    0.92 *
-                        (1 -
-                            Math.min(acuteAngleBonus, Math.pow(this.calculateAcuteAngleBonus(lastAngle), 3)));
             // Apply full wide angle bonus for distance more than one diameter
             wideAngleBonus *=
                 angleBonus *
                     osuBase.MathUtils.smootherstep(current.lazyJumpDistance, 0, diameter);
-            // 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);
             // Apply wiggle bonus for jumps that are [radius, 3*diameter] in distance, with < 110 angle
             // https://www.desmos.com/calculator/dp0v0nvowc
             wiggleBonus =
@@ -3044,6 +2981,15 @@ class OsuAimEvaluator {
                     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.
@@ -3054,10 +3000,11 @@ class OsuAimEvaluator {
                 (current.lazyJumpDistance + last.travelDistance) /
                     current.strainTime;
             // Scale with ratio of difference compared to half the max distance.
-            const distanceRatio = Math.pow(Math.sin(((Math.PI / 2) * Math.abs(prevVelocity - currentVelocity)) /
-                Math.max(prevVelocity, currentVelocity)), 2);
+            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(125 / Math.min(current.strainTime, last.strainTime), Math.abs(prevVelocity - currentVelocity));
+            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) /
@@ -3068,9 +3015,11 @@ class OsuAimEvaluator {
             sliderBonus = last.travelDistance / last.travelTime;
         }
         strain += wiggleBonus * this.wiggleMultiplier;
-        // Add in acute angle bonus or wide angle bonus + velocity change bonus, whichever is larger.
-        strain += Math.max(acuteAngleBonus * this.acuteAngleMultiplier, wideAngleBonus * this.wideAngleMultiplier +
-            velocityChangeBonus * this.velocityChangeMultiplier);
+        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;
@@ -3085,7 +3034,7 @@ class OsuAimEvaluator {
     }
 }
 OsuAimEvaluator.wideAngleMultiplier = 1.5;
-OsuAimEvaluator.acuteAngleMultiplier = 2.6;
+OsuAimEvaluator.acuteAngleMultiplier = 2.55;
 OsuAimEvaluator.sliderMultiplier = 1.35;
 OsuAimEvaluator.velocityChangeMultiplier = 0.75;
 OsuAimEvaluator.wiggleMultiplier = 1.02;
@@ -3121,6 +3070,21 @@ class OsuSkill extends StrainSkill {
     }
 }
 
+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));
+    }
+}
+
 /**
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
@@ -3132,7 +3096,7 @@ class OsuAim extends OsuSkill {
         this.reducedSectionBaseline = 0.75;
         this.decayWeight = 0.9;
         this.currentAimStrain = 0;
-        this.skillMultiplier = 25.6;
+        this.skillMultiplier = 26;
         this.sliderStrains = [];
         this.withSliders = withSliders;
     }
@@ -3150,6 +3114,12 @@ class OsuAim extends OsuSkill {
         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);
+    }
     strainValueAt(current) {
         this.currentAimStrain *= this.strainDecay(current.deltaTime);
         this.currentAimStrain +=
@@ -3186,15 +3156,23 @@ class OsuDifficultyAttributes extends DifficultyAttributes {
     constructor(cacheableAttributes) {
         super(cacheableAttributes);
         this.approachRate = 0;
+        this.drainRate = 0;
         this.speedDifficulty = 0;
         this.speedDifficultStrainCount = 0;
+        this.aimTopWeightedSliderFactor = 0;
+        this.speedTopWeightedSliderFactor = 0;
         if (!cacheableAttributes) {
             return;
         }
         this.approachRate = cacheableAttributes.approachRate;
+        this.drainRate = cacheableAttributes.drainRate;
         this.speedDifficulty = cacheableAttributes.speedDifficulty;
         this.speedDifficultStrainCount =
             cacheableAttributes.speedDifficultStrainCount;
+        this.aimTopWeightedSliderFactor =
+            cacheableAttributes.aimTopWeightedSliderFactor;
+        this.speedTopWeightedSliderFactor =
+            cacheableAttributes.speedTopWeightedSliderFactor;
     }
     toString() {
         return (super.toString() +
@@ -3205,127 +3183,9 @@ class OsuDifficultyAttributes extends DifficultyAttributes {
 }
 
 /**
- * An evaluator for calculating osu!standard Flashlight skill.
+ * An evaluator for calculating osu!standard Rhythm skill.
  */
-class OsuFlashlightEvaluator {
-    /**
-     * Evaluates the difficulty of memorizing and hitting the current object, based on:
-     *
-     * - distance between a number of previous objects and the current object,
-     * - the visual opacity of the current object,
-     * - the angle made by the current object,
-     * - length and speed of the current object (for sliders),
-     * - and whether Hidden mod is enabled.
-     *
-     * @param current The current object.
-     * @param mods The mods used.
-     */
-    static evaluateDifficultyOf(current, mods) {
-        if (current.object instanceof osuBase.Spinner) {
-            return 0;
-        }
-        const scalingFactor = 52 / current.object.radius;
-        let smallDistNerf = 1;
-        let cumulativeStrainTime = 0;
-        let result = 0;
-        let last = current;
-        let angleRepeatCount = 0;
-        for (let i = 0; i < Math.min(current.index, 10); ++i) {
-            const currentObject = current.previous(i);
-            cumulativeStrainTime += last.strainTime;
-            if (!(currentObject.object instanceof osuBase.Spinner)) {
-                const jumpDistance = current.object.stackedPosition.subtract(currentObject.object.stackedEndPosition).length;
-                // We want to nerf objects that can be easily seen within the Flashlight circle radius.
-                if (i === 0) {
-                    smallDistNerf = Math.min(1, jumpDistance / 75);
-                }
-                // We also want to nerf stacks so that only the first object of the stack is accounted for.
-                const stackNerf = Math.min(1, currentObject.lazyJumpDistance / scalingFactor / 25);
-                // Bonus based on how visible the object is.
-                const opacityBonus = 1 +
-                    this.maxOpacityBonus *
-                        (1 -
-                            current.opacityAt(currentObject.object.startTime, mods));
-                result +=
-                    (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
-                        cumulativeStrainTime;
-                if (currentObject.angle !== null && current.angle !== null) {
-                    // Objects further back in time should count less for the nerf.
-                    if (Math.abs(currentObject.angle - current.angle) < 0.02) {
-                        angleRepeatCount += Math.max(0, 1 - 0.1 * i);
-                    }
-                }
-            }
-            last = currentObject;
-        }
-        result = Math.pow(smallDistNerf * result, 2);
-        // Additional bonus for Hidden due to there being no approach circles.
-        if (mods.has(osuBase.ModHidden)) {
-            result *= 1 + this.hiddenBonus;
-        }
-        // Nerf patterns with repeated angles.
-        result *=
-            this.minAngleMultiplier +
-                (1 - this.minAngleMultiplier) / (angleRepeatCount + 1);
-        let sliderBonus = 0;
-        if (current.object instanceof osuBase.Slider) {
-            // Invert the scaling factor to determine the true travel distance independent of circle size.
-            const pixelTravelDistance = current.lazyTravelDistance / scalingFactor;
-            // Reward sliders based on velocity.
-            sliderBonus = Math.pow(Math.max(0, pixelTravelDistance / current.travelTime - this.minVelocity), 0.5);
-            // Longer sliders require more memorization.
-            sliderBonus *= pixelTravelDistance;
-            // Nerf sliders with repeats, as less memorization is required.
-            if (current.object.repeatCount > 0)
-                sliderBonus /= current.object.repeatCount + 1;
-        }
-        result += sliderBonus * this.sliderMultiplier;
-        return result;
-    }
-}
-OsuFlashlightEvaluator.maxOpacityBonus = 0.4;
-OsuFlashlightEvaluator.hiddenBonus = 0.2;
-OsuFlashlightEvaluator.minVelocity = 0.5;
-OsuFlashlightEvaluator.sliderMultiplier = 1.3;
-OsuFlashlightEvaluator.minAngleMultiplier = 0.2;
-
-/**
- * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
- */
-class OsuFlashlight extends OsuSkill {
-    constructor() {
-        super(...arguments);
-        this.strainDecayBase = 0.15;
-        this.reducedSectionCount = 0;
-        this.reducedSectionBaseline = 1;
-        this.decayWeight = 1;
-        this.currentFlashlightStrain = 0;
-        this.skillMultiplier = 0.05512;
-    }
-    difficultyValue() {
-        return this.strainPeaks.reduce((a, b) => a + b, 0);
-    }
-    strainValueAt(current) {
-        this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
-        this.currentFlashlightStrain +=
-            OsuFlashlightEvaluator.evaluateDifficultyOf(current, this.mods) *
-                this.skillMultiplier;
-        return this.currentFlashlightStrain;
-    }
-    calculateInitialStrain(time, current) {
-        var _a, _b;
-        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) {
-        current.flashlightStrain = this.currentFlashlightStrain;
-    }
-}
-
-/**
- * An evaluator for calculating osu!standard Rhythm skill.
- */
-class OsuRhythmEvaluator {
+class OsuRhythmEvaluator {
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
@@ -3351,10 +3211,10 @@ class OsuRhythmEvaluator {
                 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);
-            const prevObject = current.previous(i);
-            const lastObject = current.previous(i + 1);
             // Scale note 0 to 1 from history to now.
             const timeDecay = (this.historyTimeMax -
                 (current.startTime - currentObject.startTime)) /
@@ -3362,21 +3222,23 @@ class OsuRhythmEvaluator {
             const noteDecay = (historicalNoteCount - i) / historicalNoteCount;
             // Either we're limited by time or limited by object count.
             const currentHistoricalDecay = Math.min(timeDecay, noteDecay);
-            const currentDelta = currentObject.strainTime;
-            const prevDelta = prevObject.strainTime;
-            const lastDelta = lastObject.strainTime;
+            // 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 deltaDifferenceRatio = Math.min(prevDelta, currentDelta) /
-                Math.max(prevDelta, currentDelta);
+            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, Math.pow(Math.sin(Math.PI / deltaDifferenceRatio), 2));
+                    Math.min(0.5, osuBase.MathUtils.smoothstepBellCurve(deltaDifferenceFraction));
             // Reduce ratio bonus if delta difference is too big
-            const fraction = Math.max(prevDelta / currentDelta, currentDelta / prevDelta);
-            const fractionMultiplier = osuBase.MathUtils.clamp(2 - fraction / 8, 0, 1);
+            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 * fractionMultiplier;
+            let effectiveRatio = windowPenalty * currentRatio * differenceMultiplier;
             if (firstDeltaSwitch) {
                 if (Math.abs(prevDelta - currentDelta) < deltaDifferenceEpsilon) {
                     // Island is still progressing, count size.
@@ -3429,7 +3291,8 @@ class OsuRhythmEvaluator {
                         islandCounts.set(island, 1);
                     }
                     // Scale down the difficulty if the object is doubletappable.
-                    effectiveRatio *= 1 - prevObject.doubletapness * 0.75;
+                    effectiveRatio *=
+                        1 - prevObject.getDoubletapness(currentObject) * 0.75;
                     rhythmComplexitySum +=
                         Math.sqrt(effectiveRatio * startRatio) *
                             currentHistoricalDecay;
@@ -3460,15 +3323,18 @@ class OsuRhythmEvaluator {
                 startRatio = effectiveRatio;
                 island = new Island(currentDelta, deltaDifferenceEpsilon);
             }
+            lastObject = prevObject;
+            prevObject = currentObject;
         }
-        return (Math.sqrt(4 + rhythmComplexitySum * this.rhythmOverallMultiplier) /
+        return ((Math.sqrt(4 + rhythmComplexitySum * this.rhythmOverallMultiplier) *
+            (1 - current.getDoubletapness(current.next(0)))) /
             2);
     }
 }
 OsuRhythmEvaluator.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
 OsuRhythmEvaluator.historyObjectsMax = 32;
-OsuRhythmEvaluator.rhythmOverallMultiplier = 0.95;
-OsuRhythmEvaluator.rhythmRatioMultiplier = 12;
+OsuRhythmEvaluator.rhythmOverallMultiplier = 1;
+OsuRhythmEvaluator.rhythmRatioMultiplier = 15;
 
 /**
  * An evaluator for calculating osu!standard speed skill.
@@ -3492,7 +3358,7 @@ class OsuSpeedEvaluator {
         const prev = current.previous(0);
         let strainTime = current.strainTime;
         // Nerf doubletappable doubles.
-        const doubletapness = 1 - current.doubletapness;
+        const doubletapness = 1 - current.getDoubletapness(current.next(0));
         // Cap deltatime to the OD 300 hitwindow.
         // 0.93 is derived from making sure 260 BPM 1/4 OD8 streams aren't nerfed harshly, whilst 0.92 limits the effect of the cap.
         strainTime /= osuBase.MathUtils.clamp(strainTime / current.fullGreatWindow / 0.93, 0.92, 1);
@@ -3509,6 +3375,8 @@ class OsuSpeedEvaluator {
         // Max distance bonus is 1 * `distance_multiplier` at single_spacing_threshold
         let distanceBonus = Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 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;
         }
@@ -3523,10 +3391,10 @@ class OsuSpeedEvaluator {
  *
  * About 1.25 circles distance between hitobject centers.
  */
-OsuSpeedEvaluator.SINGLE_SPACING_THRESHOLD = 125;
+OsuSpeedEvaluator.SINGLE_SPACING_THRESHOLD = OsuDifficultyHitObject.normalizedDiameter * 1.25;
 // ~200 1/4 BPM streams
 OsuSpeedEvaluator.minSpeedBonus = 75;
-OsuSpeedEvaluator.DISTANCE_MULTIPLIER = 0.9;
+OsuSpeedEvaluator.DISTANCE_MULTIPLIER = 0.8;
 
 /**
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
@@ -3540,7 +3408,8 @@ class OsuSpeed extends OsuSkill {
         this.decayWeight = 0.9;
         this.currentSpeedStrain = 0;
         this.currentRhythm = 0;
-        this.skillMultiplier = 1.46;
+        this.skillMultiplier = 1.47;
+        this.sliderStrains = [];
         this.maxStrain = 0;
     }
     /**
@@ -3552,6 +3421,12 @@ class OsuSpeed extends OsuSkill {
         }
         return this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / this.maxStrain) * 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);
+    }
     /**
      * @param current The hitobject to calculate.
      */
@@ -3564,6 +3439,9 @@ class OsuSpeed extends OsuSkill {
         const strain = this.currentSpeedStrain * this.currentRhythm;
         this._objectStrains.push(strain);
         this.maxStrain = Math.max(this.maxStrain, strain);
+        if (current.object instanceof osuBase.Slider) {
+            this.sliderStrains.push(strain);
+        }
         return strain;
     }
     calculateInitialStrain(time, current) {
@@ -3581,137 +3459,184 @@ class OsuSpeed extends OsuSkill {
     }
 }
 
-/**
- * A difficulty calculator for osu!standard gamemode.
- */
-class OsuDifficultyCalculator extends DifficultyCalculator {
-    constructor() {
-        super();
-        this.difficultyMultiplier = 0.0675;
-        this.difficultyAdjustmentMods.push(osuBase.ModTouchDevice);
-    }
-    retainDifficultyAdjustmentMods(mods) {
-        return mods.filter((mod) => mod.isApplicableToOsu() &&
-            mod.isOsuRelevant &&
-            this.difficultyAdjustmentMods.some((m) => mod instanceof m));
+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;
     }
-    createDifficultyAttributes(beatmap, skills) {
-        const attributes = new OsuDifficultyAttributes();
-        attributes.mods = beatmap.mods;
-        attributes.maxCombo = beatmap.maxCombo;
-        attributes.clockRate = beatmap.speedMultiplier;
-        attributes.hitCircleCount = beatmap.hitObjects.circles;
-        attributes.sliderCount = beatmap.hitObjects.sliders;
-        attributes.spinnerCount = beatmap.hitObjects.spinners;
-        this.populateAimAttributes(attributes, skills);
-        this.populateSpeedAttributes(attributes, skills);
-        this.populateFlashlightAttributes(attributes, skills);
-        if (attributes.mods.has(osuBase.ModRelax)) {
-            attributes.aimDifficulty *= 0.9;
-            attributes.speedDifficulty = 0;
-            attributes.flashlightDifficulty *= 0.7;
+    computeAimRating(aimDifficultyValue) {
+        if (this.mods.has(osuBase.ModAutopilot)) {
+            return 0;
         }
-        else if (attributes.mods.has(osuBase.ModAutopilot)) {
-            attributes.aimDifficulty = 0;
-            attributes.speedDifficulty *= 0.5;
-            attributes.flashlightDifficulty *= 0.4;
+        let aimRating = OsuRatingCalculator.calculateDifficultyRating(aimDifficultyValue);
+        if (this.mods.has(osuBase.ModTouchDevice)) {
+            aimRating = Math.pow(aimRating, 0.8);
         }
-        const aimPerformanceValue = this.basePerformanceValue(attributes.aimDifficulty);
-        const speedPerformanceValue = this.basePerformanceValue(attributes.speedDifficulty);
-        const flashlightPerformanceValue = Math.pow(attributes.flashlightDifficulty, 2) * 25;
-        const basePerformanceValue = Math.pow(Math.pow(aimPerformanceValue, 1.1) +
-            Math.pow(speedPerformanceValue, 1.1) +
-            Math.pow(flashlightPerformanceValue, 1.1), 1 / 1.1);
-        if (basePerformanceValue > 1e-5) {
-            // Document for formula derivation:
-            // https://docs.google.com/document/d/10DZGYYSsT_yjz2Mtp6yIJld0Rqx4E-vVHupCqiM4TNI/edit
-            attributes.starRating =
-                Math.cbrt(1.15) *
-                    0.027 *
-                    (Math.cbrt((100000 / Math.pow(2, 1 / 1.1)) * basePerformanceValue) +
-                        4);
+        if (this.mods.has(osuBase.ModRelax)) {
+            aimRating *= 0.9;
         }
-        else {
-            attributes.starRating = 0;
+        if (this.mods.has(osuBase.ModMagnetised)) {
+            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
+            aimRating *= 1 - magnetisedStrength;
         }
-        const preempt = osuBase.BeatmapDifficulty.difficultyRange(beatmap.difficulty.ar, osuBase.HitObject.preemptMax, osuBase.HitObject.preemptMid, osuBase.HitObject.preemptMin) / attributes.clockRate;
-        attributes.approachRate = osuBase.BeatmapDifficulty.inverseDifficultyRange(preempt, osuBase.HitObject.preemptMax, osuBase.HitObject.preemptMid, osuBase.HitObject.preemptMin);
-        const { greatWindow } = new osuBase.OsuHitWindow(beatmap.difficulty.od);
-        attributes.overallDifficulty = osuBase.OsuHitWindow.greatWindowToOD(greatWindow / attributes.clockRate);
-        return attributes;
-    }
-    createPlayableBeatmap(beatmap, mods) {
-        return beatmap.createOsuPlayableBeatmap(mods);
-    }
-    createDifficultyHitObjects(beatmap) {
-        const clockRate = beatmap.speedMultiplier;
-        const difficultyObjects = [];
-        const { objects } = beatmap.hitObjects;
-        for (let i = 1; i < objects.length; ++i) {
-            const difficultyObject = new OsuDifficultyHitObject(objects[i], objects[i - 1], difficultyObjects, clockRate, i - 1);
-            difficultyObject.computeProperties(clockRate);
-            difficultyObjects.push(difficultyObject);
+        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);
         }
-        return difficultyObjects;
-    }
-    createSkills(beatmap) {
-        const { mods } = beatmap;
-        const skills = [];
-        if (!mods.has(osuBase.ModAutopilot)) {
-            skills.push(new OsuAim(mods, true));
-            skills.push(new OsuAim(mods, false));
+        else if (this.approachRate < 8) {
+            approachRateFactor = 0.05 * (8 - this.approachRate);
         }
-        if (!mods.has(osuBase.ModRelax)) {
-            skills.push(new OsuSpeed(mods));
+        if (this.mods.has(osuBase.ModRelax)) {
+            approachRateFactor = 0;
         }
-        if (mods.has(osuBase.ModFlashlight)) {
-            skills.push(new OsuFlashlight(mods));
+        // 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 skills;
-    }
-    createStrainPeakSkills(beatmap) {
-        const { mods } = beatmap;
-        return [
-            new OsuAim(mods, true),
-            new OsuAim(mods, false),
-            new OsuSpeed(mods),
-            new OsuFlashlight(mods),
-        ];
+        // 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);
     }
-    populateAimAttributes(attributes, skills) {
-        const aim = skills.find((s) => s instanceof OsuAim && s.withSliders);
-        const aimNoSlider = skills.find((s) => s instanceof OsuAim && !s.withSliders);
-        if (!aim || !aimNoSlider) {
-            return;
+    computeSpeedRating(speedDifficultyValue) {
+        if (this.mods.has(osuBase.ModRelax)) {
+            return 0;
         }
-        attributes.aimDifficulty = this.calculateRating(aim);
-        attributes.aimDifficultSliderCount = aim.countDifficultSliders();
-        attributes.aimDifficultStrainCount = aim.countTopWeightedStrains();
-        if (attributes.aimDifficulty > 0) {
-            attributes.sliderFactor =
-                this.calculateRating(aimNoSlider) / attributes.aimDifficulty;
+        let speedRating = OsuRatingCalculator.calculateDifficultyRating(speedDifficultyValue);
+        if (this.mods.has(osuBase.ModAutopilot)) {
+            speedRating *= 0.5;
+        }
+        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);
         }
-        else {
-            attributes.sliderFactor = 1;
+        if (this.mods.has(osuBase.ModAutopilot)) {
+            approachRateFactor = 0;
         }
-    }
-    populateSpeedAttributes(attributes, skills) {
-        const speed = skills.find((s) => s instanceof OsuSpeed);
-        if (!speed) {
-            return;
+        // 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);
         }
-        attributes.speedDifficulty = this.calculateRating(speed);
-        attributes.speedNoteCount = speed.relevantNoteCount();
-        attributes.speedDifficultStrainCount = speed.countTopWeightedStrains();
+        ratingMultiplier *=
+            0.95 + Math.pow(Math.max(0, this.overallDifficulty), 2) / 750;
+        return speedRating * Math.cbrt(ratingMultiplier);
     }
-    populateFlashlightAttributes(attributes, skills) {
-        const flashlight = skills.find((s) => s instanceof OsuFlashlight);
-        if (!flashlight) {
-            return;
+    computeFlashlightRating(flashlightDifficultyValue) {
+        if (!this.mods.has(osuBase.ModFlashlight)) {
+            return 0;
         }
-        attributes.flashlightDifficulty = this.calculateRating(flashlight);
+        let flashlightRating = OsuRatingCalculator.calculateDifficultyRating(flashlightDifficultyValue);
+        if (this.mods.has(osuBase.ModTouchDevice)) {
+            flashlightRating = Math.pow(flashlightRating, 0.8);
+        }
+        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);
+        }
+        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);
+    }
+    /**
+     * Calculates a visibility bonus that is applicable to Hidden and Traceable.
+     *
+     * @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.
+     */
+    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;
+        }
+        // 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;
+        }
+        return readingBonus;
+    }
+    static calculateDifficultyRating(difficultyValue) {
+        return Math.sqrt(difficultyValue) * this.difficultyMultiplier;
     }
 }
+OsuRatingCalculator.difficultyMultiplier = 0.0675;
 
 /**
  * A performance points calculator that calculates performance points for osu!standard gamemode.
@@ -3735,31 +3660,48 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
          * The flashlight performance value.
          */
         this.flashlight = 0;
-        this.finalMultiplier = 1.15;
-        this.mode = osuBase.Modes.osu;
-        this.comboPenalty = 1;
+        this._effectiveMissCount = 0;
         this.speedDeviation = 0;
     }
-    calculateValues() {
-        this.speedDeviation = this.calculateSpeedDeviation();
+    /**
+     * The amount of misses, including slider breaks.
+     */
+    get effectiveMissCount() {
+        return this._effectiveMissCount;
+    }
+    calculateValues() {
+        this._effectiveMissCount = osuBase.MathUtils.clamp(this.calculateComboBasedEstimatedMissCount(), this.computedAccuracy.nmiss, this.totalHits);
+        let { finalMultiplier } = OsuPerformanceCalculator;
+        if (this.mods.has(osuBase.ModNoFail)) {
+            finalMultiplier *= Math.max(0.9, 1 - 0.02 * this._effectiveMissCount);
+        }
+        if (this.mods.has(osuBase.ModSpunOut)) {
+            finalMultiplier *=
+                1 -
+                    Math.pow(this.difficultyAttributes.spinnerCount / this.totalHits, 0.85);
+        }
+        if (this.mods.has(osuBase.ModRelax)) {
+            const { overallDifficulty: od } = this.difficultyAttributes;
+            // Graph: https://www.desmos.com/calculator/vspzsop6td
+            // We use OD13.3 as maximum since it's the value at which great hit window becomes 0.
+            const n100Multiplier = 0.75 * Math.max(0, od > 0 ? 1 - od / 13.33 : 1);
+            const n50Multiplier = Math.max(0, od > 0 ? 1 - Math.pow(od / 13.33, 5) : 1);
+            // As we're adding 100s and 50s to an approximated number of combo breaks, the result can be higher
+            // than total hits in specific scenarios (which breaks some calculations),  so we need to clamp it.
+            this._effectiveMissCount = Math.min(this._effectiveMissCount +
+                this.computedAccuracy.n100 * n100Multiplier +
+                this.computedAccuracy.n50 * n50Multiplier, this.totalHits);
+        }
+        this.speedDeviation = this.calculateSpeedDeviation();
         this.aim = this.calculateAimValue();
         this.speed = this.calculateSpeedValue();
         this.accuracy = this.calculateAccuracyValue();
         this.flashlight = this.calculateFlashlightValue();
-    }
-    calculateTotalValue() {
-        return (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) * this.finalMultiplier);
-    }
-    handleOptions(options) {
-        var _a;
-        super.handleOptions(options);
-        const maxCombo = this.difficultyAttributes.maxCombo;
-        const miss = this.computedAccuracy.nmiss;
-        const combo = (_a = options === null || options === void 0 ? void 0 : options.combo) !== null && _a !== void 0 ? _a : maxCombo - miss;
-        this.comboPenalty = Math.min(Math.pow(combo / maxCombo, 0.8), 1);
+        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;
     }
     /**
      * Calculates the aim performance value of the beatmap.
@@ -3768,7 +3710,29 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         if (this.mods.has(osuBase.ModAutopilot)) {
             return 0;
         }
-        let aimValue = this.baseValue(this.difficultyAttributes.aimDifficulty);
+        let { aimDifficulty } = this.difficultyAttributes;
+        const { aimDifficultSliderCount, sliderFactor } = this.difficultyAttributes;
+        if (aimDifficultSliderCount > 0) {
+            let estimateImproperlyFollowedDifficultSliders;
+            if (this.usingClassicSliderAccuracy) {
+                // When the score is considered classic (regardless if it was made on old client or not),
+                // we consider all missing combo to be dropped difficult sliders.
+                estimateImproperlyFollowedDifficultSliders = osuBase.MathUtils.clamp(Math.min(this.totalImperfectHits, this.difficultyAttributes.maxCombo - this.combo), 0, aimDifficultSliderCount);
+            }
+            else {
+                // We add tick misses here since they too mean that the player didn't follow the slider
+                // properly. However aren't adding misses here because missing slider heads has a harsh
+                // penalty by itself and doesn't mean that the rest of the slider wasn't followed properly.
+                estimateImproperlyFollowedDifficultSliders = osuBase.MathUtils.clamp(this.sliderEndsDropped + this.sliderTicksMissed, 0, aimDifficultSliderCount);
+            }
+            aimDifficulty *=
+                (1 - sliderFactor) *
+                    Math.pow(1 -
+                        estimateImproperlyFollowedDifficultSliders /
+                            aimDifficultSliderCount, 3) +
+                    sliderFactor;
+        }
+        let aimValue = OsuAim.difficultyToPerformance(aimDifficulty);
         // Longer maps are worth more
         let lengthBonus = 0.95 + 0.4 * Math.min(1, this.totalHits / 2000);
         if (this.totalHits > 2000) {
@@ -3776,38 +3740,29 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         }
         aimValue *= lengthBonus;
         if (this.effectiveMissCount > 0) {
-            // Penalize misses by assessing # of misses relative to the total # of objects.
-            // Default a 3% reduction for any # of misses.
+            const aimEstimatedSliderBreaks = this.calculateEstimatedSliderBreaks(this.difficultyAttributes.aimTopWeightedSliderFactor);
+            const relevantMissCount = Math.min(this._effectiveMissCount + aimEstimatedSliderBreaks, this.totalImperfectHits + this.sliderTicksMissed);
+            aimValue *= this.calculateMissPenalty(relevantMissCount, this.difficultyAttributes.aimDifficultStrainCount);
+        }
+        // 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)) {
             aimValue *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), this.effectiveMissCount);
-        }
-        aimValue *= this.calculateStrainBasedMissPenalty(this.difficultyAttributes.aimDifficultStrainCount);
-        const calculatedAR = this.difficultyAttributes.approachRate;
-        if (!this.mods.has(osuBase.ModRelax)) {
-            // AR scaling
-            let arFactor = 0;
-            if (calculatedAR > 10.33) {
-                arFactor += 0.3 * (calculatedAR - 10.33);
-            }
-            else if (calculatedAR < 8) {
-                arFactor += 0.05 * (8 - calculatedAR);
-            }
-            // Buff for longer maps with high AR.
-            aimValue *= 1 + arFactor * lengthBonus;
+                1.3 +
+                    this.totalHits *
+                        (0.0016 / (1 + 2 * this._effectiveMissCount)) *
+                        Math.pow(this.computedAccuracy.value(), 16) *
+                        (1 -
+                            0.003 *
+                                Math.pow(this.difficultyAttributes.drainRate, 2));
         }
-        // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-        if (this.mods.has(osuBase.ModHidden) || this.mods.has(osuBase.ModTraceable)) {
-            aimValue *= 1 + 0.04 * (12 - calculatedAR);
+        else if (this.mods.has(osuBase.ModTraceable)) {
+            aimValue *=
+                1 +
+                    OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.difficultyAttributes.approachRate, undefined, this.difficultyAttributes.sliderFactor);
         }
-        // Scale the aim value with slider factor to nerf very likely dropped sliderends.
-        aimValue *= this.sliderNerfFactor;
         // Scale the aim value with accuracy.
         aimValue *= this.computedAccuracy.value();
-        // It is also important to consider accuracy difficulty when doing that.
-        const odScaling = Math.pow(this.difficultyAttributes.overallDifficulty, 2) / 2500;
-        aimValue *= 0.98 + odScaling;
         return aimValue;
     }
     /**
@@ -3818,22 +3773,28 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             this.speedDeviation === Number.POSITIVE_INFINITY) {
             return 0;
         }
-        let speedValue = this.baseValue(this.difficultyAttributes.speedDifficulty);
+        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;
-        speedValue *= this.calculateStrainBasedMissPenalty(this.difficultyAttributes.speedDifficultStrainCount);
-        // AR scaling
-        const calculatedAR = this.difficultyAttributes.approachRate;
-        if (calculatedAR > 10.33 && !this.mods.has(osuBase.ModAutopilot)) {
-            // Buff for longer maps with high AR.
-            speedValue *= 1 + 0.3 * (calculatedAR - 10.33) * lengthBonus;
-        }
-        if (this.mods.has(osuBase.ModHidden) || this.mods.has(osuBase.ModTraceable)) {
-            speedValue *= 1 + 0.04 * (12 - calculatedAR);
+        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.difficultyAttributes.approachRate, undefined, this.difficultyAttributes.sliderFactor);
         }
         // Calculate accuracy assuming the worst case scenario.
         const countGreat = this.computedAccuracy.n300;
@@ -3851,13 +3812,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                 { n300: 0, nobjects: 1 });
         speedValue *= this.calculateSpeedHighDeviationNerf();
         // Scale the speed value with accuracy and OD.
-        speedValue *=
-            (0.95 +
-                Math.pow(Math.max(0, this.difficultyAttributes.overallDifficulty), 2) /
-                    750) *
-                Math.pow((this.computedAccuracy.value() +
-                    relevantAccuracy.value(this.difficultyAttributes.speedNoteCount)) /
-                    2, (14.5 - this.difficultyAttributes.overallDifficulty) / 2);
+        speedValue *= Math.pow((this.computedAccuracy.value() + relevantAccuracy.value()) / 2, (14.5 - this.difficultyAttributes.overallDifficulty) / 2);
         return speedValue;
     }
     /**
@@ -3882,8 +3837,16 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             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));
-        if (this.mods.has(osuBase.ModHidden) || this.mods.has(osuBase.ModTraceable)) {
-            accuracyValue *= 1.08;
+        // 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)) {
+            // Decrease bonus for AR > 10.
+            accuracyValue *=
+                1 +
+                    0.08 *
+                        osuBase.Interpolation.reverseLerp(this.difficultyAttributes.approachRate, 11.5, 10);
         }
         if (this.mods.has(osuBase.ModFlashlight)) {
             accuracyValue *= 1.02;
@@ -3899,7 +3862,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         }
         let flashlightValue = Math.pow(this.difficultyAttributes.flashlightDifficulty, 2) * 25;
         // Combo scaling
-        flashlightValue *= this.comboPenalty;
+        flashlightValue *= Math.min(Math.pow(this.combo / this.difficultyAttributes.maxCombo, 0.8), 1);
         if (this.effectiveMissCount > 0) {
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
             flashlightValue *=
@@ -3916,11 +3879,23 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                     : 0);
         // Scale the flashlight value with accuracy slightly.
         flashlightValue *= 0.5 + this.computedAccuracy.value() / 2;
-        // It is also important to consider accuracy difficulty when doing that.
-        const odScaling = Math.pow(this.difficultyAttributes.overallDifficulty, 2) / 2500;
-        flashlightValue *= 0.98 + odScaling;
         return flashlightValue;
     }
+    /**
+     * Calculates a strain-based miss penalty.
+     *
+     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
+     * so we use the amount of relatively difficult sections to adjust miss penalty
+     * to make it more punishing on maps with lower amount of hard sections.
+     */
+    calculateMissPenalty(missCount, difficultStrainCount) {
+        if (missCount === 0) {
+            return 1;
+        }
+        return (0.96 /
+            (missCount / (4 * Math.pow(Math.log(difficultStrainCount), 0.94)) +
+                1));
+    }
     /**
      * Estimates a player's deviation on speed notes using {@link calculateDeviation}, assuming worst-case.
      *
@@ -3941,7 +3916,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             relevantCountMiss -
             relevantCountMeh -
             relevantCountOk);
-        return this.calculateDeviation(relevantCountGreat, relevantCountOk, relevantCountMeh, relevantCountMiss);
+        return this.calculateDeviation(relevantCountGreat, relevantCountOk, relevantCountMeh);
     }
     /**
      * Estimates the player's tap deviation based on the OD, given number of greats, oks, mehs and misses,
@@ -3952,52 +3927,51 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
      *
      * Greats and oks are assumed to follow a normal distribution, whereas mehs are assumed to follow a uniform distribution.
      */
-    calculateDeviation(relevantCountGreat, relevantCountOk, relevantCountMeh, relevantCountMiss) {
+    calculateDeviation(relevantCountGreat, relevantCountOk, relevantCountMeh) {
         if (relevantCountGreat + relevantCountOk + relevantCountMeh <= 0) {
             return Number.POSITIVE_INFINITY;
         }
-        const objectCount = relevantCountGreat +
-            relevantCountOk +
-            relevantCountMeh +
-            relevantCountMiss;
         // Obtain the great, ok, and meh windows.
+        const { clockRate, overallDifficulty } = this.difficultyAttributes;
         const hitWindow = new osuBase.OsuHitWindow(osuBase.OsuHitWindow.greatWindowToOD(
         // Convert current OD to non clock rate-adjusted OD.
-        new osuBase.OsuHitWindow(this.difficultyAttributes.overallDifficulty)
-            .greatWindow * this.difficultyAttributes.clockRate));
-        const { greatWindow, okWindow, mehWindow } = hitWindow;
-        // The probability that a player hits a circle is unknown, but we can estimate it to be
-        // the number of greats on circles divided by the number of circles, and then add one
-        // to the number of circles as a bias correction.
-        const n = Math.max(1, objectCount - relevantCountMiss - relevantCountMeh);
+        new osuBase.OsuHitWindow(overallDifficulty).greatWindow * clockRate));
+        const greatWindow = hitWindow.greatWindow / clockRate;
+        const okWindow = hitWindow.okWindow / clockRate;
+        const mehWindow = hitWindow.mehWindow / clockRate;
+        // The sample proportion of successful hits.
+        const n = Math.max(1, relevantCountGreat + relevantCountOk);
+        const p = relevantCountGreat / n;
         // 99% critical value for the normal distribution (one-tailed).
         const z = 2.32634787404;
-        // Proportion of greats hit on circles, ignoring misses and 50s.
-        const p = relevantCountGreat / n;
-        // We can be 99% confident that p is at least this value.
-        const pLowerBound = (n * p + (z * z) / 2) / (n + z * z) -
-            (z / (n + z * z)) * Math.sqrt(n * p * (1 - p) + (z * z) / 4);
-        // Compute the deviation assuming greats and oks are normally distributed, and mehs are uniformly distributed.
-        // Begin with greats and oks first. Ignoring mehs, we can be 99% confident that the deviation is not higher than:
-        let deviation = greatWindow / (Math.SQRT2 * osuBase.ErrorFunction.erfInv(pLowerBound));
-        const randomValue = (Math.sqrt(2 / Math.PI) *
-            okWindow *
-            Math.pow(Math.exp(-0.5 * (okWindow / deviation)), 2)) /
-            (deviation *
-                osuBase.ErrorFunction.erf(okWindow / (Math.SQRT2 * deviation)));
-        deviation *= Math.sqrt(1 - randomValue);
-        // Value deviation approach as greatCount approaches 0
-        const limitValue = okWindow / Math.sqrt(3);
-        // If precision is not enough to compute true deviation - use limit value
-        if (pLowerBound == 0.0 || randomValue >= 1 || deviation > limitValue) {
-            deviation = limitValue;
-        }
-        // Then compute the variance for mehs.
-        const mehVariance = (Math.pow(mehWindow, 2) +
+        // We can be 99% confident that the population proportion is at least this value.
+        const pLowerBound = Math.min(p, (n * p + Math.pow(z, 2) / 2) / (n + Math.pow(z, 2)) -
+            (z / (n + Math.pow(z, 2))) *
+                Math.sqrt(n * p * (1 - p) + Math.pow(z, 2) / 4));
+        let deviation;
+        // Tested maximum precision for the deviation calculation.
+        if (pLowerBound > 0.01) {
+            // Compute deviation assuming 300s and 109s are normally distributed.
+            deviation =
+                greatWindow / (Math.SQRT2 * osuBase.ErrorFunction.erfInv(pLowerBound));
+            // Subtract the deviation provided by tails that land outside the 100 hit window from the deviation computed above.
+            // This is equivalent to calculating the deviation of a normal distribution truncated at +-okHitWindow.
+            const okWindowTailAmount = (Math.sqrt(2 / Math.PI) *
+                okWindow *
+                Math.exp(-0.5 * Math.pow(okWindow / deviation, 2))) /
+                (deviation *
+                    osuBase.ErrorFunction.erf(okWindow / (Math.SQRT2 * deviation)));
+            deviation *= Math.sqrt(1 - okWindowTailAmount);
+        }
+        else {
+            // A tested limit value for the case of a score only containing 100s.
+            deviation = okWindow / Math.sqrt(3);
+        }
+        // Compute and add the variance for 50s, assuming that they are uniformly distriubted.
+        const mehVariance = (mehWindow * mehWindow +
             okWindow * mehWindow +
-            Math.pow(okWindow, 2)) /
+            okWindow * okWindow) /
             3;
-        // Find the total deviation.
         deviation = Math.sqrt(((relevantCountGreat + relevantCountOk) * Math.pow(deviation, 2) +
             relevantCountMeh * mehVariance) /
             (relevantCountGreat + relevantCountOk + relevantCountMeh));
@@ -4012,7 +3986,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         if (this.speedDeviation == Number.POSITIVE_INFINITY) {
             return 0;
         }
-        const speedValue = this.baseValue(this.difficultyAttributes.speedDifficulty);
+        const speedValue = OsuSpeed.difficultyToPerformance(this.difficultyAttributes.speedDifficulty);
         // Decide a point where the PP value achieved compared to the speed deviation is assumed to be tapped
         // improperly. Any PP above this point is considered "excess" speed difficulty. This is used to cause
         // PP above the cutoff to scale logarithmically towards the original speed value thus nerfing the value.
@@ -4028,6 +4002,64 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         const t = 1 - osuBase.Interpolation.reverseLerp(this.speedDeviation, 22, 27);
         return (osuBase.Interpolation.lerp(adjustedSpeedValue, speedValue, t) / speedValue);
     }
+    calculateEstimatedSliderBreaks(topWeightedSliderFactor) {
+        const { n100 } = this.computedAccuracy;
+        if (!this.usingClassicSliderAccuracy || n100 === 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;
+        // 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 *
+            osuBase.MathUtils.offsetLogistic(missedComboPercent, 0.33, 15));
+    }
+    /**
+     * Calculates the amount of misses + sliderbreaks from combo.
+     */
+    calculateComboBasedEstimatedMissCount() {
+        let missCount = this.computedAccuracy.nmiss;
+        const { combo } = this;
+        const { sliderCount, maxCombo } = this.difficultyAttributes;
+        if (sliderCount <= 0) {
+            return missCount;
+        }
+        if (this.usingClassicSliderAccuracy) {
+            // 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;
+            if (combo < fullComboThreshold) {
+                missCount = fullComboThreshold / Math.max(1, combo);
+            }
+            // In classic scores, there can't be more misses than a sum of all non-perfect judgements.
+            missCount = Math.min(missCount, this.totalImperfectHits);
+            // Every slider has *at least* 2 combo attributed in classic mechanics.
+            // If they broke on a slider with a tick, then this still works since they would have lost at least 2 combo (the tick and the end).
+            // Using this as a max means a score that loses 1 combo on a map can't possibly have been a slider break.
+            // It must have been a slider end.
+            const maxPossibleSliderBreaks = Math.min(sliderCount, (maxCombo - combo) / 2);
+            const sliderBreaks = missCount - this.computedAccuracy.nmiss;
+            if (sliderBreaks > maxPossibleSliderBreaks) {
+                missCount =
+                    this.computedAccuracy.nmiss + maxPossibleSliderBreaks;
+            }
+        }
+        else {
+            const fullComboThreshold = maxCombo - this.sliderEndsDropped;
+            if (combo < fullComboThreshold) {
+                missCount = fullComboThreshold / Math.max(1, combo);
+            }
+            // Combine regular misses with tick misses, since tick misses break combo as well.
+            missCount = Math.min(missCount, this.sliderTicksMissed + this.computedAccuracy.nmiss);
+        }
+        return missCount;
+    }
     toString() {
         return (this.total.toFixed(2) +
             " pp (" +
@@ -4036,11 +4068,275 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             this.speed.toFixed(2) +
             " speed, " +
             this.accuracy.toFixed(2) +
-            " acc, " +
+            " accuracy, " +
             this.flashlight.toFixed(2) +
             " flashlight)");
     }
 }
+OsuPerformanceCalculator.finalMultiplier = 1.14;
+
+/**
+ * An evaluator for calculating osu!standard Flashlight skill.
+ */
+class OsuFlashlightEvaluator {
+    /**
+     * Evaluates the difficulty of memorizing and hitting the current object, based on:
+     *
+     * - distance between a number of previous objects and the current object,
+     * - the visual opacity of the current object,
+     * - the angle made by the current object,
+     * - length and speed of the current object (for sliders),
+     * - and whether Hidden mod is enabled.
+     *
+     * @param current The current object.
+     * @param mods The mods used.
+     */
+    static evaluateDifficultyOf(current, mods) {
+        if (current.object instanceof osuBase.Spinner) {
+            return 0;
+        }
+        const scalingFactor = 52 / current.object.radius;
+        let smallDistNerf = 1;
+        let cumulativeStrainTime = 0;
+        let result = 0;
+        let last = current;
+        let angleRepeatCount = 0;
+        for (let i = 0; i < Math.min(current.index, 10); ++i) {
+            const currentObject = current.previous(i);
+            cumulativeStrainTime += last.strainTime;
+            if (!(currentObject.object instanceof osuBase.Spinner)) {
+                const jumpDistance = current.object.stackedPosition.subtract(currentObject.object.stackedEndPosition).length;
+                // We want to nerf objects that can be easily seen within the Flashlight circle radius.
+                if (i === 0) {
+                    smallDistNerf = Math.min(1, jumpDistance / 75);
+                }
+                // We also want to nerf stacks so that only the first object of the stack is accounted for.
+                const stackNerf = Math.min(1, currentObject.lazyJumpDistance / scalingFactor / 25);
+                // Bonus based on how visible the object is.
+                const opacityBonus = 1 +
+                    this.maxOpacityBonus *
+                        (1 -
+                            current.opacityAt(currentObject.object.startTime, mods));
+                result +=
+                    (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
+                        cumulativeStrainTime;
+                if (currentObject.angle !== null && current.angle !== null) {
+                    // Objects further back in time should count less for the nerf.
+                    if (Math.abs(currentObject.angle - current.angle) < 0.02) {
+                        angleRepeatCount += Math.max(0, 1 - 0.1 * i);
+                    }
+                }
+            }
+            last = currentObject;
+        }
+        result = Math.pow(smallDistNerf * result, 2);
+        // Additional bonus for Hidden due to there being no approach circles.
+        if (mods.has(osuBase.ModHidden)) {
+            result *= 1 + this.hiddenBonus;
+        }
+        // Nerf patterns with repeated angles.
+        result *=
+            this.minAngleMultiplier +
+                (1 - this.minAngleMultiplier) / (angleRepeatCount + 1);
+        let sliderBonus = 0;
+        if (current.object instanceof osuBase.Slider) {
+            // Invert the scaling factor to determine the true travel distance independent of circle size.
+            const pixelTravelDistance = current.lazyTravelDistance / scalingFactor;
+            // Reward sliders based on velocity.
+            sliderBonus = Math.pow(Math.max(0, pixelTravelDistance / current.travelTime - this.minVelocity), 0.5);
+            // Longer sliders require more memorization.
+            sliderBonus *= pixelTravelDistance;
+            // Nerf sliders with repeats, as less memorization is required.
+            if (current.object.repeatCount > 0)
+                sliderBonus /= current.object.repeatCount + 1;
+        }
+        result += sliderBonus * this.sliderMultiplier;
+        return result;
+    }
+}
+OsuFlashlightEvaluator.maxOpacityBonus = 0.4;
+OsuFlashlightEvaluator.hiddenBonus = 0.2;
+OsuFlashlightEvaluator.minVelocity = 0.5;
+OsuFlashlightEvaluator.sliderMultiplier = 1.3;
+OsuFlashlightEvaluator.minAngleMultiplier = 0.2;
+
+/**
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ */
+class OsuFlashlight extends OsuSkill {
+    constructor() {
+        super(...arguments);
+        this.strainDecayBase = 0.15;
+        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;
+    }
+    difficultyValue() {
+        return this.strainPeaks.reduce((a, b) => a + b, 0);
+    }
+    strainValueAt(current) {
+        this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
+        this.currentFlashlightStrain +=
+            OsuFlashlightEvaluator.evaluateDifficultyOf(current, this.mods) *
+                this.skillMultiplier;
+        return this.currentFlashlightStrain;
+    }
+    calculateInitialStrain(time, current) {
+        var _a, _b;
+        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) {
+        current.flashlightStrain = this.currentFlashlightStrain;
+    }
+}
+
+/**
+ * A difficulty calculator for osu!standard gamemode.
+ */
+class OsuDifficultyCalculator extends DifficultyCalculator {
+    constructor() {
+        super();
+        this.starRatingMultiplier = 0.0265;
+        this.difficultyAdjustmentMods.push(osuBase.ModTouchDevice, osuBase.ModBlinds);
+    }
+    retainDifficultyAdjustmentMods(mods) {
+        return mods.filter((mod) => mod.isApplicableToOsu() &&
+            mod.isOsuRelevant &&
+            this.difficultyAdjustmentMods.some((m) => mod instanceof m));
+    }
+    createDifficultyAttributes(beatmap, skills) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const attributes = new OsuDifficultyAttributes();
+        if (beatmap.hitObjects.objects.length === 0) {
+            return attributes;
+        }
+        attributes.mods = beatmap.mods;
+        attributes.maxCombo = beatmap.maxCombo;
+        attributes.clockRate = beatmap.speedMultiplier;
+        attributes.hitCircleCount = beatmap.hitObjects.circles;
+        attributes.sliderCount = beatmap.hitObjects.sliders;
+        attributes.spinnerCount = beatmap.hitObjects.spinners;
+        attributes.drainRate = beatmap.difficulty.hp;
+        attributes.approachRate =
+            OsuDifficultyCalculator.calculateRateAdjustedApproachRate(beatmap.difficulty.ar, attributes.clockRate);
+        attributes.overallDifficulty =
+            OsuDifficultyCalculator.calculateRateAdjustedOverallDifficulty(beatmap.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);
+        // 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;
+        attributes.aimDifficultStrainCount =
+            (_c = aim === null || aim === void 0 ? void 0 : aim.countTopWeightedStrains()) !== null && _c !== void 0 ? _c : 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)
+                : 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()) !== null && _f !== void 0 ? _f : 0;
+        attributes.aimTopWeightedSliderFactor =
+            aimNoSliderTopWeightedSliderCount /
+                Math.max(1, aimNoSliderDifficultStrainCount -
+                    aimNoSliderTopWeightedSliderCount);
+        // Speed attributes
+        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()) !== null && _j !== void 0 ? _j : 0;
+        const speedTopWeightedSliderCount = (_k = speed === null || speed === void 0 ? void 0 : speed.countTopWeightedSliders()) !== null && _k !== void 0 ? _k : 0;
+        attributes.speedTopWeightedSliderFactor =
+            speedTopWeightedSliderCount /
+                Math.max(1, attributes.speedDifficultStrainCount -
+                    speedTopWeightedSliderCount);
+        // Final rating
+        const mechanicalDifficultyRating = this.calculateMechanicalDifficultyRating(aimDifficultyValue, speedDifficultyValue);
+        const ratingCalculator = new OsuRatingCalculator(attributes.mods, beatmap.hitObjects.objects.length, attributes.approachRate, attributes.overallDifficulty, mechanicalDifficultyRating, attributes.sliderFactor);
+        attributes.aimDifficulty =
+            ratingCalculator.computeAimRating(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);
+        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);
+        attributes.starRating = this.calculateStarRating(basePerformance);
+        return attributes;
+    }
+    createPlayableBeatmap(beatmap, mods) {
+        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);
+            difficultyObject.computeProperties(clockRate);
+            difficultyObjects.push(difficultyObject);
+        }
+        return difficultyObjects;
+    }
+    createSkills(beatmap) {
+        const { mods } = beatmap;
+        const skills = [];
+        if (!mods.has(osuBase.ModAutopilot)) {
+            skills.push(new OsuAim(mods, true));
+            skills.push(new OsuAim(mods, false));
+        }
+        if (!mods.has(osuBase.ModRelax)) {
+            skills.push(new OsuSpeed(mods));
+        }
+        if (mods.has(osuBase.ModFlashlight)) {
+            skills.push(new OsuFlashlight(mods));
+        }
+        return skills;
+    }
+    createStrainPeakSkills(beatmap) {
+        const { mods } = beatmap;
+        return [
+            new OsuAim(mods, true),
+            new OsuAim(mods, false),
+            new OsuSpeed(mods),
+            new OsuFlashlight(mods),
+        ];
+    }
+    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);
+    }
+    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);
+    }
+    static calculateRateAdjustedOverallDifficulty(overallDifficulty, clockRate) {
+        const greatWindow = new osuBase.OsuHitWindow(overallDifficulty).greatWindow / clockRate;
+        return osuBase.OsuHitWindow.greatWindowToOD(greatWindow);
+    }
+}
 
 exports.DifficultyAttributes = DifficultyAttributes;
 exports.DifficultyCalculator = DifficultyCalculator;