@rian8337/osu-difficulty-calculator 1.4.16 → 2.0.0-alpha.2

package/dist/index.js

@@ -1,27 +1,2619 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./preprocessing/DifficultyHitObject"), exports);
-__exportStar(require("./preprocessing/DifficultyHitObjectCreator"), exports);
-__exportStar(require("./skills/DroidAim"), exports);
-__exportStar(require("./skills/DroidFlashlight"), exports);
-__exportStar(require("./DroidPerformanceCalculator"), exports);
-__exportStar(require("./skills/DroidRhythm"), exports);
-__exportStar(require("./DroidStarRating"), exports);
-__exportStar(require("./skills/DroidTap"), exports);
-__exportStar(require("./MapStars"), exports);
-__exportStar(require("./skills/OsuAim"), exports);
-__exportStar(require("./skills/OsuFlashlight"), exports);
-__exportStar(require("./OsuPerformanceCalculator"), exports);
-__exportStar(require("./skills/OsuSpeed"), exports);
-__exportStar(require("./OsuStarRating"), exports);
-//# sourceMappingURL=index.js.map
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var osuBase = require('@rian8337/osu-base');
+
+/**
+ * Represents an osu!standard hit object with difficulty calculation values.
+ */
+class DifficultyHitObject {
+    /**
+     * The underlying hitobject.
+     */
+    object;
+    /**
+     * The aim strain generated by the hitobject if sliders are considered.
+     */
+    aimStrainWithSliders = 0;
+    /**
+     * The aim strain generated by the hitobject if sliders are not considered.
+     */
+    aimStrainWithoutSliders = 0;
+    /**
+     * The tap strain generated by the hitobject.
+     *
+     * This is also used for osu!standard as opposed to "speed strain".
+     */
+    tapStrain = 0;
+    /**
+     * The tap strain generated by the hitobject if `strainTime` isn't modified by
+     * OD. This is used in three-finger detection.
+     */
+    originalTapStrain = 0;
+    /**
+     * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
+     */
+    rhythmMultiplier = 0;
+    /**
+     * The rhythm strain generated by the hitobject.
+     */
+    rhythmStrain = 0;
+    /**
+     * The flashlight strain generated by the hitobject.
+     */
+    flashlightStrain = 0;
+    /**
+     * The visual strain generated by the hitobject.
+     */
+    visualStrain = 0;
+    /**
+     * The normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
+     *
+     * The "lazy" end position is the position at which the cursor ends up if the previous hitobject is followed with as minimal movement as possible (i.e. on the edge of slider follow circles).
+     */
+    lazyJumpDistance = 0;
+    /**
+     * The normalized shortest distance to consider for a jump between the previous hitobject and this hitobject.
+     *
+     * This is bounded from above by `lazyJumpDistance`, and is smaller than the former if a more natural path is able to be taken through the previous hitobject.
+     *
+     * Suppose a linear slider - circle pattern. Following the slider lazily (see: `lazyJumpDistance`) will result in underestimating the true end position of the slider as being closer towards the start position.
+     * As a result, `lazyJumpDistance` overestimates the jump distance because the player is able to take a more natural path by following through the slider to its end,
+     * such that the jump is felt as only starting from the slider's true end position.
+     *
+     * Now consider a slider - circle pattern where the circle is stacked along the path inside the slider.
+     * In this case, the lazy end position correctly estimates the true end position of the slider and provides the more natural movement path.
+     */
+    minimumJumpDistance = 0;
+    /**
+     * The time taken to travel through `minimumJumpDistance`, with a minimum value of 25ms.
+     */
+    minimumJumpTime = 0;
+    /**
+     * The normalized distance between the start and end position of this hitobject.
+     */
+    travelDistance = 0;
+    /**
+     * The time taken to travel through `travelDistance`, with a minimum value of 25ms for a non-zero distance.
+     */
+    travelTime = 0;
+    /**
+     * Angle the player has to take to hit this hitobject.
+     *
+     * Calculated as the angle between the circles (current-2, current-1, current).
+     */
+    angle = null;
+    /**
+     * The amount of milliseconds elapsed between this hitobject and the last hitobject.
+     */
+    deltaTime = 0;
+    /**
+     * The amount of milliseconds elapsed since the start time of the previous hitobject, with a minimum of 25ms.
+     */
+    strainTime = 0;
+    /**
+     * Adjusted start time of the hitobject, taking speed multiplier into account.
+     */
+    startTime = 0;
+    /**
+     * Adjusted end time of the hitobject, taking speed multiplier into account.
+     */
+    endTime = 0;
+    /**
+     * The note density of the hitobject.
+     */
+    noteDensity = 0;
+    /**
+     * The overlapping factor of the hitobject.
+     *
+     * This is used to scale visual skill.
+     */
+    overlappingFactor = 0;
+    /**
+     * Adjusted velocity of the hitobject, taking speed multiplier into account.
+     */
+    velocity = 0;
+    /**
+     * @param object The underlying hitobject.
+     */
+    constructor(object) {
+        this.object = object;
+    }
+}
+
+/**
+ * A converter used to convert normal hitobjects into difficulty hitobjects.
+ */
+class DifficultyHitObjectCreator {
+    /**
+     * The threshold for small circle buff for osu!droid.
+     */
+    DROID_CIRCLESIZE_BUFF_THRESHOLD = 52.5;
+    /**
+     * The threshold for small circle buff for osu!standard.
+     */
+    PC_CIRCLESIZE_BUFF_THRESHOLD = 30;
+    /**
+     * The gamemode this creator is creating for.
+     */
+    mode = osuBase.modes.osu;
+    /**
+     * The base normalized radius of hitobjects.
+     */
+    normalizedRadius = 50;
+    maximumSliderRadius = this.normalizedRadius * 2.4;
+    assumedSliderRadius = this.normalizedRadius * 1.8;
+    minDeltaTime = 25;
+    /**
+     * Generates difficulty hitobjects for difficulty calculation.
+     */
+    generateDifficultyObjects(params) {
+        params.preempt ??= 600;
+        this.mode = params.mode;
+        const circleSize = params.circleSize;
+        const scale = (1 - (0.7 * (circleSize - 5)) / 5) / 2;
+        params.objects[0].scale = scale;
+        const scalingFactor = this.getScalingFactor(params.objects[0].radius);
+        const difficultyObjects = [];
+        for (let i = 0; i < params.objects.length; ++i) {
+            const object = new DifficultyHitObject(params.objects[i]);
+            object.object.scale = scale;
+            if (object.object instanceof osuBase.Slider) {
+                object.velocity =
+                    object.object.velocity * params.speedMultiplier;
+                object.object.nestedHitObjects.forEach((h) => {
+                    h.scale = scale;
+                });
+                this.calculateSliderCursorPosition(object.object);
+                object.travelDistance = object.object.lazyTravelDistance;
+                object.travelTime = Math.max(object.object.lazyTravelTime / params.speedMultiplier, this.minDeltaTime);
+            }
+            const lastObject = difficultyObjects[i - 1];
+            const lastLastObject = difficultyObjects[i - 2];
+            object.startTime = object.object.startTime / params.speedMultiplier;
+            object.endTime = object.object.endTime / params.speedMultiplier;
+            if (!lastObject) {
+                difficultyObjects.push(object);
+                continue;
+            }
+            object.deltaTime =
+                (object.object.startTime - lastObject.object.startTime) /
+                    params.speedMultiplier;
+            // Cap to 25ms to prevent difficulty calculation breaking from simultaneous objects.
+            object.strainTime = Math.max(this.minDeltaTime, object.deltaTime);
+            const visibleObjects = params.objects.filter((o) => o.startTime / params.speedMultiplier > object.startTime &&
+                o.startTime / params.speedMultiplier <=
+                    object.endTime + params.preempt);
+            object.noteDensity = 1;
+            for (const hitObject of visibleObjects) {
+                // Calculate delta time assuming the current object is a circle.
+                let deltaTime = Math.abs(hitObject.startTime / params.speedMultiplier -
+                    object.startTime);
+                // But if the current object is a slider, then we alter the delta time to account for slider end time.
+                if (object.object instanceof osuBase.Slider) {
+                    if (object.object.startTime >= hitObject.startTime &&
+                        object.object.endTime <= hitObject.startTime) {
+                        // If the object starts when the slider is active, then the slider is technically still visible.
+                        // Set delta time to 0.
+                        deltaTime = 0;
+                    }
+                    else {
+                        // Otherwise, we take the delta time from the slider head or tail, whichever is smaller as it's the closest time.
+                        deltaTime = Math.min(deltaTime, Math.abs(hitObject.startTime / params.speedMultiplier -
+                            object.endTime));
+                    }
+                }
+                object.noteDensity += 1 - deltaTime / params.preempt;
+                if (!(hitObject instanceof osuBase.Spinner)) {
+                    object.overlappingFactor +=
+                        // Penalize objects that are too close to the object in both distance
+                        // and delta time to prevent stream maps from being overweighted.
+                        Math.max(0, 1 -
+                            object.object.stackedPosition.getDistance(hitObject.stackedEndPosition) /
+                                (3 * object.object.radius)) *
+                            (7.5 /
+                                (1 +
+                                    Math.exp(0.15 *
+                                        (Math.max(deltaTime, this.minDeltaTime) -
+                                            75))));
+                }
+            }
+            if (object.object instanceof osuBase.Spinner ||
+                lastObject.object instanceof osuBase.Spinner) {
+                difficultyObjects.push(object);
+                continue;
+            }
+            const lastCursorPosition = this.getEndCursorPosition(lastObject.object);
+            object.lazyJumpDistance = object.object.stackedPosition
+                .scale(scalingFactor)
+                .subtract(lastCursorPosition.scale(scalingFactor)).length;
+            object.minimumJumpTime = object.strainTime;
+            object.minimumJumpDistance = object.lazyJumpDistance;
+            if (lastObject.object instanceof osuBase.Slider) {
+                object.minimumJumpTime = Math.max(object.strainTime - lastObject.travelTime, this.minDeltaTime);
+                // There are two types of slider-to-object patterns to consider in order to better approximate the real movement a player will take to jump between the hitobjects.
+                //
+                // 1. The anti-flow pattern, where players cut the slider short in order to move to the next hitobject.
+                //
+                //      <======o==>  ← slider
+                //             |     ← most natural jump path
+                //             o     ← a follow-up hitcircle
+                //
+                // In this case the most natural jump path is approximated by LazyJumpDistance.
+                //
+                // 2. The flow pattern, where players follow through the slider to its visual extent into the next hitobject.
+                //
+                //      <======o==>---o
+                //                  ↑
+                //        most natural jump path
+                //
+                // In this case the most natural jump path is better approximated by a new distance called "tailJumpDistance" - the distance between the slider's tail and the next hitobject.
+                //
+                // Thus, the player is assumed to jump the minimum of these two distances in all cases.
+                const tailJumpDistance = lastObject.object.tail.stackedPosition.subtract(object.object.stackedPosition).length * scalingFactor;
+                object.minimumJumpDistance = Math.max(0, Math.min(object.lazyJumpDistance -
+                    (this.maximumSliderRadius -
+                        this.assumedSliderRadius), tailJumpDistance - this.maximumSliderRadius));
+            }
+            if (lastLastObject && !(lastLastObject.object instanceof osuBase.Spinner)) {
+                const lastLastCursorPosition = this.getEndCursorPosition(lastLastObject.object);
+                const v1 = lastLastCursorPosition.subtract(lastObject.object.stackedPosition);
+                const v2 = object.object.stackedPosition.subtract(lastCursorPosition);
+                const dot = v1.dot(v2);
+                const det = v1.x * v2.y - v1.y * v2.x;
+                object.angle = Math.abs(Math.atan2(det, dot));
+            }
+            difficultyObjects.push(object);
+        }
+        return difficultyObjects;
+    }
+    /**
+     * Calculates a slider's cursor position.
+     */
+    calculateSliderCursorPosition(slider) {
+        if (slider.lazyEndPosition) {
+            return;
+        }
+        // Droid doesn't have a legacy slider tail. Since beatmap parser defaults slider tail
+        // to legacy slider tail, it needs to be changed to real slider tail first.
+        if (this.mode === osuBase.modes.droid) {
+            slider.tail.startTime += osuBase.Slider.legacyLastTickOffset;
+            slider.tail.endTime += osuBase.Slider.legacyLastTickOffset;
+            slider.nestedHitObjects.sort((a, b) => {
+                return a.startTime - b.startTime;
+            });
+            // Temporary lazy end position until a real result can be derived.
+            slider.lazyEndPosition = slider.stackedPosition;
+            // Stop here if the slider has too short duration due to float number limitation.
+            // Incredibly close start and end time fluctuates travel distance and lazy
+            // end position heavily, which we do not want to happen.
+            //
+            // In the real game, this shouldn't happen. Perhaps we need to reinvestigate this
+            // in the future.
+            if (osuBase.Precision.almostEqualsNumber(slider.startTime, slider.endTime)) {
+                return;
+            }
+        }
+        // Not using slider.endTime due to legacy last tick offset.
+        slider.lazyTravelTime =
+            slider.nestedHitObjects.at(-1).startTime - slider.startTime;
+        let endTimeMin = slider.lazyTravelTime / slider.spanDuration;
+        if (endTimeMin % 2 >= 1) {
+            endTimeMin = 1 - (endTimeMin % 1);
+        }
+        else {
+            endTimeMin %= 1;
+        }
+        // Temporary lazy end position until a real result can be derived.
+        slider.lazyEndPosition = slider.stackedPosition.add(slider.path.positionAt(endTimeMin));
+        let currentCursorPosition = slider.stackedPosition;
+        const scalingFactor = this.normalizedRadius / slider.radius;
+        for (let i = 1; i < slider.nestedHitObjects.length; ++i) {
+            const currentMovementObject = slider.nestedHitObjects[i];
+            let currentMovement = currentMovementObject.stackedPosition.subtract(currentCursorPosition);
+            let currentMovementLength = scalingFactor * currentMovement.length;
+            // The amount of movement required so that the cursor position needs to be updated.
+            let requiredMovement = this.assumedSliderRadius;
+            if (i === slider.nestedHitObjects.length - 1) {
+                // The end of a slider has special aim rules due to the relaxed time constraint on position.
+                // There is both a lazy end position as well as the actual end slider position. We assume the player takes the simpler movement.
+                // For sliders that are circular, the lazy end position may actually be farther away than the sliders' true end.
+                // This code is designed to prevent buffing situations where lazy end is actually a less efficient movement.
+                const lazyMovement = slider.lazyEndPosition.subtract(currentCursorPosition);
+                if (lazyMovement.length < currentMovement.length) {
+                    currentMovement = lazyMovement;
+                }
+                currentMovementLength = scalingFactor * currentMovement.length;
+            }
+            else if (currentMovementObject instanceof osuBase.SliderRepeat) {
+                // For a slider repeat, assume a tighter movement threshold to better assess repeat sliders.
+                requiredMovement = this.normalizedRadius;
+            }
+            if (currentMovementLength > requiredMovement) {
+                // This finds the positional delta from the required radius and the current position,
+                // and updates the currentCursorPosition accordingly, as well as rewarding distance.
+                currentCursorPosition = currentCursorPosition.add(currentMovement.scale((currentMovementLength - requiredMovement) /
+                    currentMovementLength));
+                currentMovementLength *=
+                    (currentMovementLength - requiredMovement) /
+                        currentMovementLength;
+                slider.lazyTravelDistance += currentMovementLength;
+            }
+            if (i === slider.nestedHitObjects.length - 1) {
+                slider.lazyEndPosition = currentCursorPosition;
+            }
+        }
+        // Bonus for repeat sliders until a better per nested object strain system can be achieved.
+        if (this.mode === osuBase.modes.droid) {
+            slider.lazyTravelDistance *= Math.pow(1 + slider.repeats / 4, 1 / 4);
+        }
+        else {
+            slider.lazyTravelDistance *= Math.pow(1 + slider.repeats / 2.5, 1 / 2.5);
+        }
+    }
+    /**
+     * Gets the scaling factor of a radius.
+     *
+     * @param radius The radius to get the scaling factor from.
+     */
+    getScalingFactor(radius) {
+        // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
+        let scalingFactor = this.normalizedRadius / radius;
+        // High circle size (small CS) bonus
+        switch (this.mode) {
+            case osuBase.modes.droid:
+                if (radius < this.DROID_CIRCLESIZE_BUFF_THRESHOLD) {
+                    scalingFactor *=
+                        1 +
+                            Math.min(this.DROID_CIRCLESIZE_BUFF_THRESHOLD - radius, 20) /
+                                40;
+                }
+                break;
+            case osuBase.modes.osu:
+                if (radius < this.PC_CIRCLESIZE_BUFF_THRESHOLD) {
+                    scalingFactor *=
+                        1 +
+                            Math.min(this.PC_CIRCLESIZE_BUFF_THRESHOLD - radius, 5) /
+                                50;
+                }
+        }
+        return scalingFactor;
+    }
+    /**
+     * Returns the end cursor position of a hitobject.
+     */
+    getEndCursorPosition(object) {
+        let pos = object.stackedPosition;
+        if (object instanceof osuBase.Slider) {
+            this.calculateSliderCursorPosition(object);
+            pos = object.lazyEndPosition ?? pos;
+        }
+        return pos;
+    }
+}
+
+/**
+ * A bare minimal abstract skill for fully custom skill implementations.
+ */
+class Skill {
+    /**
+     * The hitobjects that were processed previously. They can affect the strain values of the following objects.
+     *
+     * The latest hitobject is at index 0.
+     */
+    previous = [];
+    /**
+     * Number of previous hitobjects to keep inside the `previous` array.
+     */
+    historyLength = 2;
+    /**
+     * The mods that this skill processes.
+     */
+    mods;
+    constructor(mods) {
+        this.mods = mods;
+    }
+    processInternal(current) {
+        while (this.previous.length > this.historyLength) {
+            this.previous.pop();
+        }
+        this.process(current);
+        this.previous.unshift(current);
+    }
+}
+
+/**
+ * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
+ * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
+ */
+class StrainSkill extends Skill {
+    /**
+     * The strain of currently calculated hitobject.
+     */
+    currentStrain = 0;
+    /**
+     * The current section's strain peak.
+     */
+    currentSectionPeak = 0;
+    /**
+     * Strain peaks are stored here.
+     */
+    strainPeaks = [];
+    sectionLength = 400;
+    currentSectionEnd = 0;
+    /**
+     * Calculates the strain value of a hitobject and stores the value in it. This value is affected by previously processed objects.
+     *
+     * @param current The hitobject to process.
+     */
+    process(current) {
+        // The first object doesn't generate a strain, so we begin with an incremented section end
+        if (this.previous.length === 0) {
+            this.currentSectionEnd =
+                Math.ceil(current.startTime / this.sectionLength) *
+                    this.sectionLength;
+        }
+        while (current.startTime > this.currentSectionEnd) {
+            this.saveCurrentPeak();
+            this.startNewSectionFrom(this.currentSectionEnd);
+            this.currentSectionEnd += this.sectionLength;
+        }
+        this.currentStrain = this.strainValueAt(current);
+        this.saveToHitObject(current);
+        this.currentSectionPeak = Math.max(this.currentStrain, this.currentSectionPeak);
+    }
+    /**
+     * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
+     */
+    saveCurrentPeak() {
+        this.strainPeaks.push(this.currentSectionPeak);
+    }
+    /**
+     * Sets the initial strain level for a new section.
+     *
+     * @param offset The beginning of the new section in milliseconds, adjusted by speed multiplier.
+     */
+    startNewSectionFrom(offset) {
+        // The maximum strain of the new section is not zero by default, strain decays as usual regardless of section boundaries.
+        // This means we need to capture the strain level at the beginning of the new section, and use that as the initial peak level.
+        this.currentSectionPeak =
+            this.currentStrain *
+                this.strainDecay(offset - this.previous[0].startTime);
+    }
+    /**
+     * Calculates strain decay for a specified time frame.
+     *
+     * @param ms The time frame to calculate.
+     */
+    strainDecay(ms) {
+        return Math.pow(this.strainDecayBase, ms / 1000);
+    }
+}
+
+/**
+ * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
+ * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
+ */
+class DroidSkill extends StrainSkill {
+    difficultyValue() {
+        const sortedStrains = this.strainPeaks
+            .slice()
+            .sort((a, b) => {
+            return b - a;
+        });
+        // We are reducing the highest strains first to account for extreme difficulty spikes.
+        for (let i = 0; i < Math.min(sortedStrains.length, this.reducedSectionCount); ++i) {
+            const scale = Math.log10(osuBase.Interpolation.lerp(1, 10, osuBase.MathUtils.clamp(i / this.reducedSectionCount, 0, 1)));
+            sortedStrains[i] *= osuBase.Interpolation.lerp(this.reducedSectionBaseline, 1, scale);
+        }
+        // Math here preserves the property that two notes of equal difficulty x, we have their summed difficulty = x * starsPerDouble.
+        // This also applies to two sets of notes with equal difficulty.
+        return Math.pow(sortedStrains.reduce((a, v) => {
+            if (v <= 0) {
+                return a;
+            }
+            return a + Math.pow(v, 1 / Math.log2(this.starsPerDouble));
+        }, 0), Math.log2(this.starsPerDouble));
+    }
+}
+
+/**
+ * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
+ */
+class DroidAim extends DroidSkill {
+    skillMultiplier = 23.25;
+    strainDecayBase = 0.15;
+    reducedSectionCount = 10;
+    reducedSectionBaseline = 0.75;
+    starsPerDouble = 1.05;
+    /**
+     * Spacing threshold for a single hitobject spacing.
+     */
+    SINGLE_SPACING_THRESHOLD = 175;
+    // ~200 1/2 BPM jumps
+    minSpeedBonus = 150;
+    wideAngleMultiplier = 1.5;
+    acuteAngleMultiplier = 2;
+    sliderMultiplier = 1.5;
+    velocityChangeMultiplier = 0.75;
+    withSliders;
+    constructor(mods, withSliders) {
+        super(mods);
+        this.withSliders = withSliders;
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueOf(current) {
+        if (current.object instanceof osuBase.Spinner) {
+            return 0;
+        }
+        return this.aimStrainOf(current) + this.movementStrainOf(current);
+    }
+    /**
+     * Calculates the aim strain of a hitobject.
+     */
+    aimStrainOf(current) {
+        if (this.previous.length <= 1 ||
+            this.previous[0].object instanceof osuBase.Spinner) {
+            return 0;
+        }
+        const last = this.previous[0];
+        const lastLast = this.previous[1];
+        // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
+        let currentVelocity = current.lazyJumpDistance / current.strainTime;
+        // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
+        if (last.object instanceof osuBase.Slider &&
+            last.object.ticks > 0 &&
+            this.withSliders) {
+            // Calculate the slider velocity from slider head to slider end.
+            const travelVelocity = last.travelDistance / last.travelTime;
+            // Calculate the movement velocity from slider end to current object.
+            const movementVelocity = current.minimumJumpDistance / current.minimumJumpTime;
+            // Take the larger total combined velocity.
+            currentVelocity = Math.max(currentVelocity, movementVelocity + travelVelocity);
+        }
+        // As above, do the same for the previous hitobject.
+        let prevVelocity = last.lazyJumpDistance / last.strainTime;
+        if (lastLast.object instanceof osuBase.Slider &&
+            lastLast.object.ticks > 0 &&
+            this.withSliders) {
+            const travelVelocity = lastLast.travelDistance / lastLast.travelTime;
+            const movementVelocity = last.minimumJumpDistance / last.minimumJumpTime;
+            prevVelocity = Math.max(prevVelocity, movementVelocity + travelVelocity);
+        }
+        let wideAngleBonus = 0;
+        let acuteAngleBonus = 0;
+        let sliderBonus = 0;
+        let velocityChangeBonus = 0;
+        // Start strain with regular velocity.
+        let strain = currentVelocity;
+        if (Math.max(current.strainTime, last.strainTime) <
+            1.25 * Math.min(current.strainTime, last.strainTime)) {
+            // If rhythms are the same.
+            if (current.angle !== null &&
+                last.angle !== null &&
+                lastLast.angle !== null) {
+                // Rewarding angles, take the smaller velocity as base.
+                const angleBonus = Math.min(currentVelocity, prevVelocity);
+                wideAngleBonus = this.calculateWideAngleBonus(current.angle);
+                acuteAngleBonus = this.calculateAcuteAngleBonus(current.angle);
+                // Only buff deltaTime exceeding 300 BPM 1/2.
+                if (current.strainTime > 100) {
+                    acuteAngleBonus = 0;
+                }
+                else {
+                    acuteAngleBonus *=
+                        // Multiply by previous angle, we don't want to buff unless this is a wiggle type pattern.
+                        this.calculateAcuteAngleBonus(last.angle) *
+                            // The maximum velocity we buff is equal to 125 / strainTime.
+                            Math.min(angleBonus, 125 / current.strainTime) *
+                            // Scale buff from 300 BPM 1/2 to 400 BPM 1/2.
+                            Math.pow(Math.sin((Math.PI / 2) *
+                                Math.min(1, (100 - current.strainTime) / 25)), 2) *
+                            // Buff distance exceeding 50 (radius) up to 100 (diameter).
+                            Math.pow(Math.sin(((Math.PI / 2) *
+                                (osuBase.MathUtils.clamp(current.lazyJumpDistance, 50, 100) -
+                                    50)) /
+                                50), 2);
+                }
+                // Penalize wide angles if they're repeated, reducing the penalty as last.angle gets more acute.
+                wideAngleBonus *=
+                    angleBonus *
+                        (1 -
+                            Math.min(wideAngleBonus, Math.pow(this.calculateWideAngleBonus(last.angle), 3)));
+                // Penalize acute angles if they're repeated, reducing the penalty as lastLast.angle gets more obtuse.
+                acuteAngleBonus *=
+                    0.5 +
+                        0.5 *
+                            (1 -
+                                Math.min(acuteAngleBonus, Math.pow(this.calculateAcuteAngleBonus(lastLast.angle), 3)));
+            }
+        }
+        if (Math.max(prevVelocity, currentVelocity)) {
+            // We want to use the average velocity over the whole object when awarding differences, not the individual jump and slider path velocities.
+            prevVelocity =
+                (last.lazyJumpDistance + lastLast.travelDistance) /
+                    last.strainTime;
+            currentVelocity =
+                (current.lazyJumpDistance + last.travelDistance) /
+                    current.strainTime;
+            // Scale with ratio of difference compared to half the max distance.
+            const distanceRatio = Math.pow(Math.sin(((Math.PI / 2) * Math.abs(prevVelocity - currentVelocity)) /
+                Math.max(prevVelocity, currentVelocity)), 2);
+            // 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));
+            // Reward for % distance slowed down compared to previous, paying attention to not award overlap.
+            const nonOverlapVelocityBuff = Math.abs(prevVelocity - currentVelocity) *
+                // Do not award overlap.
+                Math.pow(Math.sin((Math.PI / 2) *
+                    Math.min(1, Math.min(current.lazyJumpDistance, last.lazyJumpDistance) / 100)), 2);
+            // Choose the largest bonus, multiplied by ratio.
+            velocityChangeBonus =
+                Math.max(overlapVelocityBuff, nonOverlapVelocityBuff) *
+                    distanceRatio;
+            // Penalize for rhythm changes.
+            velocityChangeBonus *= Math.pow(Math.min(current.strainTime, last.strainTime) /
+                Math.max(current.strainTime, last.strainTime), 2);
+        }
+        if (last.travelTime) {
+            // Reward sliders based on velocity.
+            sliderBonus = last.travelDistance / last.travelTime;
+        }
+        // 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);
+        // Add in additional slider velocity bonus.
+        if (this.withSliders) {
+            strain += sliderBonus * this.sliderMultiplier;
+        }
+        return strain;
+    }
+    /**
+     * Calculates the movement strain of a hitobject.
+     */
+    movementStrainOf(current) {
+        let speedBonus = 1;
+        if (current.strainTime < this.minSpeedBonus) {
+            speedBonus +=
+                0.75 *
+                    Math.pow((this.minSpeedBonus - current.strainTime) / 45, 2);
+        }
+        const travelDistance = this.previous[0]?.travelDistance ?? 0;
+        const distance = Math.min(this.SINGLE_SPACING_THRESHOLD, travelDistance + current.minimumJumpDistance);
+        return ((50 *
+            speedBonus *
+            Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 5)) /
+            current.strainTime);
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueAt(current) {
+        this.currentStrain *= this.strainDecay(current.deltaTime);
+        this.currentStrain +=
+            this.strainValueOf(current) * this.skillMultiplier;
+        return this.currentStrain;
+    }
+    /**
+     * @param current The hitobject to save to.
+     */
+    saveToHitObject(current) {
+        if (this.withSliders) {
+            current.aimStrainWithSliders = this.currentStrain;
+        }
+        else {
+            current.aimStrainWithoutSliders = this.currentStrain;
+        }
+    }
+    /**
+     * Calculates the bonus of wide angles.
+     */
+    calculateWideAngleBonus(angle) {
+        return Math.pow(Math.sin((3 / 4) *
+            (Math.min((5 / 6) * Math.PI, Math.max(Math.PI / 6, angle)) -
+                Math.PI / 6)), 2);
+    }
+    /**
+     * Calculates the bonus of acute angles.
+     */
+    calculateAcuteAngleBonus(angle) {
+        return 1 - this.calculateWideAngleBonus(angle);
+    }
+}
+
+/**
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ */
+class DroidFlashlight extends DroidSkill {
+    historyLength = 10;
+    skillMultiplier = 0.15;
+    strainDecayBase = 0.15;
+    reducedSectionCount = 10;
+    reducedSectionBaseline = 0.75;
+    starsPerDouble = 1.05;
+    strainValueOf(current) {
+        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;
+        for (let i = 0; i < this.previous.length; ++i) {
+            const currentObject = this.previous[i];
+            if (!(currentObject.object instanceof osuBase.Spinner)) {
+                const jumpDistance = current.object.stackedPosition.subtract(currentObject.object.endPosition).length;
+                cumulativeStrainTime += last.strainTime;
+                // 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);
+                result +=
+                    (stackNerf * scalingFactor * jumpDistance) /
+                        cumulativeStrainTime;
+            }
+            last = currentObject;
+        }
+        return Math.pow(smallDistNerf * result, 2);
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueAt(current) {
+        this.currentStrain *= this.strainDecay(current.deltaTime);
+        this.currentStrain +=
+            this.strainValueOf(current) * this.skillMultiplier;
+        return this.currentStrain;
+    }
+    saveToHitObject(current) {
+        current.flashlightStrain = this.currentStrain;
+    }
+}
+
+/**
+ * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
+ */
+class DroidTap extends DroidSkill {
+    skillMultiplier = 1375;
+    reducedSectionCount = 5;
+    reducedSectionBaseline = 0.75;
+    strainDecayBase = 0.3;
+    starsPerDouble = 1.1;
+    // ~200 1/4 BPM streams
+    minSpeedBonus = 75;
+    currentTapStrain = 0;
+    currentOriginalTapStrain = 0;
+    hitWindow;
+    constructor(mods, overallDifficulty) {
+        super(mods);
+        this.hitWindow = new osuBase.OsuHitWindow(overallDifficulty);
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueOf(current) {
+        if (current.object instanceof osuBase.Spinner) {
+            return 0;
+        }
+        let strainTime = current.strainTime;
+        const greatWindowFull = this.hitWindow.hitWindowFor300() * 2;
+        // Aim to nerf cheesy rhythms (very fast consecutive doubles with large deltatimes between).
+        if (this.previous[0] &&
+            strainTime < greatWindowFull &&
+            this.previous[0].strainTime > strainTime) {
+            strainTime = osuBase.Interpolation.lerp(this.previous[0].strainTime, strainTime, strainTime / greatWindowFull);
+        }
+        // Cap deltatime to the OD 300 hitwindow.
+        // 0.58 is derived from making sure 260 BPM 1/4 OD5 streams aren't nerfed harshly, whilst 0.91 limits the effect of the cap.
+        strainTime /= osuBase.MathUtils.clamp(strainTime / greatWindowFull / 0.58, 0.91, 1);
+        let speedBonus = 1;
+        if (strainTime < this.minSpeedBonus) {
+            speedBonus +=
+                0.75 * Math.pow((this.minSpeedBonus - strainTime) / 40, 2);
+        }
+        let originalSpeedBonus = 1;
+        if (current.strainTime < this.minSpeedBonus) {
+            originalSpeedBonus +=
+                0.75 *
+                    Math.pow((this.minSpeedBonus - current.strainTime) / 40, 2);
+        }
+        const decay = this.strainDecay(current.deltaTime);
+        this.currentTapStrain *= decay;
+        this.currentTapStrain +=
+            this.tapStrainOf(speedBonus, strainTime) * this.skillMultiplier;
+        this.currentOriginalTapStrain *= decay;
+        this.currentOriginalTapStrain +=
+            this.tapStrainOf(originalSpeedBonus, current.strainTime) *
+                this.skillMultiplier;
+        this.currentOriginalTapStrain *= current.rhythmMultiplier;
+        return this.currentTapStrain * current.rhythmMultiplier;
+    }
+    /**
+     * Calculates the tap strain of a hitobject given a specific speed bonus and strain time.
+     */
+    tapStrainOf(speedBonus, strainTime) {
+        return speedBonus / strainTime;
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueAt(current) {
+        return this.strainValueOf(current);
+    }
+    /**
+     * @param current The hitobject to save to.
+     */
+    saveToHitObject(current) {
+        current.tapStrain = this.currentStrain;
+        current.originalTapStrain = this.currentOriginalTapStrain;
+    }
+}
+
+/**
+ * The base of difficulty calculation.
+ */
+class StarRating {
+    /**
+     * The calculated beatmap.
+     */
+    map = new osuBase.Beatmap();
+    /**
+     * The difficulty objects of the beatmap.
+     */
+    objects = [];
+    /**
+     * The modifications applied.
+     */
+    mods = [];
+    /**
+     * The total star rating of the beatmap.
+     */
+    total = 0;
+    /**
+     * The map statistics of the beatmap after modifications are applied.
+     */
+    stats = new osuBase.MapStats();
+    /**
+     * The strain peaks of various calculated difficulties.
+     */
+    strainPeaks = {
+        aimWithSliders: [],
+        aimWithoutSliders: [],
+        speed: [],
+        flashlight: [],
+    };
+    /**
+     * Additional data that is used in performance calculation.
+     */
+    attributes = {
+        speedNoteCount: 0,
+        sliderFactor: 1,
+    };
+    sectionLength = 400;
+    /**
+     * Calculates the star rating of the specified beatmap.
+     *
+     * The beatmap is analyzed in chunks of `sectionLength` duration.
+     * For each chunk the highest hitobject strains are added to
+     * a list which is then collapsed into a weighted sum, much
+     * like scores are weighted on a user's profile.
+     *
+     * For subsequent chunks, the initial max strain is calculated
+     * by decaying the previous hitobject's strain until the
+     * beginning of the new chunk.
+     *
+     * The first object doesn't generate a strain
+     * so we begin calculating from the second object.
+     *
+     * Also don't forget to manually add the peak strain for the last
+     * section which would otherwise be ignored.
+     */
+    calculate(params, mode) {
+        const map = (this.map = osuBase.Utils.deepCopy(params.map));
+        const mod = (this.mods = params.mods ?? this.mods);
+        this.stats = new osuBase.MapStats({
+            cs: map.difficulty.cs,
+            ar: map.difficulty.ar,
+            od: map.difficulty.od,
+            hp: map.difficulty.hp,
+            mods: mod,
+            speedMultiplier: params.stats?.speedMultiplier ?? 1,
+            oldStatistics: params.stats?.oldStatistics ?? false,
+        }).calculate({ mode: mode });
+        this.generateDifficultyHitObjects(mode);
+        this.calculateAll();
+        return this;
+    }
+    /**
+     * Generates difficulty hitobjects for this calculator.
+     *
+     * @param mode The gamemode to generate difficulty hitobjects for.
+     */
+    generateDifficultyHitObjects(mode) {
+        this.objects.length = 0;
+        this.objects.push(...new DifficultyHitObjectCreator().generateDifficultyObjects({
+            objects: this.map.hitObjects.objects,
+            circleSize: this.stats.cs,
+            speedMultiplier: this.stats.speedMultiplier,
+            mode: mode,
+            preempt: osuBase.MapStats.arToMS(this.stats.ar),
+        }));
+    }
+    /**
+     * Calculates the skills provided.
+     *
+     * @param skills The skills to calculate.
+     */
+    calculateSkills(...skills) {
+        this.objects.slice(1).forEach((h, i) => {
+            skills.forEach((skill) => {
+                skill.processInternal(h);
+                if (i === this.objects.length - 2) {
+                    // Don't forget to save the last strain peak, which would otherwise be ignored.
+                    skill.saveCurrentPeak();
+                }
+            });
+        });
+    }
+    /**
+     * Calculates the star rating value of a difficulty.
+     *
+     * @param difficulty The difficulty to calculate.
+     */
+    starValue(difficulty) {
+        return Math.sqrt(difficulty) * 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;
+    }
+}
+
+/**
+ * Represents the skill required to properly follow a beatmap's rhythm.
+ */
+class DroidRhythm extends DroidSkill {
+    historyLength = 32;
+    skillMultiplier = 1;
+    reducedSectionCount = 5;
+    reducedSectionBaseline = 0.75;
+    strainDecayBase = 0.3;
+    starsPerDouble = 1.75;
+    rhythmMultiplier;
+    historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
+    currentRhythm = 1;
+    hitWindow;
+    constructor(mods, overallDifficulty) {
+        super(mods);
+        this.hitWindow = new osuBase.OsuHitWindow(overallDifficulty);
+        const odScaling = Math.pow(this.hitWindow.overallDifficulty, 2) / 400;
+        this.rhythmMultiplier =
+            0.75 +
+                (this.hitWindow.overallDifficulty >= 0 ? odScaling : -odScaling);
+    }
+    /**
+     * Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current object.
+     */
+    calculateRhythmBonus(current) {
+        if (current.object instanceof osuBase.Spinner) {
+            return 0;
+        }
+        let previousIslandSize = 0;
+        let rhythmComplexitySum = 0;
+        let islandSize = 1;
+        // Store the ratio of the current start of an island to buff for tighter rhythms.
+        let startRatio = 0;
+        let firstDeltaSwitch = false;
+        let rhythmStart = 0;
+        while (rhythmStart < this.previous.length - 2 &&
+            current.startTime - this.previous[rhythmStart].startTime <
+                this.historyTimeMax) {
+            ++rhythmStart;
+        }
+        for (let i = rhythmStart; i > 0; --i) {
+            // Scale note 0 to 1 from history to now.
+            let currentHistoricalDecay = (this.historyTimeMax -
+                (current.startTime - this.previous[i - 1].startTime)) /
+                this.historyTimeMax;
+            // Either we're limited by time or limited by object count.
+            currentHistoricalDecay = Math.min(currentHistoricalDecay, (this.previous.length - i) / this.previous.length);
+            const currentDelta = this.previous[i - 1].strainTime;
+            const prevDelta = this.previous[i].strainTime;
+            const lastDelta = this.previous[i + 1].strainTime;
+            const currentRatio = 1 +
+                6 *
+                    Math.min(0.5, Math.pow(Math.sin(Math.PI /
+                        (Math.min(prevDelta, currentDelta) /
+                            Math.max(prevDelta, currentDelta))), 2));
+            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) -
+                this.hitWindow.hitWindowFor300() * 0.4) /
+                (this.hitWindow.hitWindowFor300() * 0.4));
+            let effectiveRatio = windowPenalty * currentRatio;
+            if (firstDeltaSwitch) {
+                if (prevDelta <= 1.25 * currentDelta &&
+                    prevDelta * 1.25 >= currentDelta) {
+                    // Island is still progressing, count size.
+                    if (islandSize < 7) {
+                        ++islandSize;
+                    }
+                }
+                else {
+                    if (this.previous[i - 1].object instanceof osuBase.Slider) {
+                        // BPM change is into slider, this is easy acc window.
+                        effectiveRatio /= 8;
+                    }
+                    if (this.previous[i].object instanceof osuBase.Slider) {
+                        // BPM change was from a slider, this is typically easier than circle -> circle.
+                        effectiveRatio /= 4;
+                    }
+                    if (previousIslandSize === islandSize) {
+                        // Repeated island size (ex: triplet -> triplet).
+                        effectiveRatio /= 4;
+                    }
+                    if (previousIslandSize % 2 === islandSize % 2) {
+                        // Repeated island polarity (2 -> 4, 3 -> 5).
+                        effectiveRatio /= 2;
+                    }
+                    if (lastDelta > prevDelta + 10 &&
+                        prevDelta > currentDelta + 10) {
+                        // Previous increase happened a note ago.
+                        // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                        effectiveRatio /= 8;
+                    }
+                    rhythmComplexitySum +=
+                        (((Math.sqrt(effectiveRatio * startRatio) *
+                            currentHistoricalDecay *
+                            Math.sqrt(4 + islandSize)) /
+                            2) *
+                            Math.sqrt(4 + previousIslandSize)) /
+                            2;
+                    startRatio = effectiveRatio;
+                    previousIslandSize = islandSize;
+                    if (prevDelta * 1.25 < currentDelta) {
+                        // We're slowing down, stop counting.
+                        // If we're speeding up, this stays as is and we keep counting island size.
+                        firstDeltaSwitch = false;
+                    }
+                    islandSize = 1;
+                }
+            }
+            else if (prevDelta > 1.25 * currentDelta) {
+                // We want to be speeding up.
+                // Begin counting island until we change speed again.
+                firstDeltaSwitch = true;
+                startRatio = effectiveRatio;
+                islandSize = 1;
+            }
+        }
+        return Math.sqrt(4 + rhythmComplexitySum * this.rhythmMultiplier) / 2;
+    }
+    strainValueAt(current) {
+        this.currentRhythm = this.calculateRhythmBonus(current);
+        this.currentStrain *= this.strainDecay(current.deltaTime);
+        this.currentStrain += this.currentRhythm - 1;
+        return this.currentStrain;
+    }
+    saveToHitObject(current) {
+        current.rhythmStrain = this.currentStrain;
+        current.rhythmMultiplier = this.currentRhythm;
+    }
+}
+
+/**
+ * Represents the skill required to read every object in the map.
+ */
+class DroidVisual extends DroidSkill {
+    historyLength = 4;
+    starsPerDouble = 1.025;
+    reducedSectionCount = 10;
+    reducedSectionBaseline = 0.75;
+    skillMultiplier = 20;
+    strainDecayBase = 0.1;
+    preempt;
+    isHidden;
+    constructor(mods, preempt) {
+        super(mods);
+        this.preempt = preempt;
+        this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueOf(current) {
+        if (current.object instanceof osuBase.Spinner) {
+            return 0;
+        }
+        // Start with base density and give global bonus for Hidden.
+        // Add density caps for sanity.
+        let strain = Math.min(20, Math.pow(current.noteDensity, 2)) /
+            10 /
+            (1 + current.overlappingFactor);
+        if (this.isHidden) {
+            strain +=
+                Math.min(25, Math.pow(current.noteDensity, 1.25)) /
+                    10 /
+                    (1 + current.overlappingFactor / 1.25);
+        }
+        // Give bonus for AR higher than 10.33.
+        if (this.preempt < 400) {
+            strain += Math.pow(400 - this.preempt, 1.3) / 135;
+        }
+        if (current.object instanceof osuBase.Slider) {
+            const scalingFactor = 50 / current.object.radius;
+            // Reward sliders based on velocity.
+            strain +=
+                // Avoid overbuffing extremely fast sliders.
+                Math.min(5, current.velocity * 1.25) *
+                    // Scale with distance travelled to avoid overbuffing fast sliders with short distance.
+                    Math.min(1, current.travelDistance / scalingFactor / 125);
+            let cumulativeStrainTime = 0;
+            // Reward for velocity changes based on last few sliders.
+            for (let i = 0; i < this.previous.length; ++i) {
+                const last = this.previous[i];
+                cumulativeStrainTime += last.strainTime;
+                if (!(last.object instanceof osuBase.Slider)) {
+                    continue;
+                }
+                strain +=
+                    // Avoid overbuffing extremely fast velocity changes.
+                    Math.min(8, 2 * Math.abs(current.velocity - last.velocity)) *
+                        // Scale with distance travelled to avoid overbuffing fast sliders with short distance.
+                        Math.min(1, last.travelDistance / scalingFactor / 100) *
+                        // Scale with cumulative strain time to avoid overbuffing past sliders.
+                        Math.min(1, 300 / cumulativeStrainTime);
+            }
+        }
+        return strain;
+    }
+    strainValueAt(current) {
+        this.currentStrain *= this.strainDecay(current.deltaTime);
+        this.currentStrain +=
+            this.strainValueOf(current) * this.skillMultiplier;
+        return this.currentStrain * (1 + (current.rhythmMultiplier - 1) / 5);
+    }
+    saveToHitObject(current) {
+        current.visualStrain = this.currentStrain;
+    }
+}
+
+/**
+ * Difficulty calculator for osu!droid gamemode.
+ */
+class DroidStarRating extends StarRating {
+    /**
+     * The aim star rating of the beatmap.
+     */
+    aim = 0;
+    /**
+     * The tap star rating of the beatmap.
+     */
+    tap = 0;
+    /**
+     * The rhythm star rating of the beatmap.
+     */
+    rhythm = 0;
+    /**
+     * The flashlight star rating of the beatmap.
+     */
+    flashlight = 0;
+    /**
+     * The visual star rating of the beatmap.
+     */
+    visual = 0;
+    difficultyMultiplier = 0.18;
+    /**
+     * Calculates the star rating of the specified beatmap.
+     *
+     * The beatmap is analyzed in chunks of `sectionLength` duration.
+     * For each chunk the highest hitobject strains are added to
+     * a list which is then collapsed into a weighted sum, much
+     * like scores are weighted on a user's profile.
+     *
+     * For subsequent chunks, the initial max strain is calculated
+     * by decaying the previous hitobject's strain until the
+     * beginning of the new chunk.
+     *
+     * The first object doesn't generate a strain
+     * so we begin calculating from the second object.
+     *
+     * Also don't forget to manually add the peak strain for the last
+     * section which would otherwise be ignored.
+     */
+    calculate(params) {
+        return super.calculate(params, osuBase.modes.droid);
+    }
+    /**
+     * Generates difficulty hitobjects for this calculator.
+     */
+    generateDifficultyHitObjects() {
+        super.generateDifficultyHitObjects(osuBase.modes.droid);
+    }
+    /**
+     * Calculates the aim star rating of the beatmap and stores it in this instance.
+     */
+    calculateAim() {
+        const aimSkill = new DroidAim(this.mods, true);
+        const aimSkillWithoutSliders = new DroidAim(this.mods, false);
+        this.calculateSkills(aimSkill, aimSkillWithoutSliders);
+        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
+    }
+    /**
+     * Calculates the speed star rating of the beatmap and stores it in this instance.
+     */
+    calculateTap() {
+        const tapSkill = new DroidTap(this.mods, this.stats.od);
+        this.calculateSkills(tapSkill);
+        this.postCalculateTap(tapSkill);
+    }
+    /**
+     * Calculates the rhythm star rating of the beatmap and stores it in this instance.
+     */
+    calculateRhythm() {
+        const rhythmSkill = new DroidRhythm(this.mods, this.stats.od);
+        this.calculateSkills(rhythmSkill);
+        this.postCalculateRhythm(rhythmSkill);
+    }
+    /**
+     * Calculates the flashlight star rating of the beatmap and stores it in this instance.
+     */
+    calculateFlashlight() {
+        const flashlightSkill = new DroidFlashlight(this.mods);
+        this.calculateSkills(flashlightSkill);
+        this.postCalculateFlashlight(flashlightSkill);
+    }
+    /**
+     * Calculates the visual star rating of the beatmap and stores it in this instance.
+     */
+    calculateVisual() {
+        const visualSkill = new DroidVisual(this.mods, osuBase.MapStats.arToMS(this.stats.ar));
+        this.calculateSkills(visualSkill);
+        this.postCalculateVisual(visualSkill);
+    }
+    calculateTotal() {
+        const aimPerformanceValue = this.basePerformanceValue(this.aim);
+        const tapPerformanceValue = this.basePerformanceValue(this.tap);
+        const flashlightPerformanceValue = this.mods.some((m) => m instanceof osuBase.ModFlashlight)
+            ? Math.pow(this.flashlight, 2) * 25
+            : 0;
+        const visualPerformanceValue = Math.pow(this.visual, 2) * 25;
+        const basePerformanceValue = Math.pow(Math.pow(aimPerformanceValue, 1.1) +
+            Math.pow(tapPerformanceValue, 1.1) +
+            Math.pow(flashlightPerformanceValue, 1.1) +
+            Math.pow(visualPerformanceValue, 1.1), 1 / 1.1);
+        if (basePerformanceValue > 1e-5) {
+            this.total =
+                Math.cbrt(1.12) *
+                    0.025 *
+                    (Math.cbrt((100000 / Math.pow(2, 1 / 1.1)) * basePerformanceValue) +
+                        4);
+        }
+    }
+    calculateAll() {
+        const skills = this.createSkills();
+        const isRelax = this.mods.some((m) => m instanceof osuBase.ModRelax);
+        this.calculateSkills(...skills);
+        const aimSkill = skills[0];
+        const aimSkillWithoutSliders = skills[1];
+        const rhythmSkill = skills[2];
+        const tapSkill = skills[3];
+        const flashlightSkill = skills[4];
+        const visualSkill = skills[5];
+        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
+        if (!isRelax) {
+            this.postCalculateTap(tapSkill);
+        }
+        else {
+            this.calculateSpeedAttributes();
+        }
+        if (!isRelax) {
+            this.postCalculateRhythm(rhythmSkill);
+        }
+        this.postCalculateFlashlight(flashlightSkill);
+        this.postCalculateVisual(visualSkill);
+        this.calculateTotal();
+    }
+    /**
+     * Returns a string representative of the class.
+     */
+    toString() {
+        return (this.total.toFixed(2) +
+            " stars (" +
+            this.aim.toFixed(2) +
+            " aim, " +
+            this.tap.toFixed(2) +
+            " tap, " +
+            this.rhythm.toFixed(2) +
+            " rhythm, " +
+            this.flashlight.toFixed(2) +
+            " flashlight, " +
+            this.visual.toFixed(2) +
+            " visual)");
+    }
+    /**
+     * Creates skills to be calculated.
+     */
+    createSkills() {
+        return [
+            new DroidAim(this.mods, true),
+            new DroidAim(this.mods, false),
+            // Tap skill depends on rhythm skill, so we put it first
+            new DroidRhythm(this.mods, this.stats.od),
+            new DroidTap(this.mods, this.stats.od),
+            new DroidFlashlight(this.mods),
+            new DroidVisual(this.mods, osuBase.MapStats.arToMS(this.stats.ar)),
+        ];
+    }
+    /**
+     * Called after aim skill calculation.
+     *
+     * @param aimSkill The aim skill that considers sliders.
+     * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
+     */
+    postCalculateAim(aimSkill, aimSkillWithoutSliders) {
+        this.strainPeaks.aimWithSliders = aimSkill.strainPeaks;
+        this.strainPeaks.aimWithoutSliders = aimSkillWithoutSliders.strainPeaks;
+        this.aim = this.starValue(aimSkill.difficultyValue());
+        if (this.aim) {
+            this.attributes.sliderFactor =
+                this.starValue(aimSkillWithoutSliders.difficultyValue()) /
+                    this.aim;
+        }
+    }
+    /**
+     * Called after tap skill calculation.
+     *
+     * @param tapSkill The tap skill.
+     */
+    postCalculateTap(tapSkill) {
+        this.strainPeaks.speed = tapSkill.strainPeaks;
+        this.tap = this.starValue(tapSkill.difficultyValue());
+        this.calculateSpeedAttributes();
+    }
+    /**
+     * Calculates speed-related attributes.
+     */
+    calculateSpeedAttributes() {
+        const objectStrains = this.objects.map((v) => v.tapStrain);
+        const maxStrain = Math.max(...objectStrains);
+        if (maxStrain) {
+            this.attributes.speedNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
+        }
+    }
+    /**
+     * Called after rhythm skill calculation.
+     *
+     * @param rhythmSkill The rhythm skill.
+     */
+    postCalculateRhythm(rhythmSkill) {
+        this.rhythm = this.starValue(rhythmSkill.difficultyValue());
+    }
+    /**
+     * Called after flashlight skill calculation.
+     *
+     * @param flashlightSkill The flashlight skill.
+     */
+    postCalculateFlashlight(flashlightSkill) {
+        this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
+        this.flashlight = this.starValue(flashlightSkill.difficultyValue());
+    }
+    /**
+     * Called after visual skill calculation.
+     *
+     * @param visualSkill The visual skill.
+     */
+    postCalculateVisual(visualSkill) {
+        this.visual = this.starValue(visualSkill.difficultyValue());
+    }
+}
+
+/**
+ * The base class of performance calculators.
+ */
+class PerformanceCalculator {
+    /**
+     * The overall performance value.
+     */
+    total = 0;
+    /**
+     * The calculated accuracy.
+     */
+    computedAccuracy = new osuBase.Accuracy({});
+    /**
+     * The map statistics after applying modifications.
+     */
+    mapStatistics = new osuBase.MapStats();
+    /**
+     * Penalty for combo breaks.
+     */
+    comboPenalty = 0;
+    /**
+     * The amount of misses that are filtered out from sliderbreaks.
+     */
+    effectiveMissCount = 0;
+    /**
+     * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
+     */
+    sliderNerfFactor = 1;
+    /**
+     * Internal calculation method, used to process calculation from implementations.
+     */
+    calculateInternal(params, mode) {
+        this.handleParams(params, mode);
+        this.calculateValues();
+        this.total = this.calculateTotalValue();
+        return this;
+    }
+    /**
+     * 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 parameters for usage in performance calculation.
+     */
+    handleParams(params, mode) {
+        this.stars = params.stars;
+        const maxCombo = this.stars.map.maxCombo;
+        const miss = this.computedAccuracy.nmiss;
+        const combo = params.combo ?? maxCombo - miss;
+        const mod = this.stars.mods;
+        const baseAR = this.stars.map.difficulty.ar;
+        const baseOD = this.stars.map.difficulty.od;
+        // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+        this.comboPenalty = Math.min(Math.pow(combo / maxCombo, 0.8), 1);
+        if (params.accPercent instanceof osuBase.Accuracy) {
+            // Copy into new instance to not modify the original
+            this.computedAccuracy = new osuBase.Accuracy(params.accPercent);
+        }
+        else {
+            this.computedAccuracy = new osuBase.Accuracy({
+                percent: params.accPercent,
+                nobjects: this.stars.objects.length,
+                nmiss: params.miss || 0,
+            });
+        }
+        this.effectiveMissCount = this.calculateEffectiveMissCount(combo, maxCombo, mode);
+        if (this.stars.mods.some((m) => m instanceof osuBase.ModNoFail)) {
+            this.finalMultiplier *= Math.max(0.9, 1 - 0.02 * this.effectiveMissCount);
+        }
+        if (this.stars.mods.some((m) => m instanceof osuBase.ModSpunOut)) {
+            this.finalMultiplier *=
+                1 -
+                    Math.pow(this.stars.map.hitObjects.spinners /
+                        this.stars.objects.length, 0.85);
+        }
+        if (this.stars.mods.some((m) => m instanceof osuBase.ModRelax)) {
+            // 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 +
+                this.computedAccuracy.n50, this.stars.objects.length);
+            this.finalMultiplier *= 0.6;
+        }
+        this.mapStatistics = new osuBase.MapStats({
+            ar: baseAR,
+            od: baseOD,
+            mods: mod,
+        });
+        // We assume 15% of sliders in a beatmap are difficult since there's no way to tell from the performance calculator.
+        const estimateDifficultSliders = this.stars.map.hitObjects.sliders * 0.15;
+        const estimateSliderEndsDropped = osuBase.MathUtils.clamp(Math.min(this.computedAccuracy.n300 +
+            this.computedAccuracy.n50 +
+            this.computedAccuracy.nmiss, maxCombo - combo), 0, estimateDifficultSliders);
+        if (this.stars.map.hitObjects.sliders > 0) {
+            this.sliderNerfFactor =
+                (1 - this.stars.attributes.sliderFactor) *
+                    Math.pow(1 -
+                        estimateSliderEndsDropped /
+                            estimateDifficultSliders, 3) +
+                    this.stars.attributes.sliderFactor;
+        }
+        if (params.stats) {
+            this.mapStatistics.ar = params.stats.ar ?? this.mapStatistics.ar;
+            this.mapStatistics.isForceAR =
+                params.stats.isForceAR ?? this.mapStatistics.isForceAR;
+            this.mapStatistics.speedMultiplier =
+                params.stats.speedMultiplier ??
+                    this.mapStatistics.speedMultiplier;
+            this.mapStatistics.oldStatistics =
+                params.stats.oldStatistics ?? this.mapStatistics.oldStatistics;
+        }
+        this.mapStatistics.calculate({ mode: mode });
+    }
+    /**
+     * Calculates the amount of misses + sliderbreaks from combo.
+     */
+    calculateEffectiveMissCount(combo, maxCombo, mode) {
+        let comboBasedMissCount = 0;
+        if (this.stars.map.hitObjects.sliders > 0) {
+            const fullComboThreshold = maxCombo - 0.1 * this.stars.map.hitObjects.sliders;
+            if (combo < fullComboThreshold) {
+                // We're clamping miss count because since it's derived from combo, it can
+                // be higher than the amount of objects and that breaks some calculations.
+                comboBasedMissCount = Math.min(fullComboThreshold / Math.max(1, combo), this.stars.objects.length);
+            }
+        }
+        return Math.max(this.computedAccuracy.nmiss, mode === osuBase.modes.droid
+            ? comboBasedMissCount
+            : Math.floor(comboBasedMissCount));
+    }
+}
+
+/**
+ * A performance points calculator that calculates performance points for osu!droid gamemode.
+ */
+class DroidPerformanceCalculator extends PerformanceCalculator {
+    stars = new DroidStarRating();
+    finalMultiplier = 1.24;
+    /**
+     * The aim performance value.
+     */
+    aim = 0;
+    /**
+     * The tap performance value.
+     */
+    tap = 0;
+    /**
+     * The accuracy performance value.
+     */
+    accuracy = 0;
+    /**
+     * The flashlight performance value.
+     */
+    flashlight = 0;
+    /**
+     * The visual performance value.
+     */
+    visual = 0;
+    tapPenalty = 1;
+    calculate(params) {
+        this.tapPenalty = params.tapPenalty ?? 1;
+        return this.calculateInternal(params, osuBase.modes.droid);
+    }
+    calculateValues() {
+        this.calculateAimValue();
+        this.calculateTapValue();
+        this.calculateAccuracyValue();
+        this.calculateFlashlightValue();
+        this.calculateVisualValue();
+        // Apply tap penalty for penalized plays.
+        this.tap /= this.tapPenalty;
+    }
+    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.visual, 1.1), 1 / 1.1) * this.finalMultiplier);
+    }
+    /**
+     * Calculates the aim performance value of the beatmap.
+     */
+    calculateAimValue() {
+        // Global variables
+        const objectCount = this.stars.objects.length;
+        this.aim = this.baseValue(Math.pow(this.stars.aim, 0.8));
+        if (this.effectiveMissCount > 0) {
+            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+            this.aim *=
+                0.97 *
+                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), this.effectiveMissCount);
+        }
+        // Combo scaling
+        this.aim *= this.comboPenalty;
+        // Scale the aim value with slider factor to nerf very likely dropped sliderends.
+        this.aim *= this.sliderNerfFactor;
+        // Scale the aim value with accuracy.
+        this.aim *= this.computedAccuracy.value(objectCount);
+        // It is also important to consider accuracy difficulty when doing that.
+        const odScaling = Math.pow(this.mapStatistics.od, 2) / 2500;
+        this.aim *=
+            0.98 + (this.mapStatistics.od >= 0 ? odScaling : -odScaling);
+    }
+    /**
+     * Calculates the tap performance value of the beatmap.
+     */
+    calculateTapValue() {
+        // Global variables
+        const objectCount = this.stars.objects.length;
+        this.tap = this.baseValue(this.stars.tap);
+        if (this.effectiveMissCount > 0) {
+            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+            this.tap *=
+                0.97 *
+                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), Math.pow(this.effectiveMissCount, 0.875));
+        }
+        // Combo scaling
+        this.tap *= this.comboPenalty;
+        // Calculate accuracy assuming the worst case scenario.
+        const countGreat = this.computedAccuracy.n300;
+        const countOk = this.computedAccuracy.n100;
+        const countMeh = this.computedAccuracy.n50;
+        const relevantTotalDiff = objectCount - this.stars.attributes.speedNoteCount;
+        const relevantAccuracy = new osuBase.Accuracy({
+            n300: Math.max(0, countGreat - relevantTotalDiff),
+            n100: Math.max(0, countOk - Math.max(0, relevantTotalDiff - countGreat)),
+            n50: Math.max(0, countMeh - Math.max(0, relevantTotalDiff - countGreat - countOk)),
+            nmiss: this.effectiveMissCount,
+        });
+        // Scale the speed value with accuracy and OD.
+        const od = this.mapStatistics.od;
+        const odScaling = Math.pow(od, 2) / 750;
+        this.tap *=
+            (0.95 + (od > 0 ? odScaling : -odScaling)) *
+                Math.pow((this.computedAccuracy.value(objectCount) +
+                    relevantAccuracy.value(this.stars.attributes.speedNoteCount)) /
+                    2, (14 - Math.max(od, 2.5)) / 2);
+        // Scale the speed value with # of 50s to punish doubletapping.
+        this.tap *= Math.pow(0.98, Math.max(0, this.computedAccuracy.n50 - objectCount / 500));
+    }
+    /**
+     * Calculates the accuracy performance value of the beatmap.
+     */
+    calculateAccuracyValue() {
+        if (this.stars.mods.some((m) => m instanceof osuBase.ModRelax)) {
+            return;
+        }
+        // Global variables
+        const objectCount = this.stars.objects.length;
+        const ncircles = this.stars.mods.some((m) => m instanceof osuBase.ModScoreV2)
+            ? objectCount - this.stars.map.hitObjects.spinners
+            : this.stars.map.hitObjects.circles;
+        if (ncircles === 0) {
+            return;
+        }
+        const realAccuracy = new osuBase.Accuracy({
+            ...this.computedAccuracy,
+            n300: this.computedAccuracy.n300 - (objectCount - ncircles),
+        });
+        // Lots of arbitrary values from testing.
+        // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
+        this.accuracy =
+            Math.pow(1.4, this.mapStatistics.od) *
+                Math.pow(realAccuracy.value(ncircles), 12) *
+                10;
+        // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
+        this.accuracy *= Math.min(1.15, Math.pow(ncircles / 1000, 0.3));
+        // Scale the accuracy value with rhythm complexity.
+        this.accuracy *= 1.5 / (1 + Math.exp(-(this.stars.rhythm - 1) / 2));
+        if (this.stars.mods.some((m) => m instanceof osuBase.ModHidden)) {
+            this.accuracy *= 1.08;
+        }
+        if (this.stars.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            this.accuracy *= 1.02;
+        }
+    }
+    /**
+     * Calculates the flashlight performance value of the beatmap.
+     */
+    calculateFlashlightValue() {
+        if (!this.stars.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            return;
+        }
+        // Global variables
+        const objectCount = this.stars.objects.length;
+        this.flashlight =
+            Math.pow(Math.pow(this.stars.flashlight, 0.8), 2) * 25;
+        // Add an additional bonus for HDFL.
+        if (this.stars.mods.some((m) => m instanceof osuBase.ModHidden)) {
+            this.flashlight *= 1.3;
+        }
+        // Combo scaling
+        this.flashlight *= this.comboPenalty;
+        if (this.effectiveMissCount > 0) {
+            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+            this.flashlight *=
+                0.97 *
+                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), Math.pow(this.effectiveMissCount, 0.875));
+        }
+        // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
+        this.flashlight *=
+            0.7 +
+                0.1 * Math.min(1, objectCount / 200) +
+                (objectCount > 200
+                    ? 0.2 * Math.min(1, (objectCount - 200) / 200)
+                    : 0);
+        // Scale the flashlight value with accuracy slightly.
+        this.flashlight *= 0.5 + this.computedAccuracy.value(objectCount) / 2;
+        // It is also important to consider accuracy difficulty when doing that.
+        const odScaling = Math.pow(this.mapStatistics.od, 2) / 2500;
+        this.flashlight *=
+            0.98 + (this.mapStatistics.od >= 0 ? odScaling : -odScaling);
+    }
+    /**
+     * Calculates the visual performance value of the beatmap.
+     */
+    calculateVisualValue() {
+        // Global variables
+        const objectCount = this.stars.objects.length;
+        this.visual = Math.pow(Math.pow(this.stars.visual, 0.8), 2) * 25;
+        if (this.effectiveMissCount > 0) {
+            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+            this.visual *=
+                0.97 *
+                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), this.effectiveMissCount);
+        }
+        // Combo scaling
+        this.visual *= this.comboPenalty;
+        // Scale the visual value with object count to penalize short maps.
+        this.visual *= Math.min(1, 1.650668 +
+            (0.4845796 - 1.650668) /
+                (1 + Math.pow(objectCount / 817.9306, 1.147469)));
+        // Scale the visual value with accuracy harshly.
+        this.visual *= Math.pow(this.computedAccuracy.value(), 8);
+        // It is also important to consider accuracy difficulty when doing that.
+        const odScaling = Math.pow(this.mapStatistics.od, 2) / 2500;
+        this.visual *=
+            0.98 + (this.mapStatistics.od >= 0 ? odScaling : -odScaling);
+    }
+    toString() {
+        return (this.total.toFixed(2) +
+            " pp (" +
+            this.aim.toFixed(2) +
+            " aim, " +
+            this.tap.toFixed(2) +
+            " tap, " +
+            this.accuracy.toFixed(2) +
+            " acc, " +
+            this.flashlight.toFixed(2) +
+            " flashlight, " +
+            this.visual.toFixed(2) +
+            " visual)");
+    }
+}
+
+/**
+ * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
+ * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
+ */
+class OsuSkill extends StrainSkill {
+    difficultyValue() {
+        const sortedStrains = this.strainPeaks
+            .slice()
+            .sort((a, b) => {
+            return b - a;
+        });
+        // We are reducing the highest strains first to account for extreme difficulty spikes.
+        for (let i = 0; i < Math.min(sortedStrains.length, this.reducedSectionCount); ++i) {
+            const scale = Math.log10(osuBase.Interpolation.lerp(1, 10, osuBase.MathUtils.clamp(i / this.reducedSectionCount, 0, 1)));
+            sortedStrains[i] *= osuBase.Interpolation.lerp(this.reducedSectionBaseline, 1, scale);
+        }
+        // Difficulty is the weighted sum of the highest strains from every section.
+        // We're sorting from highest to lowest strain.
+        sortedStrains.sort((a, b) => {
+            return b - a;
+        });
+        let difficulty = 0;
+        let weight = 1;
+        for (const strain of sortedStrains) {
+            const addition = strain * weight;
+            if (difficulty + addition === difficulty) {
+                break;
+            }
+            difficulty += addition;
+            weight *= this.decayWeight;
+        }
+        return difficulty * this.difficultyMultiplier;
+    }
+}
+
+/**
+ * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
+ */
+class OsuAim extends OsuSkill {
+    skillMultiplier = 23.25;
+    strainDecayBase = 0.15;
+    reducedSectionCount = 10;
+    reducedSectionBaseline = 0.75;
+    difficultyMultiplier = 1.06;
+    decayWeight = 0.9;
+    wideAngleMultiplier = 1.5;
+    acuteAngleMultiplier = 2;
+    sliderMultiplier = 1.5;
+    velocityChangeMultiplier = 0.75;
+    withSliders;
+    constructor(mods, withSliders) {
+        super(mods);
+        this.withSliders = withSliders;
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueOf(current) {
+        if (current.object instanceof osuBase.Spinner ||
+            this.previous.length <= 1 ||
+            this.previous[0].object instanceof osuBase.Spinner) {
+            return 0;
+        }
+        const last = this.previous[0];
+        const lastLast = this.previous[1];
+        // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
+        let currentVelocity = current.lazyJumpDistance / current.strainTime;
+        // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
+        if (last.object instanceof osuBase.Slider && this.withSliders) {
+            // Calculate the slider velocity from slider head to slider end.
+            const travelVelocity = last.travelDistance / last.travelTime;
+            // Calculate the movement velocity from slider end to current object.
+            const movementVelocity = current.minimumJumpDistance / current.minimumJumpTime;
+            // Take the larger total combined velocity.
+            currentVelocity = Math.max(currentVelocity, movementVelocity + travelVelocity);
+        }
+        // As above, do the same for the previous hitobject.
+        let prevVelocity = last.lazyJumpDistance / last.strainTime;
+        if (lastLast.object instanceof osuBase.Slider && this.withSliders) {
+            const travelVelocity = lastLast.travelDistance / lastLast.travelTime;
+            const movementVelocity = last.minimumJumpDistance / last.minimumJumpTime;
+            prevVelocity = Math.max(prevVelocity, movementVelocity + travelVelocity);
+        }
+        let wideAngleBonus = 0;
+        let acuteAngleBonus = 0;
+        let sliderBonus = 0;
+        let velocityChangeBonus = 0;
+        // Start strain with regular velocity.
+        let strain = currentVelocity;
+        if (Math.max(current.strainTime, last.strainTime) <
+            1.25 * Math.min(current.strainTime, last.strainTime)) {
+            // If rhythms are the same.
+            if (current.angle !== null &&
+                last.angle !== null &&
+                lastLast.angle !== null) {
+                // Rewarding angles, take the smaller velocity as base.
+                const angleBonus = Math.min(currentVelocity, prevVelocity);
+                wideAngleBonus = this.calculateWideAngleBonus(current.angle);
+                acuteAngleBonus = this.calculateAcuteAngleBonus(current.angle);
+                // Only buff deltaTime exceeding 300 BPM 1/2.
+                if (current.strainTime > 100) {
+                    acuteAngleBonus = 0;
+                }
+                else {
+                    acuteAngleBonus *=
+                        // Multiply by previous angle, we don't want to buff unless this is a wiggle type pattern.
+                        this.calculateAcuteAngleBonus(last.angle) *
+                            // The maximum velocity we buff is equal to 125 / strainTime.
+                            Math.min(angleBonus, 125 / current.strainTime) *
+                            // Scale buff from 300 BPM 1/2 to 400 BPM 1/2.
+                            Math.pow(Math.sin((Math.PI / 2) *
+                                Math.min(1, (100 - current.strainTime) / 25)), 2) *
+                            // Buff distance exceeding 50 (radius) up to 100 (diameter).
+                            Math.pow(Math.sin(((Math.PI / 2) *
+                                (osuBase.MathUtils.clamp(current.lazyJumpDistance, 50, 100) -
+                                    50)) /
+                                50), 2);
+                }
+                // Penalize wide angles if they're repeated, reducing the penalty as last.angle gets more acute.
+                wideAngleBonus *=
+                    angleBonus *
+                        (1 -
+                            Math.min(wideAngleBonus, Math.pow(this.calculateWideAngleBonus(last.angle), 3)));
+                // Penalize acute angles if they're repeated, reducing the penalty as lastLast.angle gets more obtuse.
+                acuteAngleBonus *=
+                    0.5 +
+                        0.5 *
+                            (1 -
+                                Math.min(acuteAngleBonus, Math.pow(this.calculateAcuteAngleBonus(lastLast.angle), 3)));
+            }
+        }
+        if (Math.max(prevVelocity, currentVelocity)) {
+            // We want to use the average velocity over the whole object when awarding differences, not the individual jump and slider path velocities.
+            prevVelocity =
+                (last.lazyJumpDistance + lastLast.travelDistance) /
+                    last.strainTime;
+            currentVelocity =
+                (current.lazyJumpDistance + last.travelDistance) /
+                    current.strainTime;
+            // Scale with ratio of difference compared to half the max distance.
+            const distanceRatio = Math.pow(Math.sin(((Math.PI / 2) * Math.abs(prevVelocity - currentVelocity)) /
+                Math.max(prevVelocity, currentVelocity)), 2);
+            // 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));
+            // Reward for % distance slowed down compared to previous, paying attention to not award overlap.
+            const nonOverlapVelocityBuff = Math.abs(prevVelocity - currentVelocity) *
+                // Do not award overlap.
+                Math.pow(Math.sin((Math.PI / 2) *
+                    Math.min(1, Math.min(current.lazyJumpDistance, last.lazyJumpDistance) / 100)), 2);
+            // Choose the largest bonus, multiplied by ratio.
+            velocityChangeBonus =
+                Math.max(overlapVelocityBuff, nonOverlapVelocityBuff) *
+                    distanceRatio;
+            // Penalize for rhythm changes.
+            velocityChangeBonus *= Math.pow(Math.min(current.strainTime, last.strainTime) /
+                Math.max(current.strainTime, last.strainTime), 2);
+        }
+        if (last.travelTime) {
+            // Reward sliders based on velocity.
+            sliderBonus = last.travelDistance / last.travelTime;
+        }
+        // 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);
+        // Add in additional slider velocity bonus.
+        if (this.withSliders) {
+            strain += sliderBonus * this.sliderMultiplier;
+        }
+        return strain;
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueAt(current) {
+        this.currentStrain *= this.strainDecay(current.deltaTime);
+        this.currentStrain +=
+            this.strainValueOf(current) * this.skillMultiplier;
+        return this.currentStrain;
+    }
+    /**
+     * @param current The hitobject to save to.
+     */
+    saveToHitObject(current) {
+        current.aimStrainWithSliders = this.currentStrain;
+    }
+    /**
+     * Calculates the bonus of wide angles.
+     */
+    calculateWideAngleBonus(angle) {
+        return Math.pow(Math.sin((3 / 4) *
+            (Math.min((5 / 6) * Math.PI, Math.max(Math.PI / 6, angle)) -
+                Math.PI / 6)), 2);
+    }
+    /**
+     * Calculates the bonus of acute angles.
+     */
+    calculateAcuteAngleBonus(angle) {
+        return 1 - this.calculateWideAngleBonus(angle);
+    }
+}
+
+/**
+ * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
+ */
+class OsuSpeed extends OsuSkill {
+    /**
+     * Spacing threshold for a single hitobject spacing.
+     */
+    SINGLE_SPACING_THRESHOLD = 125;
+    historyLength = 32;
+    skillMultiplier = 1375;
+    strainDecayBase = 0.3;
+    reducedSectionCount = 5;
+    reducedSectionBaseline = 0.75;
+    difficultyMultiplier = 1.04;
+    decayWeight = 0.9;
+    rhythmMultiplier = 0.75;
+    historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
+    currentSpeedStrain = 0;
+    currentRhythm = 0;
+    // ~200 1/4 BPM streams
+    minSpeedBonus = 75;
+    greatWindow;
+    constructor(mods, greatWindow) {
+        super(mods);
+        this.greatWindow = greatWindow;
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueOf(current) {
+        if (current.object instanceof osuBase.Spinner) {
+            return 0;
+        }
+        let strainTime = current.strainTime;
+        const greatWindowFull = this.greatWindow * 2;
+        const speedWindowRatio = strainTime / greatWindowFull;
+        // Aim to nerf cheesy rhythms (very fast consecutive doubles with large deltatimes between).
+        if (this.previous[0] &&
+            strainTime < greatWindowFull &&
+            this.previous[0].strainTime > strainTime) {
+            strainTime = osuBase.Interpolation.lerp(this.previous[0].strainTime, strainTime, speedWindowRatio);
+        }
+        // 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 / greatWindowFull / 0.93, 0.92, 1);
+        let speedBonus = 1;
+        if (strainTime < this.minSpeedBonus) {
+            speedBonus +=
+                0.75 * Math.pow((this.minSpeedBonus - strainTime) / 40, 2);
+        }
+        const travelDistance = this.previous[0]?.travelDistance ?? 0;
+        const distance = Math.min(this.SINGLE_SPACING_THRESHOLD, travelDistance + current.lazyJumpDistance);
+        return ((speedBonus +
+            speedBonus *
+                Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 3.5)) /
+            strainTime);
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueAt(current) {
+        this.currentSpeedStrain *= this.strainDecay(current.deltaTime);
+        this.currentSpeedStrain +=
+            this.strainValueOf(current) * this.skillMultiplier;
+        this.currentRhythm = this.calculateRhythmBonus(current);
+        return this.currentSpeedStrain * this.currentRhythm;
+    }
+    /**
+     * Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current object.
+     */
+    calculateRhythmBonus(current) {
+        if (current.object instanceof osuBase.Spinner) {
+            return 0;
+        }
+        let previousIslandSize = 0;
+        let rhythmComplexitySum = 0;
+        let islandSize = 1;
+        // Store the ratio of the current start of an island to buff for tighter rhythms.
+        let startRatio = 0;
+        let firstDeltaSwitch = false;
+        let rhythmStart = 0;
+        while (rhythmStart < this.previous.length - 2 &&
+            current.startTime - this.previous[rhythmStart].startTime <
+                this.historyTimeMax) {
+            ++rhythmStart;
+        }
+        for (let i = rhythmStart; i > 0; --i) {
+            // Scale note 0 to 1 from history to now.
+            let currentHistoricalDecay = (this.historyTimeMax -
+                (current.startTime - this.previous[i - 1].startTime)) /
+                this.historyTimeMax;
+            // Either we're limited by time or limited by object count.
+            currentHistoricalDecay = Math.min(currentHistoricalDecay, (this.previous.length - i) / this.previous.length);
+            const currentDelta = this.previous[i - 1].strainTime;
+            const prevDelta = this.previous[i].strainTime;
+            const lastDelta = this.previous[i + 1].strainTime;
+            const currentRatio = 1 +
+                6 *
+                    Math.min(0.5, Math.pow(Math.sin(Math.PI /
+                        (Math.min(prevDelta, currentDelta) /
+                            Math.max(prevDelta, currentDelta))), 2));
+            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - this.greatWindow * 0.6) /
+                (this.greatWindow * 0.6));
+            let effectiveRatio = windowPenalty * currentRatio;
+            if (firstDeltaSwitch) {
+                if (prevDelta <= 1.25 * currentDelta &&
+                    prevDelta * 1.25 >= currentDelta) {
+                    // Island is still progressing, count size.
+                    if (islandSize < 7) {
+                        ++islandSize;
+                    }
+                }
+                else {
+                    if (this.previous[i - 1].object instanceof osuBase.Slider) {
+                        // BPM change is into slider, this is easy acc window.
+                        effectiveRatio /= 8;
+                    }
+                    if (this.previous[i].object instanceof osuBase.Slider) {
+                        // BPM change was from a slider, this is typically easier than circle -> circle.
+                        effectiveRatio /= 4;
+                    }
+                    if (previousIslandSize === islandSize) {
+                        // Repeated island size (ex: triplet -> triplet).
+                        effectiveRatio /= 4;
+                    }
+                    if (previousIslandSize % 2 === islandSize % 2) {
+                        // Repeated island polarity (2 -> 4, 3 -> 5).
+                        effectiveRatio /= 2;
+                    }
+                    if (lastDelta > prevDelta + 10 &&
+                        prevDelta > currentDelta + 10) {
+                        // Previous increase happened a note ago.
+                        // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                        effectiveRatio /= 8;
+                    }
+                    rhythmComplexitySum +=
+                        (((Math.sqrt(effectiveRatio * startRatio) *
+                            currentHistoricalDecay *
+                            Math.sqrt(4 + islandSize)) /
+                            2) *
+                            Math.sqrt(4 + previousIslandSize)) /
+                            2;
+                    startRatio = effectiveRatio;
+                    previousIslandSize = islandSize;
+                    if (prevDelta * 1.25 < currentDelta) {
+                        // We're slowing down, stop counting.
+                        // If we're speeding up, this stays as is and we keep counting island size.
+                        firstDeltaSwitch = false;
+                    }
+                    islandSize = 1;
+                }
+            }
+            else if (prevDelta > 1.25 * currentDelta) {
+                // We want to be speeding up.
+                // Begin counting island until we change speed again.
+                firstDeltaSwitch = true;
+                startRatio = effectiveRatio;
+                islandSize = 1;
+            }
+        }
+        return Math.sqrt(4 + rhythmComplexitySum * this.rhythmMultiplier) / 2;
+    }
+    /**
+     * @param current The hitobject to save to.
+     */
+    saveToHitObject(current) {
+        current.tapStrain = this.currentStrain;
+        current.rhythmMultiplier = this.currentRhythm;
+    }
+}
+
+/**
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ */
+class OsuFlashlight extends OsuSkill {
+    historyLength = 10;
+    skillMultiplier = 0.15;
+    strainDecayBase = 0.15;
+    reducedSectionCount = 10;
+    reducedSectionBaseline = 0.75;
+    difficultyMultiplier = 1.06;
+    decayWeight = 1;
+    strainValueOf(current) {
+        if (current.object instanceof osuBase.Spinner) {
+            return 0;
+        }
+        const scalingFactor = 52 / current.object.radius;
+        let smallDistNerf = 1;
+        let cumulativeStrainTime = 0;
+        let result = 0;
+        for (let i = 0; i < this.previous.length; ++i) {
+            const previous = this.previous[i];
+            if (previous.object instanceof osuBase.Spinner) {
+                continue;
+            }
+            const jumpDistance = current.object.stackedPosition.subtract(previous.object.endPosition).length;
+            cumulativeStrainTime += previous.strainTime;
+            // 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, previous.lazyJumpDistance / scalingFactor / 25);
+            result +=
+                (Math.pow(0.8, i) * stackNerf * scalingFactor * jumpDistance) /
+                    cumulativeStrainTime;
+        }
+        return Math.pow(smallDistNerf * result, 2);
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueAt(current) {
+        this.currentStrain *= this.strainDecay(current.deltaTime);
+        this.currentStrain +=
+            this.strainValueOf(current) * this.skillMultiplier;
+        return this.currentStrain;
+    }
+    saveToHitObject(current) {
+        current.flashlightStrain = this.currentStrain;
+    }
+}
+
+/**
+ * Difficulty calculator for osu!standard gamemode.
+ */
+class OsuStarRating extends StarRating {
+    /**
+     * The aim star rating of the beatmap.
+     */
+    aim = 0;
+    /**
+     * The speed star rating of the beatmap.
+     */
+    speed = 0;
+    /**
+     * The flashlight star rating of the beatmap.
+     */
+    flashlight = 0;
+    difficultyMultiplier = 0.0675;
+    calculate(params) {
+        return super.calculate(params, osuBase.modes.osu);
+    }
+    /**
+     * Generates difficulty hitobjects for this calculator.
+     */
+    generateDifficultyHitObjects() {
+        super.generateDifficultyHitObjects(osuBase.modes.osu);
+    }
+    /**
+     * Calculates the aim star rating of the beatmap and stores it in this instance.
+     */
+    calculateAim() {
+        const aimSkill = new OsuAim(this.mods, true);
+        const aimSkillWithoutSliders = new OsuAim(this.mods, false);
+        this.calculateSkills(aimSkill, aimSkillWithoutSliders);
+        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
+    }
+    /**
+     * Calculates the speed star rating of the beatmap and stores it in this instance.
+     */
+    calculateSpeed() {
+        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
+            return;
+        }
+        const speedSkill = new OsuSpeed(this.mods, new osuBase.OsuHitWindow(this.stats.od).hitWindowFor300());
+        this.calculateSkills(speedSkill);
+        this.postCalculateSpeed(speedSkill);
+    }
+    /**
+     * Calculates the flashlight star rating of the beatmap and stores it in this instance.
+     */
+    calculateFlashlight() {
+        const flashlightSkill = new OsuFlashlight(this.mods);
+        this.calculateSkills(flashlightSkill);
+        this.postCalculateFlashlight(flashlightSkill);
+    }
+    calculateTotal() {
+        const aimPerformanceValue = this.basePerformanceValue(this.aim);
+        const speedPerformanceValue = this.basePerformanceValue(this.speed);
+        let flashlightPerformanceValue = 0;
+        if (this.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            flashlightPerformanceValue = Math.pow(this.flashlight, 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) {
+            this.total =
+                Math.cbrt(1.12) *
+                    0.027 *
+                    (Math.cbrt((100000 / Math.pow(2, 1 / 1.1)) * basePerformanceValue) +
+                        4);
+        }
+    }
+    calculateAll() {
+        const skills = this.createSkills();
+        const isRelax = this.mods.some((m) => m instanceof osuBase.ModRelax);
+        this.calculateSkills(...skills);
+        const aimSkill = skills[0];
+        const aimSkillWithoutSliders = skills[1];
+        let speedSkill;
+        let flashlightSkill;
+        if (isRelax) {
+            flashlightSkill = skills[2];
+        }
+        else {
+            speedSkill = skills[2];
+            flashlightSkill = skills[3];
+        }
+        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
+        if (speedSkill) {
+            this.postCalculateSpeed(speedSkill);
+        }
+        this.postCalculateFlashlight(flashlightSkill);
+        this.calculateTotal();
+    }
+    /**
+     * Returns a string representative of the class.
+     */
+    toString() {
+        return (this.total.toFixed(2) +
+            " stars (" +
+            this.aim.toFixed(2) +
+            " aim, " +
+            this.speed.toFixed(2) +
+            " speed, " +
+            this.flashlight.toFixed(2) +
+            " flashlight)");
+    }
+    /**
+     * Creates skills to be calculated.
+     */
+    createSkills() {
+        return [
+            new OsuAim(this.mods, true),
+            new OsuAim(this.mods, false),
+            new OsuSpeed(this.mods, new osuBase.OsuHitWindow(this.stats.od).hitWindowFor300()),
+            new OsuFlashlight(this.mods),
+        ];
+    }
+    /**
+     * Called after aim skill calculation.
+     *
+     * @param aimSkill The aim skill that considers sliders.
+     * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
+     */
+    postCalculateAim(aimSkill, aimSkillWithoutSliders) {
+        this.strainPeaks.aimWithSliders = aimSkill.strainPeaks;
+        this.strainPeaks.aimWithoutSliders = aimSkillWithoutSliders.strainPeaks;
+        this.aim = this.starValue(aimSkill.difficultyValue());
+        if (this.aim) {
+            this.attributes.sliderFactor =
+                this.starValue(aimSkillWithoutSliders.difficultyValue()) /
+                    this.aim;
+        }
+    }
+    /**
+     * Called after speed skill calculation.
+     *
+     * @param speedSkill The speed skill.
+     */
+    postCalculateSpeed(speedSkill) {
+        this.strainPeaks.speed = speedSkill.strainPeaks;
+        this.speed = this.starValue(speedSkill.difficultyValue());
+    }
+    /**
+     * Called after flashlight skill calculation.
+     *
+     * @param flashlightSkill The flashlight skill.
+     */
+    postCalculateFlashlight(flashlightSkill) {
+        this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
+        this.flashlight = this.starValue(flashlightSkill.difficultyValue());
+    }
+}
+
+/**
+ * A star rating calculator that configures which mode to calculate difficulty for and what mods are applied.
+ */
+class MapStars {
+    /**
+     * The osu!droid star rating of the beatmap.
+     */
+    droidStars = new DroidStarRating();
+    /**
+     * The osu!standard star rating of the beatmap.
+     */
+    pcStars = new OsuStarRating();
+    /**
+     * Calculates the star rating of a beatmap.
+     */
+    calculate(params) {
+        const mod = params.mods ?? [];
+        const stats = new osuBase.MapStats({
+            speedMultiplier: params.stats?.speedMultiplier ?? 1,
+            isForceAR: params.stats?.isForceAR ?? false,
+            oldStatistics: params.stats?.oldStatistics ?? false,
+        });
+        this.droidStars.calculate({
+            map: params.map,
+            mods: mod,
+            stats,
+        });
+        this.pcStars.calculate({
+            map: params.map,
+            mods: mod,
+            stats,
+        });
+        return this;
+    }
+    /**
+     * Returns a string representative of the class.
+     */
+    toString() {
+        return `${this.droidStars.toString()}\n${this.pcStars.toString()}`;
+    }
+}
+
+/**
+ * A performance points calculator that calculates performance points for osu!standard gamemode.
+ */
+class OsuPerformanceCalculator extends PerformanceCalculator {
+    stars = new OsuStarRating();
+    finalMultiplier = 1.12;
+    /**
+     * The aim performance value.
+     */
+    aim = 0;
+    /**
+     * The speed performance value.
+     */
+    speed = 0;
+    /**
+     * The accuracy performance value.
+     */
+    accuracy = 0;
+    /**
+     * The flashlight performance value.
+     */
+    flashlight = 0;
+    calculate(params) {
+        return this.calculateInternal(params, osuBase.modes.osu);
+    }
+    calculateValues() {
+        this.calculateAimValue();
+        this.calculateSpeedValue();
+        this.calculateAccuracyValue();
+        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);
+    }
+    /**
+     * Calculates the aim performance value of the beatmap.
+     */
+    calculateAimValue() {
+        // Global variables
+        const objectCount = this.stars.objects.length;
+        const calculatedAR = this.mapStatistics.ar;
+        this.aim = this.baseValue(Math.pow(this.stars.aim, this.stars.mods.some((m) => m instanceof osuBase.ModTouchDevice)
+            ? 0.8
+            : 1));
+        // Longer maps are worth more
+        let lengthBonus = 0.95 + 0.4 * Math.min(1, objectCount / 2000);
+        if (objectCount > 2000) {
+            lengthBonus += Math.log10(objectCount / 2000) * 0.5;
+        }
+        this.aim *= 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.
+            this.aim *=
+                0.97 *
+                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), this.effectiveMissCount);
+        }
+        // Combo scaling
+        this.aim *= this.comboPenalty;
+        // AR scaling
+        let arFactor = 0;
+        if (calculatedAR > 10.33) {
+            arFactor += 0.3 * (calculatedAR - 10.33);
+        }
+        else if (calculatedAR < 8) {
+            arFactor += 0.1 * (8 - calculatedAR);
+        }
+        // Buff for longer maps with high AR.
+        this.aim *= 1 + arFactor * lengthBonus;
+        // 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.stars.mods.some((m) => m instanceof osuBase.ModHidden)) {
+            this.aim *= 1 + 0.04 * (12 - calculatedAR);
+        }
+        // Scale the aim value with slider factor to nerf very likely dropped sliderends.
+        this.aim *= this.sliderNerfFactor;
+        // Scale the aim value with accuracy.
+        this.aim *= this.computedAccuracy.value(objectCount);
+        // It is also important to consider accuracy difficulty when doing that.
+        const odScaling = Math.pow(this.mapStatistics.od, 2) / 2500;
+        this.aim *= 0.98 + odScaling;
+    }
+    /**
+     * Calculates the speed performance value of the beatmap.
+     */
+    calculateSpeedValue() {
+        // Global variables
+        const objectCount = this.stars.objects.length;
+        const calculatedAR = this.mapStatistics.ar;
+        const n50 = this.computedAccuracy.n50;
+        this.speed = this.baseValue(this.stars.speed);
+        // Longer maps are worth more
+        let lengthBonus = 0.95 + 0.4 * Math.min(1, objectCount / 2000);
+        if (objectCount > 2000) {
+            lengthBonus += Math.log10(objectCount / 2000) * 0.5;
+        }
+        this.speed *= 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.
+            this.speed *=
+                0.97 *
+                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), Math.pow(this.effectiveMissCount, 0.875));
+        }
+        // Combo scaling
+        this.speed *= this.comboPenalty;
+        // AR scaling
+        if (calculatedAR > 10.33) {
+            // Buff for longer maps with high AR.
+            this.speed *= 1 + 0.3 * (calculatedAR - 10.33) * lengthBonus;
+        }
+        if (this.stars.mods.some((m) => m instanceof osuBase.ModHidden)) {
+            this.speed *= 1 + 0.04 * (12 - calculatedAR);
+        }
+        // Scale the speed value with accuracy and OD.
+        this.speed *=
+            (0.95 + Math.pow(this.mapStatistics.od, 2) / 750) *
+                Math.pow(this.computedAccuracy.value(objectCount), (14.5 - Math.max(this.mapStatistics.od, 8)) / 2);
+        // Scale the speed value with # of 50s to punish doubletapping.
+        this.speed *= Math.pow(0.98, Math.max(0, n50 - objectCount / 500));
+    }
+    /**
+     * Calculates the accuracy performance value of the beatmap.
+     */
+    calculateAccuracyValue() {
+        if (this.stars.mods.some((m) => m instanceof osuBase.ModRelax)) {
+            return;
+        }
+        // Global variables
+        const nobjects = this.stars.objects.length;
+        const ncircles = this.stars.mods.some((m) => m instanceof osuBase.ModScoreV2)
+            ? nobjects - this.stars.map.hitObjects.spinners
+            : this.stars.map.hitObjects.circles;
+        if (ncircles === 0) {
+            return;
+        }
+        const realAccuracy = new osuBase.Accuracy({
+            ...this.computedAccuracy,
+            n300: this.computedAccuracy.n300 -
+                (this.stars.objects.length - ncircles),
+        });
+        // Lots of arbitrary values from testing.
+        // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
+        this.accuracy =
+            Math.pow(1.52163, this.mapStatistics.od) *
+                Math.pow(realAccuracy.value(ncircles), 24) *
+                2.83;
+        // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
+        this.accuracy *= Math.min(1.15, Math.pow(ncircles / 1000, 0.3));
+        if (this.stars.mods.some((m) => m instanceof osuBase.ModHidden)) {
+            this.accuracy *= 1.08;
+        }
+        if (this.stars.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            this.accuracy *= 1.02;
+        }
+    }
+    /**
+     * Calculates the flashlight performance value of the beatmap.
+     */
+    calculateFlashlightValue() {
+        if (!this.stars.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            return;
+        }
+        // Global variables
+        const objectCount = this.stars.objects.length;
+        this.flashlight =
+            Math.pow(Math.pow(this.stars.flashlight, this.stars.mods.some((m) => m instanceof osuBase.ModTouchDevice)
+                ? 0.8
+                : 1), 2) * 25;
+        // Add an additional bonus for HDFL.
+        if (this.stars.mods.some((m) => m instanceof osuBase.ModHidden)) {
+            this.flashlight *= 1.3;
+        }
+        // Combo scaling
+        this.flashlight *= this.comboPenalty;
+        if (this.effectiveMissCount > 0) {
+            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+            this.flashlight *=
+                0.97 *
+                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), Math.pow(this.effectiveMissCount, 0.875));
+        }
+        // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
+        this.flashlight *=
+            0.7 +
+                0.1 * Math.min(1, objectCount / 200) +
+                (objectCount > 200
+                    ? 0.2 * Math.min(1, (objectCount - 200) / 200)
+                    : 0);
+        // Scale the flashlight value with accuracy slightly.
+        this.flashlight *= 0.5 + this.computedAccuracy.value(objectCount) / 2;
+        // It is also important to consider accuracy difficulty when doing that.
+        const odScaling = Math.pow(this.mapStatistics.od, 2) / 2500;
+        this.flashlight *= 0.98 + odScaling;
+    }
+    toString() {
+        return (this.total.toFixed(2) +
+            " pp (" +
+            this.aim.toFixed(2) +
+            " aim, " +
+            this.speed.toFixed(2) +
+            " speed, " +
+            this.accuracy.toFixed(2) +
+            " acc, " +
+            this.flashlight.toFixed(2) +
+            " flashlight)");
+    }
+}
+
+exports.DifficultyHitObject = DifficultyHitObject;
+exports.DifficultyHitObjectCreator = DifficultyHitObjectCreator;
+exports.DroidAim = DroidAim;
+exports.DroidFlashlight = DroidFlashlight;
+exports.DroidPerformanceCalculator = DroidPerformanceCalculator;
+exports.DroidRhythm = DroidRhythm;
+exports.DroidStarRating = DroidStarRating;
+exports.DroidTap = DroidTap;
+exports.MapStars = MapStars;
+exports.OsuAim = OsuAim;
+exports.OsuFlashlight = OsuFlashlight;
+exports.OsuPerformanceCalculator = OsuPerformanceCalculator;
+exports.OsuSpeed = OsuSpeed;
+exports.OsuStarRating = OsuStarRating;
+exports.PerformanceCalculator = PerformanceCalculator;
+exports.StarRating = StarRating;
+//# sourceMappingURL=index.js.map