@rian8337/osu-droid-replay-analyzer 4.0.0-beta.16 → 4.0.0-beta.18

package/dist/index.js

@@ -51,18 +51,6 @@ exports.MovementType = void 0;
  * Represents a cursor's occurrence.
  */
 class CursorOccurrence {
-    /**
-     * The time of this occurrence.
-     */
-    time;
-    /**
-     * The position of the occurrence.
-     */
-    position;
-    /**
-     * The movement ID of the occurrence.
-     */
-    id;
     constructor(time, x, y, id) {
         this.time = time;
         this.position = new osuBase.Vector2(x, y);
@@ -125,7 +113,8 @@ class CursorOccurrenceGroup {
      * The time at which this cursor occurrence group ends.
      */
     get endTime() {
-        return this._up?.time ?? this._moves.at(-1)?.time ?? this._down.time;
+        var _a, _b, _c, _d;
+        return (_d = (_b = (_a = this._up) === null || _a === void 0 ? void 0 : _a.time) !== null && _b !== void 0 ? _b : (_c = this._moves.at(-1)) === null || _c === void 0 ? void 0 : _c.time) !== null && _d !== void 0 ? _d : this._down.time;
     }
     /**
      * The duration this cursor occurrence group is active for.
@@ -145,20 +134,6 @@ class CursorOccurrenceGroup {
         }
         return cursors;
     }
-    /**
-     * The cursor occurrence of movement type `movementType.DOWN`.
-     */
-    _down;
-    /**
-     * The cursor occurrences of movement type `movementType.MOVE`.
-     */
-    _moves;
-    /**
-     * The cursor occurrence of movement type `movementType.UP`.
-     *
-     * May not exist, such as when the player holds their cursor until the end of a beatmap.
-     */
-    _up;
     constructor(down, moves, up) {
         this._down = down;
         this._moves = moves;
@@ -182,13 +157,14 @@ class CursorOccurrenceGroup {
      * @returns The cursor occurrence at the given time, `null` if not found.
      */
     cursorAt(time) {
+        var _a;
         if (!this.isActiveAt(time)) {
             return null;
         }
         if (this._down.time === time) {
             return this._down;
         }
-        if (this._up?.time === time) {
+        if (((_a = this._up) === null || _a === void 0 ? void 0 : _a.time) === time) {
             return this._up;
         }
         let l = 0;
@@ -218,17 +194,14 @@ class CursorOccurrenceGroup {
  * This is used when analyzing replays using replay analyzer.
  */
 class CursorData {
-    /**
-     * The occurrence groups of this cursor instance.
-     */
-    occurrenceGroups = [];
     /**
      * The time at which the first occurrence of this cursor instance occurs.
      *
      * Will return `null` if there are no occurrences.
      */
     get earliestOccurrenceTime() {
-        return this.occurrenceGroups.at(0)?.startTime ?? null;
+        var _a, _b;
+        return (_b = (_a = this.occurrenceGroups.at(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : null;
     }
     /**
      * The time at which the latest occurrence of this cursor instance occurs.
@@ -236,7 +209,8 @@ class CursorData {
      * Will return `null` if there are no occurrences.
      */
     get latestOccurrenceTime() {
-        return this.occurrenceGroups.at(-1)?.endTime ?? null;
+        var _a, _b;
+        return (_b = (_a = this.occurrenceGroups.at(-1)) === null || _a === void 0 ? void 0 : _a.endTime) !== null && _b !== void 0 ? _b : null;
     }
     /**
      * The amount of cursor occurrences of this cursor instance.
@@ -263,6 +237,10 @@ class CursorData {
         return this.occurrenceGroups.flatMap((v) => v.allOccurrences);
     }
     constructor(values) {
+        /**
+         * The occurrence groups of this cursor instance.
+         */
+        this.occurrenceGroups = [];
         let downOccurrence = null;
         let moveOccurrences = [];
         for (let i = 0; i < values.size; ++i) {
@@ -316,102 +294,50 @@ exports.HitResult = void 0;
  * Utility to check whether or not a beatmap is three-fingered for rebalance scores.
  */
 class RebalanceThreeFingerChecker {
-    /**
-     * The beatmap that is being analyzed.
-     */
-    beatmap;
-    /**
-     * The data of the replay.
-     */
-    data;
-    /**
-     * The difficulty attributes of the beatmap.
-     */
-    difficultyAttributes;
-    /**
-     * The hitobjects to be analyzed.
-     *
-     * This is being maintained separately due to possible change in object scale.
-     */
-    hitObjects;
-    /**
-     * The distance threshold between cursors to assume that two cursors are
-     * actually pressed with 1 finger in osu!pixels.
-     *
-     * This is used to prevent cases where a player would lift their finger
-     * too fast to the point where the 4th cursor instance or beyond is recorded
-     * as 1st, 2nd, or 3rd cursor instance.
-     */
-    cursorDistancingDistanceThreshold = 60;
-    /**
-     * The threshold for the amount of cursors that are assumed to be pressed
-     * by a single finger.
-     */
-    cursorDistancingCountThreshold = 10;
-    /**
-     * The threshold for the time difference of cursors that are assumed to be pressed
-     * by a single finger, in milliseconds.
-     */
-    cursorDistancingTimeThreshold = 1000;
-    /**
-     * The amount of notes that has a tap strain exceeding `strainThreshold`.
-     */
-    strainNoteCount;
-    /**
-     * The ratio threshold between non-3 finger cursors and 3-finger cursors.
-     *
-     * Increasing this number will increase detection accuracy, however
-     * it also increases the chance of falsely flagged plays.
-     */
-    threeFingerRatioThreshold = 0.01;
-    /**
-     * Extended sections of the beatmap for drag detection.
-     */
-    beatmapSections = [];
-    /**
-     * The hit window of this beatmap. Keep in mind that speed-changing mods do not change hit window length in game logic.
-     */
-    hitWindow;
-    /**
-     * A reprocessed break points to match right on object time.
-     *
-     * This is used to increase detection accuracy since break points do not start right at the
-     * start of the hitobject before it and do not end right at the first hitobject after it.
-     */
-    breakPointAccurateTimes = [];
-    /**
-     * A cursor occurrence nested array that only contains `movementType.DOWN` movement ID occurrences.
-     *
-     * Each index represents the cursor index.
-     */
-    downCursorInstances = [];
-    /**
-     * Nerf factors from all sections that were three-fingered.
-     */
-    nerfFactors = [];
-    /**
-     * Whether this score uses the Precise mod.
-     */
-    isPrecise;
     /**
      * @param beatmap The beatmap to analyze.
      * @param data The data of the replay.
      * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
     constructor(beatmap, data, difficultyAttributes) {
+        /**
+         * The ratio threshold between non-3 finger cursors and 3-finger cursors.
+         *
+         * Increasing this number will increase detection accuracy, however
+         * it also increases the chance of falsely flagged plays.
+         */
+        this.threeFingerRatioThreshold = 0.01;
+        /**
+         * Extended sections of the beatmap for drag detection.
+         */
+        this.beatmapSections = [];
+        /**
+         * A reprocessed break points to match right on object time.
+         *
+         * This is used to increase detection accuracy since break points do not start right at the
+         * start of the hitobject before it and do not end right at the first hitobject after it.
+         */
+        this.breakPointAccurateTimes = [];
+        /**
+         * A cursor occurrence nested array that only contains `movementType.DOWN` movement ID occurrences.
+         *
+         * Each index represents the cursor index.
+         */
+        this.downCursorInstances = [];
+        /**
+         * Nerf factors from all sections that were three-fingered.
+         */
+        this.nerfFactors = [];
         this.beatmap = beatmap;
         this.data = data;
         this.difficultyAttributes = difficultyAttributes;
         const od = osuBase.calculateDroidDifficultyStatistics({
             overallDifficulty: beatmap.difficulty.od,
-            mods: this.difficultyAttributes.mods.filter((m) => m.isApplicableToDroid() &&
-                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
+            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
             convertOverallDifficulty: false,
         }).overallDifficulty;
         this.isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
         this.hitWindow = new osuBase.DroidHitWindow(od);
-        this.strainNoteCount =
-            this.difficultyAttributes.possibleThreeFingeredSections.reduce((a, v) => a + v.lastObjectIndex - v.firstObjectIndex + 1, 0);
         this.hitObjects = beatmap.hitObjects.objects;
     }
     /**
@@ -433,12 +359,18 @@ class RebalanceThreeFingerChecker {
      * nerf factor, taking beatmap difficulty into account.
      */
     check() {
-        if (this.strainNoteCount === 0) {
+        if (this.difficultyAttributes.possibleThreeFingeredSections.length === 0) {
             return { is3Finger: false, penalty: 1 };
         }
         this.getAccurateBreakPoints();
         this.filterCursorInstances();
+        if (this.downCursorInstances.filter((v) => v.length > 0).length <= 3) {
+            return { is3Finger: false, penalty: 1 };
+        }
         this.getBeatmapSections();
+        if (this.downCursorInstances.filter((v) => v.length > 0).length <= 3) {
+            return { is3Finger: false, penalty: 1 };
+        }
         this.calculateNerfFactors();
         const finalPenalty = this.calculateFinalPenalty();
         return { is3Finger: finalPenalty > 1, penalty: finalPenalty };
@@ -554,16 +486,9 @@ class RebalanceThreeFingerChecker {
             const dragFingerIndex = this.findDragIndex(section);
             const objects = [];
             for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
-                objects.push({
-                    object: this.hitObjects[i],
-                    ...this.getObjectPressIndex(this.hitObjects[i], this.data.hitObjectData[i], cursorLookupIndices, dragFingerIndex),
-                });
+                objects.push(Object.assign({ object: this.hitObjects[i] }, this.getObjectPressIndex(this.hitObjects[i], this.data.hitObjectData[i], cursorLookupIndices, dragFingerIndex)));
             }
-            this.beatmapSections.push({
-                ...section,
-                dragFingerIndex: dragFingerIndex,
-                objects: objects,
-            });
+            this.beatmapSections.push(Object.assign(Object.assign({}, section), { dragFingerIndex: dragFingerIndex, objects: objects }));
         }
     }
     /**
@@ -639,8 +564,8 @@ class RebalanceThreeFingerChecker {
             }
         }
         return {
-            pressingCursorInstanceIndex: nearestCursorInstanceIndex ?? -1,
-            pressingCursorIndex: nearestCursorIndex ?? -1,
+            pressingCursorInstanceIndex: nearestCursorInstanceIndex !== null && nearestCursorInstanceIndex !== void 0 ? nearestCursorInstanceIndex : -1,
+            pressingCursorIndex: nearestCursorIndex !== null && nearestCursorIndex !== void 0 ? nearestCursorIndex : -1,
         };
     }
     /**
@@ -651,6 +576,7 @@ class RebalanceThreeFingerChecker {
      * @param section The section to check.
      */
     findDragIndex(section) {
+        var _a;
         const objectData = this.data.hitObjectData;
         const firstObject = this.hitObjects[section.firstObjectIndex];
         const lastObject = this.hitObjects[section.lastObjectIndex];
@@ -763,31 +689,25 @@ class RebalanceThreeFingerChecker {
                 }
             }
         }
-        return cursorIndices.find((v) => v !== -1) ?? -1;
+        return (_a = cursorIndices.find((v) => v !== -1)) !== null && _a !== void 0 ? _a : -1;
     }
     /**
      * Creates nerf factors by scanning through objects.
      */
     calculateNerfFactors() {
         for (const beatmapSection of this.beatmapSections) {
-            const cursorAmounts = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
-            const cursorVectorTimes = [];
+            const cursorCounts = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
             for (const object of beatmapSection.objects) {
                 if (object.pressingCursorIndex === -1 ||
                     object.pressingCursorInstanceIndex ===
                         beatmapSection.dragFingerIndex) {
                     continue;
                 }
-                ++cursorAmounts[object.pressingCursorInstanceIndex];
-                const cursor = this.downCursorInstances[object.pressingCursorInstanceIndex][object.pressingCursorIndex];
-                cursorVectorTimes.push({
-                    vector: new osuBase.Vector2(cursor.position.x, cursor.position.y),
-                    time: cursor.time,
-                });
+                ++cursorCounts[object.pressingCursorInstanceIndex];
             }
             if (beatmapSection.dragFingerIndex !== -1) {
                 // Remove the drag index to prevent it from being picked up into the detection.
-                cursorAmounts.splice(beatmapSection.dragFingerIndex, 1);
+                cursorCounts.splice(beatmapSection.dragFingerIndex, 1);
             }
             // This index will be used to detect if a section is 3-fingered.
             // If the section is dragged, the dragged instance will be ignored,
@@ -795,77 +715,34 @@ class RebalanceThreeFingerChecker {
             const fingerSplitIndex = beatmapSection.dragFingerIndex !== -1 ? 2 : 3;
             // Divide >=4th (3rd for drag) cursor instances with 1st + 2nd (+ 3rd for nondrag)
             // to check if the section is 3-fingered.
-            const threeFingerRatio = cursorAmounts
+            const threeFingerRatio = cursorCounts
                 .slice(fingerSplitIndex)
                 .reduce((acc, value) => acc + value, 0) /
-                Math.max(cursorAmounts
+                Math.max(cursorCounts
                     .slice(0, fingerSplitIndex)
                     .reduce((acc, value) => acc + value, 0), 1);
-            const similarPresses = [];
-            cursorVectorTimes.sort((a, b) => a.time - b.time);
-            for (const cursorVectorTime of cursorVectorTimes) {
-                const pressIndex = similarPresses.findIndex((v) => v.vector.getDistance(cursorVectorTime.vector) <=
-                    this.cursorDistancingDistanceThreshold);
-                if (pressIndex !== -1) {
-                    if (cursorVectorTime.time -
-                        similarPresses[pressIndex].lastTime >=
-                        this.cursorDistancingTimeThreshold) {
-                        // If the previous press is too late, remove it from the
-                        // list and register the current press as a new press.
-                        similarPresses.splice(pressIndex, 1);
-                        similarPresses.push({
-                            vector: cursorVectorTime.vector,
-                            count: 1,
-                            lastTime: cursorVectorTime.time,
-                        });
-                        continue;
-                    }
-                    similarPresses[pressIndex].vector = cursorVectorTime.vector;
-                    similarPresses[pressIndex].lastTime = cursorVectorTime.time;
-                    ++similarPresses[pressIndex].count;
-                }
-                else {
-                    similarPresses.push({
-                        vector: cursorVectorTime.vector,
-                        count: 1,
-                        lastTime: cursorVectorTime.time,
-                    });
-                }
-            }
-            // Sort by highest count; assume the order is 3rd, 4th, 5th, ... finger
-            const threeFingerPresses = similarPresses
-                .filter((v) => v.count >= this.cursorDistancingCountThreshold)
-                .sort((a, b) => b.count - a.count)
-                .slice(fingerSplitIndex);
-            if (threeFingerRatio > this.threeFingerRatioThreshold ||
-                threeFingerPresses.length > 0) {
-                const objectCount = beatmapSection.lastObjectIndex -
+            if (threeFingerRatio > this.threeFingerRatioThreshold) {
+                const threeFingeredObjectCount = cursorCounts
+                    .slice(fingerSplitIndex)
+                    .reduce((acc, value) => acc + value, 0);
+                const sectionObjectCount = beatmapSection.lastObjectIndex -
                     beatmapSection.firstObjectIndex +
                     1;
+                const threeFingeredObjectRatio = threeFingeredObjectCount / sectionObjectCount;
                 // We can ignore the first 3 (2 for drag) filled cursor instances
                 // since they are guaranteed not 3 finger.
-                const threeFingerCursorAmounts = cursorAmounts
+                const threeFingerCursorCounts = cursorCounts
                     .slice(fingerSplitIndex)
                     .filter((amount) => amount > 0);
                 // Finger factor applies more penalty if more fingers were used.
-                const fingerFactor = threeFingerRatio > this.threeFingerRatioThreshold
-                    ? threeFingerCursorAmounts.reduce((acc, value, index) => acc +
-                        Math.pow(((index + 1) * value * objectCount) /
-                            this.strainNoteCount, 0.9), 1)
-                    : Math.pow(threeFingerPresses.reduce((acc, value, index) => acc +
-                        Math.pow(((index + 1) *
-                            (value.count /
-                                (this
-                                    .cursorDistancingCountThreshold *
-                                    2)) *
-                            objectCount) /
-                            this.strainNoteCount, 0.2), 1), 0.2);
+                const fingerFactor = threeFingerCursorCounts.reduce((acc, count, index) => acc +
+                    Math.pow((index + 1) * count * threeFingeredObjectRatio, 0.9), 1);
                 // Length factor applies more penalty if there are more 3-fingered object.
-                const lengthFactor = 1 + Math.pow(objectCount / this.strainNoteCount, 1.2);
+                const lengthFactor = 1 + Math.pow(threeFingeredObjectRatio, 1.2);
                 this.nerfFactors.push({
-                    strainFactor: Math.max(1, beatmapSection.sumStrain),
-                    fingerFactor,
-                    lengthFactor,
+                    strainFactor: beatmapSection.sumStrain * threeFingeredObjectRatio,
+                    fingerFactor: fingerFactor,
+                    lengthFactor: lengthFactor,
                 });
             }
         }
@@ -880,6 +757,38 @@ class RebalanceThreeFingerChecker {
     }
 }
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 /**
  * Represents a replay data in an osu!droid replay.
  *
@@ -888,29 +797,6 @@ class RebalanceThreeFingerChecker {
  * This is used when analyzing replays using replay analyzer.
  */
 class ReplayData {
-    replayVersion;
-    folderName;
-    fileName;
-    hash;
-    time;
-    hit300k;
-    hit100k;
-    score;
-    maxCombo;
-    accuracy;
-    isFullCombo;
-    playerName;
-    rawMods;
-    rank;
-    convertedMods;
-    cursorMovement;
-    hitObjectData;
-    speedMultiplier;
-    forceCS;
-    forceAR;
-    forceOD;
-    forceHP;
-    flashlightFollowDelay;
     constructor(values) {
         this.replayVersion = values.replayVersion;
         this.folderName = values.folderName;
@@ -942,98 +828,73 @@ class ReplayData {
  * Utility to check whether or not a beatmap is three-fingered.
  */
 class ThreeFingerChecker {
-    /**
-     * The beatmap that is being analyzed.
-     */
-    beatmap;
-    /**
-     * The data of the replay.
-     */
-    data;
-    /**
-     * The difficulty attributes of the beatmap.
-     */
-    difficultyAttributes;
-    /**
-     * The distance threshold between cursors to assume that two cursors are
-     * actually pressed with 1 finger in osu!pixels.
-     *
-     * This is used to prevent cases where a player would lift their finger
-     * too fast to the point where the 4th cursor instance or beyond is recorded
-     * as 1st, 2nd, or 3rd cursor instance.
-     */
-    cursorDistancingDistanceThreshold = 60;
-    /**
-     * The threshold for the amount of cursors that are assumed to be pressed
-     * by a single finger.
-     */
-    cursorDistancingCountThreshold = 10;
-    /**
-     * The threshold for the time difference of cursors that are assumed to be pressed
-     * by a single finger, in milliseconds.
-     */
-    cursorDistancingTimeThreshold = 1000;
-    /**
-     * The amount of notes that has a tap strain exceeding `strainThreshold`.
-     */
-    strainNoteCount;
-    /**
-     * The ratio threshold between non-3 finger cursors and 3-finger cursors.
-     *
-     * Increasing this number will increase detection accuracy, however
-     * it also increases the chance of falsely flagged plays.
-     */
-    threeFingerRatioThreshold = 0.01;
-    /**
-     * Extended sections of the beatmap for drag detection.
-     */
-    beatmapSections = [];
-    /**
-     * This threshold is used to filter out accidental taps.
-     *
-     * Increasing this number makes the filtration more sensitive, however it
-     * will also increase the chance of 3-fingered plays getting out from
-     * being flagged.
-     */
-    accidentalTapThreshold = 400;
-    /**
-     * The hit window of this beatmap. Keep in mind that speed-changing mods do not change hit window length in game logic.
-     */
-    hitWindow;
-    /**
-     * A reprocessed break points to match right on object time.
-     *
-     * This is used to increase detection accuracy since break points do not start right at the
-     * start of the hitobject before it and do not end right at the first hitobject after it.
-     */
-    breakPointAccurateTimes = [];
-    /**
-     * A cursor occurrence nested array that only contains `movementType.DOWN` movement ID occurrences.
-     *
-     * Each index represents the cursor index.
-     */
-    downCursorInstances = [];
-    /**
-     * Nerf factors from all sections that were three-fingered.
-     */
-    nerfFactors = [];
-    /**
-     * Whether this score uses the Precise mod.
-     */
-    isPrecise;
     /**
      * @param beatmap The beatmap to analyze.
      * @param data The data of the replay.
      * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
     constructor(beatmap, data, difficultyAttributes) {
+        /**
+         * The distance threshold between cursors to assume that two cursors are
+         * actually pressed with 1 finger in osu!pixels.
+         *
+         * This is used to prevent cases where a player would lift their finger
+         * too fast to the point where the 4th cursor instance or beyond is recorded
+         * as 1st, 2nd, or 3rd cursor instance.
+         */
+        this.cursorDistancingDistanceThreshold = 60;
+        /**
+         * The threshold for the amount of cursors that are assumed to be pressed
+         * by a single finger.
+         */
+        this.cursorDistancingCountThreshold = 10;
+        /**
+         * The threshold for the time difference of cursors that are assumed to be pressed
+         * by a single finger, in milliseconds.
+         */
+        this.cursorDistancingTimeThreshold = 1000;
+        /**
+         * The ratio threshold between non-3 finger cursors and 3-finger cursors.
+         *
+         * Increasing this number will increase detection accuracy, however
+         * it also increases the chance of falsely flagged plays.
+         */
+        this.threeFingerRatioThreshold = 0.01;
+        /**
+         * Extended sections of the beatmap for drag detection.
+         */
+        this.beatmapSections = [];
+        /**
+         * This threshold is used to filter out accidental taps.
+         *
+         * Increasing this number makes the filtration more sensitive, however it
+         * will also increase the chance of 3-fingered plays getting out from
+         * being flagged.
+         */
+        this.accidentalTapThreshold = 400;
+        /**
+         * A reprocessed break points to match right on object time.
+         *
+         * This is used to increase detection accuracy since break points do not start right at the
+         * start of the hitobject before it and do not end right at the first hitobject after it.
+         */
+        this.breakPointAccurateTimes = [];
+        /**
+         * A cursor occurrence nested array that only contains `movementType.DOWN` movement ID occurrences.
+         *
+         * Each index represents the cursor index.
+         */
+        this.downCursorInstances = [];
+        /**
+         * Nerf factors from all sections that were three-fingered.
+         */
+        this.nerfFactors = [];
         this.beatmap = beatmap;
         this.data = data;
         this.difficultyAttributes = difficultyAttributes;
         const od = osuBase.calculateDroidDifficultyStatistics({
             overallDifficulty: beatmap.difficulty.od,
-            mods: this.difficultyAttributes.mods.filter((m) => m.isApplicableToDroid() &&
-                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
+            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
             convertOverallDifficulty: false,
         }).overallDifficulty;
         this.isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
@@ -1196,11 +1057,7 @@ class ThreeFingerChecker {
     getBeatmapSections() {
         for (const section of this.difficultyAttributes
             .possibleThreeFingeredSections) {
-            this.beatmapSections.push({
-                ...section,
-                isDragged: false,
-                dragFingerIndex: -1,
-            });
+            this.beatmapSections.push(Object.assign(Object.assign({}, section), { isDragged: false, dragFingerIndex: -1 }));
         }
     }
     /**
@@ -1288,6 +1145,7 @@ class ThreeFingerChecker {
      * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
      */
     findDragIndex(sectionObjects, sectionReplayObjectData, cursorIndexes) {
+        var _a;
         const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
         for (let i = 0; i < sectionObjects.length && cursorIndexes.every((v) => v !== -1); ++i) {
             const object = sectionObjects[i];
@@ -1347,7 +1205,7 @@ class ThreeFingerChecker {
                 }
             }
         }
-        return cursorIndexes.find((v) => v !== -1) ?? -1;
+        return (_a = cursorIndexes.find((v) => v !== -1)) !== null && _a !== void 0 ? _a : -1;
     }
     /**
      * Attempts to prevent accidental taps from being flagged.
@@ -1402,7 +1260,7 @@ class ThreeFingerChecker {
                     ? objectData[beatmapSection.lastObjectIndex].accuracy
                     : this.hitWindow.hitWindowFor50(this.isPrecise));
             const cursorAmounts = [];
-            const cursorVectorTimes = [];
+            const sectionCursors = [];
             for (let i = 0; i < this.downCursorInstances.length; ++i) {
                 // Do not include drag cursor instance.
                 if (i === dragIndex) {
@@ -1414,14 +1272,12 @@ class ThreeFingerChecker {
                     if (cursors[j].time >= startTime &&
                         cursors[j].time <= endTime) {
                         ++amount;
-                        cursorVectorTimes.push({
-                            vector: new osuBase.Vector2(cursors[j].position.x, cursors[j].position.y),
-                            time: cursors[j].time,
-                        });
+                        sectionCursors.push(cursors[j]);
                     }
                 }
                 cursorAmounts.push(amount);
             }
+            sectionCursors.sort((a, b) => a.time - b.time);
             // This index will be used to detect if a section is 3-fingered.
             // If the section is dragged, the dragged instance will be ignored,
             // hence why the index is 1 less than nondragged section.
@@ -1435,31 +1291,31 @@ class ThreeFingerChecker {
                     .slice(0, fingerSplitIndex)
                     .reduce((acc, value) => acc + value, 0);
             const similarPresses = [];
-            cursorVectorTimes.sort((a, b) => a.time - b.time);
-            for (const cursorVectorTime of cursorVectorTimes) {
-                const pressIndex = similarPresses.findIndex((v) => v.vector.getDistance(cursorVectorTime.vector) <=
+            for (const sectionCursor of sectionCursors) {
+                const pressIndex = similarPresses.findIndex((v) => v.lastPosition.getDistance(sectionCursor.position) <=
                     this.cursorDistancingDistanceThreshold);
                 if (pressIndex !== -1) {
-                    if (cursorVectorTime.time -
+                    if (sectionCursor.time -
                         similarPresses[pressIndex].lastTime >=
                         this.cursorDistancingTimeThreshold) {
                         similarPresses.splice(pressIndex, 1);
                         similarPresses.push({
-                            vector: cursorVectorTime.vector,
+                            lastPosition: sectionCursor.position,
                             count: 1,
-                            lastTime: cursorVectorTime.time,
+                            lastTime: sectionCursor.time,
                         });
                         continue;
                     }
-                    similarPresses[pressIndex].vector = cursorVectorTime.vector;
-                    similarPresses[pressIndex].lastTime = cursorVectorTime.time;
+                    similarPresses[pressIndex].lastPosition =
+                        sectionCursor.position;
+                    similarPresses[pressIndex].lastTime = sectionCursor.time;
                     ++similarPresses[pressIndex].count;
                 }
                 else {
                     similarPresses.push({
-                        vector: cursorVectorTime.vector,
+                        lastPosition: sectionCursor.position,
                         count: 1,
-                        lastTime: cursorVectorTime.time,
+                        lastTime: sectionCursor.time,
                     });
                 }
             }
@@ -1519,49 +1375,6 @@ class ThreeFingerChecker {
  * Contains information about which cursor index hits a hitobject.
  */
 class IndexedHitObject {
-    /**
-     * The cursor index that hits the hitobject.
-     *
-     * If -1, the detection was unable to find any cursor that attempted to hit
-     * the hitobject or it did not meet the criteria for detection.
-     */
-    cursorIndex;
-    /**
-     * The group index of the cursor within the cursor index that hits the hitobject.
-     *
-     * If -1, the detection was unable to find any cursor that attempted to hit
-     * the hitobject or it did not meet the criteria for detection.
-     */
-    groupIndex;
-    /**
-     * The occurrence index within the group of the cursor within the cursor index that hits the hitobject.
-     *
-     * If -1, the detection was unable to find any cursor that attempted to hit
-     * the hitobject or it did not meet the criteria for detection.
-     */
-    occurrenceIndex;
-    /**
-     * The angle of the movement of the cursor towards the next hitobject.
-     */
-    angle;
-    /**
-     * If this is a slider, whether the slider was cheesed.
-     */
-    sliderCheesed = false;
-    /**
-     * The underlying difficulty hitobject.
-     */
-    object;
-    /**
-     * The position of the cursor at the end of this hitobject.
-     *
-     * Will be altered during detection.
-     */
-    endCursorPosition;
-    /**
-     * Whether the hitobject is likely two-handed.
-     */
-    is2Handed;
     /**
      * @param object The underlying difficulty hitobject.
      * @param cursorIndex The cursor index that moves towards the hitobject.
@@ -1570,6 +1383,10 @@ class IndexedHitObject {
      * @param angle The angle of the movement of the cursor that moves towards the hitobject.
      */
     constructor(object, cursorIndex, groupIndex, occurrenceIndex, angle, is2Handed) {
+        /**
+         * If this is a slider, whether the slider was cheesed.
+         */
+        this.sliderCheesed = false;
         this.object = object;
         this.cursorIndex = cursorIndex;
         this.groupIndex = groupIndex;
@@ -1585,38 +1402,21 @@ class IndexedHitObject {
  * Utility to check whether or not a beatmap is two-handed.
  */
 class TwoHandChecker {
-    /**
-     * The difficulty calculator that is being analyzed.
-     */
-    calculator;
-    /**
-     * The data of the replay.
-     */
-    data;
-    /**
-     * The hitobjects of the beatmap that have been assigned with their respective cursor index.
-     */
-    indexedHitObjects = [];
-    /**
-     * The osu!droid hitwindow of the analyzed beatmap.
-     */
-    hitWindow;
-    /**
-     * The 50 osu!droid hit window of the analyzed beatmap.
-     */
-    hitWindow50;
     // private csvString: string;
     /**
      * @param calculator The difficulty calculator to analyze.
      * @param data The data of the replay.
      */
     constructor(calculator, data) {
+        /**
+         * The hitobjects of the beatmap that have been assigned with their respective cursor index.
+         */
+        this.indexedHitObjects = [];
         this.calculator = calculator;
         this.data = data;
         const od = osuBase.calculateDroidDifficultyStatistics({
             overallDifficulty: calculator.beatmap.difficulty.od,
-            mods: calculator.mods.filter((m) => m.isApplicableToDroid() &&
-                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
+            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
             convertOverallDifficulty: false,
         }).overallDifficulty;
         this.hitWindow = new osuBase.DroidHitWindow(od);
@@ -2197,22 +1997,6 @@ class TwoHandChecker {
  * Utility to check whether relevant sliders in a beatmap are cheesed.
  */
 class SliderCheeseChecker {
-    /**
-     * The beatmap that is being analyzed.
-     */
-    beatmap;
-    /**
-     * The data of the replay.
-     */
-    data;
-    /**
-     * The difficulty attributes of the beatmap.
-     */
-    difficultyAttributes;
-    /**
-     * The 50 osu!droid hit window of the analyzed beatmap.
-     */
-    hitWindow50;
     /**
      * @param beatmap The beatmap to analyze.
      * @param data The data of the replay.
@@ -2224,8 +2008,7 @@ class SliderCheeseChecker {
         this.difficultyAttributes = difficultyAttributes;
         const od = osuBase.calculateDroidDifficultyStatistics({
             overallDifficulty: beatmap.difficulty.od,
-            mods: this.difficultyAttributes.mods.filter((m) => m.isApplicableToDroid() &&
-                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
+            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
             convertOverallDifficulty: false,
         }).overallDifficulty;
         this.hitWindow50 = new osuBase.DroidHitWindow(od).hitWindowFor50(this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise));
@@ -2427,78 +2210,57 @@ class SliderCheeseChecker {
  * Once analyzed, the result can be accessed via the `data` property.
  */
 class ReplayAnalyzer {
-    /**
-     * The score ID of the replay.
-     */
-    scoreID;
-    /**
-     * The original odr file of the replay.
-     */
-    originalODR = null;
-    /**
-     * The fixed odr file of the replay.
-     */
-    fixedODR = null;
-    /**
-     * Whether or not the play is considered using >=3 finger abuse.
-     */
-    is3Finger;
-    /**
-     * Whether or not the play is considered 2-handed.
-     */
-    is2Hand;
-    /**
-     * The beatmap that is being analyzed. `DroidDifficultyCalculator` or `RebalanceDroidDifficultyCalculator` is required for three finger or two hand analyzing.
-     */
-    beatmap;
-    /**
-     * The difficulty attributes of the beatmap.
-     */
-    difficultyAttributes;
-    /**
-     * The results of the analyzer. `null` when initialized.
-     */
-    data = null;
-    /**
-     * Penalty value used to penalize dpp for 2-hand.
-     */
-    aimPenalty = 1;
-    /**
-     * Penalty value used to penalize dpp for 3 finger abuse.
-     */
-    tapPenalty = 1;
-    /**
-     * Penalty values used to penalize dpp for slider cheesing.
-     */
-    sliderCheesePenalty = {
-        aimPenalty: 1,
-        flashlightPenalty: 1,
-        visualPenalty: 1,
-    };
-    /**
-     * Whether this replay has been checked against 3 finger usage.
-     */
-    hasBeenCheckedFor3Finger = false;
-    /**
-     * Whether this replay has been checked against 2 hand usage.
-     */
-    hasBeenCheckedFor2Hand = false;
-    /**
-     * Whether this replay has been checked against slider cheesing.
-     */
-    hasBeenCheckedForSliderCheesing = false;
-    /**
-     * The amount of two-handed objects.
-     */
-    twoHandedNoteCount = 0;
-    convertedBeatmap;
-    // Sizes of primitive data types in Java (in bytes)
-    BYTE_LENGTH = 1;
-    SHORT_LENGTH = 2;
-    INT_LENGTH = 4;
-    FLOAT_LENGTH = 4;
-    LONG_LENGTH = 8;
     constructor(values) {
+        /**
+         * The original odr file of the replay.
+         */
+        this.originalODR = null;
+        /**
+         * The fixed odr file of the replay.
+         */
+        this.fixedODR = null;
+        /**
+         * The results of the analyzer. `null` when initialized.
+         */
+        this.data = null;
+        /**
+         * Penalty value used to penalize dpp for 2-hand.
+         */
+        this.aimPenalty = 1;
+        /**
+         * Penalty value used to penalize dpp for 3 finger abuse.
+         */
+        this.tapPenalty = 1;
+        /**
+         * Penalty values used to penalize dpp for slider cheesing.
+         */
+        this.sliderCheesePenalty = {
+            aimPenalty: 1,
+            flashlightPenalty: 1,
+            visualPenalty: 1,
+        };
+        /**
+         * Whether this replay has been checked against 3 finger usage.
+         */
+        this.hasBeenCheckedFor3Finger = false;
+        /**
+         * Whether this replay has been checked against 2 hand usage.
+         */
+        this.hasBeenCheckedFor2Hand = false;
+        /**
+         * Whether this replay has been checked against slider cheesing.
+         */
+        this.hasBeenCheckedForSliderCheesing = false;
+        /**
+         * The amount of two-handed objects.
+         */
+        this.twoHandedNoteCount = 0;
+        // Sizes of primitive data types in Java (in bytes)
+        this.BYTE_LENGTH = 1;
+        this.SHORT_LENGTH = 2;
+        this.INT_LENGTH = 4;
+        this.FLOAT_LENGTH = 4;
+        this.LONG_LENGTH = 8;
         this.scoreID = values.scoreID;
         this.beatmap = values.map;
         this.difficultyAttributes = values.difficultyAttributes;
@@ -2509,35 +2271,39 @@ class ReplayAnalyzer {
     /**
      * Analyzes a replay.
      */
-    async analyze() {
-        if (!this.originalODR && !this.fixedODR) {
-            this.originalODR = await this.downloadReplay();
-        }
-        if (!this.originalODR) {
-            return this;
-        }
-        if (!this.fixedODR) {
-            this.fixedODR = await this.decompress().catch(() => null);
-        }
-        if (!this.fixedODR) {
+    analyze() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.originalODR && !this.fixedODR) {
+                this.originalODR = yield this.downloadReplay();
+            }
+            if (!this.originalODR) {
+                return this;
+            }
+            if (!this.fixedODR) {
+                this.fixedODR = yield this.decompress().catch(() => null);
+            }
+            if (!this.fixedODR) {
+                return this;
+            }
+            this.parseReplay();
             return this;
-        }
-        this.parseReplay();
-        return this;
+        });
     }
     /**
      * Downloads the given score ID's replay.
      */
-    async downloadReplay() {
-        const apiRequestBuilder = new osuBase.DroidAPIRequestBuilder()
-            .setRequireAPIkey(false)
-            .setEndpoint("upload")
-            .addParameter("", `${this.scoreID}.odr`);
-        const result = await apiRequestBuilder.sendRequest();
-        if (result.statusCode !== 200) {
-            return null;
-        }
-        return result.data;
+    downloadReplay() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const apiRequestBuilder = new osuBase.DroidAPIRequestBuilder()
+                .setRequireAPIkey(false)
+                .setEndpoint("upload")
+                .addParameter("", `${this.scoreID}.odr`);
+            const result = yield apiRequestBuilder.sendRequest();
+            if (result.statusCode !== 200) {
+                return null;
+            }
+            return result.data;
+        });
     }
     /**
      * Decompresses a replay.
@@ -2551,15 +2317,15 @@ class ReplayAnalyzer {
             stream.push(null);
             stream
                 .pipe(unzipper.Parse())
-                .on("entry", async (entry) => {
+                .on("entry", (entry) => __awaiter(this, void 0, void 0, function* () {
                 const fileName = entry.path;
                 if (fileName === "data") {
-                    return resolve(await entry.buffer());
+                    return resolve(yield entry.buffer());
                 }
                 else {
                     entry.autodrain();
                 }
-            })
+            }))
                 .on("error", (e) => {
                 setTimeout(() => reject(e), 2000);
             });
@@ -2569,6 +2335,7 @@ class ReplayAnalyzer {
      * Parses a replay after being downloaded and converted to a buffer.
      */
     parseReplay() {
+        var _a, _b, _c;
         if (!this.fixedODR) {
             return;
         }
@@ -2579,7 +2346,7 @@ class ReplayAnalyzer {
         try {
             rawObject = javaDeserialization__namespace.parse(this.fixedODR);
         }
-        catch {
+        catch (_d) {
             return;
         }
         const resultObject = {
@@ -2593,11 +2360,12 @@ class ReplayAnalyzer {
             rank: "",
         };
         const determineRank = () => {
+            var _a, _b;
             const totalHits = resultObject.accuracy.n300 +
                 resultObject.accuracy.n100 +
                 resultObject.accuracy.n50 +
                 resultObject.accuracy.nmiss;
-            const isHidden = resultObject.convertedMods?.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModFlashlight) ?? false;
+            const isHidden = (_b = (_a = resultObject.convertedMods) === null || _a === void 0 ? void 0 : _a.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModFlashlight)) !== null && _b !== void 0 ? _b : false;
             const hit300Ratio = resultObject.accuracy.n300 / totalHits;
             switch (true) {
                 case resultObject.accuracy.value() === 1:
@@ -2780,10 +2548,10 @@ class ReplayAnalyzer {
         }
         // Parse max combo, hit results, and accuracy in old replay version
         if (resultObject.replayVersion < 3) {
-            const objects = (this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
+            const objects = (_a = (this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
                 this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
                 ? this.beatmap.beatmap
-                : this.beatmap)?.hitObjects.objects;
+                : this.beatmap)) === null || _a === void 0 ? void 0 : _a.hitObjects.objects;
             let grantsGekiOrKatu = true;
             for (let i = 0; i < resultObject.hitObjectData.length; ++i) {
                 // Hit result
@@ -2805,14 +2573,14 @@ class ReplayAnalyzer {
                     case exports.HitResult.good:
                         ++resultObject.accuracy.n100;
                         if (grantsGekiOrKatu && isNextNewCombo) {
-                            resultObject.hit100k ??= 0;
+                            (_b = resultObject.hit100k) !== null && _b !== void 0 ? _b : (resultObject.hit100k = 0);
                             ++resultObject.hit100k;
                         }
                         break;
                     case exports.HitResult.great:
                         ++resultObject.accuracy.n300;
                         if (grantsGekiOrKatu && isNextNewCombo) {
-                            resultObject.hit300k ??= 0;
+                            (_c = resultObject.hit300k) !== null && _c !== void 0 ? _c : (resultObject.hit300k = 0);
                             ++resultObject.hit300k;
                         }
                         break;
@@ -2846,7 +2614,7 @@ class ReplayAnalyzer {
         const { objects } = beatmap.hitObjects;
         const od = osuBase.calculateDroidDifficultyStatistics({
             overallDifficulty: beatmap.difficulty.od,
-            mods: this.data.convertedMods.filter((m) => !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
+            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
         }).overallDifficulty;
         const hitWindow50 = new osuBase.DroidHitWindow(od).hitWindowFor50(this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise));
         // The accuracy of sliders is set to (50 hit window)ms + 13ms if their head was not hit:
@@ -2923,6 +2691,7 @@ class ReplayAnalyzer {
      * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
      */
     checkFor3Finger() {
+        var _a;
         if (!this.beatmap || !this.data || !this.difficultyAttributes) {
             return;
         }
@@ -2941,13 +2710,13 @@ class ReplayAnalyzer {
                     hp: this.data.forceHP,
                 }));
             }
-            this.convertedBeatmap ??= new osuBase.BeatmapConverter(this.beatmap instanceof osuBase.Beatmap
+            (_a = this.convertedBeatmap) !== null && _a !== void 0 ? _a : (this.convertedBeatmap = new osuBase.BeatmapConverter(this.beatmap instanceof osuBase.Beatmap
                 ? this.beatmap
                 : this.beatmap.beatmap).convert({
                 mode: osuBase.Modes.droid,
                 mods: mods,
                 customSpeedMultiplier: this.data.speedMultiplier,
-            });
+            }));
         }
         const threeFingerChecker = this.difficultyAttributes.mode === "rebalance"
             ? new RebalanceThreeFingerChecker(this.convertedBeatmap, this.data, this.difficultyAttributes)
@@ -2980,6 +2749,7 @@ class ReplayAnalyzer {
      * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
      */
     checkForSliderCheesing() {
+        var _a;
         if (!this.beatmap || !this.data || !this.difficultyAttributes) {
             return;
         }
@@ -2998,13 +2768,13 @@ class ReplayAnalyzer {
                     hp: this.data.forceHP,
                 }));
             }
-            this.convertedBeatmap ??= new osuBase.BeatmapConverter(this.beatmap instanceof osuBase.Beatmap
+            (_a = this.convertedBeatmap) !== null && _a !== void 0 ? _a : (this.convertedBeatmap = new osuBase.BeatmapConverter(this.beatmap instanceof osuBase.Beatmap
                 ? this.beatmap
                 : this.beatmap.beatmap).convert({
                 mode: osuBase.Modes.droid,
                 mods: mods,
                 customSpeedMultiplier: this.data.speedMultiplier,
-            });
+            }));
         }
         const sliderCheeseChecker = new SliderCheeseChecker(this.convertedBeatmap, this.data, this.difficultyAttributes);
         this.sliderCheesePenalty = sliderCheeseChecker.check();
@@ -3020,33 +2790,6 @@ class ReplayAnalyzer {
  * This is used when analyzing replays using replay analyzer.
  */
 class ReplayObjectData {
-    /**
-     * For circles, this is the offset at which the circle was hit. If the hit accuracy is 10000, it means the circle was tapped too late ([game source code](https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/HitCircle.java#L298-L306)).
-     *
-     * For sliders, this is the offset at which the slider head was hit. For
-     * sliderbreaks, the accuracy would be `Math.floor(<hit window 50>ms) + 13ms` ([game source code](https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/Slider.java#L821)).
-     *
-     * For spinners, this is the total amount at which the spinner was spinned:
-     * ```js
-     * const rotations = Math.floor(data.accuracy / 4);
-     * ```
-     * The remainder of the division denotes the hit result of the spinner:
-     * - `HitResult.great`: 3
-     * - `HitResult.good`: 2
-     * - `HitResult.meh`: 1
-     * - `HitResult.miss`: 0
-     */
-    accuracy;
-    /**
-     * The tickset of the hitobject.
-     *
-     * This is used to determine whether or not a slider event (tick, repeat, and end) is hit based on the order they appear.
-     */
-    tickset;
-    /**
-     * The bitwise hit result of the hitobject.
-     */
-    result;
     constructor(values) {
         this.accuracy = values.accuracy;
         this.tickset = values.tickset;