@rian8337/osu-difficulty-calculator 4.0.0-beta.8 → 4.0.0-beta.80

package/typings/index.d.ts

@@ -1,43 +1,13 @@
-import { MapStats, Mod, PlaceableHitObject, Modes, Beatmap, HitObject, Accuracy } from '@rian8337/osu-base';
-
-/**
- * An evaluator for calculating aim skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-declare abstract class AimEvaluator {
-    protected static readonly wideAngleMultiplier: number;
-    protected static readonly acuteAngleMultiplier: number;
-    protected static readonly sliderMultiplier: number;
-    protected static readonly velocityChangeMultiplier: number;
-    /**
-     * Calculates the bonus of wide angles.
-     */
-    protected static calculateWideAngleBonus(angle: number): number;
-    /**
-     * Calculates the bonus of acute angles.
-     */
-    protected static calculateAcuteAngleBonus(angle: number): number;
-}
-
-/**
- * The base of calculation options.
- */
-interface CalculationOptions {
-    /**
-     * Custom map statistics to apply custom speed multiplier as well as old statistics.
-     */
-    stats?: MapStats;
-}
+import { ModMap, SerializedMod, PlaceableHitObject, Vector2, Modes, PlayableBeatmap, Mod, Beatmap, DroidPlayableBeatmap, Accuracy, OsuPlayableBeatmap } from '@rian8337/osu-base';
 
 /**
  * Holds data that can be used to calculate performance points.
  */
-interface DifficultyAttributes {
+interface IDifficultyAttributes {
     /**
      * The mods which were applied to the beatmap.
      */
-    mods: Mod[];
+    mods: ModMap;
     /**
      * The combined star rating of all skills.
      */
@@ -72,12 +42,6 @@ interface DifficultyAttributes {
      * The overall clock rate that was applied to the beatmap.
      */
     clockRate: number;
-    /**
-     * The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
-     *
-     * Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
-     */
-    approachRate: number;
     /**
      * The perceived overall difficulty inclusive of rate-adjusting mods (DT/HT/etc), based on osu!standard judgement.
      *
@@ -96,22 +60,61 @@ interface DifficultyAttributes {
      * The number of spinners in the beatmap.
      */
     spinnerCount: number;
+    /**
+     * The number of sliders weighted by difficulty.
+     */
+    aimDifficultSliderCount: number;
+    /**
+     * The amount of strains that are considered difficult with respect to the aim skill.
+     */
+    aimDifficultStrainCount: number;
 }
 
 /**
- * Represents options for difficulty calculation.
+ * Represents difficulty attributes that can be cached.
  */
-interface DifficultyCalculationOptions extends CalculationOptions {
+type CacheableDifficultyAttributes<T extends IDifficultyAttributes> = Omit<T, "mods" | "toCacheableAttributes"> & {
+    /**
+     * The mods which were applied to the beatmap.
+     */
+    mods: SerializedMod[];
+};
+
+/**
+ * Holds data that can be used to calculate performance points.
+ */
+declare abstract class DifficultyAttributes implements IDifficultyAttributes {
+    mods: ModMap;
+    starRating: number;
+    maxCombo: number;
+    aimDifficulty: number;
+    flashlightDifficulty: number;
+    speedNoteCount: number;
+    sliderFactor: number;
+    clockRate: number;
+    overallDifficulty: number;
+    hitCircleCount: number;
+    sliderCount: number;
+    spinnerCount: number;
+    aimDifficultSliderCount: number;
+    aimDifficultStrainCount: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IDifficultyAttributes>);
     /**
-     * The modifications to apply.
+     * Converts this `DifficultyAttributes` instance to an attribute structure that can be cached.
+     *
+     * @returns The cacheable attributes.
      */
-    mods?: Mod[];
+    toCacheableAttributes(): CacheableDifficultyAttributes<this>;
+    /**
+     * Returns a string representation of the difficulty attributes.
+     */
+    toString(): string;
 }
 
 /**
- * Represents an osu!standard hit object with difficulty calculation values.
+ * Represents a hit object with difficulty calculation values.
  */
-declare class DifficultyHitObject {
+declare abstract class DifficultyHitObject {
     /**
      * The underlying hitobject.
      */
@@ -121,19 +124,7 @@ declare class DifficultyHitObject {
      *
      * This is one less than the actual index of the hitobject in the beatmap.
      */
-    index: number;
-    /**
-     * The preempt time of the hitobject.
-     */
-    baseTimePreempt: number;
-    /**
-     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
-     */
-    timePreempt: number;
-    /**
-     * The fade in time of the hitobject.
-     */
-    timeFadeIn: number;
+    readonly index: number;
     /**
      * The aim strain generated by the hitobject if sliders are considered.
      */
@@ -142,41 +133,10 @@ declare class DifficultyHitObject {
      * The aim strain generated by the hitobject if sliders are not considered.
      */
     aimStrainWithoutSliders: number;
-    /**
-     * The tap strain generated by the hitobject.
-     *
-     * This is also used for osu!standard as opposed to "speed strain".
-     */
-    tapStrain: number;
-    /**
-     * The tap strain generated by the hitobject if `strainTime` isn't modified by
-     * OD. This is used in three-finger detection.
-     */
-    originalTapStrain: number;
     /**
      * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
      */
     rhythmMultiplier: number;
-    /**
-     * The rhythm strain generated by the hitobject.
-     */
-    rhythmStrain: number;
-    /**
-     * The flashlight strain generated by the hitobject if sliders are considered.
-     */
-    flashlightStrainWithSliders: number;
-    /**
-     * The flashlight strain generated by the hitobject if sliders are not considered.
-     */
-    flashlightStrainWithoutSliders: number;
-    /**
-     * The visual strain generated by the hitobject if sliders are considered.
-     */
-    visualStrainWithSliders: number;
-    /**
-     * The visual strain generated by the hitobject if sliders are not considered.
-     */
-    visualStrainWithoutSliders: number;
     /**
      * The normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
      *
@@ -208,6 +168,21 @@ declare class DifficultyHitObject {
      * The time taken to travel through `travelDistance`, with a minimum value of 25ms for sliders.
      */
     travelTime: number;
+    /**
+     * The position of the cursor at the point of completion of this hitobject if it was hit
+     * with as few movements as possible.
+     */
+    lazyEndPosition?: Vector2;
+    /**
+     * The distance travelled by the cursor upon completion of this hitobject if it was hit
+     * with as few movements as possible.
+     */
+    lazyTravelDistance: number;
+    /**
+     * The time taken by the cursor upon completion of this hitobject if it was hit with
+     * as few movements as possible.
+     */
+    lazyTravelTime: number;
     /**
      * Angle the player has to take to hit this hitobject.
      *
@@ -217,42 +192,66 @@ declare class DifficultyHitObject {
     /**
      * The amount of milliseconds elapsed between this hitobject and the last hitobject.
      */
-    deltaTime: number;
+    readonly deltaTime: number;
     /**
      * The amount of milliseconds elapsed since the start time of the previous hitobject, with a minimum of 25ms.
      */
-    strainTime: number;
+    readonly strainTime: number;
     /**
      * Adjusted start time of the hitobject, taking speed multiplier into account.
      */
-    startTime: number;
+    readonly startTime: number;
     /**
      * Adjusted end time of the hitobject, taking speed multiplier into account.
      */
-    endTime: number;
+    readonly endTime: number;
     /**
-     * The note density of the hitobject.
+     * The full great window of the hitobject.
      */
-    noteDensity: number;
+    readonly fullGreatWindow: number;
     /**
-     * The overlapping factor of the hitobject.
-     *
-     * This is used to scale visual skill.
+     * Selective bonus for beatmaps with higher circle size.
      */
-    overlappingFactor: number;
+    abstract get smallCircleBonus(): number;
     /**
-     * Adjusted velocity of the hitobject, taking speed multiplier into account.
+     * Other hitobjects in the beatmap, including this hitobject.
      */
-    velocity: number;
+    protected readonly hitObjects: readonly DifficultyHitObject[];
     /**
-     * Other hitobjects in the beatmap, including this hitobject.
+     * The normalized radius of the hitobject.
      */
-    private readonly hitObjects;
+    static readonly normalizedRadius: number;
+    /**
+     * The normalized diameter of the hitobject.
+     */
+    static get normalizedDiameter(): number;
+    protected abstract readonly mode: Modes;
+    protected readonly maximumSliderRadius: number;
+    protected readonly assumedSliderRadius: number;
+    /**
+     * The lowest possible delta time value.
+     */
+    static readonly minDeltaTime = 25;
+    private readonly lastObject;
+    private readonly lastDifficultyObject;
+    private readonly lastLastDifficultyObject;
     /**
+     * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
+     * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue).
+     *
      * @param object The underlying hitobject.
-     * @param hitObjects All difficulty hitobjects in the processed beatmap.
+     * @param lastObject The hitobject before this hitobject.
+     * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
+     * @param clockRate The clock rate of the beatmap.
+     * @param index The index of this hitobject in the list of all hitobjects.
      */
-    constructor(object: PlaceableHitObject, hitObjects: DifficultyHitObject[]);
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, index: number);
+    /**
+     * Computes the properties of this hitobject.
+     *
+     * @param clockRate The clock rate of the beatmap.
+     */
+    computeProperties(clockRate: number): void;
     /**
      * Gets the difficulty hitobject at a specific index with respect to the current
      * difficulty hitobject's index.
@@ -263,7 +262,7 @@ declare class DifficultyHitObject {
      * @returns The difficulty hitobject at the index with respect to the current
      * difficulty hitobject's index, `null` if the index is out of range.
      */
-    previous(backwardsIndex: number): DifficultyHitObject | null;
+    previous(backwardsIndex: number): this | null;
     /**
      * Gets the difficulty hitobject at a specific index with respect to the current
      * difficulty hitobject's index.
@@ -274,26 +273,25 @@ declare class DifficultyHitObject {
      * @returns The difficulty hitobject at the index with respect to the current
      * difficulty hitobject's index, `null` if the index is out of range.
      */
-    next(forwardsIndex: number): DifficultyHitObject | null;
+    next(forwardsIndex: number): this | null;
     /**
      * Calculates the opacity of the hitobject at a given time.
      *
      * @param time The time to calculate the hitobject's opacity at.
-     * @param isHidden Whether Hidden mod is used.
-     * @param mode The gamemode to calculate the opacity for.
+     * @param mods The mods used.
      * @returns The opacity of the hitobject at the given time.
      */
-    opacityAt(time: number, isHidden: boolean, mode: Modes): number;
+    opacityAt(time: number, mods: ModMap): number;
     /**
-     * Determines whether this hitobject is considered overlapping with the hitobject before it.
-     *
-     * Keep in mind that "overlapping" in this case is overlapping to the point where both hitobjects
-     * can be hit with just a single tap in osu!droid.
+     * How possible is it to doubletap this object together with the next one and get perfect
+     * judgement in range from 0 to 1.
      *
-     * @param considerDistance Whether to consider the distance between both hitobjects.
-     * @returns Whether the hitobject is considered overlapping.
+     * A value closer to 1 indicates a higher possibility.
      */
-    isOverlapping(considerDistance: boolean): boolean;
+    get doubletapness(): number;
+    protected setDistances(clockRate: number): void;
+    private calculateSliderCursorPosition;
+    private getEndCursorPosition;
 }
 
 /**
@@ -305,8 +303,8 @@ declare abstract class Skill {
     /**
      * The mods that this skill processes.
      */
-    protected readonly mods: Mod[];
-    constructor(mods: Mod[]);
+    protected readonly mods: ModMap;
+    constructor(mods: ModMap);
     /**
      * Processes a hitobject.
      *
@@ -320,18 +318,32 @@ declare abstract class Skill {
 }
 
 /**
- * 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.
+ * Represents the strain peaks of various calculated difficulties.
  */
-declare abstract class StrainSkill extends Skill {
+interface StrainPeaks {
     /**
-     * The strain of currently calculated hitobject.
+     * The strain peaks of aim difficulty if sliders are considered.
      */
-    protected currentStrain: number;
+    aimWithSliders: number[];
     /**
-     * The current section's strain peak.
+     * The strain peaks of aim difficulty if sliders are not considered.
      */
-    protected currentSectionPeak: number;
+    aimWithoutSliders: number[];
+    /**
+     * The strain peaks of speed difficulty.
+     */
+    speed: number[];
+    /**
+     * The strain peaks of flashlight difficulty.
+     */
+    flashlight: number[];
+}
+
+/**
+ * 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.
+ */
+declare abstract class StrainSkill extends Skill {
     /**
      * Strain peaks are stored here.
      */
@@ -345,247 +357,265 @@ declare abstract class StrainSkill extends Skill {
      * The baseline multiplier applied to the section with the biggest strain.
      */
     protected abstract readonly reducedSectionBaseline: number;
-    /**
-     * Strain values are multiplied by this number for the given skill. Used to balance the value of different skills between each other.
-     */
-    protected abstract readonly skillMultiplier: number;
     /**
      * Determines how quickly strain decays for the given skill.
      *
      * For example, a value of 0.15 indicates that strain decays to 15% of its original value in one second.
      */
     protected abstract readonly strainDecayBase: number;
-    private readonly sectionLength;
-    private currentSectionEnd;
-    private isFirstObject;
+    protected readonly _objectStrains: number[];
+    protected difficulty: number;
     /**
-     * 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.
+     * The strains of hitobjects.
      */
+    get objectStrains(): readonly number[];
+    private readonly sectionLength;
+    private currentStrain;
+    private currentSectionPeak;
+    private currentSectionEnd;
     process(current: DifficultyHitObject): void;
     /**
      * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
      */
     saveCurrentPeak(): void;
+    /**
+     * Returns the number of strains weighed against the top strain.
+     *
+     * The result is scaled by clock rate as it affects the total number of strains.
+     */
+    countTopWeightedStrains(): number;
     /**
      * Calculates strain decay for a specified time frame.
      *
      * @param ms The time frame to calculate.
      */
     protected strainDecay(ms: number): number;
+    /**
+     * Calculates the starting time of a strain section at an object.
+     *
+     * @param current The object at which the strain section starts.
+     * @returns The start time of the strain section.
+     */
+    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
     /**
      * Calculates the strain value at a hitobject.
+     *
+     * @param current The hitobject to calculate.
      */
     protected abstract strainValueAt(current: DifficultyHitObject): number;
     /**
      * Saves the current strain to a hitobject.
      */
     protected abstract saveToHitObject(current: DifficultyHitObject): void;
+    /**
+     * Retrieves the peak strain at a point in time.
+     *
+     * @param time The time to retrieve the peak strain at.
+     * @param current The current hit object.
+     * @returns The peak strain.
+     */
+    protected abstract calculateInitialStrain(time: number, current: DifficultyHitObject): number;
     /**
      * Sets the initial strain level for a new section.
      *
-     * @param offset The beginning of the new section in milliseconds, adjusted by speed multiplier.
+     * @param time The beginning of the new section in milliseconds.
      * @param current The current hitobject.
      */
     private startNewSectionFrom;
 }
 
 /**
- * Represents the strain peaks of various calculated difficulties.
+ * The base of a difficulty calculator.
  */
-interface StrainPeaks {
-    /**
-     * The strain peaks of aim difficulty if sliders are considered.
-     */
-    aimWithSliders: number[];
-    /**
-     * The strain peaks of aim difficulty if sliders are not considered.
-     */
-    aimWithoutSliders: number[];
-    /**
-     * The strain peaks of speed difficulty.
-     */
-    speed: number[];
-    /**
-     * The strain peaks of flashlight difficulty.
-     */
-    flashlight: number[];
-}
-
-/**
- * The base of difficulty calculators.
- */
-declare abstract class DifficultyCalculator {
-    /**
-     * The calculated beatmap.
-     */
-    readonly beatmap: Beatmap;
-    /**
-     * The difficulty objects of the beatmap.
-     */
-    readonly objects: DifficultyHitObject[];
-    /**
-     * The modifications applied.
-     */
-    mods: Mod[];
+declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, THitObject extends DifficultyHitObject, TAttributes extends DifficultyAttributes> {
+    protected abstract readonly difficultyMultiplier: number;
     /**
-     * The total star rating of the beatmap.
+     * `Mod`s that adjust the difficulty of a beatmap.
      */
-    total: number;
+    protected readonly difficultyAdjustmentMods: (typeof Mod)[];
     /**
-     * The map statistics of the beatmap after modifications are applied.
+     * Retains `Mod`s that adjust a beatmap's difficulty from the specified mods.
+     *
+     * @param mods The mods to retain the difficulty adjustment mods from.
+     * @returns The retained difficulty adjustment mods.
      */
-    stats: MapStats;
+    abstract retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
     /**
-     * The strain peaks of various calculated difficulties.
+     * Calculates the difficulty of a `PlayableBeatmap`.
+     *
+     * @param beatmap The `PlayableBeatmap` whose difficulty is to be calculated.
+     * @returns A `DifficultyAttributes` object describing the difficulty of the `Beatmap`.
      */
-    readonly strainPeaks: StrainPeaks;
+    calculate(beatmap: TBeatmap): TAttributes;
     /**
-     * Holds data that can be used to calculate performance points.
+     * Calculates the difficulty of a `Beatmap` with specific `Mod`s.
+     *
+     * @param beatmap The `Beatmap` whose difficulty is to be calculated.
+     * @param mods The `Mod`s to apply to the beatmap. Defaults to No Mod.
+     * @returns A `DifficultyAttributes` object describing the difficulty of the `Beatmap`.
      */
-    abstract readonly attributes: DifficultyAttributes;
-    protected abstract readonly difficultyMultiplier: number;
-    protected abstract readonly mode: Modes;
+    calculate(beatmap: Beatmap, mods?: ModMap): TAttributes;
     /**
-     * Constructs a new instance of the calculator.
+     * Obtains the strain peaks of a `PlayableBeatmap`.
      *
-     * @param beatmap The beatmap to calculate. This beatmap will be deep-cloned to prevent reference changes.
+     * @param beatmap The `PlayableBeatmap` whose strain peaks are to be calculated.
+     * @returns The strain peaks of the `PlayableBeatmap`.
      */
-    constructor(beatmap: Beatmap);
+    calculateStrainPeaks(beatmap: TBeatmap): StrainPeaks;
     /**
-     * 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.
+     * Obtains the strain peaks of a `Beatmap` with specific `Mod`s.
      *
-     * For subsequent chunks, the initial max strain is calculated
-     * by decaying the previous hitobject's strain until the
-     * beginning of the new chunk.
-     *
-     * @param options Options for the difficulty calculation.
-     * @returns The current instance.
+     * @param beatmap The `Beatmap` whose strain peaks are to be calculated.
+     * @param mods The `Mod`s to apply to the beatmap. Defaults to No Mod.
+     * @returns The strain peaks of the `Beatmap`.
      */
-    calculate(options?: DifficultyCalculationOptions): this;
+    calculateStrainPeaks(beatmap: Beatmap, mods?: ModMap): StrainPeaks;
     /**
-     * Generates difficulty hitobjects for this calculator.
+     * Creates the `Skill`s to calculate the difficulty of a `PlayableBeatmap`.
+     *
+     * @param beatmap The `PlayableBeatmap` whose difficulty will be calculated.
+     * @return The `Skill`s.
      */
-    generateDifficultyHitObjects(): void;
+    protected abstract createSkills(beatmap: TBeatmap): Skill[];
     /**
-     * Performs some pre-processing before proceeding with difficulty calculation.
+     * Creates the `Skill`s to obtain the strain peaks of a `PlayableBeatmap`.
+     *
+     * @param beatmap
      */
-    protected preProcess(): void;
+    protected abstract createStrainPeakSkills(beatmap: TBeatmap): StrainSkill[];
     /**
-     * Calculates the skills provided.
+     * Creates difficulty hitobjects for this calculator.
      *
-     * @param skills The skills to calculate.
+     * @param beatmap The beatmap to generate difficulty hitobjects from.
+     * @returns The generated difficulty hitobjects.
      */
-    protected calculateSkills(...skills: StrainSkill[]): void;
+    protected abstract createDifficultyHitObjects(beatmap: TBeatmap): THitObject[];
     /**
-     * Calculates the total star rating of the beatmap and stores it in this instance.
+     * Creates a `DifficultyAttributes` object to describe a `PlayableBeatmap`'s difficulty.
+     *
+     * @param beatmap The `PlayableBeatmap` whose difficulty was calculated.
+     * @param skills The `Skill`s which processed the `PlayableBeatmap`.
+     * @param objects The `DifficultyHitObject`s which were processed.
+     * @returns The `DifficultyAttributes` object.
      */
-    abstract calculateTotal(): void;
+    protected abstract createDifficultyAttributes(beatmap: TBeatmap, skills: Skill[], objects: THitObject[]): TAttributes;
     /**
-     * Calculates every star rating of the beatmap and stores it in this instance.
+     * Constructs a `PlayableBeatmap` from a `Beatmap` with specific `Mod`s.
+     *
+     * @param beatmap The `Beatmap` to create a `PlayableBeatmap` from.
+     * @param mods The `Mod`s to apply to the `Beatmap`.
+     * @returns The `PlayableBeatmap`.
      */
-    abstract calculateAll(): void;
+    protected abstract createPlayableBeatmap(beatmap: Beatmap, mods?: ModMap): TBeatmap;
     /**
-     * Returns a string representative of the class.
+     * Calculates the base rating of a `Skill`.
+     *
+     * @param skill The `Skill` to calculate the rating of.
+     * @returns The rating of the `Skill`.
      */
-    abstract toString(): string;
+    protected calculateRating(skill: Skill): number;
     /**
-     * Creates skills to be calculated.
+     * Calculates the base performance value of a difficulty rating.
+     *
+     * @param rating The difficulty rating.
      */
-    protected abstract createSkills(): StrainSkill[];
+    protected basePerformanceValue(rating: number): number;
+    private createPlayableBeatmapWithDifficultyAdjustmentMods;
+}
+
+/**
+ * Represents a slider that is considered difficult.
+ *
+ * This structure is a part of difficulty attributes and can be cached.
+ */
+interface DifficultSlider {
     /**
-     * Populates the stored difficulty attributes with necessary data.
+     * The index of the slider in the beatmap.
      */
-    protected populateDifficultyAttributes(): void;
+    readonly index: number;
     /**
-     * Calculates the star rating value of a difficulty.
+     * The difficulty rating of this slider compared to other sliders, based on the velocity of the slider.
      *
-     * @param difficulty The difficulty to calculate.
-     */
-    protected starValue(difficulty: number): number;
-    /**
-     * Calculates the base performance value of a difficulty rating.
+     * A value closer to 1 indicates that this slider is more difficult compared to most sliders.
      *
-     * @param rating The difficulty rating.
+     * A value closer to 0 indicates that this slider is easier compared to most sliders.
      */
-    protected basePerformanceValue(rating: number): number;
+    readonly difficultyRating: number;
 }
 
 /**
- * A converter used to convert normal hitobjects into difficulty hitobjects.
+ * Represents an osu!droid hit object with difficulty calculation values.
  */
-declare class DifficultyHitObjectCreator {
+declare class DroidDifficultyHitObject extends DifficultyHitObject {
     /**
-     * The threshold for small circle buff for osu!droid.
+     * The tap strain generated by the hitobject.
      */
-    private readonly DROID_CIRCLESIZE_BUFF_THRESHOLD;
+    tapStrain: number;
     /**
-     * The threshold for small circle buff for osu!standard.
+     * The tap strain generated by the hitobject if `strainTime` isn't modified by
+     * OD. This is used in three-finger detection.
      */
-    private readonly PC_CIRCLESIZE_BUFF_THRESHOLD;
+    originalTapStrain: number;
     /**
-     * The gamemode this creator is creating for.
+     * The rhythm strain generated by the hitobject.
      */
-    private mode;
+    rhythmStrain: number;
     /**
-     * The base normalized radius of hitobjects.
+     * The flashlight strain generated by the hitobject if sliders are considered.
      */
-    private readonly normalizedRadius;
-    private maximumSliderRadius;
-    private readonly assumedSliderRadius;
-    private readonly minDeltaTime;
+    flashlightStrainWithSliders: number;
     /**
-     * Generates difficulty hitobjects for difficulty calculation.
+     * The flashlight strain generated by the hitobject if sliders are not considered.
      */
-    generateDifficultyObjects(params: {
-        objects: readonly HitObject[];
-        circleSize: number;
-        mods: Mod[];
-        speedMultiplier: number;
-        mode: Modes;
-        preempt?: number;
-    }): DifficultyHitObject[];
+    flashlightStrainWithoutSliders: number;
     /**
-     * Calculates a slider's cursor position.
+     * The reading difficulty generated by the hitobject.
      */
-    private calculateSliderCursorPosition;
+    readingDifficulty: number;
     /**
-     * Gets the scaling factor of a radius.
+     * The note density of the hitobject.
+     */
+    noteDensity: number;
+    /**
+     * The overlapping factor of the hitobject.
      *
-     * @param radius The radius to get the scaling factor from.
+     * This is used to scale visual skill.
      */
-    private getScalingFactor;
+    overlappingFactor: number;
     /**
-     * Returns the end cursor position of a hitobject.
+     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
      */
-    private getEndCursorPosition;
-    private applyToOverlappingFactor;
-}
-
-/**
- * Represents a slider that is considered difficult.
- *
- * This structure is a part of difficulty attributes and can be cached.
- */
-interface DifficultSlider {
+    readonly timePreempt: number;
+    private readonly radiusBuffThreshold;
+    protected readonly mode = Modes.droid;
+    protected readonly maximumSliderRadius: number;
+    get smallCircleBonus(): number;
     /**
-     * The index of the slider in the beatmap.
+     * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
+     * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue).
+     *
+     * @param object The underlying hitobject.
+     * @param lastObject The hitobject before this hitobject.
+     * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
+     * @param clockRate The clock rate of the beatmap.
      */
-    readonly index: number;
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, index: number);
+    opacityAt(time: number, mods: ModMap): number;
+    previous(backwardsIndex: number): this | null;
+    next(forwardsIndex: number): this | null;
     /**
-     * The difficulty rating of this slider compared to other sliders, based on the velocity of the slider.
+     * Determines whether this hitobject is considered overlapping with the hitobject before it.
      *
-     * A value closer to 1 indicates that this slider is more difficult compared to most sliders.
+     * Keep in mind that "overlapping" in this case is overlapping to the point where both hitobjects
+     * can be hit with just a single tap in osu!droid.
      *
-     * A value closer to 0 indicates that this slider is easier compared to most sliders.
+     * In the case of sliders, it is considered overlapping if all nested hitobjects can be hit with
+     * one aim motion.
+     *
+     * @param considerDistance Whether to consider the distance between both hitobjects.
+     * @returns Whether the hitobject is considered overlapping.
      */
-    readonly difficultyRating: number;
+    isOverlapping(considerDistance: boolean): boolean;
 }
 
 /**
@@ -597,41 +627,55 @@ declare abstract class DroidSkill extends StrainSkill {
      * The bonus multiplier that is given for a sequence of notes of equal difficulty.
      */
     protected abstract readonly starsPerDouble: number;
+    process(current: DifficultyHitObject): void;
     difficultyValue(): number;
+    /**
+     * Gets the strain of a hitobject.
+     *
+     * @param current The hitobject to get the strain from.
+     * @returns The strain of the hitobject.
+     */
+    protected abstract getObjectStrain(current: DifficultyHitObject): number;
+    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
 }
 
 /**
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 declare class DroidAim extends DroidSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly starsPerDouble: number;
-    private readonly withSliders;
-    constructor(mods: Mod[], withSliders: boolean);
-    /**
-     * @param current The hitobject to calculate.
-     */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly starsPerDouble = 1.05;
+    private readonly skillMultiplier;
+    private currentAimStrain;
+    private readonly sliderStrains;
+    private maxSliderStrain;
+    readonly withSliders: boolean;
+    constructor(mods: ModMap, withSliders: boolean);
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
+     */
+    countDifficultSliders(): number;
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
     /**
      * @param current The hitobject to save to.
      */
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!droid Aim skill.
  */
-declare abstract class DroidAimEvaluator extends AimEvaluator {
-    protected static readonly wideAngleMultiplier: number;
-    protected static readonly sliderMultiplier: number;
-    protected static readonly velocityChangeMultiplier: number;
-    /**
-     * Spacing threshold for a single hitobject spacing.
-     */
-    private static readonly SINGLE_SPACING_THRESHOLD;
+declare abstract class DroidAimEvaluator {
+    private static readonly wideAngleMultiplier;
+    private static readonly acuteAngleMultiplier;
+    private static readonly sliderMultiplier;
+    private static readonly velocityChangeMultiplier;
+    private static readonly wiggleMultiplier;
+    private static readonly singleSpacingThreshold;
     private static readonly minSpeedBonus;
     /**
      * Evaluates the difficulty of aiming the current object, based on:
@@ -644,21 +688,23 @@ declare abstract class DroidAimEvaluator extends AimEvaluator {
      * @param current The current object.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, withSliders: boolean): number;
     /**
-     * Calculates the aim strain of a hitobject.
+     * Calculates the snap aim strain of a hitobject.
      */
-    private static aimStrainOf;
+    private static snapAimStrainOf;
     /**
-     * Calculates the movement strain of a hitobject.
+     * Calculates the flow aim strain of a hitobject.
      */
-    private static movementStrainOf;
+    private static flowAimStrainOf;
+    private static calculateWideAngleBonus;
+    private static calculateAcuteAngleBonus;
 }
 
 /**
  * Holds data that can be used to calculate osu!droid performance points.
  */
-interface DroidDifficultyAttributes extends DifficultyAttributes {
+interface IDroidDifficultyAttributes extends IDifficultyAttributes {
     /**
      * The difficulty corresponding to the tap skill.
      */
@@ -668,211 +714,163 @@ interface DroidDifficultyAttributes extends DifficultyAttributes {
      */
     rhythmDifficulty: number;
     /**
-     * The difficulty corresponding to the visual skill.
+     * The difficulty corresponding to the reading skill.
      */
-    visualDifficulty: number;
-}
-
-/**
- * Represents a beatmap section at which the strains of objects are considerably high.
- */
-interface HighStrainSection {
-    /**
-     * The index of the first object in this section with respect to the full beatmap.
-     */
-    readonly firstObjectIndex: number;
-    /**
-     * The index of the last object in this section with respect to the full beatmap.
-     */
-    readonly lastObjectIndex: number;
-    /**
-     * The summed strain of this section.
-     */
-    readonly sumStrain: number;
-}
-
-/**
- * Holds data that can be used to calculate osu!droid performance points as well
- * as doing some analysis using the replay of a score.
- */
-interface ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes {
+    readingDifficulty: number;
     /**
-     * Possible sections at which the player can use three fingers on.
+     * The amount of strains that are considered difficult with respect to the tap skill.
      */
-    possibleThreeFingeredSections: HighStrainSection[];
+    tapDifficultStrainCount: number;
     /**
-     * Sliders that are considered difficult.
+     * The amount of strains that are considered difficult with respect to the flashlight skill.
      */
-    difficultSliders: DifficultSlider[];
+    flashlightDifficultStrainCount: number;
     /**
-     * The number of clickable objects weighted by difficulty.
-     *
-     * Related to aim difficulty.
+     * The amount of notes that are considered difficult with respect to the reading skill.
      */
-    aimNoteCount: number;
+    readingDifficultNoteCount: number;
     /**
-     * Describes how much of flashlight difficulty is contributed to by hitcircles or sliders.
-     *
-     * A value closer to 1 indicates most of flashlight difficulty is contributed by hitcircles.
-     *
-     * A value closer to 0 indicates most of flashlight difficulty is contributed by sliders.
+     * The average delta time of speed objects.
      */
-    flashlightSliderFactor: number;
+    averageSpeedDeltaTime: number;
     /**
-     * Describes how much of visual difficulty is contributed to by hitcircles or sliders.
+     * Describes how much of tap difficulty is contributed by notes that are "vibroable".
      *
-     * A value closer to 1 indicates most of visual difficulty is contributed by hitcircles.
+     * A value closer to 1 indicates most of tap difficulty is contributed by notes that are not "vibroable".
      *
-     * A value closer to 0 indicates most of visual difficulty is contributed by sliders.
+     * A value closer to 0 indicates most of tap difficulty is contributed by notes that are "vibroable".
      */
-    visualSliderFactor: number;
+    vibroFactor: number;
 }
 
 /**
- * A difficulty calculator for osu!droid gamemode.
- */
-declare class DroidDifficultyCalculator extends DifficultyCalculator {
-    /**
-     * The aim star rating of the beatmap.
-     */
-    aim: number;
-    /**
-     * The tap star rating of the beatmap.
-     */
-    tap: number;
-    /**
-     * The rhythm star rating of the beatmap.
-     */
-    rhythm: number;
-    /**
-     * The flashlight star rating of the beatmap.
-     */
-    flashlight: number;
-    /**
-     * The visual star rating of the beatmap.
-     */
-    visual: number;
-    /**
-     * The strain threshold to start detecting for possible three-fingered section.
-     *
-     * Increasing this number will result in less sections being flagged.
-     */
-    static readonly threeFingerStrainThreshold: number;
-    readonly attributes: ExtendedDroidDifficultyAttributes;
-    protected readonly difficultyMultiplier: number;
-    protected readonly mode: Modes;
-    /**
-     * Calculates the aim star rating of the beatmap and stores it in this instance.
-     */
-    calculateAim(): void;
-    /**
-     * Calculates the tap star rating of the beatmap and stores it in this instance.
-     */
-    calculateTap(): void;
-    /**
-     * Calculates the rhythm star rating of the beatmap and stores it in this instance.
-     */
-    calculateRhythm(): void;
-    /**
-     * Calculates the flashlight star rating of the beatmap and stores it in this instance.
-     */
-    calculateFlashlight(): void;
-    /**
-     * Calculates the visual star rating of the beatmap and stores it in this instance.
-     */
-    calculateVisual(): void;
-    calculateTotal(): void;
-    calculateAll(): void;
+ * Holds data that can be used to calculate osu!droid performance points.
+ */
+declare class DroidDifficultyAttributes extends DifficultyAttributes implements IDroidDifficultyAttributes {
+    tapDifficulty: number;
+    rhythmDifficulty: number;
+    readingDifficulty: number;
+    tapDifficultStrainCount: number;
+    flashlightDifficultStrainCount: number;
+    readingDifficultNoteCount: number;
+    averageSpeedDeltaTime: number;
+    vibroFactor: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IDroidDifficultyAttributes>);
     toString(): string;
-    protected preProcess(): void;
-    protected createSkills(): DroidSkill[];
+}
+
+/**
+ * Represents a beatmap section at which the strains of objects are considerably high.
+ */
+interface HighStrainSection {
     /**
-     * Called after aim skill calculation.
-     *
-     * @param aimSkill The aim skill that considers sliders.
-     * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
+     * The index of the first object in this section with respect to the full beatmap.
      */
-    private postCalculateAim;
+    readonly firstObjectIndex: number;
     /**
-     * Calculates aim-related attributes.
+     * The index of the last object in this section with respect to the full beatmap.
      */
-    private calculateAimAttributes;
+    readonly lastObjectIndex: number;
     /**
-     * Called after tap skill calculation.
-     *
-     * @param tapSkill The tap skill.
+     * The summed strain of this section.
      */
-    private postCalculateTap;
+    readonly sumStrain: number;
+}
+
+/**
+ * Holds data that can be used to calculate osu!droid performance points as well
+ * as doing some analysis using the replay of a score.
+ */
+interface IExtendedDroidDifficultyAttributes extends IDroidDifficultyAttributes {
     /**
-     * Calculates speed-related attributes.
+     * The mode of the difficulty calculation.
      */
-    private calculateSpeedAttributes;
+    mode: "live";
     /**
-     * Calculates the sum of strains for possible three-fingered sections.
-     *
-     * @param firstObjectIndex The index of the first object in the section.
-     * @param lastObjectIndex The index of the last object in the section.
-     * @returns The summed strain of the section.
+     * Possible sections at which the player can use three fingers on.
      */
-    private calculateThreeFingerSummedStrain;
+    possibleThreeFingeredSections: HighStrainSection[];
     /**
-     * Called after rhythm skill calculation.
-     *
-     * @param rhythmSkill The rhythm skill.
+     * Sliders that are considered difficult.
      */
-    private postCalculateRhythm;
+    difficultSliders: DifficultSlider[];
     /**
-     * Called after flashlight skill calculation.
+     * Describes how much of flashlight difficulty is contributed to by hitcircles or sliders.
      *
-     * @param flashlightSkill The flashlight skill that considers sliders.
-     * @param flashlightSkillWithoutSliders The flashlight skill that doesn't consider sliders.
-     */
-    private postCalculateFlashlight;
-    /**
-     * Called after visual skill calculation.
+     * A value closer to 1 indicates most of flashlight difficulty is contributed by hitcircles.
      *
-     * @param visualSkillWithSliders The visual skill that considers sliders.
-     * @param visualSkillWithoutSliders The visual skill that doesn't consider sliders.
+     * A value closer to 0 indicates most of flashlight difficulty is contributed by sliders.
      */
-    private postCalculateVisual;
+    flashlightSliderFactor: number;
 }
 
 /**
- * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ * Holds data that can be used to calculate osu!droid performance points as well
+ * as doing some analysis using the replay of a score.
  */
-declare class DroidFlashlight extends DroidSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly starsPerDouble: number;
-    private readonly isHidden;
-    private readonly withSliders;
-    constructor(mods: Mod[], withSliders: boolean);
+declare class ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes implements IExtendedDroidDifficultyAttributes {
+    mode: "live";
+    possibleThreeFingeredSections: HighStrainSection[];
+    difficultSliders: DifficultSlider[];
+    flashlightSliderFactor: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IExtendedDroidDifficultyAttributes>);
+}
+
+/**
+ * A difficulty calculator for osu!droid gamemode.
+ */
+declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidPlayableBeatmap, DroidDifficultyHitObject, ExtendedDroidDifficultyAttributes> {
     /**
-     * @param current The hitobject to calculate.
+     * The strain threshold to start detecting for possible three-fingered section.
+     *
+     * Increasing this number will result in less sections being flagged.
      */
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    static readonly threeFingerStrainThreshold = 175;
+    protected readonly difficultyMultiplier = 0.18;
+    constructor();
+    retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
+    protected createDifficultyAttributes(beatmap: DroidPlayableBeatmap, skills: Skill[], objects: DroidDifficultyHitObject[]): ExtendedDroidDifficultyAttributes;
+    protected createPlayableBeatmap(beatmap: Beatmap, mods?: ModMap): DroidPlayableBeatmap;
+    protected createDifficultyHitObjects(beatmap: DroidPlayableBeatmap): DroidDifficultyHitObject[];
+    protected createSkills(beatmap: DroidPlayableBeatmap): Skill[];
+    protected createStrainPeakSkills(beatmap: DroidPlayableBeatmap): StrainSkill[];
+    private populateAimAttributes;
+    private populateTapAttributes;
+    private populateRhythmAttributes;
+    private populateFlashlightAttributes;
+    private populateReadingAttributes;
 }
 
 /**
- * An evaluator for calculating flashlight skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
-declare abstract class FlashlightEvaluator {
-    protected static readonly maxOpacityBonus: number;
-    protected static readonly hiddenBonus: number;
-    protected static readonly minVelocity: number;
-    protected static readonly sliderMultiplier: number;
-    protected static readonly minAngleMultiplier: number;
+declare class DroidFlashlight extends DroidSkill {
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 0;
+    protected readonly reducedSectionBaseline = 1;
+    protected readonly starsPerDouble = 1.06;
+    private readonly skillMultiplier;
+    private currentFlashlightStrain;
+    readonly withSliders: boolean;
+    constructor(mods: ModMap, withSliders: boolean);
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
+    protected getObjectStrain(): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
+    difficultyValue(): number;
 }
 
 /**
  * An evaluator for calculating osu!droid Flashlight skill.
  */
-declare abstract class DroidFlashlightEvaluator extends FlashlightEvaluator {
+declare abstract class DroidFlashlightEvaluator {
+    private static readonly maxOpacityBonus;
+    private static readonly hiddenBonus;
+    private static readonly traceableCircleBonus;
+    private static readonly traceableObjectBonus;
+    private static readonly minVelocity;
+    private static readonly sliderMultiplier;
+    private static readonly minAngleMultiplier;
     /**
      * Evaluates the difficulty of memorizing and hitting the current object, based on:
      *
@@ -883,10 +881,10 @@ declare abstract class DroidFlashlightEvaluator extends FlashlightEvaluator {
      * - and whether Hidden mod is enabled.
      *
      * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
+     * @param mods The mods used.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, isHiddenMod: boolean, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: ModMap, withSliders: boolean): number;
 }
 
 /**
@@ -905,6 +903,14 @@ interface PerformanceCalculationOptions {
      * The amount of misses achieved in the score.
      */
     miss?: number;
+    /**
+     * The amount of slider ends dropped in the score.
+     */
+    sliderEndsDropped?: number;
+    /**
+     * The amount of slider ticks missed in the score.
+     */
+    sliderTicksMissed?: number;
     /**
      * The tap penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
      */
@@ -926,7 +932,7 @@ interface PerformanceCalculationOptions {
 /**
  * The base class of performance calculators.
  */
-declare abstract class PerformanceCalculator {
+declare abstract class PerformanceCalculator<T extends IDifficultyAttributes> {
     /**
      * The overall performance value.
      */
@@ -938,11 +944,11 @@ declare abstract class PerformanceCalculator {
     /**
      * The difficulty attributes that is being calculated.
      */
-    abstract readonly difficultyAttributes: DifficultyAttributes;
+    readonly difficultyAttributes: T | CacheableDifficultyAttributes<T>;
     /**
-     * Penalty for combo breaks.
+     * The mods that were used.
      */
-    protected comboPenalty: number;
+    protected readonly mods: ModMap;
     /**
      * The global multiplier to be applied to the final performance value.
      *
@@ -957,10 +963,29 @@ declare abstract class PerformanceCalculator {
      * The amount of misses that are filtered out from sliderbreaks.
      */
     protected effectiveMissCount: number;
+    /**
+     * The amount of slider ends dropped in the score.
+     */
+    protected sliderEndsDropped: number;
+    /**
+     * The amount of slider ticks missed in the score.
+     *
+     * This is used to calculate the slider accuracy.
+     */
+    protected sliderTicksMissed: number;
+    private _usingClassicSliderAccuracy;
+    /**
+     * Whether this score uses classic slider accuracy.
+     */
+    protected get usingClassicSliderAccuracy(): boolean;
     /**
      * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
      */
     protected sliderNerfFactor: number;
+    /**
+     * @param difficultyAttributes The difficulty attributes to calculate.
+     */
+    constructor(difficultyAttributes: T | CacheableDifficultyAttributes<T>);
     /**
      * Calculates the performance points of the beatmap.
      *
@@ -980,7 +1005,7 @@ declare abstract class PerformanceCalculator {
     /**
      * Calculates the total performance value of the beatmap and stores it in this instance.
      */
-    protected abstract calculateTotalValue(): void;
+    protected abstract calculateTotalValue(): number;
     /**
      * The total hits that can be done in the beatmap.
      */
@@ -989,6 +1014,10 @@ declare abstract class PerformanceCalculator {
      * The total hits that were successfully done.
      */
     protected get totalSuccessfulHits(): number;
+    /**
+     * The total of imperfect hits (100s, 50s, misses).
+     */
+    protected get totalImperfectHits(): number;
     /**
      * Calculates the base performance value of a star rating.
      */
@@ -999,16 +1028,31 @@ declare abstract class PerformanceCalculator {
      * @param options Options for performance calculation.
      */
     protected handleOptions(options?: PerformanceCalculationOptions): void;
+    /**
+     * Calculates a strain-based miss penalty.
+     *
+     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
+     * so we use the amount of relatively difficult sections to adjust miss penalty
+     * to make it more punishing on maps with lower amount of hard sections.
+     */
+    protected calculateStrainBasedMissPenalty(difficultStrainCount: number): number;
     /**
      * Calculates the amount of misses + sliderbreaks from combo.
      */
     private calculateEffectiveMissCount;
+    /**
+     * Determines whether an attribute is a cacheable attribute.
+     *
+     * @param attributes The attributes to check.
+     * @returns Whether the attributes are cacheable.
+     */
+    private isCacheableAttribute;
 }
 
 /**
  * A performance points calculator that calculates performance points for osu!droid gamemode.
  */
-declare class DroidPerformanceCalculator extends PerformanceCalculator {
+declare class DroidPerformanceCalculator extends PerformanceCalculator<IDroidDifficultyAttributes> {
     /**
      * The aim performance value.
      */
@@ -1026,9 +1070,9 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     flashlight: number;
     /**
-     * The visual performance value.
+     * The reading performance value.
      */
-    visual: number;
+    reading: number;
     /**
      * The penalty used to penalize the tap performance value.
      *
@@ -1055,25 +1099,13 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      * Can be properly obtained by analyzing the replay associated with the score.
      */
     get flashlightSliderCheesePenalty(): number;
-    /**
-     * The penalty used to penalize the visual performance value.
-     *
-     * Can be properly obtained by analyzing the replay associated with the score.
-     */
-    get visualSliderCheesePenalty(): number;
-    readonly difficultyAttributes: DroidDifficultyAttributes;
     protected finalMultiplier: number;
-    protected readonly mode: Modes;
+    protected readonly mode = Modes.droid;
     private _aimSliderCheesePenalty;
     private _flashlightSliderCheesePenalty;
-    private _visualSliderCheesePenalty;
     private _tapPenalty;
     private _deviation;
     private _tapDeviation;
-    /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
-     */
-    constructor(difficultyAttributes: DroidDifficultyAttributes);
     /**
      * Applies a tap penalty value to this calculator.
      *
@@ -1098,16 +1130,8 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      * @param value The slider cheese penalty value. Must be between 0 and 1.
      */
     applyFlashlightSliderCheesePenalty(value: number): void;
-    /**
-     * Applies a visual slider cheese penalty value to this calculator.
-     *
-     * The visual and total performance value will be recalculated afterwards.
-     *
-     * @param value The slider cheese penalty value. Must be between 0 and 1.
-     */
-    applyVisualSliderCheesePenalty(value: number): void;
     protected calculateValues(): void;
-    protected calculateTotalValue(): void;
+    protected calculateTotalValue(): number;
     protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
      * Calculates the aim performance value of the beatmap.
@@ -1126,11 +1150,24 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     private calculateFlashlightValue;
     /**
-     * Calculates the visual performance value of the beatmap.
+     * Calculates the reading performance value of the beatmap.
+     */
+    private calculateReadingValue;
+    /**
+     * The object-based proportional miss penalty.
      */
-    private calculateVisualValue;
+    private get proportionalMissPenalty();
     /**
-     * Estimates the player's tap deviation based on the OD, number of circles and sliders,
+     * Calculates the object-based length scaling based on the deviation of a player for a full
+     * combo in this beatmap, taking retries into account.
+     *
+     * @param objectCount The amount of objects to be considered. Defaults to the amount of
+     * objects in this beatmap.
+     * @param punishForMemorization Whether to punish the deviation for memorization. Defaults to `false`.
+     */
+    private calculateDeviationBasedLengthScaling;
+    /**
+     * Estimates the player's deviation based on the OD, number of circles and sliders,
      * and number of 300s, 100s, 50s, and misses, assuming the player's mean hit error is 0.
      *
      * The estimation is consistent in that two SS scores on the same map
@@ -1151,281 +1188,255 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      * This is fine though, since this method is only used to scale tap pp.
      */
     private calculateTapDeviation;
+    /**
+     * Calculates a multiplier for tap to account for improper tapping based on the deviation and tap difficulty.
+     *
+     * [Graph](https://www.desmos.com/calculator/z5l9ebrwpi)
+     */
+    private calculateTapHighDeviationNerf;
+    private getConvertedHitWindow;
     toString(): string;
 }
 
 /**
- * Represents the skill required to properly follow a beatmap's rhythm.
+ * Represents the skill required to read every object in the map.
  */
-declare class DroidRhythm extends DroidSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly strainDecayBase: number;
-    protected readonly starsPerDouble: number;
-    private currentRhythm;
-    private readonly hitWindow;
-    constructor(mods: Mod[], overallDifficulty: number);
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): void;
+declare class DroidReading extends Skill {
+    private readonly clockRate;
+    private readonly hitObjects;
+    private readonly noteDifficulties;
+    private readonly strainDecayBase;
+    private readonly skillMultiplier;
+    private currentNoteDifficulty;
+    private difficulty;
+    private noteWeightSum;
+    constructor(mods: ModMap, clockRate: number, hitObjects: readonly PlaceableHitObject[]);
+    process(current: DroidDifficultyHitObject): void;
+    difficultyValue(): number;
+    /**
+     * Returns the number of relevant objects weighted against the top note.
+     */
+    countTopWeightedNotes(): number;
+    private strainDecay;
 }
 
 /**
- * An evaluator for calculating rhythm skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
+ * An evaluator for calculating osu!droid reading skill.
+ */
+declare abstract class DroidReadingEvaluator {
+    private static readonly emptyModMap;
+    private static readonly readingWindowSize;
+    private static readonly distanceInfluenceThreshold;
+    private static readonly hiddenMultiplier;
+    private static readonly densityMultiplier;
+    private static readonly densityDifficultyBase;
+    private static readonly preemptBalancingFactor;
+    private static readonly preemptStartingPoint;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, clockRate: number, mods: ModMap): number;
+    /**
+     * Retrieves a list of objects that are visible at the point in time the current object needs to be hit.
+     *
+     * @param current The current object.
+     */
+    private static retrievePastVisibleObjects;
+    /**
+     * Calculates the density of objects visible at the point in time the current object needs to be hit.
+     *
+     * @param current The current object.
+     */
+    private static calculateCurrentVisibleObjectsDensity;
+    /**
+     * Returns the time an object spends invisible with the Hidden mod at the current approach rate.
+     *
+     * @param current The current object.
+     */
+    private static getDurationSpentInvisible;
+    /**
+     * Calculates a factor of how often the current object's angle has been repeated in a certain time frame.
+     * It does this by checking the difference in angle between current and past objects and sums them up
+     * based on a range of similarity.
+     *
+     * @param current The current object.
+     */
+    private static getConstantAngleNerfFactor;
+    private static getTimeNerfFactor;
+}
+
+/**
+ * Represents the skill required to properly follow a beatmap's rhythm.
  */
-declare abstract class RhythmEvaluator {
-    protected static readonly rhythmMultiplier: number;
-    protected static readonly historyTimeMax: number;
+declare class DroidRhythm extends DroidSkill {
+    protected readonly reducedSectionCount = 5;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly strainDecayBase = 0.3;
+    protected readonly starsPerDouble = 1.75;
+    private readonly useSliderAccuracy;
+    private currentRhythmStrain;
+    private currentRhythmMultiplier;
+    constructor(mods: ModMap);
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!droid Rhythm skill.
  */
-declare abstract class DroidRhythmEvaluator extends RhythmEvaluator {
+declare abstract class DroidRhythmEvaluator {
+    private static readonly historyTimeMax;
+    private static readonly historyObjectsMax;
+    private static readonly rhythmOverallMultiplier;
+    private static readonly rhythmRatioMultiplier;
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
+     * @param useSliderAccuracy Whether to use slider accuracy.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, useSliderAccuracy: boolean): number;
 }
 
 /**
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
 declare class DroidTap extends DroidSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly strainDecayBase: number;
-    protected readonly starsPerDouble: number;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly strainDecayBase = 0.3;
+    protected readonly starsPerDouble = 1.1;
     private currentTapStrain;
-    private currentOriginalTapStrain;
-    private readonly greatWindow;
-    constructor(mods: Mod[], overallDifficulty: number);
+    private currentRhythmMultiplier;
+    private readonly skillMultiplier;
+    private readonly _objectDeltaTimes;
+    private maxStrain;
     /**
-     * @param current The hitobject to calculate.
+     * The delta time of hitobjects.
+     */
+    get objectDeltaTimes(): readonly number[];
+    readonly considerCheesability: boolean;
+    readonly strainTimeCap?: number;
+    constructor(mods: ModMap, considerCheesability: boolean, strainTimeCap?: number);
+    /**
+     * The amount of notes that are relevant to the difficulty.
+     */
+    relevantNoteCount(): number;
+    /**
+     * The delta time relevant to the difficulty.
      */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    relevantDeltaTime(): number;
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
     /**
      * @param current The hitobject to save to.
      */
-    protected saveToHitObject(current: DifficultyHitObject): void;
-}
-
-/**
- * An evaluator for calculating speed or tap skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-declare abstract class SpeedEvaluator {
-    protected static readonly minSpeedBonus: number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!droid tap skill.
  */
-declare abstract class DroidTapEvaluator extends SpeedEvaluator {
+declare abstract class DroidTapEvaluator {
+    private static readonly minSpeedBonus;
     /**
      * Evaluates the difficulty of tapping the current object, based on:
      *
      * - time between pressing the previous and current object,
      * - distance between those objects,
-     * - and how easily they can be cheesed.
+     * - how easily they can be cheesed,
+     * - and the strain time cap.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      * @param considerCheesability Whether to consider cheesability.
+     * @param strainTimeCap The strain time to cap the object's strain time to.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number, considerCheesability: boolean): number;
-}
-
-/**
- * Represents the skill required to read every object in the map.
- */
-declare class DroidVisual extends DroidSkill {
-    protected readonly starsPerDouble: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    private readonly isHidden;
-    private readonly withSliders;
-    constructor(mods: Mod[], withSliders: boolean);
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): void;
-}
-
-/**
- * An evaluator for calculating osu!droid Visual skill.
- */
-declare abstract class DroidVisualEvaluator {
-    /**
-     * Evaluates the difficulty of reading the current object, based on:
-     *
-     * - note density of the current object,
-     * - overlapping factor of the current object,
-     * - the preempt time of the current object,
-     * - the visual opacity of the current object,
-     * - the velocity of the current object if it's a slider,
-     * - past objects' velocity if they are sliders,
-     * - and whether the Hidden mod is enabled.
-     *
-     * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
-     * @param withSliders Whether to take slider difficulty into account.
-     */
-    static evaluateDifficultyOf(current: DifficultyHitObject, isHiddenMod: boolean, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, considerCheesability: boolean, strainTimeCap?: number): number;
 }
 
 /**
- * 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.
+ * Holds data that can be used to calculate osu!standard performance points.
  */
-declare abstract class OsuSkill extends StrainSkill {
+interface IOsuDifficultyAttributes extends IDifficultyAttributes {
     /**
-     * The default multiplier applied to the final difficulty value after all other calculations.
+     * The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
      *
-     * May be overridden via {@link difficultyMultiplier}.
-     */
-    static readonly defaultDifficultyMultiplier: number;
-    /**
-     * The final multiplier to be applied to the final difficulty value after all other calculations.
-     */
-    protected readonly difficultyMultiplier: number;
-    /**
-     * The weight by which each strain value decays.
+     * Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
      */
-    protected abstract readonly decayWeight: number;
-    difficultyValue(): number;
-}
-
-/**
- * Holds data that can be used to calculate osu!standard performance points.
- */
-interface OsuDifficultyAttributes extends DifficultyAttributes {
+    approachRate: number;
     /**
      * The difficulty corresponding to the speed skill.
      */
     speedDifficulty: number;
+    /**
+     * The amount of strains that are considered difficult with respect to the speed skill.
+     */
+    speedDifficultStrainCount: number;
 }
 
 /**
- * A difficulty calculator for osu!standard gamemode.
+ * Represents an osu!standard hit object with difficulty calculation values.
  */
-declare class OsuDifficultyCalculator extends DifficultyCalculator {
-    /**
-     * The aim star rating of the beatmap.
-     */
-    aim: number;
-    /**
-     * The speed star rating of the beatmap.
-     */
-    speed: number;
-    /**
-     * The flashlight star rating of the beatmap.
-     */
-    flashlight: number;
-    readonly attributes: OsuDifficultyAttributes;
-    protected readonly difficultyMultiplier: number;
-    protected readonly mode: Modes;
-    /**
-     * Calculates the aim star rating of the beatmap and stores it in this instance.
-     */
-    calculateAim(): void;
-    /**
-     * Calculates the speed star rating of the beatmap and stores it in this instance.
-     */
-    calculateSpeed(): void;
+declare class OsuDifficultyHitObject extends DifficultyHitObject {
     /**
-     * Calculates the flashlight star rating of the beatmap and stores it in this instance.
+     * The speed strain generated by the hitobject.
      */
-    calculateFlashlight(): void;
-    calculateTotal(): void;
-    calculateAll(): void;
-    toString(): string;
-    protected preProcess(): void;
-    protected createSkills(): OsuSkill[];
-    /**
-     * Called after aim skill calculation.
-     *
-     * @param aimSkill The aim skill that considers sliders.
-     * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
-     */
-    private postCalculateAim;
-    /**
-     * Called after speed skill calculation.
-     *
-     * @param speedSkill The speed skill.
-     */
-    private postCalculateSpeed;
-    /**
-     * Calculates speed-related attributes.
-     */
-    private calculateSpeedAttributes;
+    speedStrain: number;
     /**
-     * Called after flashlight skill calculation.
-     *
-     * @param flashlightSkill The flashlight skill.
+     * The flashlight strain generated by this hitobject.
      */
-    private postCalculateFlashlight;
+    flashlightStrain: number;
+    get smallCircleBonus(): number;
+    protected readonly mode = Modes.osu;
 }
 
 /**
- * A difficulty calculator that calculates for both osu!droid and osu!standard gamemode.
+ * 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.
  */
-declare class MapStars {
-    /**
-     * The osu!droid difficulty calculator of the beatmap.
-     */
-    readonly droid: DroidDifficultyCalculator;
-    /**
-     * The osu!standard difficulty calculator of the beatmap.
-     */
-    readonly osu: OsuDifficultyCalculator;
-    /**
-     * Constructs this instance and calculates the given beatmap's osu!droid and osu!standard difficulty.
-     *
-     * @param beatmap The beatmap to calculate.
-     * @param options Options for the difficulty calculation.
-     */
-    constructor(beatmap: Beatmap, options?: DifficultyCalculationOptions);
+declare abstract class OsuSkill extends StrainSkill {
     /**
-     * Returns a string representative of the class.
+     * The weight by which each strain value decays.
      */
-    toString(): string;
+    protected abstract readonly decayWeight: number;
+    difficultyValue(): number;
 }
 
 /**
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 declare class OsuAim extends OsuSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly difficultyMultiplier: number;
-    protected readonly decayWeight: number;
-    private readonly withSliders;
-    constructor(mods: Mod[], withSliders: boolean);
-    /**
-     * @param current The hitobject to calculate.
-     */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly decayWeight = 0.9;
+    private currentAimStrain;
+    private readonly skillMultiplier;
+    private readonly sliderStrains;
+    readonly withSliders: boolean;
+    constructor(mods: ModMap, withSliders: boolean);
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
+     */
+    countDifficultSliders(): number;
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
     /**
      * @param current The hitobject to save to.
      */
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!standard Aim skill.
  */
-declare abstract class OsuAimEvaluator extends AimEvaluator {
+declare abstract class OsuAimEvaluator {
+    private static readonly wideAngleMultiplier;
+    private static readonly acuteAngleMultiplier;
+    private static readonly sliderMultiplier;
+    private static readonly velocityChangeMultiplier;
+    private static readonly wiggleMultiplier;
     /**
      * Evaluates the difficulty of aiming the current object, based on:
      *
@@ -1437,31 +1448,64 @@ declare abstract class OsuAimEvaluator extends AimEvaluator {
      * @param current The current object.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, withSliders: boolean): number;
+    private static calculateWideAngleBonus;
+    private static calculateAcuteAngleBonus;
+}
+
+/**
+ * Holds data that can be used to calculate osu!standard performance points.
+ */
+declare class OsuDifficultyAttributes extends DifficultyAttributes implements IOsuDifficultyAttributes {
+    approachRate: number;
+    speedDifficulty: number;
+    speedDifficultStrainCount: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IOsuDifficultyAttributes>);
+    toString(): string;
+}
+
+/**
+ * A difficulty calculator for osu!standard gamemode.
+ */
+declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuPlayableBeatmap, OsuDifficultyHitObject, OsuDifficultyAttributes> {
+    protected readonly difficultyMultiplier = 0.0675;
+    constructor();
+    retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
+    protected createDifficultyAttributes(beatmap: OsuPlayableBeatmap, skills: Skill[]): OsuDifficultyAttributes;
+    protected createPlayableBeatmap(beatmap: Beatmap, mods?: ModMap): OsuPlayableBeatmap;
+    protected createDifficultyHitObjects(beatmap: OsuPlayableBeatmap): OsuDifficultyHitObject[];
+    protected createSkills(beatmap: OsuPlayableBeatmap): OsuSkill[];
+    protected createStrainPeakSkills(beatmap: OsuPlayableBeatmap): StrainSkill[];
+    private populateAimAttributes;
+    private populateSpeedAttributes;
+    private populateFlashlightAttributes;
 }
 
 /**
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 declare class OsuFlashlight extends OsuSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly decayWeight: number;
-    private readonly isHidden;
-    constructor(mods: Mod[]);
-    /**
-     * @param current The hitobject to calculate.
-     */
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 0;
+    protected readonly reducedSectionBaseline = 1;
+    protected readonly decayWeight = 1;
+    private currentFlashlightStrain;
+    private readonly skillMultiplier;
+    difficultyValue(): number;
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!standard Flashlight skill.
  */
-declare abstract class OsuFlashlightEvaluator extends FlashlightEvaluator {
+declare abstract class OsuFlashlightEvaluator {
+    private static readonly maxOpacityBonus;
+    private static readonly hiddenBonus;
+    private static readonly minVelocity;
+    private static readonly sliderMultiplier;
+    private static readonly minAngleMultiplier;
     /**
      * Evaluates the difficulty of memorizing and hitting the current object, based on:
      *
@@ -1472,15 +1516,15 @@ declare abstract class OsuFlashlightEvaluator extends FlashlightEvaluator {
      * - and whether Hidden mod is enabled.
      *
      * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
+     * @param mods The mods used.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, isHiddenMod: boolean): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: ModMap): number;
 }
 
 /**
  * A performance points calculator that calculates performance points for osu!standard gamemode.
  */
-declare class OsuPerformanceCalculator extends PerformanceCalculator {
+declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficultyAttributes> {
     /**
      * The aim performance value.
      */
@@ -1497,15 +1541,13 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator {
      * The flashlight performance value.
      */
     flashlight: number;
-    readonly difficultyAttributes: OsuDifficultyAttributes;
     protected finalMultiplier: number;
-    protected readonly mode: Modes;
-    /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
-     */
-    constructor(difficultyAttributes: OsuDifficultyAttributes);
+    protected readonly mode = Modes.osu;
+    private comboPenalty;
+    private speedDeviation;
     protected calculateValues(): void;
-    protected calculateTotalValue(): void;
+    protected calculateTotalValue(): number;
+    protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
      * Calculates the aim performance value of the beatmap.
      */
@@ -1522,55 +1564,87 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator {
      * Calculates the flashlight performance value of the beatmap.
      */
     private calculateFlashlightValue;
+    /**
+     * Estimates a player's deviation on speed notes using {@link calculateDeviation}, assuming worst-case.
+     *
+     * Treats all speed notes as hit circles.
+     */
+    private calculateSpeedDeviation;
+    /**
+     * Estimates the player's tap deviation based on the OD, given number of greats, oks, mehs and misses,
+     * assuming the player's mean hit error is 0. The estimation is consistent in that two SS scores on the
+     * same map with the same settings will always return the same deviation.
+     *
+     * Misses are ignored because they are usually due to misaiming.
+     *
+     * Greats and oks are assumed to follow a normal distribution, whereas mehs are assumed to follow a uniform distribution.
+     */
+    private calculateDeviation;
+    /**
+     * Calculates multiplier for speed to account for improper tapping based on the deviation and speed difficulty.
+     *
+     * [Graph](https://www.desmos.com/calculator/dmogdhzofn)
+     */
+    private calculateSpeedHighDeviationNerf;
     toString(): string;
 }
 
 /**
  * An evaluator for calculating osu!standard Rhythm skill.
  */
-declare abstract class OsuRhythmEvaluator extends RhythmEvaluator {
+declare abstract class OsuRhythmEvaluator {
+    private static readonly historyTimeMax;
+    private static readonly historyObjectsMax;
+    private static readonly rhythmOverallMultiplier;
+    private static readonly rhythmRatioMultiplier;
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
 }
 
 /**
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
 declare class OsuSpeed extends OsuSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly difficultyMultiplier: number;
-    protected readonly decayWeight: number;
+    protected readonly strainDecayBase = 0.3;
+    protected readonly reducedSectionCount = 5;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly decayWeight = 0.9;
     private currentSpeedStrain;
     private currentRhythm;
-    private readonly greatWindow;
-    constructor(mods: Mod[], greatWindow: number);
+    private readonly skillMultiplier;
+    private maxStrain;
+    /**
+     * The amount of notes that are relevant to the difficulty.
+     */
+    relevantNoteCount(): number;
     /**
      * @param current The hitobject to calculate.
      */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
     /**
      * @param current The hitobject to save to.
      */
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!standard speed skill.
  */
-declare abstract class OsuSpeedEvaluator extends SpeedEvaluator {
+declare abstract class OsuSpeedEvaluator {
     /**
      * Spacing threshold for a single hitobject spacing.
+     *
+     * About 1.25 circles distance between hitobject centers.
      */
     private static readonly SINGLE_SPACING_THRESHOLD;
+    private static readonly minSpeedBonus;
+    private static readonly DISTANCE_MULTIPLIER;
     /**
      * Evaluates the difficulty of tapping the current object, based on:
      *
@@ -1579,9 +1653,9 @@ declare abstract class OsuSpeedEvaluator extends SpeedEvaluator {
      * - and how easily they can be cheesed.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
+     * @param mods The mods applied.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: ModMap): number;
 }
 
-export { AimEvaluator, CalculationOptions, DifficultSlider, DifficultyAttributes, DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DifficultyHitObjectCreator, DroidAim, DroidAimEvaluator, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, ExtendedDroidDifficultyAttributes, FlashlightEvaluator, HighStrainSection, MapStars, OsuAim, OsuAimEvaluator, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, PerformanceCalculationOptions, PerformanceCalculator, RhythmEvaluator, SpeedEvaluator, StrainPeaks };
+export { type CacheableDifficultyAttributes, type DifficultSlider, DifficultyAttributes, DifficultyCalculator, DifficultyHitObject, DroidAim, DroidAimEvaluator, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidReading, DroidReadingEvaluator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, ExtendedDroidDifficultyAttributes, type HighStrainSection, type IDifficultyAttributes, type IDroidDifficultyAttributes, type IExtendedDroidDifficultyAttributes, type IOsuDifficultyAttributes, OsuAim, OsuAimEvaluator, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, type PerformanceCalculationOptions, PerformanceCalculator, type StrainPeaks };