@rian8337/osu-difficulty-calculator 4.0.0-beta.10 → 4.0.0-beta.101

package/typings/index.d.ts

@@ -1,117 +1,9 @@
-import { MapStats, Mod, PlaceableHitObject, Beatmap, Modes, HitObject, Accuracy } from '@rian8337/osu-base';
+import { PlaceableHitObject, Vector2, Modes, ModMap, HitResult, HitWindow, SerializedMod, PlayableBeatmap, Mod, Beatmap, Accuracy, DroidPlayableBeatmap, OsuPlayableBeatmap } 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;
-}
-
-/**
- * Holds data that can be used to calculate performance points.
- */
-interface DifficultyAttributes {
-    /**
-     * The mods which were applied to the beatmap.
-     */
-    mods: Mod[];
-    /**
-     * The combined star rating of all skills.
-     */
-    starRating: number;
-    /**
-     * The maximum achievable combo.
-     */
-    maxCombo: number;
-    /**
-     * The difficulty corresponding to the aim skill.
-     */
-    aimDifficulty: number;
-    /**
-     * The difficulty corresponding to the flashlight skill.
-     */
-    flashlightDifficulty: number;
-    /**
-     * The number of clickable objects weighted by difficulty.
-     *
-     * Related to speed/tap difficulty.
-     */
-    speedNoteCount: number;
-    /**
-     * Describes how much of aim difficulty is contributed to by hitcircles or sliders.
-     *
-     * A value closer to 1 indicates most of aim difficulty is contributed by hitcircles.
-     *
-     * A value closer to 0 indicates most of aim difficulty is contributed by sliders.
-     */
-    sliderFactor: number;
-    /**
-     * 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.
-     *
-     * Rate-adjusting mods don't directly affect the overall difficulty value, but have a perceived effect as a result of adjusting audio timing.
-     */
-    overallDifficulty: number;
-    /**
-     * The number of hitcircles in the beatmap.
-     */
-    hitCircleCount: number;
-    /**
-     * The number of sliders in the beatmap.
-     */
-    sliderCount: number;
-    /**
-     * The number of spinners in the beatmap.
-     */
-    spinnerCount: number;
-}
-
-/**
- * Represents options for difficulty calculation.
- */
-interface DifficultyCalculationOptions extends CalculationOptions {
-    /**
-     * The modifications to apply.
-     */
-    mods?: Mod[];
-}
-
-/**
- * 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 +13,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.
      */
@@ -143,40 +23,21 @@ declare class DifficultyHitObject {
      */
     aimStrainWithoutSliders: number;
     /**
-     * The tap strain generated by the hitobject.
-     *
-     * This is also used for osu!standard as opposed to "speed strain".
+     * The flashlight strain generated by the hitobject.
      */
-    tapStrain: number;
+    flashlightStrain: number;
     /**
-     * The tap strain generated by the hitobject if `strainTime` isn't modified by
-     * OD. This is used in three-finger detection.
+     * The reading difficulty generated by the hitobject.
      */
-    originalTapStrain: number;
+    readingDifficulty: number;
     /**
      * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
      */
     rhythmMultiplier: number;
     /**
-     * The rhythm strain generated by the hitobject.
+     * The normalized distance from the start position of the previous hitobject to the start position of this 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;
+    jumpDistance: number;
     /**
      * The normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
      *
@@ -208,51 +69,114 @@ 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.
      *
      * Calculated as the angle between the circles (current-2, current-1, current).
      */
-    angle: number | null;
+    angleSigned: number | null;
+    /**
+     * Unsigned angle the player has to take to hit this hitobject.
+     *
+     * Calculated as the angle between the circles (current-2, current-1, current).
+     */
+    get angle(): number | null;
+    /**
+     * Angle of the vector created between current and current-1 normalized to consider
+     * symmetrical vectors in any axis to be the same angle.
+     */
+    normalizedVectorAngle: number | null;
     /**
      * 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;
+    /**
+     * The amount of milliseconds elapsed between the last {@link DifficultyHitObject}'s {@link endTime} and
+     * this {@link DifficultyHitObject}'s {@link startTime} capped to a minimum of {@link minDeltaTime}ms.
+     */
+    readonly lastObjectEndDeltaTime: 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.
+     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
      */
-    noteDensity: number;
+    readonly timePreempt: number;
     /**
-     * The overlapping factor of the hitobject.
-     *
-     * This is used to scale visual skill.
+     * The beatmap clock rate.
      */
-    overlappingFactor: number;
+    readonly clockRate: number;
     /**
-     * Adjusted velocity of the hitobject, taking speed multiplier into account.
+     * Selective bonus for beatmaps with higher circle size.
      */
-    velocity: number;
+    abstract get smallCircleBonus(): number;
+    /**
+     * This {@link DifficultyHitObject}'s immediate overall difficulty value calculated from the raw hitwindow.
+     */
+    get overallDifficulty(): number;
     /**
      * Other hitobjects in the beatmap, including this hitobject.
      */
-    private readonly hitObjects;
+    protected readonly hitObjects: readonly DifficultyHitObject[];
+    /**
+     * The normalized radius of the hitobject.
+     */
+    abstract readonly normalizedRadius: number;
+    /**
+     * The normalized diameter of the hitobject.
+     */
+    get normalizedDiameter(): number;
+    protected abstract readonly mode: Modes;
+    protected get maximumSliderRadius(): number;
+    protected get 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, lastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, index: number);
+    /**
+     * Computes the properties of this hitobject.
+     *
+     * @param clockRate The clock rate of the beatmap.
      */
-    constructor(object: PlaceableHitObject, hitObjects: DifficultyHitObject[]);
+    computeProperties(clockRate: number): void;
     /**
      * Gets the difficulty hitobject at a specific index with respect to the current
      * difficulty hitobject's index.
@@ -263,7 +187,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,119 +198,179 @@ 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 mods The mods used. Defaults to No Mod.
      * @returns The opacity of the hitobject at the given time.
      */
-    opacityAt(time: number, isHidden: boolean): 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;
+    getDoubletapness(nextObj: this | null): number;
+    /**
+     * Retrieves the full rate-adjusted hit window for a {@link HitResult}.
+     */
+    hitWindowFor(result: HitResult): number;
+    /**
+     * The {@link HitWindow} for this {@link DifficultyHitObject}.
+     */
+    protected get rawHitWindow(): HitWindow;
+    private setDistances;
+    private calculateAngle;
+    private calculateSliderAngle;
+    private calculateSliderCursorPosition;
+    private getEndCursorPosition;
 }
 
 /**
- * A bare minimal abstract skill for fully custom skill implementations.
- *
- * This class should be considered a "processing" class and not persisted.
+ * Holds data that can be used to calculate performance points.
  */
-declare abstract class Skill {
+interface IDifficultyAttributes {
     /**
-     * The mods that this skill processes.
+     * The mods which were applied to the beatmap.
      */
-    protected readonly mods: Mod[];
-    constructor(mods: Mod[]);
+    mods: ModMap;
     /**
-     * Processes a hitobject.
-     *
-     * @param current The hitobject to process.
+     * The combined star rating of all skills.
      */
-    abstract process(current: DifficultyHitObject): void;
+    starRating: number;
     /**
-     * Returns the calculated difficulty value representing all hitobjects that have been processed up to this point.
+     * The maximum achievable combo.
      */
-    abstract difficultyValue(): 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 {
+    maxCombo: number;
     /**
-     * The strain of currently calculated hitobject.
+     * The difficulty corresponding to the aim skill.
      */
-    protected currentStrain: number;
+    aimDifficulty: number;
     /**
-     * The current section's strain peak.
+     * The difficulty corresponding to the flashlight skill.
      */
-    protected currentSectionPeak: number;
+    flashlightDifficulty: number;
     /**
-     * Strain peaks are stored here.
+     * The difficulty corresponding to the reading skill.
      */
-    readonly strainPeaks: number[];
+    readingDifficulty: number;
     /**
-     * The number of sections with the highest strains, which the peak strain reductions will apply to.
-     * This is done in order to decrease their impact on the overall difficulty of the map for this skill.
+     * The number of clickable objects weighted by difficulty.
+     *
+     * Related to speed/tap difficulty.
      */
-    protected abstract readonly reducedSectionCount: number;
+    speedNoteCount: number;
     /**
-     * The baseline multiplier applied to the section with the biggest strain.
+     * Describes how much of aim difficulty is contributed to by hitcircles or sliders.
+     *
+     * A value closer to 1 indicates most of aim difficulty is contributed by hitcircles.
+     *
+     * A value closer to 0 indicates most of aim difficulty is contributed by sliders.
      */
-    protected abstract readonly reducedSectionBaseline: number;
+    sliderFactor: number;
     /**
-     * Strain values are multiplied by this number for the given skill. Used to balance the value of different skills between each other.
+     * The overall clock rate that was applied to the beatmap.
      */
-    protected abstract readonly skillMultiplier: number;
+    clockRate: number;
     /**
-     * Determines how quickly strain decays for the given skill.
+     * The perceived overall difficulty **exclusive** of rate-adjusting mods (DT/HT/etc).
      *
-     * For example, a value of 0.15 indicates that strain decays to 15% of its original value in one second.
+     * Rate-adjusting mods don't directly affect the overall difficulty value, but have a perceived effect as a result of adjusting audio timing.
      */
-    protected abstract readonly strainDecayBase: number;
-    private readonly sectionLength;
-    private currentSectionEnd;
+    overallDifficulty: 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 number of hitcircles in the beatmap.
      */
-    process(current: DifficultyHitObject): void;
+    hitCircleCount: number;
     /**
-     * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
+     * The number of sliders in the beatmap.
+     */
+    sliderCount: number;
+    /**
+     * The number of spinners in the beatmap.
+     */
+    spinnerCount: number;
+    /**
+     * The number of sliders weighted by difficulty.
      */
-    saveCurrentPeak(): void;
+    aimDifficultSliderCount: number;
+    /**
+     * The amount of strains that are considered difficult with respect to the aim skill.
+     */
+    aimDifficultStrainCount: number;
     /**
-     * Calculates strain decay for a specified time frame.
+     * Describes how much of {@link aimDifficultStrainCount} is contributed to by circles or sliders.
      *
-     * @param ms The time frame to calculate.
+     * A value closer to 0 indicates most of {@link aimDifficultStrainCount} is contributed by circles.
+     *
+     * A value closer to infinity indicates most of {@link aimDifficultStrainCount} is contributed by sliders.
      */
-    protected strainDecay(ms: number): number;
+    aimTopWeightedSliderFactor: number;
     /**
-     * Calculates the strain value at a hitobject.
+     * The amount of notes that are considered difficult with respect to the reading skill.
      */
-    protected abstract strainValueAt(current: DifficultyHitObject): number;
+    readingDifficultNoteCount: number;
+}
+
+/**
+ * Represents difficulty attributes that can be cached.
+ */
+type CacheableDifficultyAttributes<T extends IDifficultyAttributes> = Omit<T, "mods" | "toCacheableAttributes"> & {
     /**
-     * Saves the current strain to a hitobject.
+     * The mods which were applied to the beatmap.
      */
-    protected abstract saveToHitObject(current: DifficultyHitObject): void;
+    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;
+    readingDifficulty: number;
+    speedNoteCount: number;
+    sliderFactor: number;
+    clockRate: number;
+    overallDifficulty: number;
+    hitCircleCount: number;
+    sliderCount: number;
+    spinnerCount: number;
+    aimDifficultSliderCount: number;
+    aimDifficultStrainCount: number;
+    aimTopWeightedSliderFactor: number;
+    readingDifficultNoteCount: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IDifficultyAttributes>);
     /**
-     * Sets the initial strain level for a new section.
+     * Converts this `DifficultyAttributes` instance to an attribute structure that can be cached.
      *
-     * @param offset The beginning of the new section in milliseconds, adjusted by speed multiplier.
-     * @param current The current hitobject.
+     * @returns The cacheable attributes.
      */
-    private startNewSectionFrom;
+    toCacheableAttributes(): CacheableDifficultyAttributes<this>;
+    /**
+     * Returns a string representation of the difficulty attributes.
+     */
+    toString(): string;
+}
+
+/**
+ * Represents a strain peak at a specific point in time.
+ */
+interface TimedStrainPeak {
+    /**
+     * The time at which this peak occurs, in milliseconds.
+     */
+    readonly time: number;
+    /**
+     * The strain value of this peak.
+     */
+    readonly value: number;
 }
 
 /**
@@ -396,267 +380,385 @@ interface StrainPeaks {
     /**
      * The strain peaks of aim difficulty if sliders are considered.
      */
-    aimWithSliders: number[];
+    aimWithSliders: readonly TimedStrainPeak[];
     /**
      * The strain peaks of aim difficulty if sliders are not considered.
      */
-    aimWithoutSliders: number[];
+    aimWithoutSliders: readonly TimedStrainPeak[];
     /**
      * The strain peaks of speed difficulty.
      */
-    speed: number[];
+    speed: readonly TimedStrainPeak[];
     /**
      * The strain peaks of flashlight difficulty.
      */
-    flashlight: number[];
+    flashlight: readonly TimedStrainPeak[];
 }
 
 /**
- * The base of difficulty calculators.
+ * An interface for `Skill`s that have peak difficulties.
  */
-declare abstract class DifficultyCalculator {
+interface IHasPeakDifficulty {
     /**
-     * The calculated beatmap.
+     * The peak difficulties calculated by this `Skill`, in chronological order.
      */
-    readonly beatmap: Beatmap;
+    get peaks(): readonly TimedStrainPeak[];
+}
+
+/**
+ * A bare minimal abstract skill for fully custom skill implementations.
+ */
+declare abstract class Skill {
     /**
-     * The difficulty objects of the beatmap.
+     * The mods that this skill processes.
      */
-    readonly objects: DifficultyHitObject[];
+    protected readonly mods: ModMap;
+    private _objectDifficulties;
     /**
-     * The modifications applied.
+     * The difficulties of {@link DifficultyHitObject}s, populated by {@link Skill.process}.
      */
-    mods: Mod[];
+    protected get objectDifficulties(): readonly number[];
+    constructor(mods: ModMap);
     /**
-     * The total star rating of the beatmap.
+     * 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.
      */
-    total: number;
+    process(current: DifficultyHitObject): void;
     /**
-     * The map statistics of the beatmap after modifications are applied.
+     * Returns the calculated difficulty value representing all hitobjects that have been processed up to this point.
      */
-    stats: MapStats;
+    abstract difficultyValue(): number;
     /**
-     * The strain peaks of various calculated difficulties.
+     * Saves the calculated difficulty to a {@link DifficultyHitObject}.
+     *
+     * @param current The {@link DifficultyHitObject} to save the difficulty to.
+     * @param difficulty The difficulty to save.
      */
-    readonly strainPeaks: StrainPeaks;
+    protected saveToHitObject(current: DifficultyHitObject, difficulty: number): void;
     /**
-     * Holds data that can be used to calculate performance points.
+     * Calculates the difficulty value of a hitobject and stores the value in it.
+     *
+     * @param current The hitobject to process.
      */
-    abstract readonly attributes: DifficultyAttributes;
-    protected abstract readonly difficultyMultiplier: number;
-    protected abstract readonly mode: Modes;
+    protected abstract processInternal(current: DifficultyHitObject): number;
+}
+
+/**
+ * Wraps a `DifficultyAttributes` object and adds a time value for which the attribute is valid.
+ *
+ * Output by `DifficultyCalculator.calculateTimed` methods.
+ */
+interface TimedDifficultyAttributes<TAttributes extends DifficultyAttributes> {
     /**
-     * Constructs a new instance of the calculator.
-     *
-     * @param beatmap The beatmap to calculate. This beatmap will be deep-cloned to prevent reference changes.
+     * The non-clock-adjusted time value at which the attributes take effect.
      */
-    constructor(beatmap: Beatmap);
+    readonly time: number;
     /**
-     * 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.
-     *
-     * @param options Options for the difficulty calculation.
-     * @returns The current instance.
+     * The attributes.
      */
-    calculate(options?: DifficultyCalculationOptions): this;
+    readonly attributes: TAttributes;
     /**
-     * Generates difficulty hitobjects for this calculator.
+     * The number of sliders in the beatmap up to this point.
      */
-    generateDifficultyHitObjects(): void;
+    readonly sliderCount: number;
     /**
-     * Performs some pre-processing before proceeding with difficulty calculation.
+     * The number of slider ticks in the beatmap up to this point.
      */
-    protected preProcess(): void;
+    readonly sliderTickCount: number;
     /**
-     * Calculates the skills provided.
+     * The number of slider repeats in the beatmap up to this point.
+     */
+    readonly sliderRepeatCount: number;
+}
+
+/**
+ * The base of a difficulty calculator.
+ */
+declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, THitObject extends DifficultyHitObject, TAttributes extends DifficultyAttributes> {
+    /**
+     * `Mod`s that adjust the difficulty of a beatmap.
+     */
+    protected readonly difficultyAdjustmentMods: (typeof Mod)[];
+    /**
+     * Retains `Mod`s that adjust a beatmap's difficulty from the specified mods.
      *
-     * @param skills The skills to calculate.
+     * @param mods The mods to retain the difficulty adjustment mods from.
+     * @returns The retained difficulty adjustment mods.
      */
-    protected calculateSkills(...skills: StrainSkill[]): void;
+    abstract retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
     /**
-     * Calculates the total star rating of the beatmap and stores it in this instance.
+     * Calculates the difficulty of a `Beatmap` with specific `Mod`s.
+     *
+     * @param beatmap The `Beatmap` whose difficulty is to be calculated.
+     * @param mods The `Mod`s to apply to the beatmap. Defaults to No Mod.
+     * @returns A `DifficultyAttributes` object describing the difficulty of the `Beatmap`.
+     */
+    calculate(beatmap: Beatmap, mods?: ModMap): TAttributes;
+    /**
+     * Obtains the strain peaks of a `PlayableBeatmap`.
+     *
+     * @param beatmap The `PlayableBeatmap` whose strain peaks are to be calculated.
+     * @returns The strain peaks of the `PlayableBeatmap`.
      */
-    abstract calculateTotal(): void;
+    calculateStrainPeaks(beatmap: TBeatmap): StrainPeaks;
     /**
-     * Calculates every star rating of the beatmap and stores it in this instance.
+     * Obtains the strain peaks of a `Beatmap` with specific `Mod`s.
+     *
+     * @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`.
+     */
+    calculateStrainPeaks(beatmap: Beatmap, mods?: ModMap): StrainPeaks;
+    /**
+     * Calculates the difficulty of a `Beatmap` with specific `Mod`s and returns a set of
+     * `TimedDifficultyAttributes` representing the difficulty at every relevant time value in the `Beatmap`.
+     *
+     * @param beatmap The `Beatmap` whose difficulty is to be calculated.
+     * @param mods The `Mod`s to apply to the `Beatmap`.
+     * @return The set of `TimedDifficultyAttributes`.
      */
-    abstract calculateAll(): void;
+    calculateTimed(beatmap: Beatmap, mods?: ModMap): TimedDifficultyAttributes<TAttributes>[];
     /**
-     * Returns a string representative of the class.
+     * Creates the `Skill`s to calculate the difficulty of a `PlayableBeatmap`.
+     *
+     * @param beatmap The `PlayableBeatmap` whose difficulty will be calculated.
+     * @returns The `Skill`s.
      */
-    abstract toString(): string;
+    protected abstract createSkills(beatmap: TBeatmap): Skill[];
     /**
-     * Creates skills to be calculated.
+     * Creates the `Skill`s to obtain the strain peaks of a `PlayableBeatmap`.
+     *
+     * @param beatmap The `PlayableBeatmap` whose strain peaks will be calculated.
+     * @returns The `Skill`s.
      */
-    protected abstract createSkills(): StrainSkill[];
+    protected abstract createStrainPeakSkills(beatmap: TBeatmap): (Skill & IHasPeakDifficulty)[];
     /**
-     * Populates the stored difficulty attributes with necessary data.
+     * Creates difficulty hitobjects for this calculator.
+     *
+     * @param beatmap The beatmap to generate difficulty hitobjects from.
+     * @returns The generated difficulty hitobjects.
      */
-    protected populateDifficultyAttributes(): void;
+    protected abstract createDifficultyHitObjects(beatmap: TBeatmap): THitObject[];
     /**
-     * Calculates the star rating value of a difficulty.
+     * Creates a `DifficultyAttributes` object to describe a `PlayableBeatmap`'s difficulty.
      *
-     * @param difficulty The difficulty to calculate.
+     * @param beatmap The `Beatmap` whose difficulty was calculated.
+     * @param playableBeatmap 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.
      */
-    protected starValue(difficulty: number): number;
+    protected abstract createDifficultyAttributes(beatmap: Beatmap, playableBeatmap: PlayableBeatmap, skills: Skill[], objects: THitObject[]): TAttributes;
     /**
-     * Calculates the base performance value of a difficulty rating.
+     * Constructs a `PlayableBeatmap` from a `Beatmap` with specific `Mod`s.
      *
-     * @param rating The difficulty rating.
+     * @param beatmap The `Beatmap` to create a `PlayableBeatmap` from.
+     * @param mods The `Mod`s to apply to the `Beatmap`.
+     * @returns The `PlayableBeatmap`.
      */
-    protected basePerformanceValue(rating: number): number;
+    protected abstract createPlayableBeatmap(beatmap: Beatmap, mods?: ModMap): TBeatmap;
 }
 
 /**
- * A converter used to convert normal hitobjects into difficulty hitobjects.
+ * Represents options for performance calculation.
  */
-declare class DifficultyHitObjectCreator {
+interface PerformanceCalculationOptions {
     /**
-     * The threshold for small circle buff for osu!droid.
+     * The maximum combo achieved in the score.
      */
-    private readonly DROID_CIRCLESIZE_BUFF_THRESHOLD;
+    combo?: number;
     /**
-     * The threshold for small circle buff for osu!standard.
+     * The accuracy achieved in the score.
      */
-    private readonly PC_CIRCLESIZE_BUFF_THRESHOLD;
+    accPercent?: Accuracy | number;
     /**
-     * The gamemode this creator is creating for.
+     * The amount of misses achieved in the score.
+     *
+     * If {@link accPercent} is provided as an {@link Accuracy} object, this value will be ignored.
      */
-    private mode;
+    miss?: number;
     /**
-     * The base normalized radius of hitobjects.
+     * The amount of slider ends dropped in the score.
      */
-    private readonly normalizedRadius;
-    private maximumSliderRadius;
-    private readonly assumedSliderRadius;
-    private readonly minDeltaTime;
+    sliderEndsDropped?: number;
     /**
-     * Generates difficulty hitobjects for difficulty calculation.
+     * The amount of slider ticks missed in the score.
      */
-    generateDifficultyObjects(params: {
-        objects: readonly HitObject[];
-        circleSize: number;
-        mods: Mod[];
-        speedMultiplier: number;
-        mode: Modes;
-        preempt?: number;
-    }): DifficultyHitObject[];
+    sliderTicksMissed?: number;
     /**
-     * Calculates a slider's cursor position.
+     * The tap penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
      */
-    private calculateSliderCursorPosition;
+    tapPenalty?: number;
     /**
-     * Gets the scaling factor of a radius.
-     *
-     * @param radius The radius to get the scaling factor from.
+     * The aim slider cheese penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
      */
-    private getScalingFactor;
+    sliderCheesePenalty?: number;
     /**
-     * Returns the end cursor position of a hitobject.
+     * The total score achieved in the score.
      */
-    private getEndCursorPosition;
-    private applyToOverlappingFactor;
+    totalScore?: number;
 }
 
 /**
- * Represents a slider that is considered difficult.
- *
- * This structure is a part of difficulty attributes and can be cached.
+ * Represents the calculated performance of a score.
  */
-interface DifficultSlider {
+interface IPerformanceAttributes {
     /**
-     * The index of the slider in the beatmap.
+     * Calculated score performance points.
      */
-    readonly index: number;
+    total: number;
     /**
-     * The difficulty rating of this slider compared to other sliders, based on the velocity of the slider.
-     *
-     * A value closer to 1 indicates that this slider is more difficult compared to most sliders.
-     *
-     * A value closer to 0 indicates that this slider is easier compared to most sliders.
+     * The amount of misses, including slider breaks.
      */
-    readonly difficultyRating: number;
+    effectiveMissCount: 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.
+ * The base class of performance calculators.
  */
-declare abstract class DroidSkill extends StrainSkill {
+declare abstract class PerformanceCalculator<TDifficultyAttributes extends IDifficultyAttributes, TPerformanceAttributes extends IPerformanceAttributes> {
     /**
-     * The bonus multiplier that is given for a sequence of notes of equal difficulty.
+     * The calculated accuracy.
      */
-    protected abstract readonly starsPerDouble: 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 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);
+    computedAccuracy: Accuracy;
     /**
-     * @param current The hitobject to calculate.
+     * The calculated maximum combo.
+     */
+    combo: number;
+    /**
+     * The difficulty attributes that is being calculated.
+     */
+    readonly difficultyAttributes: TDifficultyAttributes | CacheableDifficultyAttributes<TDifficultyAttributes>;
+    /**
+     * The mods that were used.
+     */
+    protected readonly mods: ModMap;
+    private _sliderEndsDropped;
+    /**
+     * The amount of slider ends dropped in the score.
+     */
+    protected get sliderEndsDropped(): number;
+    private _sliderTicksMissed;
+    /**
+     * The amount of slider ticks missed in the score.
+     *
+     * This is used to calculate the slider accuracy.
+     */
+    protected get sliderTicksMissed(): number;
+    private _usingClassicSliderAccuracy;
+    /**
+     * Whether this score uses classic slider accuracy.
+     */
+    protected get usingClassicSliderAccuracy(): boolean;
+    /**
+     * @param difficultyAttributes The difficulty attributes to calculate.
+     */
+    constructor(difficultyAttributes: TDifficultyAttributes | CacheableDifficultyAttributes<TDifficultyAttributes>);
+    /**
+     * Calculates the performance points of the beatmap.
+     *
+     * @param options Options for performance calculation.
+     * @returns The attributes representing the performance.
+     */
+    calculate(options?: PerformanceCalculationOptions): TPerformanceAttributes;
+    /**
+     * Creates the performance attributes for this calculator.
+     *
+     * @returns The performance attributes.
+     */
+    protected abstract createPerformanceAttributes(): TPerformanceAttributes;
+    /**
+     * The total hits that can be done in the beatmap.
+     */
+    protected get totalHits(): number;
+    /**
+     * The total hits that were successfully done.
+     */
+    protected get totalSuccessfulHits(): number;
+    /**
+     * The total of imperfect hits (100s, 50s, misses).
+     */
+    protected get totalImperfectHits(): number;
+    /**
+     * Processes given options for usage in performance calculation.
+     *
+     * @param options Options for performance calculation.
      */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
-     * @param current The hitobject to save to.
+     * Determines whether an attribute is a cacheable attribute.
+     *
+     * @param attributes The attributes to check.
+     * @returns Whether the attributes are cacheable.
      */
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    private isCacheableAttribute;
 }
 
 /**
- * An evaluator for calculating osu!droid Aim skill.
+ * Represents an osu!droid hit object with difficulty calculation values.
  */
-declare abstract class DroidAimEvaluator extends AimEvaluator {
-    protected static readonly wideAngleMultiplier: number;
-    protected static readonly sliderMultiplier: number;
-    protected static readonly velocityChangeMultiplier: number;
+declare class DroidDifficultyHitObject extends DifficultyHitObject {
     /**
-     * Spacing threshold for a single hitobject spacing.
+     * The tap difficulty generated by the hitobject.
      */
-    private static readonly SINGLE_SPACING_THRESHOLD;
-    private static readonly minSpeedBonus;
+    tapDifficulty: number;
     /**
-     * Evaluates the difficulty of aiming the current object, based on:
+     * The tap difficulty generated by the hitobject if `strainTime` isn't modified by
+     * OD. This is used in three-finger detection.
+     */
+    originalTapDifficulty: number;
+    /**
+     * The rhythm difficulty generated by the hitobject.
+     */
+    rhythmDifficulty: number;
+    readonly normalizedRadius = 50;
+    protected readonly mode = Modes.Droid;
+    protected get maximumSliderRadius(): number;
+    get smallCircleBonus(): number;
+    opacityAt(time: number, mods?: ModMap): number;
+    previous(backwardsIndex: number): this | null;
+    next(forwardsIndex: number): this | null;
+    /**
+     * Determines whether this hitobject is considered overlapping with the hitobject before it.
      *
-     * - cursor velocity to the current object,
-     * - angle difficulty,
-     * - sharp velocity increases,
-     * - and slider difficulty.
+     * 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.
      *
-     * @param current The current object.
-     * @param withSliders Whether to take slider difficulty into account.
+     * 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.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, withSliders: boolean): number;
+    isOverlapping(considerDistance: boolean): boolean;
+}
+
+/**
+ * Represents a slider that is considered difficult.
+ *
+ * This structure is a part of difficulty attributes and can be cached.
+ */
+interface DifficultSlider {
     /**
-     * Calculates the aim strain of a hitobject.
+     * The index of the slider in the beatmap.
      */
-    private static aimStrainOf;
+    readonly index: number;
     /**
-     * Calculates the movement strain of a hitobject.
+     * The difficulty rating of this slider compared to other sliders, based on the velocity of the slider.
+     *
+     * A value closer to 1 indicates that this slider is more difficult compared to most sliders.
+     *
+     * A value closer to 0 indicates that this slider is easier compared to most sliders.
      */
-    private static movementStrainOf;
+    readonly difficultyRating: number;
 }
 
 /**
  * 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.
      */
@@ -665,30 +767,35 @@ interface DroidDifficultyAttributes extends DifficultyAttributes {
      * The difficulty corresponding to the rhythm skill.
      */
     rhythmDifficulty: number;
-    /**
-     * The difficulty corresponding to the visual skill.
-     */
-    visualDifficulty: number;
-    /**
-     * The amount of strains that are considered difficult with respect to the aim skill.
-     */
-    aimDifficultStrainCount: number;
     /**
      * The amount of strains that are considered difficult with respect to the tap skill.
      */
     tapDifficultStrainCount: number;
     /**
-     * The amount of strains that are considered difficult with respect to the flashlight skill.
-     */
-    flashlightDifficultStrainCount: number;
-    /**
-     * The amount of strains that are considered difficult with respect to the visual skill.
+     * Describes how much of {@link tapDifficultStrainCount} is contributed to by circles or sliders.
+     *
+     * A value closer to 0 indicates most of {@link tapDifficultStrainCount} is contributed by circles.
+     *
+     * A value closer to infinity indicates most of {@link tapDifficultStrainCount} is contributed by sliders.
      */
-    visualDifficultStrainCount: number;
+    tapTopWeightedSliderFactor: number;
     /**
-     * The average delta time of speed objects.
+     * The maximum score obtainable on the beatmap.
      */
-    averageSpeedDeltaTime: number;
+    maximumScore: number;
+}
+
+/**
+ * Holds data that can be used to calculate osu!droid performance points.
+ */
+declare class DroidDifficultyAttributes extends DifficultyAttributes implements IDroidDifficultyAttributes {
+    tapDifficulty: number;
+    tapTopWeightedSliderFactor: number;
+    rhythmDifficulty: number;
+    tapDifficultStrainCount: number;
+    maximumScore: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IDroidDifficultyAttributes>);
+    toString(): string;
 }
 
 /**
@@ -713,7 +820,11 @@ interface HighStrainSection {
  * 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 {
+interface IExtendedDroidDifficultyAttributes extends IDroidDifficultyAttributes {
+    /**
+     * The mode of the difficulty calculation.
+     */
+    mode: "live";
     /**
      * Possible sections at which the player can use three fingers on.
      */
@@ -722,176 +833,212 @@ interface ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes {
      * Sliders that are considered difficult.
      */
     difficultSliders: DifficultSlider[];
-    /**
-     * The number of clickable objects weighted by difficulty.
-     *
-     * Related to aim difficulty.
-     */
-    aimNoteCount: 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.
-     */
-    flashlightSliderFactor: number;
-    /**
-     * Describes how much of visual difficulty is contributed to by hitcircles or sliders.
-     *
-     * A value closer to 1 indicates most of visual difficulty is contributed by hitcircles.
-     *
-     * A value closer to 0 indicates most of visual difficulty is contributed by sliders.
-     */
-    visualSliderFactor: 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.
+ */
+declare class ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes implements IExtendedDroidDifficultyAttributes {
+    mode: "live";
+    possibleThreeFingeredSections: HighStrainSection[];
+    difficultSliders: DifficultSlider[];
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IExtendedDroidDifficultyAttributes>);
 }
 
 /**
  * A difficulty calculator for osu!droid gamemode.
  */
-declare class DroidDifficultyCalculator extends DifficultyCalculator {
+declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidPlayableBeatmap, DroidDifficultyHitObject, ExtendedDroidDifficultyAttributes> {
+    constructor();
+    retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
+    protected createDifficultyAttributes(beatmap: Beatmap, playableBeatmap: PlayableBeatmap, 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): (Skill & IHasPeakDifficulty)[];
+    private populateAimAttributes;
+    private populateTapAttributes;
+    private populateRhythmAttributes;
+    private populateFlashlightAttributes;
+    private populateReadingAttributes;
+    private calculateAimDifficultyRating;
+    private calculateDifficultyRating;
+    static sumCognitionDifficulty(reading: number, flashlight: number): number;
+}
+
+/**
+ * Represents the calculated performance of a score in osu!droid.
+ */
+interface IDroidPerformanceAttributes extends IPerformanceAttributes {
     /**
-     * The aim star rating of the beatmap.
+     * The aim performance points.
      */
     aim: number;
     /**
-     * The tap star rating of the beatmap.
+     * The tap performance points.
      */
     tap: number;
     /**
-     * The rhythm star rating of the beatmap.
+     * The accuracy performance points.
      */
-    rhythm: number;
+    accuracy: number;
     /**
-     * The flashlight star rating of the beatmap.
+     * The flashlight performance points.
      */
     flashlight: number;
     /**
-     * The visual star rating of the beatmap.
+     * The reading performance points.
      */
-    visual: number;
+    reading: number;
     /**
-     * The strain threshold to start detecting for possible three-fingered section.
-     *
-     * Increasing this number will result in less sections being flagged.
+     * The penalty used to penalize the tap performance points.
+     */
+    tapPenalty: number;
+    /**
+     * The estimated deviation of the score.
      */
-    static readonly threeFingerStrainThreshold: number;
-    readonly attributes: ExtendedDroidDifficultyAttributes;
-    protected readonly difficultyMultiplier: number;
-    protected readonly mode: Modes;
+    deviation: number;
     /**
-     * Calculates the aim star rating of the beatmap and stores it in this instance.
+     * The estimated tap deviation of the score.
      */
-    calculateAim(): void;
+    tapDeviation: number;
     /**
-     * Calculates the tap star rating of the beatmap and stores it in this instance.
+     * The penalty used to penalize the aim performance points.
      */
-    calculateTap(): void;
+    sliderCheesePenalty: number;
+}
+
+/**
+ * A performance points calculator that calculates performance points for osu!droid gamemode.
+ */
+declare class DroidPerformanceCalculator extends PerformanceCalculator<IDroidDifficultyAttributes, IDroidPerformanceAttributes> {
     /**
-     * Calculates the rhythm star rating of the beatmap and stores it in this instance.
+     * The total score achieved in the score.
      */
-    calculateRhythm(): void;
+    get totalScore(): number | null;
+    static readonly finalMultiplier = 1.24;
+    static readonly normExponent = 1.1;
+    private _sliderCheesePenalty;
+    private _tapPenalty;
+    private _effectiveMissCount;
+    private _deviation;
+    private _tapDeviation;
+    private _totalScore;
+    protected createPerformanceAttributes(): IDroidPerformanceAttributes;
+    protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
-     * Calculates the flashlight star rating of the beatmap and stores it in this instance.
+     * Calculates the aim performance value of the beatmap.
      */
-    calculateFlashlight(): void;
+    private calculateAimValue;
     /**
-     * Calculates the visual star rating of the beatmap and stores it in this instance.
+     * Calculates the tap performance value of the beatmap.
      */
-    calculateVisual(): void;
-    calculateTotal(): void;
-    calculateAll(): void;
-    toString(): string;
-    protected preProcess(): void;
-    protected createSkills(): DroidSkill[];
+    private calculateTapValue;
     /**
-     * Called after aim skill calculation.
-     *
-     * @param aimSkill The aim skill that considers sliders.
-     * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
+     * Calculates the accuracy performance value of the beatmap.
+     */
+    private calculateAccuracyValue;
+    /**
+     * Calculates the flashlight performance value of the beatmap.
      */
-    private postCalculateAim;
+    private calculateFlashlightValue;
     /**
-     * Calculates aim-related attributes.
+     * Calculates the reading performance value of the beatmap.
      */
-    private calculateAimAttributes;
+    private calculateReadingValue;
     /**
-     * Called after tap skill calculation.
+     * Calculates a strain-based miss penalty.
      *
-     * @param tapSkill The tap skill.
+     * 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.
      */
-    private postCalculateTap;
+    private calculateStrainBasedMissPenalty;
     /**
-     * Calculates speed-related attributes.
+     * The object-based proportional miss penalty.
      */
-    private calculateSpeedAttributes;
+    private get proportionalMissPenalty();
     /**
-     * Calculates the sum of strains for possible three-fingered sections.
+     * 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
+     * with the same settings will always return the same deviation.
+     *
+     * Sliders are treated as circles with a 50 hit window.
+     *
+     * Misses are ignored because they are usually due to misaiming, and 50s
+     * are grouped with 100s since they are usually due to misreading.
      *
-     * @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.
+     * Inaccuracies are capped to the number of circles in the map.
      */
-    private calculateThreeFingerSummedStrain;
+    private calculateAimDeviation;
     /**
-     * Called after rhythm skill calculation.
+     * Does the same as {@link calculateAimDeviation}, but only for notes and inaccuracies that are relevant to tap difficulty.
      *
-     * @param rhythmSkill The rhythm skill.
+     * Treats all difficult speed notes as circles, so this method can sometimes return a lower deviation than {@link calculateAimDeviation}.
+     * This is fine though, since this method is only used to scale tap pp.
      */
-    private postCalculateRhythm;
+    private calculateTapDeviation;
     /**
-     * Called after flashlight skill calculation.
+     * 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.
      *
-     * @param flashlightSkill The flashlight skill that considers sliders.
-     * @param flashlightSkillWithoutSliders The flashlight skill that doesn't consider sliders.
+     * Greats and oks are assumed to follow a normal distribution, whereas mehs are assumed to follow a uniform distribution.
      */
-    private postCalculateFlashlight;
+    private calculateDeviation;
     /**
-     * Called after visual skill calculation.
+     * Calculates a multiplier for tap to account for improper tapping based on the deviation and tap difficulty.
      *
-     * @param visualSkillWithSliders The visual skill that considers sliders.
-     * @param visualSkillWithoutSliders The visual skill that doesn't consider sliders.
+     * [Graph](https://www.desmos.com/calculator/z5l9ebrwpi)
+     */
+    private calculateTapHighDeviationNerf;
+    private getHitWindow;
+    private calculateEstimatedSliderBreaks;
+    private calculateMaximumComboBasedMissCount;
+    /**
+     * Calculates the amount of misses + sliderbreaks from combo.
      */
-    private postCalculateVisual;
+    private calculateComboBasedEstimatedMissCount;
 }
 
 /**
- * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ * An evaluator for calculating osu!droid agility aim difficulty.
  */
-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 abstract class DroidAgilityEvaluator {
     /**
-     * @param current The hitobject to calculate.
+     * Evaluates the difficulty of fast aiming the current object.
+     *
+     * @param current The current object.
      */
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): void;
-    difficultyValue(): number;
-}
-
-/**
- * An evaluator for calculating flashlight skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-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;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject): number;
+    private static highBpmBonus;
 }
 
 /**
  * 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:
      *
@@ -902,240 +1049,466 @@ 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 withSliders Whether to take slider difficulty into account.
+     * @param mods The mods used.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, isHiddenMod: boolean, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: ModMap): number;
 }
 
 /**
- * Represents options for performance calculation.
+ * An evaluator for calculating osu!droid flow aim difficulty.
  */
-interface PerformanceCalculationOptions {
+declare abstract class DroidFlowAimEvaluator {
+    private static readonly velocityChangeMultiplier;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, withSliders: boolean): number;
+    private static calculateOverlapFactor;
+}
+
+/**
+ * Evaluator for reading difficulty in osu!droid.
+ */
+declare abstract class DroidReadingEvaluator {
+    private static readonly readingWindowSize;
+    private static readonly hiddenMultiplier;
+    private static readonly traceableMultiplier;
+    private static readonly densityMultiplier;
+    private static readonly densityDifficultyBase;
+    private static readonly preemptBalancingFactor;
+    private static readonly preemptStartingPoint;
+    private static readonly minimumAngleRelevancyTime;
+    private static readonly maximumAngleRelevancyTime;
     /**
-     * The maximum combo achieved in the score.
+     * Evaluates the difficulty of reading the object.
      */
-    combo?: number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: ModMap): number;
     /**
-     * The accuracy achieved in the score.
+     * Calculates the density difficulty of the current object and how hard it is to aim it because of it based on:
+     *
+     * - cursor velocity to the current object,
+     * - how many times the current object's angle was repeated,
+     * - density of objects visible when the current object appears, and
+     * - density of objects visible when the current object needs to be clicked.
      */
-    accPercent?: Accuracy | number;
+    private static calculateDensityDifficulty;
     /**
-     * The amount of misses achieved in the score.
+     * Calculates the difficulty of aiming the current object when the approach rate is very high based on:
+     *
+     * - cursor velocity to the current object,
+     * - how many times the current object's angle was repeated, and
+     * - how many milliseconds elapse between the approach circle appearing and touching the inner circle.
      */
-    miss?: number;
+    private static calculatePreemptDifficulty;
     /**
-     * The tap penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
+     * Calculates the difficulty of aiming the current object when the Hidden mod is active based on:
+     *
+     * - cursor velocity to the current object,
+     * - time the current object spends invisible,
+     * - density of objects visible when the current object appears,
+     * - density of objects visible when the current object needs to be clicked,
+     * - how many times the current object's angle was repeated, and
+     * - if the current object is perfectly stacked to the previous one.
      */
-    tapPenalty?: number;
+    private static calculateHiddenDifficulty;
+    private static calculateTraceableDifficulty;
+    private static getPastObjectDifficultyInfluence;
     /**
-     * The aim slider cheese penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
+     * Returns a list of objects that are visible on screen at the point in time the current object becomes visible.
      */
-    aimSliderCheesePenalty?: number;
+    private static retrievePastVisibleObjects;
     /**
-     * The flashlight slider cheese penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
+     * Returns the density of objects visible at the point in time the current object needs to be clicked capped by the reading window.
      */
-    flashlightSliderCheesePenalty?: number;
+    private static retrieveCurrentVisibleObjectDensity;
     /**
-     * The visual slider cheese penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
+     * Returns a factor of how often the current object's angle has been repeated in a certain time frame.
+     * It does this by checking the difference in angle between current and past objects and sums them based on a range of similarity.
+     * https://www.desmos.com/calculator/eb057a4822
      */
-    visualSliderCheesePenalty?: number;
+    private static getConstantAngleNerfFactor;
+    /**
+     * Returns a nerfing factor for when objects are very distant in time, affecting reading less.
+     */
+    private static getTimeNerfFactor;
+    private static highBpmBonus;
 }
 
 /**
- * The base class of performance calculators.
+ * An evaluator for calculating osu!droid Rhythm skill.
  */
-declare abstract class PerformanceCalculator {
+declare abstract class DroidRhythmEvaluator {
+    private static readonly historyTimeMax;
+    private static readonly historyObjectsMax;
+    private static readonly rhythmOverallMultiplier;
+    private static readonly rhythmRatioMultiplier;
     /**
-     * The overall performance value.
+     * Calculates a rhythm multiplier for the difficulty of the tap associated
+     * with historic data of the current object.
+     *
+     * @param current The current object.
+     * @param useSliderAccuracy Whether to use slider accuracy.
      */
-    total: number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, useSliderAccuracy: boolean): number;
+    private static getEffectiveRatio;
+}
+
+/**
+ * An evaluator for calculating osu!droid snap aim difficulty.
+ */
+declare abstract class DroidSnapAimEvaluator {
+    private static readonly wideAngleMultiplier;
+    private static readonly acuteAngleMultiplier;
+    private static readonly sliderMultiplier;
+    private static readonly velocityChangeMultiplier;
+    private static readonly wiggleMultiplier;
+    private static readonly angleRepetitionNoteLimit;
+    private static readonly maximumRepetitionNerf;
+    private static readonly maximumVectorInfluence;
     /**
-     * The calculated accuracy.
+     * Evaluates the difficulty of aiming the current object, based on:
+     *
+     * - cursor velocity to the current object,
+     * - angle difficulty,
+     * - sharp velocity increases,
+     * - and slider difficulty.
+     *
+     * @param current The current object.
+     * @param withSliders Whether to take slider difficulty into account.
      */
-    computedAccuracy: Accuracy;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, withSliders: boolean): number;
+    private static calculateWideAngleAcuteness;
+    static calculateAcuteAngleAcuteness(angle: number): number;
+    private static highBpmBonus;
+    private static calculateVectorAngleRepetition;
+}
+
+/**
+ * An evaluator for calculating osu!droid tap skill.
+ */
+declare abstract class DroidTapEvaluator {
+    private static readonly minSpeedBonus;
     /**
-     * The difficulty attributes that is being calculated.
+     * Evaluates the difficulty of tapping the current object, based on:
+     *
+     * - time between pressing the previous and current object,
+     * - distance between those objects,
+     * - how easily they can be cheesed,
+     * - and the strain time cap.
+     *
+     * @param current The current object.
+     * @param considerCheesability Whether to consider cheesability.
      */
-    abstract readonly difficultyAttributes: DifficultyAttributes;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, considerCheesability: boolean): number;
+    private static highBpmBonus;
+}
+
+/**
+ * Represents an osu!standard hit object with difficulty calculation values.
+ */
+declare class OsuDifficultyHitObject extends DifficultyHitObject {
     /**
-     * Penalty for combo breaks.
+     * The speed strain generated by the hitobject.
      */
-    protected comboPenalty: number;
+    speedStrain: number;
+    readonly normalizedRadius = 50;
+    get smallCircleBonus(): number;
+    get overallDifficulty(): number;
+    protected readonly mode = Modes.Osu;
+}
+
+/**
+ * An evaluator for calculating osu!standard agility aim difficulty.
+ */
+declare abstract class OsuAgilityEvaluator {
     /**
-     * The global multiplier to be applied to the final performance value.
+     * Evaluates the difficulty of fast aiming the current object.
      *
-     * This is being adjusted to keep the final value scaled around what it used to be when changing things.
-     */
-    protected abstract finalMultiplier: number;
-    /**
-     * The gamemode to calculate for.
+     * @param current The current object.
      */
-    protected abstract readonly mode: Modes;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
+    private static highBpmBonus;
+}
+
+/**
+ * An evaluator for calculating osu!standard Flashlight skill.
+ */
+declare abstract class OsuFlashlightEvaluator {
+    private static readonly maxOpacityBonus;
+    private static readonly hiddenBonus;
+    private static readonly minVelocity;
+    private static readonly sliderMultiplier;
+    private static readonly minAngleMultiplier;
     /**
-     * The amount of misses that are filtered out from sliderbreaks.
+     * Evaluates the difficulty of memorizing and hitting the current object, based on:
+     *
+     * - distance between a number of previous objects and the current object,
+     * - the visual opacity of the current object,
+     * - the angle made by the current object,
+     * - length and speed of the current object (for sliders),
+     * - and whether Hidden mod is enabled.
+     *
+     * @param current The current object.
+     * @param mods The mods used.
      */
-    protected effectiveMissCount: number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: ModMap): number;
+}
+
+/**
+ * An evaluator for calculating osu!standard flow aim difficulty.
+ */
+declare abstract class OsuFlowAimEvaluator {
+    private static readonly velocityChangeMultiplier;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, withSliders: boolean): number;
+    private static calculateOverlapFactor;
+}
+
+/**
+ * Evaluator for reading difficulty in osu!standard.
+ */
+declare abstract class OsuReadingEvaluator {
+    private static readonly readingWindowSize;
+    private static readonly hiddenMultiplier;
+    private static readonly densityMultiplier;
+    private static readonly densityDifficultyBase;
+    private static readonly preemptBalancingFactor;
+    private static readonly preemptStartingPoint;
+    private static readonly minimumAngleRelevancyTime;
+    private static readonly maximumAngleRelevancyTime;
     /**
-     * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
+     * Evaluates the difficulty of reading the object.
      */
-    protected sliderNerfFactor: number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: ModMap): number;
     /**
-     * Calculates the performance points of the beatmap.
+     * Calculates the density difficulty of the current object and how hard it is to aim it because of it based on:
      *
-     * @param options Options for performance calculation.
-     * @returns The current instance.
+     * - cursor velocity to the current object,
+     * - how many times the current object's angle was repeated,
+     * - density of objects visible when the current object appears, and
+     * - density of objects visible when the current object needs to be clicked.
      */
-    calculate(options?: PerformanceCalculationOptions): this;
+    private static calculateDensityDifficulty;
     /**
-     * Returns a string representative of the class.
+     * Calculates the difficulty of aiming the current object when the approach rate is very high based on:
+     *
+     * - cursor velocity to the current object,
+     * - how many times the current object's angle was repeated, and
+     * - how many milliseconds elapse between the approach circle appearing and touching the inner circle.
      */
-    abstract toString(): string;
+    private static calculatePreemptDifficulty;
     /**
-     * Calculates all values that will be used for calculating the total
-     * performance value of the beatmap and stores them in this instance.
+     * Calculates the difficulty of aiming the current object when the Hidden mod is active based on:
+     *
+     * - cursor velocity to the current object,
+     * - time the current object spends invisible,
+     * - density of objects visible when the current object appears,
+     * - density of objects visible when the current object needs to be clicked,
+     * - how many times the current object's angle was repeated, and
+     * - if the current object is perfectly stacked to the previous one.
      */
-    protected abstract calculateValues(): void;
+    private static calculateHiddenDifficulty;
+    private static getPastObjectDifficultyInfluence;
     /**
-     * Calculates the total performance value of the beatmap and stores it in this instance.
+     * Returns a list of objects that are visible on screen at the point in time the current object becomes visible.
      */
-    protected abstract calculateTotalValue(): void;
+    private static retrievePastVisibleObjects;
     /**
-     * The total hits that can be done in the beatmap.
+     * Returns the density of objects visible at the point in time the current object needs to be clicked capped by the reading window.
      */
-    protected get totalHits(): number;
+    private static retrieveCurrentVisibleObjectDensity;
     /**
-     * The total hits that were successfully done.
+     * Returns a factor of how often the current object's angle has been repeated in a certain time frame.
+     * It does this by checking the difference in angle between current and past objects and sums them based on a range of similarity.
+     * https://www.desmos.com/calculator/eb057a4822
      */
-    protected get totalSuccessfulHits(): number;
+    private static getConstantAngleNerfFactor;
     /**
-     * Calculates the base performance value of a star rating.
+     * Returns a nerfing factor for when objects are very distant in time, affecting reading less.
      */
-    protected baseValue(stars: number): number;
+    private static getTimeNerfFactor;
+    private static highBpmBonus;
+}
+
+/**
+ * An evaluator for calculating osu!standard Rhythm skill.
+ */
+declare abstract class OsuRhythmEvaluator {
+    private static readonly historyTimeMax;
+    private static readonly historyObjectsMax;
+    private static readonly rhythmOverallMultiplier;
+    private static readonly rhythmRatioMultiplier;
     /**
-     * Processes given options for usage in performance calculation.
+     * Calculates a rhythm multiplier for the difficulty of the tap associated
+     * with historic data of the current object.
      *
-     * @param options Options for performance calculation.
+     * @param current The current object.
      */
-    protected handleOptions(options?: PerformanceCalculationOptions): void;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
+    private static getEffectiveRatio;
+}
+
+/**
+ * An evaluator for calculating osu!standard snap aim difficulty.
+ */
+declare abstract class OsuSnapAimEvaluator {
+    private static readonly wideAngleMultiplier;
+    private static readonly acuteAngleMultiplier;
+    private static readonly sliderMultiplier;
+    private static readonly velocityChangeMultiplier;
+    private static readonly wiggleMultiplier;
+    private static readonly angleRepetitionNoteLimit;
+    private static readonly maximumRepetitionNerf;
+    private static readonly maximumVectorInfluence;
     /**
-     * Calculates the amount of misses + sliderbreaks from combo.
+     * Evaluates the difficulty of aiming the current object, based on:
+     *
+     * - cursor velocity to the current object,
+     * - angle difficulty,
+     * - sharp velocity increases,
+     * - and slider difficulty.
+     *
+     * @param current The current object.
+     * @param withSliders Whether to take slider difficulty into account.
      */
-    private calculateEffectiveMissCount;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, withSliders: boolean): number;
+    private static calculateWideAngleAcuteness;
+    static calculateAcuteAngleAcuteness(angle: number): number;
+    private static highBpmBonus;
+    private static calculateVectorAngleRepetition;
 }
 
 /**
- * A performance points calculator that calculates performance points for osu!droid gamemode.
+ * An evaluator for calculating osu!standard speed skill.
  */
-declare class DroidPerformanceCalculator extends PerformanceCalculator {
+declare abstract class OsuSpeedEvaluator {
+    private static readonly minSpeedBonus;
     /**
-     * The aim performance value.
+     * Evaluates the difficulty of tapping the current object, based on:
+     *
+     * - time between pressing the previous and current object,
+     * - and how easily they can be cheesed.
+     *
+     * @param current The current object.
      */
-    aim: number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
+    private static highBpmBonus;
+}
+
+/**
+ * Holds data that can be used to calculate osu!standard performance points.
+ */
+interface IOsuDifficultyAttributes extends IDifficultyAttributes {
     /**
-     * The tap performance value.
+     * The perceived approach rate **exclusive** 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.
      */
-    tap: number;
+    approachRate: number;
     /**
-     * The accuracy performance value.
+     * The health drain rate of the beatmap.
      */
-    accuracy: number;
+    drainRate: number;
     /**
-     * The flashlight performance value.
+     * The difficulty corresponding to the speed skill.
      */
-    flashlight: number;
+    speedDifficulty: number;
     /**
-     * The visual performance value.
+     * The amount of strains that are considered difficult with respect to the speed skill.
      */
-    visual: number;
+    speedDifficultStrainCount: number;
     /**
-     * The penalty used to penalize the tap performance value.
+     * Describes how much of {@link aimDifficultStrainCount} is contributed to by circles or sliders.
      *
-     * Can be properly obtained by analyzing the replay associated with the score.
-     */
-    get tapPenalty(): number;
-    /**
-     * The estimated deviation of the score.
-     */
-    get deviation(): number;
-    /**
-     * The estimated tap deviation of the score.
-     */
-    get tapDeviation(): number;
-    /**
-     * The penalty used to penalize the aim performance value.
+     * A value closer to 0 indicates most of {@link aimDifficultStrainCount} is contributed by circles.
      *
-     * Can be properly obtained by analyzing the replay associated with the score.
+     * A value closer to infinity indicates most of {@link aimDifficultStrainCount} is contributed by sliders.
      */
-    get aimSliderCheesePenalty(): number;
+    aimTopWeightedSliderFactor: number;
     /**
-     * The penalty used to penalize the flashlight performance value.
+     * Describes how much of {@link speedDifficultStrainCount} is contributed to by circles or sliders.
      *
-     * Can be properly obtained by analyzing the replay associated with the score.
-     */
-    get flashlightSliderCheesePenalty(): number;
-    /**
-     * The penalty used to penalize the visual performance value.
+     * A value closer to 0 indicates most of {@link speedDifficultStrainCount} is contributed by circles.
      *
-     * Can be properly obtained by analyzing the replay associated with the score.
+     * A value closer to infinity indicates most of {@link speedDifficultStrainCount} is contributed by sliders.
      */
-    get visualSliderCheesePenalty(): number;
-    readonly difficultyAttributes: DroidDifficultyAttributes;
-    protected finalMultiplier: number;
-    protected readonly mode: Modes;
-    private _aimSliderCheesePenalty;
-    private _flashlightSliderCheesePenalty;
-    private _visualSliderCheesePenalty;
-    private _tapPenalty;
-    private _deviation;
-    private _tapDeviation;
+    speedTopWeightedSliderFactor: number;
+}
+
+/**
+ * Holds data that can be used to calculate osu!standard performance points.
+ */
+declare class OsuDifficultyAttributes extends DifficultyAttributes implements IOsuDifficultyAttributes {
+    approachRate: number;
+    drainRate: number;
+    speedDifficulty: number;
+    speedDifficultStrainCount: number;
+    speedTopWeightedSliderFactor: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IOsuDifficultyAttributes>);
+    toString(): string;
+}
+
+/**
+ * A difficulty calculator for osu!standard gamemode.
+ */
+declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuPlayableBeatmap, OsuDifficultyHitObject, OsuDifficultyAttributes> {
+    constructor();
+    retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
+    protected createDifficultyAttributes(beatmap: Beatmap, playableBeatmap: PlayableBeatmap, skills: Skill[]): OsuDifficultyAttributes;
+    protected createPlayableBeatmap(beatmap: Beatmap, mods?: ModMap): OsuPlayableBeatmap;
+    protected createDifficultyHitObjects(beatmap: OsuPlayableBeatmap): OsuDifficultyHitObject[];
+    protected createSkills(beatmap: OsuPlayableBeatmap): Skill[];
+    protected createStrainPeakSkills(beatmap: OsuPlayableBeatmap): (Skill & IHasPeakDifficulty)[];
+    private calculateAimDifficultyRating;
+    private calculateDifficultyRating;
+    private calculateStarRating;
+    static sumCognitionDifficulty(reading: number, flashlight: number): number;
+}
+
+/**
+ * Represents the calculated performance of a score in osu!.
+ */
+interface IOsuPerformanceAttributes extends IPerformanceAttributes {
     /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
+     * The aim performance points.
      */
-    constructor(difficultyAttributes: DroidDifficultyAttributes);
+    aim: number;
     /**
-     * Applies a tap penalty value to this calculator.
-     *
-     * The tap and total performance value will be recalculated afterwards.
-     *
-     * @param value The tap penalty value. Must be greater than or equal to 1.
+     * The speed performance points.
      */
-    applyTapPenalty(value: number): void;
+    speed: number;
     /**
-     * Applies an aim slider cheese penalty value to this calculator.
-     *
-     * The aim and total performance value will be recalculated afterwards.
-     *
-     * @param value The slider cheese penalty value. Must be between than 0 and 1.
+     * The accuracy performance points.
      */
-    applyAimSliderCheesePenalty(value: number): void;
+    accuracy: number;
     /**
-     * Applies a flashlight slider cheese penalty value to this calculator.
-     *
-     * The flashlight and total performance value will be recalculated afterwards.
-     *
-     * @param value The slider cheese penalty value. Must be between 0 and 1.
+     * The flashlight performance points.
      */
-    applyFlashlightSliderCheesePenalty(value: number): void;
+    flashlight: number;
     /**
-     * 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.
+     * The reading performance points.
      */
-    applyVisualSliderCheesePenalty(value: number): void;
-    protected calculateValues(): void;
-    protected calculateTotalValue(): void;
-    protected handleOptions(options?: PerformanceCalculationOptions): void;
+    reading: number;
+}
+
+/**
+ * A performance points calculator that calculates performance points for osu!standard gamemode.
+ */
+declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficultyAttributes, IOsuPerformanceAttributes> {
+    static readonly finalMultiplier = 1.12;
+    static readonly normExponent = 1.1;
+    private greatWindow;
+    private okWindow;
+    private mehWindow;
+    private approachRate;
+    private overallDifficulty;
+    private _effectiveMissCount;
+    private speedDeviation;
+    protected createPerformanceAttributes(): IOsuPerformanceAttributes;
     /**
      * Calculates the aim performance value of the beatmap.
      */
     private calculateAimValue;
     /**
-     * Calculates the tap performance value of the beatmap.
+     * Calculates the speed performance value of the beatmap.
      */
-    private calculateTapValue;
+    private calculateSpeedValue;
     /**
      * Calculates the accuracy performance value of the beatmap.
      */
@@ -1145,470 +1518,581 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     private calculateFlashlightValue;
     /**
-     * Calculates the visual performance value of the beatmap.
+     * Calculates the reading performance value of the beatmap.
      */
-    private calculateVisualValue;
+    private calculateReadingValue;
     /**
-     * Calculates miss penalty.
+     * Calculates a strain-based miss penalty.
      *
-     * Miss penalty assumes that a player will miss on the hardest parts of a map,
+     * 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.
      */
     private calculateMissPenalty;
     /**
-     * Estimates the player's tap 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.
+     * Estimates a player's deviation on speed notes using {@link calculateDeviation}, assuming worst-case.
      *
-     * The estimation is consistent in that two SS scores on the same map
-     * with the same settings will always return the same deviation.
-     *
-     * Sliders are treated as circles with a 50 hit window.
+     * 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, and 50s
-     * are grouped with 100s since they are usually due to misreading.
+     * Misses are ignored because they are usually due to misaiming.
      *
-     * Inaccuracies are capped to the number of circles in the map.
+     * Greats and oks are assumed to follow a normal distribution, whereas mehs are assumed to follow a uniform distribution.
      */
     private calculateDeviation;
     /**
-     * Does the same as {@link calculateDeviation}, but only for notes and inaccuracies that are relevant to tap difficulty.
+     * Calculates multiplier for speed to account for improper tapping based on the deviation and speed difficulty.
      *
-     * Treats all difficult speed notes as circles, so this method can sometimes return a lower deviation than {@link calculateDeviation}.
-     * This is fine though, since this method is only used to scale tap pp.
+     * [Graph](https://www.desmos.com/calculator/dmogdhzofn)
      */
-    private calculateTapDeviation;
-    toString(): string;
-}
-
-/**
- * Represents the skill required to properly follow a beatmap's rhythm.
- */
-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;
+    private calculateSpeedHighDeviationNerf;
+    private calculateEstimatedSliderBreaks;
+    /**
+     * Calculates the amount of misses + sliderbreaks from combo.
+     */
+    private calculateComboBasedEstimatedMissCount;
+    private calculateTraceableBonus;
+    private calculateRateAdjustedApproachRate;
 }
 
 /**
- * An evaluator for calculating rhythm skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
+ * Data class for variable length strain.
  */
-declare abstract class RhythmEvaluator {
-    protected static readonly rhythmMultiplier: number;
-    protected static readonly historyTimeMax: number;
+declare class StrainPeak {
+    readonly value: number;
+    readonly sectionLength: number;
+    constructor(value: number, sectionLength: number);
+    compareTo(other: StrainPeak): number;
 }
 
 /**
- * An evaluator for calculating osu!droid Rhythm skill.
+ * A skill that evaluates strain over a variable length of time. A new strain peak is created for every
+ * {@link DifficultyHitObject}.
  */
-declare abstract class DroidRhythmEvaluator extends RhythmEvaluator {
+declare abstract class VariableLengthStrainSkill extends Skill implements IHasPeakDifficulty {
     /**
-     * Calculates a rhythm multiplier for the difficulty of the tap associated
-     * with historic data of the current object.
+     * The weight by which each strain value decays.
+     */
+    protected readonly decayWeight: number;
+    /**
+     * The maximum length of a strain section, in milliseconds.
+     */
+    protected readonly maxSectionLength: number;
+    /**
+     * The number of {@link maxSectionLength} sections calculated such that enough of the difficulty value is preserved.
      *
-     * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
+     * This should be overridden if strains are ever used outside of {@link difficultyValue}, or if {@link difficultyValue}
+     * is overridden to not use the default geometric sum.
+     *
+     * This should be removed in the future when a better memory-saving technique is implemented.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number): 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;
-    private currentTapStrain;
-    private currentOriginalTapStrain;
-    private readonly greatWindow;
-    constructor(mods: Mod[], overallDifficulty: number);
+    protected get maxStoredSections(): number;
+    private currentSectionPeak;
+    private currentSectionBegin;
+    private currentSectionEnd;
+    private totalLength;
+    private readonly strainPeaks;
     /**
-     * @param current The hitobject to calculate.
+     * The peaks of this skill in chronological order, used for graphing purposes.
+     *
+     * Unlike {@link strainPeaks}, this is never trimmed, as it does not contribute to {@link difficultyValue}.
      */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    private readonly chronologicalPeaks;
+    get peaks(): readonly TimedStrainPeak[];
     /**
-     * @param current The hitobject to save to.
+     * Stores previous strains so that, if a difficult {@link DifficultyHitObject} is followed by an easier
+     * {@link DifficultyHitObject}, the difficult one gets a full strain instead of being cut short.
      */
-    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;
-}
-
-/**
- * An evaluator for calculating osu!droid tap skill.
- */
-declare abstract class DroidTapEvaluator extends SpeedEvaluator {
+    private readonly queuedStrains;
+    static difficultyToPerformance(difficulty: number): number;
     /**
-     * Evaluates the difficulty of tapping the current object, based on:
+     * Obtains the live strain peaks for each {@link maxSectionLength} of the beatmap, including the
+     * peak of the current section.
+     */
+    get currentStrainPeaks(): StrainPeak[];
+    difficultyValue(): number;
+    /**
+     * Returns the number of strains weighed against the top strain.
      *
-     * - time between pressing the previous and current object,
-     * - distance between those objects,
-     * - and how easily they can be cheesed.
+     * The result is scaled by clock rate as it affects the total number of strains.
+     */
+    countTopWeightedStrains(difficultyValue: number): number;
+    protected processInternal(current: DifficultyHitObject): number;
+    /**
+     * Calculates the strain value at the {@link DifficultyHitObject}. This value is calculated with or without respect to
+     * previous {@link DifficultyHitObject}s.
      *
-     * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
-     * @param considerCheesability Whether to consider cheesability.
+     * @param current The {@link DifficultyHitObject} for which the strain value should be calculated.
      */
-    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 {
+    protected abstract strainValueAt(current: DifficultyHitObject): number;
     /**
-     * Evaluates the difficulty of reading the current object, based on:
+     * Retrieves the peak strain at a point in time.
      *
-     * - 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 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;
+    /**
+     * Fills the space between the end of the current section and the current {@link DifficultyHitObject}, if any.
      *
-     * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
-     * @param withSliders Whether to take slider difficulty into account.
+     * @param current The current {@link DifficultyHitObject}.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, isHiddenMod: boolean, withSliders: boolean): number;
+    private backfillPeaks;
+    /**
+     * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
+     */
+    private saveCurrentPeak;
+    private startNewSectionFrom;
+    private addStrainPeakInPlace;
 }
 
 /**
- * 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 skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
-declare abstract class OsuSkill extends StrainSkill {
+declare class DroidAim extends VariableLengthStrainSkill {
+    private currentStrain;
+    private readonly skillMultiplierSnap;
+    private readonly skillMultiplierAgility;
+    private readonly skillMultiplierFlow;
+    private readonly skillMultiplierTotal;
+    private readonly combinedSnapNormExponent;
     /**
-     * The default multiplier applied to the final difficulty value after all other calculations.
-     *
-     * May be overridden via {@link difficultyMultiplier}.
+     * The number of sections with the highest strains, which the peak strain reductions will apply to.
+     * This is done in order to decrease their impact on the overall difficulty of the beatmap.
+     */
+    private readonly reducedSectionTime;
+    /**
+     * The baseline multiplier applied to the section with the biggest strain.
      */
-    static readonly defaultDifficultyMultiplier: number;
+    private readonly reducedStrainBaseline;
+    private readonly sliderStrains;
+    private maxSliderStrain;
+    readonly withSliders: boolean;
+    constructor(mods: ModMap, withSliders: boolean);
     /**
-     * The final multiplier to be applied to the final difficulty value after all other calculations.
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
      */
-    protected readonly difficultyMultiplier: number;
+    countDifficultSliders(): number;
     /**
-     * The weight by which each strain value decays.
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain, weighted by consistency.
+     *
+     * @param difficultyValue The final difficulty value.
      */
-    protected abstract readonly decayWeight: number;
+    countTopWeightedSliders(difficultyValue: number): number;
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject, difficulty: number): void;
+    private calculateAdjustedDifficulty;
+    private calculateTotalValue;
+    /**
+     * Converts the ratio of snap to flow into the probability of snapping or flowing.
+     *
+     * Constraints:
+     * - `P(snap) + P(flow) = 1` (the object is always either snapped or flowed)
+     * - `P(snap) = f(snap / flow)` and `P(flow) = f(flow/snap)` (i.e., snap and flow are symmetric and
+     * reversible). This means `f(x) + f(1/x) = 1`
+     * - `0 <= f(x) <= 1` (cannot have negative or greater than 100% probability of snapping or flowing)
+     *
+     * This logistic function is a solution, which fits nicely with the general idea of interpolation and
+     * provides a tuneable constant.
+     *
+     * @param ratio The ratio.
+     * @returns The probability.
+     */
+    private calculateSnapFlowProbability;
     difficultyValue(): number;
+    private getReducedStrainPeaks;
+    private strainDecay;
 }
 
 /**
- * Holds data that can be used to calculate osu!standard performance points.
+ * 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.
  */
-interface OsuDifficultyAttributes extends DifficultyAttributes {
+declare abstract class StrainSkill extends Skill implements IHasPeakDifficulty {
     /**
-     * The difficulty corresponding to the speed skill.
+     * The number of sections with the highest strains, which the peak strain reductions will apply to.
+     * This is done in order to decrease their impact on the overall difficulty of the map for this skill.
      */
-    speedDifficulty: number;
-}
-
-/**
- * A difficulty calculator for osu!standard gamemode.
- */
-declare class OsuDifficultyCalculator extends DifficultyCalculator {
+    protected readonly reducedSectionCount: number;
     /**
-     * The aim star rating of the beatmap.
+     * The baseline multiplier applied to the section with the biggest strain.
      */
-    aim: number;
+    protected readonly reducedSectionBaseline: number;
+    protected readonly _objectStrains: number[];
     /**
-     * The speed star rating of the beatmap.
+     * The strains of hitobjects.
      */
-    speed: number;
+    get objectStrains(): readonly number[];
+    protected readonly strainPeaks: number[];
+    private readonly strainPeakTimes;
+    get peaks(): readonly TimedStrainPeak[];
+    private readonly sectionLength;
+    private currentStrain;
+    private currentSectionPeak;
+    private currentSectionEnd;
     /**
-     * The flashlight star rating of the beatmap.
+     * Converts a difficulty value to a performance value.
+     *
+     * @param difficulty The difficulty value to convert.
+     * @returns The performance value.
      */
-    flashlight: number;
-    readonly attributes: OsuDifficultyAttributes;
-    protected readonly difficultyMultiplier: number;
-    protected readonly mode: Modes;
+    static difficultyToPerformance(difficulty: number): number;
     /**
-     * Calculates the aim star rating of the beatmap and stores it in this instance.
+     * Obtains the live strain peaks for each {@link sectionLength} of the beatmap, including the peak of the current section.
      */
-    calculateAim(): void;
+    get currentStrainPeaks(): number[];
     /**
-     * Calculates the speed star rating of the beatmap and stores it in this instance.
+     * 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.
+     *
+     * @param difficultyValue The final difficulty value.
      */
-    calculateSpeed(): void;
+    countTopWeightedStrains(difficultyValue: number): number;
+    protected processInternal(current: DifficultyHitObject): number;
     /**
-     * Calculates the flashlight star rating of the beatmap and stores it in this instance.
+     * 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.
      */
-    calculateFlashlight(): void;
-    calculateTotal(): void;
-    calculateAll(): void;
-    toString(): string;
-    protected preProcess(): void;
-    protected createSkills(): OsuSkill[];
+    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
     /**
-     * Called after aim skill calculation.
+     * Calculates the strain value at a hitobject.
      *
-     * @param aimSkill The aim skill that considers sliders.
-     * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
+     * @param current The hitobject to calculate.
      */
-    private postCalculateAim;
+    protected abstract strainValueAt(current: DifficultyHitObject): number;
     /**
-     * Called after speed skill calculation.
+     * Retrieves the peak strain at a point in time.
      *
-     * @param speedSkill The speed skill.
+     * @param time The time to retrieve the peak strain at.
+     * @param current The current hit object.
+     * @returns The peak strain.
      */
-    private postCalculateSpeed;
+    protected abstract calculateInitialStrain(time: number, current: DifficultyHitObject): number;
     /**
-     * Calculates speed-related attributes.
+     * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
      */
-    private calculateSpeedAttributes;
+    private saveCurrentPeak;
     /**
-     * Called after flashlight skill calculation.
+     * Sets the initial strain level for a new section.
      *
-     * @param flashlightSkill The flashlight skill.
+     * @param time The beginning of the new section in milliseconds.
+     * @param current The current hitobject.
      */
-    private postCalculateFlashlight;
+    private startNewSectionFrom;
 }
 
 /**
- * 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;
+declare abstract class DroidSkill extends StrainSkill {
     /**
-     * The osu!standard difficulty calculator of the beatmap.
+     * The bonus multiplier that is given for a sequence of notes of equal difficulty.
      */
-    readonly osu: OsuDifficultyCalculator;
+    protected abstract readonly starsPerDouble: number;
+    protected difficulty: number;
+    process(current: DifficultyHitObject): void;
+    difficultyValue(): number;
     /**
-     * Constructs this instance and calculates the given beatmap's osu!droid and osu!standard difficulty.
+     * Gets the strain of a hitobject.
      *
-     * @param beatmap The beatmap to calculate.
-     * @param options Options for the difficulty calculation.
+     * @param current The hitobject to get the strain from.
+     * @returns The strain of the hitobject.
      */
-    constructor(beatmap: Beatmap, options?: DifficultyCalculationOptions);
-    /**
-     * Returns a string representative of the class.
-     */
-    toString(): string;
+    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.
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
-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;
-    /**
-     * @param current The hitobject to save to.
-     */
-    protected saveToHitObject(current: DifficultyHitObject): void;
+declare class DroidFlashlight extends DroidSkill {
+    private readonly totalObjects;
+    protected readonly reducedSectionCount = 0;
+    protected readonly reducedSectionBaseline = 1;
+    protected readonly starsPerDouble = 1;
+    private readonly skillMultiplier;
+    private currentFlashlightStrain;
+    static difficultyToPerformance(difficulty: number): number;
+    constructor(mods: ModMap, totalObjects: number);
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
+    protected getObjectStrain(): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
+    difficultyValue(): number;
+    private calculateAdjustedDifficulty;
+    private strainDecay;
 }
 
 /**
- * An evaluator for calculating osu!standard Aim skill.
+ * A skill that calculates the difficulty of {@link DifficultyHitObject}s using harmonic summation.
  */
-declare abstract class OsuAimEvaluator extends AimEvaluator {
+declare abstract class HarmonicSkill extends Skill implements IHasPeakDifficulty {
+    private _noteWeightSum;
+    private _objectTimes;
     /**
-     * Evaluates the difficulty of aiming the current object, based on:
+     * The sum of note weights, calculated during summation.
      *
-     * - cursor velocity to the current object,
-     * - angle difficulty,
-     * - sharp velocity increases,
-     * - and slider difficulty.
+     * Required for any calculations that normalizes the difficulty value.
+     */
+    protected get noteWeightSum(): number;
+    /**
+     * The start times of {@link DifficultyHitObject}s, populated by {@link HarmonicSkill.process}.
      *
-     * @param current The current object.
-     * @param withSliders Whether to take slider difficulty into account.
+     * Indices correspond to {@link objectDifficulties}.
+     */
+    protected get objectTimes(): readonly number[];
+    /**
+     * Scaling factor applied as `x / (i + 1)`, where `x` is the skill's {@link harmonicScale} and `i`
+     * is the index of the {@link DifficultyHitObject} being processed.
+     *
+     * A higher value increases the influence of the hardest {@link DifficultyHitObject}s during summation.
+     */
+    protected readonly harmonicScale: number;
+    /**
+     * An exponent that controls the rate of which decay increases as the index increases.
+     *
+     * Values closer to 1 decay faster, whilst lower values give more weight to easier {@link DifficultyHitObject}s.
+     */
+    protected readonly decayExponent: number;
+    get peaks(): readonly TimedStrainPeak[];
+    static difficultyToPerformance(difficulty: number): number;
+    difficultyValue(): number;
+    /**
+     * Calculates the amount of object difficulties weighed against the top object difficulty.
+     *
+     * @param difficultyValue The final difficulty value.
+     */
+    countTopWeightedObjectDifficulties(difficultyValue: number): number;
+    /**
+     * Transforms the difficulties of {@link DifficultyHitObject}s before they are summed together.
+     *
+     * This can be used to decrease weight of certain {@link DifficultyHitObject}s based on a skill-specific criteria.
+     *
+     * @param difficulties The difficulties of {@link DifficultyHitObject}s to transform.
+     */
+    protected applyDifficultyTransformation(difficulties: number[]): void;
+    process(current: DifficultyHitObject): void;
+    protected processInternal(current: DifficultyHitObject): number;
+    /**
+     * Calculates the difficulty value of a {@link DifficultyHitObject}. This value is calculated with or without respect to previous objects.
+     *
+     * @param current The {@link DifficultyHitObject} for which the difficulty value should be calculated.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, withSliders: boolean): number;
+    protected abstract objectDifficultyOf(current: DifficultyHitObject): number;
 }
 
 /**
- * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ * Represents the skill required to read every object in the beatmap.
  */
-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;
+declare class DroidReading extends HarmonicSkill {
+    private readonly clockRate;
+    private readonly hitObjects;
+    private currentDifficulty;
+    private readonly skillMultiplier;
+    private readonly difficultyDecayBase;
+    constructor(mods: ModMap, clockRate: number, hitObjects: readonly PlaceableHitObject[]);
+    countTopWeightedObjectDifficulties(difficultyValue: number): number;
+    protected objectDifficultyOf(current: DroidDifficultyHitObject): number;
+    protected applyDifficultyTransformation(difficulties: number[]): void;
+    protected saveToHitObject(current: DroidDifficultyHitObject, difficulty: number): void;
+    private calculateAdjustedDifficulty;
+    private calculateReducedNoteCount;
+    private difficultyDecay;
 }
 
 /**
- * An evaluator for calculating osu!standard Flashlight skill.
+ * Represents the skill required to properly follow a beatmap's rhythm.
  */
-declare abstract class OsuFlashlightEvaluator extends FlashlightEvaluator {
-    /**
-     * Evaluates the difficulty of memorizing and hitting the current object, based on:
-     *
-     * - distance between a number of previous objects and the current object,
-     * - the visual opacity of the current object,
-     * - the angle made by the current object,
-     * - length and speed of the current object (for sliders),
-     * - and whether Hidden mod is enabled.
-     *
-     * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
-     */
-    static evaluateDifficultyOf(current: DifficultyHitObject, isHiddenMod: boolean): number;
+declare class DroidRhythm extends HarmonicSkill {
+    protected readonly harmonicScale = 25;
+    protected readonly decayExponent = 0.8;
+    private readonly skillMultiplier;
+    private readonly strainDecayBase;
+    private currentRhythmDifficulty;
+    private currentRhythmMultiplier;
+    private readonly useSliderAccuracy;
+    constructor(mods: ModMap);
+    protected objectDifficultyOf(current: DroidDifficultyHitObject): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
+    private strainDecay;
 }
 
 /**
- * A performance points calculator that calculates performance points for osu!standard gamemode.
+ * 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 OsuPerformanceCalculator extends PerformanceCalculator {
+declare class DroidTap extends HarmonicSkill {
+    protected readonly harmonicScale = 20;
+    private readonly skillMultiplier;
+    private readonly strainDecayBase;
+    private currentTapDifficulty;
+    private currentRhythmMultiplier;
+    private readonly sliderDifficulties;
+    private maxDifficulty;
+    readonly considerCheesability: boolean;
+    constructor(mods: ModMap, considerCheesability: boolean);
     /**
-     * The aim performance value.
+     * The amount of notes that are relevant to the difficulty.
      */
-    aim: number;
-    /**
-     * The speed performance value.
-     */
-    speed: number;
-    /**
-     * The accuracy performance value.
-     */
-    accuracy: number;
+    relevantNoteCount(): number;
     /**
-     * The flashlight performance value.
+     * Obtains the amount of sliders that are considered difficult in terms of relative difficulty, weighted by consistency.
+     *
+     * @param difficultyValue The final difficulty value.
      */
-    flashlight: number;
-    readonly difficultyAttributes: OsuDifficultyAttributes;
-    protected finalMultiplier: number;
-    protected readonly mode: Modes;
+    countTopWeightedSliders(difficultyValue: number): number;
+    protected objectDifficultyOf(current: DroidDifficultyHitObject): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
+    private strainDecay;
+}
+
+/**
+ * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
+ */
+declare class OsuAim extends VariableLengthStrainSkill {
+    private currentStrain;
+    private readonly skillMultiplierSnap;
+    private readonly skillMultiplierAgility;
+    private readonly skillMultiplierFlow;
+    private readonly skillMultiplierTotal;
+    private readonly combinedSnapNormExponent;
     /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
+     * The number of sections with the highest strains, which the peak strain reductions will apply to.
+     * This is done in order to decrease their impact on the overall difficulty of the beatmap.
      */
-    constructor(difficultyAttributes: OsuDifficultyAttributes);
-    protected calculateValues(): void;
-    protected calculateTotalValue(): void;
+    private readonly reducedSectionTime;
     /**
-     * Calculates the aim performance value of the beatmap.
+     * The baseline multiplier applied to the section with the biggest strain.
      */
-    private calculateAimValue;
+    private readonly reducedStrainBaseline;
+    private readonly sliderStrains;
+    private maxSliderStrain;
+    readonly withSliders: boolean;
+    constructor(mods: ModMap, withSliders: boolean);
     /**
-     * Calculates the speed performance value of the beatmap.
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
      */
-    private calculateSpeedValue;
+    countDifficultSliders(): number;
     /**
-     * Calculates the accuracy performance value of the beatmap.
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain, weighted by consistency.
+     *
+     * @param difficultyValue The final difficulty value.
      */
-    private calculateAccuracyValue;
+    countTopWeightedSliders(difficultyValue: number): number;
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
+    private calculateAdjustedDifficulty;
+    private calculateTotalValue;
     /**
-     * Calculates the flashlight performance value of the beatmap.
+     * Converts the ratio of snap to flow into the probability of snapping or flowing.
+     *
+     * Constraints:
+     * - `P(snap) + P(flow) = 1` (the object is always either snapped or flowed)
+     * - `P(snap) = f(snap / flow)` and `P(flow) = f(flow/snap)` (i.e., snap and flow are symmetric and
+     * reversible). This means `f(x) + f(1/x) = 1`
+     * - `0 <= f(x) <= 1` (cannot have negative or greater than 100% probability of snapping or flowing)
+     *
+     * This logistic function is a solution, which fits nicely with the general idea of interpolation and
+     * provides a tuneable constant.
+     *
+     * @param ratio The ratio.
+     * @returns The probability.
      */
-    private calculateFlashlightValue;
-    toString(): string;
+    private calculateSnapFlowProbability;
+    difficultyValue(): number;
+    private getReducedStrainPeaks;
+    private strainDecay;
 }
 
 /**
- * An evaluator for calculating osu!standard Rhythm 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.
  */
-declare abstract class OsuRhythmEvaluator extends RhythmEvaluator {
+declare abstract class OsuSkill extends StrainSkill {
     /**
-     * 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.
+     * The weight by which each strain value decays.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number): number;
+    protected abstract readonly decayWeight: number;
+    protected difficulty: number;
+    difficultyValue(): 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.
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
-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;
-    private currentSpeedStrain;
-    private currentRhythm;
-    private readonly greatWindow;
-    constructor(mods: Mod[], greatWindow: number);
-    /**
-     * @param current The hitobject to calculate.
-     */
-    protected strainValueAt(current: DifficultyHitObject): number;
-    /**
-     * @param current The hitobject to save to.
-     */
-    protected saveToHitObject(current: DifficultyHitObject): void;
+declare class OsuFlashlight extends OsuSkill {
+    private readonly totalObjects;
+    protected readonly reducedSectionCount = 0;
+    protected readonly reducedSectionBaseline = 1;
+    protected readonly decayWeight = 1;
+    private currentFlashlightStrain;
+    private readonly skillMultiplier;
+    static difficultyToPerformance(difficulty: number): number;
+    constructor(mods: ModMap, totalObjects: number);
+    difficultyValue(): number;
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
+    private calculateAdjustedDifficulty;
+    private strainDecay;
 }
 
 /**
- * An evaluator for calculating osu!standard speed skill.
+ * Represents the skill required to read every object in the beatmap.
+ */
+declare class OsuReading extends HarmonicSkill {
+    private readonly clockRate;
+    private readonly hitObjects;
+    private currentDifficulty;
+    private readonly skillMultiplier;
+    private readonly difficultyDecayBase;
+    constructor(mods: ModMap, clockRate: number, hitObjects: readonly PlaceableHitObject[]);
+    countTopWeightedObjectDifficulties(difficultyValue: number): number;
+    protected objectDifficultyOf(current: OsuDifficultyHitObject): number;
+    protected applyDifficultyTransformation(difficulties: number[]): void;
+    protected saveToHitObject(current: DifficultyHitObject, difficulty: number): void;
+    private calculateAdjustedDifficulty;
+    private calculateReducedNoteCount;
+    private difficultyDecay;
+}
+
+/**
+ * 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 abstract class OsuSpeedEvaluator extends SpeedEvaluator {
+declare class OsuSpeed extends HarmonicSkill {
+    protected readonly harmonicScale = 20;
+    private currentDifficulty;
+    private currentRhythm;
+    private readonly skillMultiplier;
+    private readonly strainDecayBase;
+    private readonly sliderDifficulties;
+    private maxDifficulty;
     /**
-     * Spacing threshold for a single hitobject spacing.
+     * The amount of notes that are relevant to the difficulty.
      */
-    private static readonly SINGLE_SPACING_THRESHOLD;
+    relevantNoteCount(): number;
     /**
-     * Evaluates the difficulty of tapping the current object, based on:
+     * Obtains the amount of sliders that are considered difficult in terms of relative difficulty, weighted by consistency.
      *
-     * - time between pressing the previous and current object,
-     * - distance between those objects,
-     * - and how easily they can be cheesed.
-     *
-     * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
+     * @param difficultyValue The final difficulty value.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number): number;
+    countTopWeightedSliders(difficultyValue: number): number;
+    protected objectDifficultyOf(current: OsuDifficultyHitObject): number;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
+    private calculateAdjustedDifficulty;
+    private strainDecay;
 }
 
-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 { DifficultyAttributes, DifficultyCalculator, DifficultyHitObject, DroidAgilityEvaluator, DroidAim, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidFlowAimEvaluator, DroidPerformanceCalculator, DroidReading, DroidReadingEvaluator, DroidRhythm, DroidRhythmEvaluator, DroidSnapAimEvaluator, DroidTap, DroidTapEvaluator, ExtendedDroidDifficultyAttributes, OsuAgilityEvaluator, OsuAim, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuFlowAimEvaluator, OsuPerformanceCalculator, OsuReading, OsuReadingEvaluator, OsuRhythmEvaluator, OsuSnapAimEvaluator, OsuSpeed, OsuSpeedEvaluator, PerformanceCalculator };
+export type { CacheableDifficultyAttributes, DifficultSlider, HighStrainSection, IDifficultyAttributes, IDroidDifficultyAttributes, IDroidPerformanceAttributes, IExtendedDroidDifficultyAttributes, IOsuDifficultyAttributes, IOsuPerformanceAttributes, IPerformanceAttributes, PerformanceCalculationOptions, StrainPeaks, TimedDifficultyAttributes, TimedStrainPeak };