@rian8337/osu-difficulty-calculator 4.0.0-beta.16 → 4.0.0-beta.18

package/dist/index.js

@@ -8,10 +8,6 @@ var osuBase = require('@rian8337/osu-base');
  * This class should be considered an "evaluating" class and not persisted.
  */
 class AimEvaluator {
-    static wideAngleMultiplier = 1.5;
-    static acuteAngleMultiplier = 1.95;
-    static sliderMultiplier = 1.35;
-    static velocityChangeMultiplier = 0.75;
     /**
      * Calculates the bonus of wide angles.
      */
@@ -27,52 +23,49 @@ class AimEvaluator {
         return 1 - this.calculateWideAngleBonus(angle);
     }
 }
+AimEvaluator.wideAngleMultiplier = 1.5;
+AimEvaluator.acuteAngleMultiplier = 1.95;
+AimEvaluator.sliderMultiplier = 1.35;
+AimEvaluator.velocityChangeMultiplier = 0.75;
 
 /**
  * The base of a difficulty calculator.
  */
 class DifficultyCalculator {
-    /**
-     * The calculated beatmap.
-     */
-    beatmap;
-    /**
-     * The difficulty objects of the beatmap.
-     */
-    objects = [];
-    /**
-     * The modifications applied.
-     */
-    mods = [];
     /**
      * The total star rating of the beatmap.
      */
     get total() {
         return this.attributes.starRating;
     }
-    /**
-     * The difficulty statistics of the beatmap after modifications are applied.
-     */
-    difficultyStatistics;
-    /**
-     * The strain peaks of various calculated difficulties.
-     */
-    strainPeaks = {
-        aimWithSliders: [],
-        aimWithoutSliders: [],
-        speed: [],
-        flashlight: [],
-    };
     /**
      * Constructs a new instance of the calculator.
      *
      * @param beatmap The beatmap to calculate. This beatmap will be deep-cloned to prevent reference changes.
      */
     constructor(beatmap) {
+        var _a;
+        /**
+         * The difficulty objects of the beatmap.
+         */
+        this.objects = [];
+        /**
+         * The modifications applied.
+         */
+        this.mods = [];
+        /**
+         * The strain peaks of various calculated difficulties.
+         */
+        this.strainPeaks = {
+            aimWithSliders: [],
+            aimWithoutSliders: [],
+            speed: [],
+            flashlight: [],
+        };
         this.beatmap = beatmap;
         this.difficultyStatistics = {
             circleSize: beatmap.difficulty.cs,
-            approachRate: beatmap.difficulty.ar ?? beatmap.difficulty.od,
+            approachRate: (_a = beatmap.difficulty.ar) !== null && _a !== void 0 ? _a : beatmap.difficulty.od,
             overallDifficulty: beatmap.difficulty.od,
             healthDrain: beatmap.difficulty.hp,
             overallSpeedMultiplier: 1,
@@ -94,11 +87,12 @@ class DifficultyCalculator {
      * @returns The current instance.
      */
     calculate(options) {
-        this.mods = options?.mods ?? [];
+        var _a;
+        this.mods = (_a = options === null || options === void 0 ? void 0 : options.mods) !== null && _a !== void 0 ? _a : [];
         const converted = new osuBase.BeatmapConverter(this.beatmap).convert({
             mode: this.mode,
             mods: this.mods,
-            customSpeedMultiplier: options?.customSpeedMultiplier,
+            customSpeedMultiplier: options === null || options === void 0 ? void 0 : options.customSpeedMultiplier,
         });
         this.difficultyStatistics = Object.seal(this.computeDifficultyStatistics(options));
         this.populateDifficultyAttributes();
@@ -156,91 +150,6 @@ class DifficultyCalculator {
  * Represents a hit object with difficulty calculation values.
  */
 class DifficultyHitObject {
-    /**
-     * The underlying hitobject.
-     */
-    object;
-    /**
-     * The index of this hitobject in the list of all hitobjects.
-     *
-     * This is one less than the actual index of the hitobject in the beatmap.
-     */
-    index;
-    /**
-     * The aim strain generated by the hitobject if sliders are considered.
-     */
-    aimStrainWithSliders = 0;
-    /**
-     * The aim strain generated by the hitobject if sliders are not considered.
-     */
-    aimStrainWithoutSliders = 0;
-    /**
-     * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
-     */
-    rhythmMultiplier = 0;
-    /**
-     * The normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
-     *
-     * The "lazy" end position is the position at which the cursor ends up if the previous hitobject is followed with as minimal movement as possible (i.e. on the edge of slider follow circles).
-     */
-    lazyJumpDistance = 0;
-    /**
-     * The normalized shortest distance to consider for a jump between the previous hitobject and this hitobject.
-     *
-     * This is bounded from above by `lazyJumpDistance`, and is smaller than the former if a more natural path is able to be taken through the previous hitobject.
-     *
-     * Suppose a linear slider - circle pattern. Following the slider lazily (see: `lazyJumpDistance`) will result in underestimating the true end position of the slider as being closer towards the start position.
-     * As a result, `lazyJumpDistance` overestimates the jump distance because the player is able to take a more natural path by following through the slider to its end,
-     * such that the jump is felt as only starting from the slider's true end position.
-     *
-     * Now consider a slider - circle pattern where the circle is stacked along the path inside the slider.
-     * In this case, the lazy end position correctly estimates the true end position of the slider and provides the more natural movement path.
-     */
-    minimumJumpDistance = 0;
-    /**
-     * The time taken to travel through `minimumJumpDistance`, with a minimum value of 25ms.
-     */
-    minimumJumpTime = 0;
-    /**
-     * The normalized distance between the start and end position of this hitobject.
-     */
-    travelDistance = 0;
-    /**
-     * The time taken to travel through `travelDistance`, with a minimum value of 25ms for sliders.
-     */
-    travelTime = 0;
-    /**
-     * Angle the player has to take to hit this hitobject.
-     *
-     * Calculated as the angle between the circles (current-2, current-1, current).
-     */
-    angle = null;
-    /**
-     * The amount of milliseconds elapsed between this hitobject and the last hitobject.
-     */
-    deltaTime;
-    /**
-     * The amount of milliseconds elapsed since the start time of the previous hitobject, with a minimum of 25ms.
-     */
-    strainTime;
-    /**
-     * Adjusted start time of the hitobject, taking speed multiplier into account.
-     */
-    startTime;
-    /**
-     * Adjusted end time of the hitobject, taking speed multiplier into account.
-     */
-    endTime;
-    /**
-     * Other hitobjects in the beatmap, including this hitobject.
-     */
-    hitObjects;
-    normalizedRadius = 50;
-    maximumSliderRadius = this.normalizedRadius * 2.4;
-    assumedSliderRadius = this.normalizedRadius * 1.8;
-    minDeltaTime = 25;
-    lastObject;
-    lastLastObject;
     /**
      * 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.).
@@ -255,6 +164,59 @@ class DifficultyHitObject {
      * @param mode The gamemode to compute properties for.
      */
     constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate) {
+        /**
+         * The aim strain generated by the hitobject if sliders are considered.
+         */
+        this.aimStrainWithSliders = 0;
+        /**
+         * The aim strain generated by the hitobject if sliders are not considered.
+         */
+        this.aimStrainWithoutSliders = 0;
+        /**
+         * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
+         */
+        this.rhythmMultiplier = 0;
+        /**
+         * The normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
+         *
+         * The "lazy" end position is the position at which the cursor ends up if the previous hitobject is followed with as minimal movement as possible (i.e. on the edge of slider follow circles).
+         */
+        this.lazyJumpDistance = 0;
+        /**
+         * The normalized shortest distance to consider for a jump between the previous hitobject and this hitobject.
+         *
+         * This is bounded from above by `lazyJumpDistance`, and is smaller than the former if a more natural path is able to be taken through the previous hitobject.
+         *
+         * Suppose a linear slider - circle pattern. Following the slider lazily (see: `lazyJumpDistance`) will result in underestimating the true end position of the slider as being closer towards the start position.
+         * As a result, `lazyJumpDistance` overestimates the jump distance because the player is able to take a more natural path by following through the slider to its end,
+         * such that the jump is felt as only starting from the slider's true end position.
+         *
+         * Now consider a slider - circle pattern where the circle is stacked along the path inside the slider.
+         * In this case, the lazy end position correctly estimates the true end position of the slider and provides the more natural movement path.
+         */
+        this.minimumJumpDistance = 0;
+        /**
+         * The time taken to travel through `minimumJumpDistance`, with a minimum value of 25ms.
+         */
+        this.minimumJumpTime = 0;
+        /**
+         * The normalized distance between the start and end position of this hitobject.
+         */
+        this.travelDistance = 0;
+        /**
+         * The time taken to travel through `travelDistance`, with a minimum value of 25ms for sliders.
+         */
+        this.travelTime = 0;
+        /**
+         * Angle the player has to take to hit this hitobject.
+         *
+         * Calculated as the angle between the circles (current-2, current-1, current).
+         */
+        this.angle = null;
+        this.normalizedRadius = 50;
+        this.maximumSliderRadius = this.normalizedRadius * 2.4;
+        this.assumedSliderRadius = this.normalizedRadius * 1.8;
+        this.minDeltaTime = 25;
         this.object = object;
         this.lastObject = lastObject;
         this.lastLastObject = lastLastObject;
@@ -295,7 +257,8 @@ class DifficultyHitObject {
      * difficulty hitobject's index, `null` if the index is out of range.
      */
     previous(backwardsIndex) {
-        return this.hitObjects[this.index - backwardsIndex] ?? null;
+        var _a;
+        return (_a = this.hitObjects[this.index - backwardsIndex]) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * Gets the difficulty hitobject at a specific index with respect to the current
@@ -308,7 +271,8 @@ class DifficultyHitObject {
      * difficulty hitobject's index, `null` if the index is out of range.
      */
     next(forwardsIndex) {
-        return (this.hitObjects[this.index + forwardsIndex + 2] ?? null);
+        var _a;
+        return ((_a = this.hitObjects[this.index + forwardsIndex + 2]) !== null && _a !== void 0 ? _a : null);
     }
     /**
      * Calculates the opacity of the hitobject at a given time.
@@ -461,10 +425,11 @@ class DifficultyHitObject {
         }
     }
     getEndCursorPosition(object) {
+        var _a;
         let pos = object.getStackedPosition(this.mode);
         if (object instanceof osuBase.Slider) {
             this.calculateSliderCursorPosition(object);
-            pos = object.lazyEndPosition ?? pos;
+            pos = (_a = object.lazyEndPosition) !== null && _a !== void 0 ? _a : pos;
         }
         return pos;
     }
@@ -474,12 +439,6 @@ class DifficultyHitObject {
  * An evaluator for calculating osu!droid Aim skill.
  */
 class DroidAimEvaluator extends AimEvaluator {
-    static wideAngleMultiplier = 1.65;
-    static sliderMultiplier = 1.5;
-    static velocityChangeMultiplier = 0.85;
-    static singleSpacingThreshold = 100;
-    // 200 1/4 BPM delta time
-    static minSpeedBonus = 75;
     /**
      * Evaluates the difficulty of aiming the current object, based on:
      *
@@ -504,8 +463,9 @@ class DroidAimEvaluator extends AimEvaluator {
      * Calculates the snap aim strain of a hitobject.
      */
     static snapAimStrainOf(current, withSliders) {
+        var _a;
         if (current.index <= 1 ||
-            current.previous(0)?.object instanceof osuBase.Spinner) {
+            ((_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.object) instanceof osuBase.Spinner) {
             return 0;
         }
         const last = current.previous(0);
@@ -616,17 +576,24 @@ class DroidAimEvaluator extends AimEvaluator {
      * Calculates the flow aim strain of a hitobject.
      */
     static flowAimStrainOf(current) {
+        var _a, _b;
         let speedBonus = 1;
         if (current.strainTime < this.minSpeedBonus) {
             speedBonus +=
                 0.75 *
                     Math.pow((this.minSpeedBonus - current.strainTime) / 40, 2);
         }
-        const travelDistance = current.previous(0)?.travelDistance ?? 0;
+        const travelDistance = (_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.travelDistance) !== null && _b !== void 0 ? _b : 0;
         const shortDistancePenalty = Math.pow(Math.min(this.singleSpacingThreshold, travelDistance + current.minimumJumpDistance) / this.singleSpacingThreshold, 3.5);
         return (200 * speedBonus * shortDistancePenalty) / current.strainTime;
     }
 }
+DroidAimEvaluator.wideAngleMultiplier = 1.65;
+DroidAimEvaluator.sliderMultiplier = 1.5;
+DroidAimEvaluator.velocityChangeMultiplier = 0.85;
+DroidAimEvaluator.singleSpacingThreshold = 100;
+// 200 1/4 BPM delta time
+DroidAimEvaluator.minSpeedBonus = 75;
 
 /**
  * A bare minimal abstract skill for fully custom skill implementations.
@@ -634,10 +601,6 @@ class DroidAimEvaluator extends AimEvaluator {
  * This class should be considered a "processing" class and not persisted.
  */
 class Skill {
-    /**
-     * The mods that this skill processes.
-     */
-    mods;
     constructor(mods) {
         this.mods = mods;
     }
@@ -648,14 +611,17 @@ class Skill {
  * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
  */
 class StrainSkill extends Skill {
-    /**
-     * Strain peaks are stored here.
-     */
-    strainPeaks = [];
-    sectionLength = 400;
-    currentStrain = 0;
-    currentSectionPeak = 0;
-    currentSectionEnd = 0;
+    constructor() {
+        super(...arguments);
+        /**
+         * Strain peaks are stored here.
+         */
+        this.strainPeaks = [];
+        this.sectionLength = 400;
+        this.currentStrain = 0;
+        this.currentSectionPeak = 0;
+        this.currentSectionEnd = 0;
+    }
     process(current) {
         // The first object doesn't generate a strain, so we begin with an incremented section end
         if (current.index === 0) {
@@ -734,15 +700,14 @@ class DroidSkill extends StrainSkill {
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 class DroidAim extends DroidSkill {
-    strainDecayBase = 0.15;
-    reducedSectionCount = 10;
-    reducedSectionBaseline = 0.75;
-    starsPerDouble = 1.05;
-    skillMultiplier = 24.55;
-    withSliders;
-    currentAimStrain = 0;
     constructor(mods, withSliders) {
         super(mods);
+        this.strainDecayBase = 0.15;
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.starsPerDouble = 1.05;
+        this.skillMultiplier = 24.55;
+        this.currentAimStrain = 0;
         this.withSliders = withSliders;
     }
     strainValueAt(current) {
@@ -753,8 +718,9 @@ class DroidAim extends DroidSkill {
         return this.currentAimStrain;
     }
     calculateInitialStrain(time, current) {
+        var _a, _b;
         return (this.currentAimStrain *
-            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
     /**
      * @param current The hitobject to save to.
@@ -775,9 +741,9 @@ class DroidAim extends DroidSkill {
  * This class should be considered an "evaluating" class and not persisted.
  */
 class SpeedEvaluator {
-    // ~200 1/4 BPM streams
-    static minSpeedBonus = 75;
 }
+// ~200 1/4 BPM streams
+SpeedEvaluator.minSpeedBonus = 75;
 
 /**
  * An evaluator for calculating osu!droid tap skill.
@@ -829,17 +795,15 @@ class DroidTapEvaluator extends SpeedEvaluator {
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
 class DroidTap extends DroidSkill {
-    reducedSectionCount = 10;
-    reducedSectionBaseline = 0.75;
-    strainDecayBase = 0.3;
-    starsPerDouble = 1.1;
-    currentTapStrain = 0;
-    currentRhythmMultiplier = 0;
-    skillMultiplier = 1375;
-    greatWindow;
-    considerCheesability;
     constructor(mods, overallDifficulty, considerCheesability) {
         super(mods);
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.strainDecayBase = 0.3;
+        this.starsPerDouble = 1.1;
+        this.currentTapStrain = 0;
+        this.currentRhythmMultiplier = 0;
+        this.skillMultiplier = 1375;
         this.greatWindow = new osuBase.OsuHitWindow(overallDifficulty).hitWindowFor300();
         this.considerCheesability = considerCheesability;
     }
@@ -852,9 +816,10 @@ class DroidTap extends DroidSkill {
         return this.currentTapStrain * current.rhythmMultiplier;
     }
     calculateInitialStrain(time, current) {
+        var _a, _b;
         return (this.currentTapStrain *
             this.currentRhythmMultiplier *
-            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
     /**
      * @param current The hitobject to save to.
@@ -876,12 +841,12 @@ class DroidTap extends DroidSkill {
  * This class should be considered an "evaluating" class and not persisted.
  */
 class FlashlightEvaluator {
-    static maxOpacityBonus = 0.4;
-    static hiddenBonus = 0.2;
-    static minVelocity = 0.5;
-    static sliderMultiplier = 1.3;
-    static minAngleMultiplier = 0.2;
 }
+FlashlightEvaluator.maxOpacityBonus = 0.4;
+FlashlightEvaluator.hiddenBonus = 0.2;
+FlashlightEvaluator.minVelocity = 0.5;
+FlashlightEvaluator.sliderMultiplier = 1.3;
+FlashlightEvaluator.minAngleMultiplier = 0.2;
 
 /**
  * An evaluator for calculating osu!droid Flashlight skill.
@@ -974,16 +939,14 @@ class DroidFlashlightEvaluator extends FlashlightEvaluator {
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 class DroidFlashlight extends DroidSkill {
-    strainDecayBase = 0.15;
-    reducedSectionCount = 0;
-    reducedSectionBaseline = 1;
-    starsPerDouble = 1.06;
-    skillMultiplier = 0.052;
-    isHidden;
-    withSliders;
-    currentFlashlightStrain = 0;
     constructor(mods, withSliders) {
         super(mods);
+        this.strainDecayBase = 0.15;
+        this.reducedSectionCount = 0;
+        this.reducedSectionBaseline = 1;
+        this.starsPerDouble = 1.06;
+        this.skillMultiplier = 0.052;
+        this.currentFlashlightStrain = 0;
         this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
         this.withSliders = withSliders;
     }
@@ -994,8 +957,9 @@ class DroidFlashlight extends DroidSkill {
         return this.currentFlashlightStrain;
     }
     calculateInitialStrain(time, current) {
+        var _a, _b;
         return (this.currentFlashlightStrain *
-            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
     saveToHitObject(current) {
         if (this.withSliders) {
@@ -1017,9 +981,9 @@ class DroidFlashlight extends DroidSkill {
  * This class should be considered an "evaluating" class and not persisted.
  */
 class RhythmEvaluator {
-    static rhythmMultiplier = 0.75;
-    static historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
 }
+RhythmEvaluator.rhythmMultiplier = 0.75;
+RhythmEvaluator.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
 
 /**
  * An evaluator for calculating osu!droid Rhythm skill.
@@ -1155,15 +1119,14 @@ class DroidRhythmEvaluator extends RhythmEvaluator {
  * Represents the skill required to properly follow a beatmap's rhythm.
  */
 class DroidRhythm extends DroidSkill {
-    reducedSectionCount = 5;
-    reducedSectionBaseline = 0.75;
-    strainDecayBase = 0.3;
-    starsPerDouble = 1.75;
-    currentRhythmStrain = 0;
-    currentRhythmMultiplier = 1;
-    hitWindow;
     constructor(mods, overallDifficulty) {
         super(mods);
+        this.reducedSectionCount = 5;
+        this.reducedSectionBaseline = 0.75;
+        this.strainDecayBase = 0.3;
+        this.starsPerDouble = 1.75;
+        this.currentRhythmStrain = 0;
+        this.currentRhythmMultiplier = 1;
         this.hitWindow = new osuBase.OsuHitWindow(overallDifficulty);
     }
     strainValueAt(current) {
@@ -1174,8 +1137,9 @@ class DroidRhythm extends DroidSkill {
         return this.currentRhythmStrain;
     }
     calculateInitialStrain(time, current) {
+        var _a, _b;
         return (this.currentRhythmStrain *
-            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
     saveToHitObject(current) {
         current.rhythmStrain = this.currentRhythmStrain;
@@ -1283,17 +1247,15 @@ class DroidVisualEvaluator {
  * Represents the skill required to read every object in the map.
  */
 class DroidVisual extends DroidSkill {
-    starsPerDouble = 1.025;
-    reducedSectionCount = 10;
-    reducedSectionBaseline = 0.75;
-    strainDecayBase = 0.1;
-    isHidden;
-    withSliders;
-    currentVisualStrain = 0;
-    currentRhythmMultiplier = 1;
-    skillMultiplier = 10;
     constructor(mods, withSliders) {
         super(mods);
+        this.starsPerDouble = 1.025;
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.strainDecayBase = 0.1;
+        this.currentVisualStrain = 0;
+        this.currentRhythmMultiplier = 1;
+        this.skillMultiplier = 10;
         this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
         this.withSliders = withSliders;
     }
@@ -1305,9 +1267,10 @@ class DroidVisual extends DroidSkill {
         return this.currentVisualStrain * this.currentRhythmMultiplier;
     }
     calculateInitialStrain(time, current) {
+        var _a, _b;
         return (this.currentVisualStrain *
             this.currentRhythmMultiplier *
-            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
     saveToHitObject(current) {
         const strain = this.currentVisualStrain * this.currentRhythmMultiplier;
@@ -1324,52 +1287,6 @@ class DroidVisual extends DroidSkill {
  * Represents an osu!droid hit object with difficulty calculation values.
  */
 class DroidDifficultyHitObject extends DifficultyHitObject {
-    /**
-     * The tap strain generated by the hitobject.
-     */
-    tapStrain = 0;
-    /**
-     * The tap strain generated by the hitobject if `strainTime` isn't modified by
-     * OD. This is used in three-finger detection.
-     */
-    originalTapStrain = 0;
-    /**
-     * The rhythm strain generated by the hitobject.
-     */
-    rhythmStrain = 0;
-    /**
-     * The flashlight strain generated by the hitobject if sliders are considered.
-     */
-    flashlightStrainWithSliders = 0;
-    /**
-     * The flashlight strain generated by the hitobject if sliders are not considered.
-     */
-    flashlightStrainWithoutSliders = 0;
-    /**
-     * The visual strain generated by the hitobject if sliders are considered.
-     */
-    visualStrainWithSliders = 0;
-    /**
-     * The visual strain generated by the hitobject if sliders are not considered.
-     */
-    visualStrainWithoutSliders = 0;
-    /**
-     * The note density of the hitobject.
-     */
-    noteDensity = 1;
-    /**
-     * The overlapping factor of the hitobject.
-     *
-     * This is used to scale visual skill.
-     */
-    overlappingFactor = 0;
-    /**
-     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
-     */
-    timePreempt;
-    radiusBuffThreshold = 70;
-    mode = osuBase.Modes.droid;
-    maximumSliderRadius = this.normalizedRadius * 2;
     get scalingFactor() {
         const radius = this.object.radius;
         // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
@@ -1394,6 +1311,48 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
      */
     constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, isForceAR) {
         super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate);
+        /**
+         * The tap strain generated by the hitobject.
+         */
+        this.tapStrain = 0;
+        /**
+         * The tap strain generated by the hitobject if `strainTime` isn't modified by
+         * OD. This is used in three-finger detection.
+         */
+        this.originalTapStrain = 0;
+        /**
+         * The rhythm strain generated by the hitobject.
+         */
+        this.rhythmStrain = 0;
+        /**
+         * The flashlight strain generated by the hitobject if sliders are considered.
+         */
+        this.flashlightStrainWithSliders = 0;
+        /**
+         * The flashlight strain generated by the hitobject if sliders are not considered.
+         */
+        this.flashlightStrainWithoutSliders = 0;
+        /**
+         * The visual strain generated by the hitobject if sliders are considered.
+         */
+        this.visualStrainWithSliders = 0;
+        /**
+         * The visual strain generated by the hitobject if sliders are not considered.
+         */
+        this.visualStrainWithoutSliders = 0;
+        /**
+         * The note density of the hitobject.
+         */
+        this.noteDensity = 1;
+        /**
+         * The overlapping factor of the hitobject.
+         *
+         * This is used to scale visual skill.
+         */
+        this.overlappingFactor = 0;
+        this.radiusBuffThreshold = 70;
+        this.mode = osuBase.Modes.droid;
+        this.maximumSliderRadius = this.normalizedRadius * 2;
         this.timePreempt = object.timePreempt;
         if (!isForceAR) {
             this.timePreempt /= clockRate;
@@ -1498,6 +1457,40 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
  * A difficulty calculator for osu!droid gamemode.
  */
 class DroidDifficultyCalculator extends DifficultyCalculator {
+    constructor() {
+        super(...arguments);
+        this.attributes = {
+            mode: "live",
+            tapDifficulty: 0,
+            rhythmDifficulty: 0,
+            visualDifficulty: 0,
+            aimNoteCount: 0,
+            mods: [],
+            starRating: 0,
+            maxCombo: 0,
+            aimDifficulty: 0,
+            flashlightDifficulty: 0,
+            speedNoteCount: 0,
+            sliderFactor: 0,
+            clockRate: 1,
+            approachRate: 0,
+            overallDifficulty: 0,
+            hitCircleCount: 0,
+            sliderCount: 0,
+            spinnerCount: 0,
+            aimDifficultStrainCount: 0,
+            tapDifficultStrainCount: 0,
+            flashlightDifficultStrainCount: 0,
+            visualDifficultStrainCount: 0,
+            flashlightSliderFactor: 0,
+            visualSliderFactor: 0,
+            possibleThreeFingeredSections: [],
+            difficultSliders: [],
+            averageSpeedDeltaTime: 0,
+        };
+        this.difficultyMultiplier = 0.18;
+        this.mode = osuBase.Modes.droid;
+    }
     /**
      * The aim star rating of the beatmap.
      */
@@ -1528,41 +1521,6 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     get visual() {
         return this.attributes.visualDifficulty;
     }
-    /**
-     * The strain threshold to start detecting for possible three-fingered section.
-     *
-     * Increasing this number will result in less sections being flagged.
-     */
-    static threeFingerStrainThreshold = 175;
-    attributes = {
-        mode: "live",
-        tapDifficulty: 0,
-        rhythmDifficulty: 0,
-        visualDifficulty: 0,
-        aimNoteCount: 0,
-        mods: [],
-        starRating: 0,
-        maxCombo: 0,
-        aimDifficulty: 0,
-        flashlightDifficulty: 0,
-        speedNoteCount: 0,
-        sliderFactor: 0,
-        clockRate: 1,
-        approachRate: 0,
-        overallDifficulty: 0,
-        hitCircleCount: 0,
-        sliderCount: 0,
-        spinnerCount: 0,
-        aimDifficultStrainCount: 0,
-        tapDifficultStrainCount: 0,
-        flashlightDifficultStrainCount: 0,
-        visualDifficultStrainCount: 0,
-        flashlightSliderFactor: 0,
-        visualSliderFactor: 0,
-        possibleThreeFingeredSections: [],
-        difficultSliders: [],
-        averageSpeedDeltaTime: 0,
-    };
     get cacheableAttributes() {
         return {
             tapDifficulty: this.tap,
@@ -1588,8 +1546,6 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             averageSpeedDeltaTime: this.attributes.averageSpeedDeltaTime,
         };
     }
-    difficultyMultiplier = 0.18;
-    mode = osuBase.Modes.droid;
     calculate(options) {
         return super.calculate(options);
     }
@@ -1698,26 +1654,28 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             " visual)");
     }
     generateDifficultyHitObjects(beatmap) {
+        var _a, _b;
         const difficultyObjects = [];
         const { objects } = beatmap.hitObjects;
         const difficultyAdjustMod = this.mods.find((m) => m instanceof osuBase.ModDifficultyAdjust);
         for (let i = 0; i < objects.length; ++i) {
-            const difficultyObject = new DroidDifficultyHitObject(objects[i], objects[i - 1] ?? null, objects[i - 2] ?? null, difficultyObjects, this.difficultyStatistics.overallSpeedMultiplier, difficultyAdjustMod?.ar !== undefined);
+            const difficultyObject = new DroidDifficultyHitObject(objects[i], (_a = objects[i - 1]) !== null && _a !== void 0 ? _a : null, (_b = objects[i - 2]) !== null && _b !== void 0 ? _b : null, difficultyObjects, this.difficultyStatistics.overallSpeedMultiplier, (difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.ar) !== undefined);
             difficultyObject.computeProperties(this.difficultyStatistics.overallSpeedMultiplier, objects);
             difficultyObjects.push(difficultyObject);
         }
         return difficultyObjects;
     }
     computeDifficultyStatistics(options) {
+        var _a;
         const { difficulty } = this.beatmap;
         return osuBase.calculateDroidDifficultyStatistics({
             circleSize: difficulty.cs,
-            approachRate: difficulty.ar ?? difficulty.od,
+            approachRate: (_a = difficulty.ar) !== null && _a !== void 0 ? _a : difficulty.od,
             overallDifficulty: difficulty.od,
             healthDrain: difficulty.hp,
             mods: this.mods,
-            customSpeedMultiplier: options?.customSpeedMultiplier,
-            oldStatistics: options?.oldStatistics,
+            customSpeedMultiplier: options === null || options === void 0 ? void 0 : options.customSpeedMultiplier,
+            oldStatistics: options === null || options === void 0 ? void 0 : options.oldStatistics,
         });
     }
     createSkills() {
@@ -1977,44 +1935,43 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         }
     }
 }
+/**
+ * The strain threshold to start detecting for possible three-fingered section.
+ *
+ * Increasing this number will result in less sections being flagged.
+ */
+DroidDifficultyCalculator.threeFingerStrainThreshold = 175;
 
 /**
  * The base class of performance calculators.
  */
 class PerformanceCalculator {
-    /**
-     * The overall performance value.
-     */
-    total = 0;
-    /**
-     * The calculated accuracy.
-     */
-    computedAccuracy = new osuBase.Accuracy({});
-    /**
-     * The difficulty attributes that is being calculated.
-     */
-    difficultyAttributes;
-    /**
-     * Penalty for combo breaks.
-     */
-    comboPenalty = 0;
-    /**
-     * The amount of misses that are filtered out from sliderbreaks.
-     */
-    effectiveMissCount = 0;
-    /**
-     * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
-     */
-    sliderNerfFactor = 1;
     /**
      * @param difficultyAttributes The difficulty attributes to calculate.
      */
     constructor(difficultyAttributes) {
+        /**
+         * The overall performance value.
+         */
+        this.total = 0;
+        /**
+         * The calculated accuracy.
+         */
+        this.computedAccuracy = new osuBase.Accuracy({});
+        /**
+         * Penalty for combo breaks.
+         */
+        this.comboPenalty = 0;
+        /**
+         * The amount of misses that are filtered out from sliderbreaks.
+         */
+        this.effectiveMissCount = 0;
+        /**
+         * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
+         */
+        this.sliderNerfFactor = 1;
         if (this.isCacheableAttribute(difficultyAttributes)) {
-            this.difficultyAttributes = {
-                ...difficultyAttributes,
-                mods: osuBase.ModUtil.pcStringToMods(difficultyAttributes.mods),
-            };
+            this.difficultyAttributes = Object.assign(Object.assign({}, difficultyAttributes), { mods: osuBase.ModUtil.pcStringToMods(difficultyAttributes.mods) });
         }
         else {
             this.difficultyAttributes = osuBase.Utils.deepCopy(difficultyAttributes);
@@ -2060,11 +2017,12 @@ class PerformanceCalculator {
      * @param options Options for performance calculation.
      */
     handleOptions(options) {
+        var _a;
         const maxCombo = this.difficultyAttributes.maxCombo;
         const miss = this.computedAccuracy.nmiss;
-        const combo = options?.combo ?? maxCombo - miss;
+        const combo = (_a = options === null || options === void 0 ? void 0 : options.combo) !== null && _a !== void 0 ? _a : maxCombo - miss;
         this.comboPenalty = Math.min(Math.pow(combo / maxCombo, 0.8), 1);
-        if (options?.accPercent instanceof osuBase.Accuracy) {
+        if ((options === null || options === void 0 ? void 0 : options.accPercent) instanceof osuBase.Accuracy) {
             // Copy into new instance to not modify the original
             this.computedAccuracy = new osuBase.Accuracy(options.accPercent);
             if (this.computedAccuracy.n300 <= 0) {
@@ -2079,9 +2037,9 @@ class PerformanceCalculator {
         }
         else {
             this.computedAccuracy = new osuBase.Accuracy({
-                percent: options?.accPercent,
+                percent: options === null || options === void 0 ? void 0 : options.accPercent,
                 nobjects: this.totalHits,
-                nmiss: options?.miss || 0,
+                nmiss: (options === null || options === void 0 ? void 0 : options.miss) || 0,
             });
         }
         this.effectiveMissCount = this.calculateEffectiveMissCount(combo, maxCombo);
@@ -2158,26 +2116,37 @@ class PerformanceCalculator {
  * A performance points calculator that calculates performance points for osu!droid gamemode.
  */
 class DroidPerformanceCalculator extends PerformanceCalculator {
-    /**
-     * The aim performance value.
-     */
-    aim = 0;
-    /**
-     * The tap performance value.
-     */
-    tap = 0;
-    /**
-     * The accuracy performance value.
-     */
-    accuracy = 0;
-    /**
-     * The flashlight performance value.
-     */
-    flashlight = 0;
-    /**
-     * The visual performance value.
-     */
-    visual = 0;
+    constructor() {
+        super(...arguments);
+        /**
+         * The aim performance value.
+         */
+        this.aim = 0;
+        /**
+         * The tap performance value.
+         */
+        this.tap = 0;
+        /**
+         * The accuracy performance value.
+         */
+        this.accuracy = 0;
+        /**
+         * The flashlight performance value.
+         */
+        this.flashlight = 0;
+        /**
+         * The visual performance value.
+         */
+        this.visual = 0;
+        this.finalMultiplier = 1.24;
+        this.mode = osuBase.Modes.droid;
+        this._aimSliderCheesePenalty = 1;
+        this._flashlightSliderCheesePenalty = 1;
+        this._visualSliderCheesePenalty = 1;
+        this._tapPenalty = 1;
+        this._deviation = 0;
+        this._tapDeviation = 0;
+    }
     /**
      * The penalty used to penalize the tap performance value.
      *
@@ -2222,14 +2191,6 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
     get visualSliderCheesePenalty() {
         return this._visualSliderCheesePenalty;
     }
-    finalMultiplier = 1.24;
-    mode = osuBase.Modes.droid;
-    _aimSliderCheesePenalty = 1;
-    _flashlightSliderCheesePenalty = 1;
-    _visualSliderCheesePenalty = 1;
-    _tapPenalty = 1;
-    _deviation = 0;
-    _tapDeviation = 0;
     /**
      * Applies a tap penalty value to this calculator.
      *
@@ -2328,12 +2289,13 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             Math.pow(this.visual, 1.1), 1 / 1.1) * this.finalMultiplier);
     }
     handleOptions(options) {
-        this._tapPenalty = options?.tapPenalty ?? 1;
-        this._aimSliderCheesePenalty = options?.aimSliderCheesePenalty ?? 1;
+        var _a, _b, _c, _d;
+        this._tapPenalty = (_a = options === null || options === void 0 ? void 0 : options.tapPenalty) !== null && _a !== void 0 ? _a : 1;
+        this._aimSliderCheesePenalty = (_b = options === null || options === void 0 ? void 0 : options.aimSliderCheesePenalty) !== null && _b !== void 0 ? _b : 1;
         this._flashlightSliderCheesePenalty =
-            options?.flashlightSliderCheesePenalty ?? 1;
+            (_c = options === null || options === void 0 ? void 0 : options.flashlightSliderCheesePenalty) !== null && _c !== void 0 ? _c : 1;
         this._visualSliderCheesePenalty =
-            options?.visualSliderCheesePenalty ?? 1;
+            (_d = options === null || options === void 0 ? void 0 : options.visualSliderCheesePenalty) !== null && _d !== void 0 ? _d : 1;
         super.handleOptions(options);
     }
     /**
@@ -2639,16 +2601,13 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
  * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
  */
 class OsuSkill extends StrainSkill {
-    /**
-     * The default multiplier applied to the final difficulty value after all other calculations.
-     *
-     * May be overridden via {@link difficultyMultiplier}.
-     */
-    static defaultDifficultyMultiplier = 1.06;
-    /**
-     * The final multiplier to be applied to the final difficulty value after all other calculations.
-     */
-    difficultyMultiplier = OsuSkill.defaultDifficultyMultiplier;
+    constructor() {
+        super(...arguments);
+        /**
+         * The final multiplier to be applied to the final difficulty value after all other calculations.
+         */
+        this.difficultyMultiplier = OsuSkill.defaultDifficultyMultiplier;
+    }
     difficultyValue() {
         const strains = this.strainPeaks
             .slice()
@@ -2676,6 +2635,12 @@ class OsuSkill extends StrainSkill {
         return difficulty * this.difficultyMultiplier;
     }
 }
+/**
+ * The default multiplier applied to the final difficulty value after all other calculations.
+ *
+ * May be overridden via {@link difficultyMultiplier}.
+ */
+OsuSkill.defaultDifficultyMultiplier = 1.06;
 
 /**
  * An evaluator for calculating osu!standard Aim skill.
@@ -2696,7 +2661,7 @@ class OsuAimEvaluator extends AimEvaluator {
         const last = current.previous(0);
         if (current.object instanceof osuBase.Spinner ||
             current.index <= 1 ||
-            last?.object instanceof osuBase.Spinner) {
+            (last === null || last === void 0 ? void 0 : last.object) instanceof osuBase.Spinner) {
             return 0;
         }
         const lastLast = current.previous(1);
@@ -2803,15 +2768,14 @@ class OsuAimEvaluator extends AimEvaluator {
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 class OsuAim extends OsuSkill {
-    strainDecayBase = 0.15;
-    reducedSectionCount = 10;
-    reducedSectionBaseline = 0.75;
-    decayWeight = 0.9;
-    currentAimStrain = 0;
-    skillMultiplier = 23.55;
-    withSliders;
     constructor(mods, withSliders) {
         super(mods);
+        this.strainDecayBase = 0.15;
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.decayWeight = 0.9;
+        this.currentAimStrain = 0;
+        this.skillMultiplier = 23.55;
         this.withSliders = withSliders;
     }
     strainValueAt(current) {
@@ -2822,8 +2786,9 @@ class OsuAim extends OsuSkill {
         return this.currentAimStrain;
     }
     calculateInitialStrain(time, current) {
+        var _a, _b;
         return (this.currentAimStrain *
-            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
     /**
      * @param current The hitobject to save to.
@@ -2842,10 +2807,6 @@ class OsuAim extends OsuSkill {
  * An evaluator for calculating osu!standard speed skill.
  */
 class OsuSpeedEvaluator extends SpeedEvaluator {
-    /**
-     * Spacing threshold for a single hitobject spacing.
-     */
-    static SINGLE_SPACING_THRESHOLD = 125;
     /**
      * Evaluates the difficulty of tapping the current object, based on:
      *
@@ -2857,6 +2818,7 @@ class OsuSpeedEvaluator extends SpeedEvaluator {
      * @param greatWindow The great hit window of the current object.
      */
     static evaluateDifficultyOf(current, greatWindow) {
+        var _a;
         if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
@@ -2882,7 +2844,7 @@ class OsuSpeedEvaluator extends SpeedEvaluator {
             speedBonus +=
                 0.75 * Math.pow((this.minSpeedBonus - strainTime) / 40, 2);
         }
-        const travelDistance = prev?.travelDistance ?? 0;
+        const travelDistance = (_a = prev === null || prev === void 0 ? void 0 : prev.travelDistance) !== null && _a !== void 0 ? _a : 0;
         const distance = Math.min(this.SINGLE_SPACING_THRESHOLD, travelDistance + current.minimumJumpDistance);
         return (((speedBonus +
             speedBonus *
@@ -2891,6 +2853,10 @@ class OsuSpeedEvaluator extends SpeedEvaluator {
             strainTime);
     }
 }
+/**
+ * Spacing threshold for a single hitobject spacing.
+ */
+OsuSpeedEvaluator.SINGLE_SPACING_THRESHOLD = 125;
 
 /**
  * An evaluator for calculating osu!standard Rhythm skill.
@@ -3005,17 +2971,16 @@ class OsuRhythmEvaluator extends RhythmEvaluator {
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
 class OsuSpeed extends OsuSkill {
-    strainDecayBase = 0.3;
-    reducedSectionCount = 5;
-    reducedSectionBaseline = 0.75;
-    difficultyMultiplier = 1.04;
-    decayWeight = 0.9;
-    currentSpeedStrain = 0;
-    currentRhythm = 0;
-    skillMultiplier = 1375;
-    greatWindow;
     constructor(mods, overallDifficulty) {
         super(mods);
+        this.strainDecayBase = 0.3;
+        this.reducedSectionCount = 5;
+        this.reducedSectionBaseline = 0.75;
+        this.difficultyMultiplier = 1.04;
+        this.decayWeight = 0.9;
+        this.currentSpeedStrain = 0;
+        this.currentRhythm = 0;
+        this.skillMultiplier = 1375;
         this.greatWindow = new osuBase.OsuHitWindow(overallDifficulty).hitWindowFor300();
     }
     /**
@@ -3030,9 +2995,10 @@ class OsuSpeed extends OsuSkill {
         return this.currentSpeedStrain * this.currentRhythm;
     }
     calculateInitialStrain(time, current) {
+        var _a, _b;
         return (this.currentSpeedStrain *
             this.currentRhythm *
-            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
     /**
      * @param current The hitobject to save to.
@@ -3129,15 +3095,14 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 class OsuFlashlight extends OsuSkill {
-    strainDecayBase = 0.15;
-    reducedSectionCount = 0;
-    reducedSectionBaseline = 1;
-    decayWeight = 1;
-    currentFlashlightStrain = 0;
-    skillMultiplier = 0.052;
-    isHidden;
     constructor(mods) {
         super(mods);
+        this.strainDecayBase = 0.15;
+        this.reducedSectionCount = 0;
+        this.reducedSectionBaseline = 1;
+        this.decayWeight = 1;
+        this.currentFlashlightStrain = 0;
+        this.skillMultiplier = 0.052;
         this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
     }
     strainValueAt(current) {
@@ -3147,8 +3112,9 @@ class OsuFlashlight extends OsuSkill {
         return this.currentFlashlightStrain;
     }
     calculateInitialStrain(time, current) {
+        var _a, _b;
         return (this.currentFlashlightStrain *
-            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
     saveToHitObject(current) {
         current.flashlightStrain = this.currentFlashlightStrain;
@@ -3159,16 +3125,6 @@ class OsuFlashlight extends OsuSkill {
  * Represents an osu!standard hit object with difficulty calculation values.
  */
 class OsuDifficultyHitObject extends DifficultyHitObject {
-    /**
-     * The speed strain generated by the hitobject.
-     */
-    speedStrain = 0;
-    /**
-     * The flashlight strain generated by this hitobject.
-     */
-    flashlightStrain = 0;
-    radiusBuffThreshold = 30;
-    mode = osuBase.Modes.osu;
     get scalingFactor() {
         const radius = this.object.radius;
         // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
@@ -3192,6 +3148,16 @@ class OsuDifficultyHitObject extends DifficultyHitObject {
      */
     constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate) {
         super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate);
+        /**
+         * The speed strain generated by the hitobject.
+         */
+        this.speedStrain = 0;
+        /**
+         * The flashlight strain generated by this hitobject.
+         */
+        this.flashlightStrain = 0;
+        this.radiusBuffThreshold = 30;
+        this.mode = osuBase.Modes.osu;
     }
 }
 
@@ -3199,6 +3165,27 @@ class OsuDifficultyHitObject extends DifficultyHitObject {
  * A difficulty calculator for osu!standard gamemode.
  */
 class OsuDifficultyCalculator extends DifficultyCalculator {
+    constructor() {
+        super(...arguments);
+        this.attributes = {
+            speedDifficulty: 0,
+            mods: [],
+            starRating: 0,
+            maxCombo: 0,
+            aimDifficulty: 0,
+            flashlightDifficulty: 0,
+            speedNoteCount: 0,
+            sliderFactor: 0,
+            clockRate: 1,
+            approachRate: 0,
+            overallDifficulty: 0,
+            hitCircleCount: 0,
+            sliderCount: 0,
+            spinnerCount: 0,
+        };
+        this.difficultyMultiplier = 0.0675;
+        this.mode = osuBase.Modes.osu;
+    }
     /**
      * The aim star rating of the beatmap.
      */
@@ -3217,30 +3204,9 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
     get flashlight() {
         return this.attributes.flashlightDifficulty;
     }
-    attributes = {
-        speedDifficulty: 0,
-        mods: [],
-        starRating: 0,
-        maxCombo: 0,
-        aimDifficulty: 0,
-        flashlightDifficulty: 0,
-        speedNoteCount: 0,
-        sliderFactor: 0,
-        clockRate: 1,
-        approachRate: 0,
-        overallDifficulty: 0,
-        hitCircleCount: 0,
-        sliderCount: 0,
-        spinnerCount: 0,
-    };
     get cacheableAttributes() {
-        return {
-            ...this.attributes,
-            mods: osuBase.ModUtil.modsToOsuString(this.attributes.mods),
-        };
+        return Object.assign(Object.assign({}, this.attributes), { mods: osuBase.ModUtil.modsToOsuString(this.attributes.mods) });
     }
-    difficultyMultiplier = 0.0675;
-    mode = osuBase.Modes.osu;
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
@@ -3323,24 +3289,26 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             " flashlight)");
     }
     generateDifficultyHitObjects() {
+        var _a, _b;
         const difficultyObjects = [];
         const { objects } = this.beatmap.hitObjects;
         for (let i = 0; i < objects.length; ++i) {
-            const difficultyObject = new OsuDifficultyHitObject(objects[i], objects[i - 1] ?? null, objects[i - 2] ?? null, difficultyObjects, this.difficultyStatistics.overallSpeedMultiplier);
+            const difficultyObject = new OsuDifficultyHitObject(objects[i], (_a = objects[i - 1]) !== null && _a !== void 0 ? _a : null, (_b = objects[i - 2]) !== null && _b !== void 0 ? _b : null, difficultyObjects, this.difficultyStatistics.overallSpeedMultiplier);
             difficultyObject.computeProperties(this.difficultyStatistics.overallSpeedMultiplier, objects);
             difficultyObjects.push(difficultyObject);
         }
         return difficultyObjects;
     }
     computeDifficultyStatistics(options) {
+        var _a;
         const { difficulty } = this.beatmap;
         return osuBase.calculateOsuDifficultyStatistics({
             circleSize: difficulty.cs,
-            approachRate: difficulty.ar ?? difficulty.od,
+            approachRate: (_a = difficulty.ar) !== null && _a !== void 0 ? _a : difficulty.od,
             overallDifficulty: difficulty.od,
             healthDrain: difficulty.hp,
-            mods: options?.mods,
-            customSpeedMultiplier: options?.customSpeedMultiplier,
+            mods: options === null || options === void 0 ? void 0 : options.mods,
+            customSpeedMultiplier: options === null || options === void 0 ? void 0 : options.customSpeedMultiplier,
         });
     }
     createSkills() {
@@ -3413,24 +3381,27 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
  * A performance points calculator that calculates performance points for osu!standard gamemode.
  */
 class OsuPerformanceCalculator extends PerformanceCalculator {
-    /**
-     * The aim performance value.
-     */
-    aim = 0;
-    /**
-     * The speed performance value.
-     */
-    speed = 0;
-    /**
-     * The accuracy performance value.
-     */
-    accuracy = 0;
-    /**
-     * The flashlight performance value.
-     */
-    flashlight = 0;
-    finalMultiplier = 1.14;
-    mode = osuBase.Modes.osu;
+    constructor() {
+        super(...arguments);
+        /**
+         * The aim performance value.
+         */
+        this.aim = 0;
+        /**
+         * The speed performance value.
+         */
+        this.speed = 0;
+        /**
+         * The accuracy performance value.
+         */
+        this.accuracy = 0;
+        /**
+         * The flashlight performance value.
+         */
+        this.flashlight = 0;
+        this.finalMultiplier = 1.14;
+        this.mode = osuBase.Modes.osu;
+    }
     calculateValues() {
         this.aim = this.calculateAimValue();
         this.speed = this.calculateSpeedValue();
@@ -3564,10 +3535,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         if (ncircles === 0) {
             return 0;
         }
-        const realAccuracy = new osuBase.Accuracy({
-            ...this.computedAccuracy,
-            n300: this.computedAccuracy.n300 - (this.totalHits - ncircles),
-        });
+        const realAccuracy = new osuBase.Accuracy(Object.assign(Object.assign({}, this.computedAccuracy), { n300: this.computedAccuracy.n300 - (this.totalHits - ncircles) }));
         // Lots of arbitrary values from testing.
         // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
         let accuracyValue = Math.pow(1.52163, this.difficultyAttributes.overallDifficulty) *